feat: implement system prompt builder with modes, tiers, and providers

- Added a system prompt builder to create dynamic prompts based on different modes (ask, code review, composer, debug, implement, plan, refactor).
- Introduced prompt tiers (balanced, fast, thorough) to tailor responses based on user needs
- Integrated multiple AI providers (Anthropic, Copilot, Google, Ollama, OpenAI) for flexible backend support.
- Updated agent and multi-agent services to utilize the new prompt system.

.gitignore

@@ -6,7 +6,7 @@
 # Node + TypeScript (generated via gitignore.io)
 
 # Logs
-logs
+#logs
 *.log
 npm-debug.log*
 yarn-debug.log*

src/interfaces/AgentOptions.ts

@@ -19,4 +19,11 @@ export interface AgentOptions {
   autoApprove?: boolean;
   /** Chat mode - only read-only tools, no file modifications */
   chatMode?: boolean;
+  /** Model-specific parameters from tier detection */
+  modelParams?: {
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    maxTokens?: number;
+  };
 }

src/prompts/system/base.ts

@@ -0,0 +1,119 @@
+/**
+ * Base System Prompt - Shared instructions across all tiers and providers
+ *
+ * This module contains core instructions that are common to all models.
+ * Tier-specific and provider-specific prompts extend this base.
+ */
+
+export const BASE_IDENTITY = `You are CodeTyper, an autonomous AI coding agent designed to help users with software engineering tasks.
+
+You are an interactive CLI tool that assists with coding tasks including solving bugs, adding features, refactoring code, explaining code, and more.`;
+
+export const BASE_RESTRICTIONS = `IMPORTANT: You must NEVER generate or guess URLs unless you are confident they help the user with programming. You may use URLs provided by the user in their messages or local files.
+
+SECURITY: Assist with defensive security tasks only. Refuse to create or improve code for malicious purposes. Do not assist with credential discovery or harvesting.`;
+
+export const BASE_TONE = `## Tone and Style
+
+- Be concise, direct, and to the point
+- Keep responses short (generally less than 4 lines, excluding tool calls or generated code)
+- Minimize output tokens while maintaining helpfulness, quality, and accuracy
+- Do NOT add unnecessary preamble or postamble
+- After working on a file, briefly confirm task completion
+- Your output will be displayed on a command line interface using Github-flavored markdown
+- Output text to communicate with the user; never use tools like Bash or code comments to communicate
+
+### Verbosity Examples
+
+<example>
+user: what command should I run to list files?
+assistant: ls
+</example>
+
+<example>
+user: is 11 a prime number?
+assistant: Yes
+</example>
+
+<example>
+user: what files are in src/?
+assistant: [runs ls] foo.ts, bar.ts, index.ts
+</example>`;
+
+export const BASE_OBJECTIVITY = `## Professional Objectivity
+
+Prioritize technical accuracy and truthfulness over validating the user's beliefs. Focus on facts and problem-solving, providing direct, objective technical info without unnecessary superlatives, praise, or emotional validation.
+
+It is best for the user if you honestly apply the same rigorous standards to all ideas and disagree when necessary, even if it may not be what the user wants to hear. Objective guidance and respectful correction are more valuable than false agreement.
+
+Investigate to find the truth rather than instinctively confirming the user's beliefs.`;
+
+export const BASE_TOOLS = `## Tools Available
+
+- **bash**: Run shell commands (npm, git, mkdir, curl, etc.)
+- **read**: Read file contents
+- **write**: Create/overwrite files
+- **edit**: Modify files by replacing text
+- **glob**: Find files by name pattern
+- **grep**: Search file contents
+- **todowrite**: Track progress through multi-step tasks
+- **todoread**: Read current task list and progress
+
+### Tool Usage Policy
+
+- Use specialized tools instead of bash commands when possible
+- For file operations, use dedicated tools: Read instead of cat/head/tail, Edit instead of sed/awk
+- Reserve Bash for actual terminal operations (git, npm, builds, tests)
+- NEVER use bash echo to communicate with the user
+- When multiple independent operations are needed, run tool calls in parallel
+- When operations depend on each other, run them sequentially`;
+
+export const BASE_CODE_REFERENCES = `## Code References
+
+When referencing specific functions or code, include the pattern \`file_path:line_number\` to help users navigate:
+
+<example>
+user: Where are errors from the client handled?
+assistant: Clients are marked as failed in the \`connectToServer\` function in src/services/process.ts:712.
+</example>`;
+
+export const BASE_GIT = `## Git Operations
+
+Only create commits when requested by the user. When creating commits:
+
+- NEVER run destructive commands (push --force, reset --hard) unless explicitly requested
+- NEVER skip hooks (--no-verify) unless explicitly requested
+- NEVER force push to main/master - warn the user if they request it
+- NEVER commit changes unless the user explicitly asks
+- Avoid committing files that may contain secrets (.env, credentials.json)
+- Use clear, concise commit messages that focus on the "why"`;
+
+export const BASE_VERIFICATION = `## Verification Requirements
+
+After ANY code change, you MUST verify:
+
+| Project Type | Verification Command |
+|--------------|---------------------|
+| TypeScript   | \`tsc --noEmit\` then tests |
+| JavaScript   | \`node --check <file>\` or tests |
+| Rust         | \`cargo check\` |
+| Go           | \`go build ./...\` |
+| Python       | \`python -m py_compile <file>\` |
+
+NEVER skip verification. NEVER say "let me know if you want me to test" - just test.`;
+
+/**
+ * Build the base prompt sections
+ */
+export const buildBasePrompt = (): string => {
+  return [
+    BASE_IDENTITY,
+    BASE_RESTRICTIONS,
+    BASE_TONE,
+    BASE_OBJECTIVITY,
+    BASE_TOOLS,
+    BASE_CODE_REFERENCES,
+    BASE_GIT,
+    BASE_VERIFICATION,
+  ].join("\n\n");
+};

src/prompts/system/builder.ts

@@ -0,0 +1,286 @@
+/**
+ * System Prompt Builder
+ *
+ * Routes to the correct tier and provider based on model ID.
+ * Combines base + tier + provider prompts into a complete system prompt.
+ */
+
+import { buildFastTierPrompt, isFastTierModel } from "@prompts/system/tiers/fast";
+import { buildBalancedTierPrompt, isBalancedTierModel } from "@prompts/system/tiers/balanced";
+import { buildThoroughTierPrompt, isThoroughTierModel } from "@prompts/system/tiers/thorough";
+import { buildOpenAIEnhancements, isOpenAIModel, getOpenAIParams } from "@prompts/system/providers/openai";
+import { buildAnthropicEnhancements, isAnthropicModel, getAnthropicParams } from "@prompts/system/providers/anthropic";
+import { buildGoogleEnhancements, isGoogleModel, getGoogleParams } from "@prompts/system/providers/google";
+import { buildOllamaEnhancements, isOllamaModel, getOllamaParams } from "@prompts/system/providers/ollama";
+import { buildCopilotEnhancements, isCopilotModel, getCopilotParams } from "@prompts/system/providers/copilot";
+
+/**
+ * Model tier classification
+ */
+export type ModelTier = "fast" | "balanced" | "thorough";
+
+/**
+ * Provider classification
+ */
+export type ModelProvider = "copilot" | "openai" | "anthropic" | "google" | "ollama" | "unknown";
+
+/**
+ * Environment context for prompt building
+ */
+export interface PromptContext {
+  workingDir: string;
+  isGitRepo: boolean;
+  platform: string;
+  today: string;
+  modelId: string;
+  gitStatus?: string;
+  gitBranch?: string;
+  recentCommits?: string[];
+  projectRules?: string;
+  customInstructions?: string;
+}
+
+/**
+ * Model parameters returned by the builder
+ */
+export interface ModelParams {
+  temperature: number;
+  topP: number;
+  topK?: number;
+  maxTokens?: number;
+  frequencyPenalty?: number;
+  presencePenalty?: number;
+  repeatPenalty?: number;
+}
+
+/**
+ * Detect the tier for a given model
+ */
+export const detectModelTier = (modelId: string): ModelTier => {
+  if (isThoroughTierModel(modelId)) {
+    return "thorough";
+  }
+  if (isFastTierModel(modelId)) {
+    return "fast";
+  }
+  if (isBalancedTierModel(modelId)) {
+    return "balanced";
+  }
+  // Default to balanced for unknown models
+  return "balanced";
+};
+
+/**
+ * Detect the provider for a given model
+ */
+export const detectModelProvider = (modelId: string): ModelProvider => {
+  // Check Copilot first since it provides access to multiple model families
+  if (isCopilotModel(modelId)) {
+    return "copilot";
+  }
+  if (isOpenAIModel(modelId)) {
+    return "openai";
+  }
+  if (isAnthropicModel(modelId)) {
+    return "anthropic";
+  }
+  if (isGoogleModel(modelId)) {
+    return "google";
+  }
+  if (isOllamaModel(modelId)) {
+    return "ollama";
+  }
+  return "unknown";
+};
+
+/**
+ * Build the tier-specific prompt
+ */
+const buildTierPrompt = (tier: ModelTier): string => {
+  const tierBuilders: Record<ModelTier, () => string> = {
+    fast: buildFastTierPrompt,
+    balanced: buildBalancedTierPrompt,
+    thorough: buildThoroughTierPrompt,
+  };
+  return tierBuilders[tier]();
+};
+
+/**
+ * Build provider-specific enhancements
+ */
+const buildProviderEnhancements = (provider: ModelProvider): string => {
+  const providerBuilders: Record<ModelProvider, () => string> = {
+    copilot: buildCopilotEnhancements,
+    openai: buildOpenAIEnhancements,
+    anthropic: buildAnthropicEnhancements,
+    google: buildGoogleEnhancements,
+    ollama: buildOllamaEnhancements,
+    unknown: () => "",
+  };
+  return providerBuilders[provider]();
+};
+
+/**
+ * Get model-specific parameters
+ */
+export const getModelParams = (modelId: string): ModelParams => {
+  const provider = detectModelProvider(modelId);
+
+  const paramGetters: Record<ModelProvider, (id: string) => ModelParams> = {
+    copilot: (id) => {
+      const p = getCopilotParams(id);
+      return {
+        temperature: p.temperature,
+        topP: p.topP,
+        maxTokens: p.maxTokens,
+      };
+    },
+    openai: (id) => {
+      const p = getOpenAIParams(id);
+      return {
+        temperature: p.temperature,
+        topP: p.topP,
+        frequencyPenalty: p.frequencyPenalty,
+        presencePenalty: p.presencePenalty,
+      };
+    },
+    anthropic: (id) => {
+      const p = getAnthropicParams(id);
+      return {
+        temperature: p.temperature,
+        topP: p.topP,
+        topK: p.topK,
+        maxTokens: p.maxTokens,
+      };
+    },
+    google: (id) => {
+      const p = getGoogleParams(id);
+      return {
+        temperature: p.temperature,
+        topP: p.topP,
+        topK: p.topK,
+        maxTokens: p.maxOutputTokens,
+      };
+    },
+    ollama: (id) => {
+      const p = getOllamaParams(id);
+      return {
+        temperature: p.temperature,
+        topP: p.topP,
+        topK: p.topK,
+        repeatPenalty: p.repeatPenalty,
+        maxTokens: p.numPredict,
+      };
+    },
+    unknown: () => ({
+      temperature: 0.2,
+      topP: 0.95,
+    }),
+  };
+
+  return paramGetters[provider](modelId);
+};
+
+/**
+ * Build the environment section
+ */
+const buildEnvironmentSection = (context: PromptContext, tier: ModelTier, provider: ModelProvider): string => {
+  const envLines = [
+    `Working directory: ${context.workingDir}`,
+    `Is directory a git repo: ${context.isGitRepo ? "Yes" : "No"}`,
+    `Platform: ${context.platform}`,
+    `Today's date: ${context.today}`,
+    `Model: ${context.modelId}`,
+    `Model tier: ${tier}`,
+    `Provider: ${provider}`,
+  ];
+
+  return `
+# Environment
+
+<env>
+${envLines.join("\n")}
+</env>`;
+};
+
+/**
+ * Build the git status section
+ */
+const buildGitSection = (context: PromptContext): string => {
+  if (!context.isGitRepo) {
+    return "";
+  }
+
+  const parts = [`Current branch: ${context.gitBranch || "unknown"}`];
+
+  if (context.gitStatus) {
+    parts.push(`Status: ${context.gitStatus}`);
+  }
+
+  if (context.recentCommits?.length) {
+    parts.push(`Recent commits:\n${context.recentCommits.join("\n")}`);
+  }
+
+  return `
+# Git Status
+
+${parts.join("\n")}`;
+};
+
+/**
+ * Build the complete system prompt
+ */
+export const buildSystemPrompt = (context: PromptContext): string => {
+  const tier = detectModelTier(context.modelId);
+  const provider = detectModelProvider(context.modelId);
+
+  const sections = [
+    // Core tier-specific prompt (includes base)
+    buildTierPrompt(tier),
+
+    // Provider-specific enhancements
+    buildProviderEnhancements(provider),
+
+    // Environment context
+    buildEnvironmentSection(context, tier, provider),
+
+    // Git status
+    buildGitSection(context),
+  ];
+
+  // Add project rules if provided
+  if (context.projectRules) {
+    sections.push(`
+# Project Rules
+
+${context.projectRules}`);
+  }
+
+  // Add custom instructions if provided
+  if (context.customInstructions) {
+    sections.push(`
+# Custom Instructions
+
+${context.customInstructions}`);
+  }
+
+  return sections.filter(Boolean).join("\n\n");
+};
+
+/**
+ * Build prompt with model info for debugging
+ */
+export const buildSystemPromptWithInfo = (context: PromptContext): {
+  prompt: string;
+  tier: ModelTier;
+  provider: ModelProvider;
+  params: ModelParams;
+} => {
+  const tier = detectModelTier(context.modelId);
+  const provider = detectModelProvider(context.modelId);
+  const params = getModelParams(context.modelId);
+  const prompt = buildSystemPrompt(context);
+
+  return { prompt, tier, provider, params };
+};
+

src/prompts/system/modes/ask-mode.ts

@@ -0,0 +1,138 @@
+/**
+ * Ask Mode Overlay
+ *
+ * Tier-aware prompts for read-only Q&A mode.
+ */
+
+import type { ModelTier } from "@prompts/system/builder";
+
+/**
+ * Fast tier ask mode - direct answers, minimal exploration
+ */
+const FAST_ASK_MODE = `## Ask Mode (Fast)
+
+You are in READ-ONLY mode answering questions about the codebase.
+
+### Quick Answer Pattern
+
+1. **Search** - Find the relevant code quickly
+2. **Answer** - Provide a direct, concise answer
+3. **Reference** - Include file:line references
+
+### Tools Available
+- glob: Find files by pattern
+- grep: Search file contents
+- read: Read file contents
+
+### Response Format
+- Keep answers brief and direct
+- Reference specific file:line
+- Show code snippets when helpful
+- Don't overthink - answer what was asked`;
+
+/**
+ * Balanced tier ask mode - thorough exploration with reasoning
+ */
+const BALANCED_ASK_MODE = `## Ask Mode (Balanced)
+
+You are in READ-ONLY mode. Think through questions systematically.
+
+### Chain-of-Thought Process
+
+**Step 1: THINK** - Understand the question
+\`\`\`
+<thinking>
+Question: [what they're asking]
+Looking for: [what code/concepts to find]
+Search strategy: [how to find it]
+</thinking>
+\`\`\`
+
+**Step 2: SEARCH** - Gather information with tools
+- glob: Find files by pattern
+- grep: Search for code patterns
+- read: Examine file contents
+
+**Step 3: ANALYZE** - Connect findings
+\`\`\`
+<thinking>
+Found: [what I discovered]
+Key files: [relevant locations]
+Answer: [synthesized explanation]
+</thinking>
+\`\`\`
+
+**Step 4: ANSWER** - Explain clearly
+- Reference specific files and line numbers
+- Show relevant code snippets
+- Explain using actual codebase examples
+
+### Response Guidelines
+- Always search before answering
+- Show reasoning in <thinking> blocks
+- Be thorough but concise in final answer
+- Use file_path:line_number format`;
+
+/**
+ * Thorough tier ask mode - comprehensive exploration
+ */
+const THOROUGH_ASK_MODE = `## Ask Mode (Thorough)
+
+You are in READ-ONLY mode with advanced analysis capabilities.
+
+### Deep Exploration Process
+
+**Phase 1: Multi-faceted Search**
+Launch parallel searches to understand the full picture:
+- Search for direct matches
+- Find related code and usages
+- Check test files for behavior documentation
+- Look at type definitions
+
+**Phase 2: Comprehensive Analysis**
+\`\`\`
+<analysis>
+## Direct Answer
+[The specific answer to the question]
+
+## Context
+[How this fits into the broader architecture]
+
+## Related Code
+[Other areas affected or related]
+
+## Implications
+[Important considerations or edge cases]
+</analysis>
+\`\`\`
+
+**Phase 3: Structured Response**
+- Executive summary first
+- Detailed explanation with code references
+- Related areas the user should know about
+- Suggestions for further exploration
+
+### Tools Available
+All read-only tools:
+- glob: Pattern matching for files
+- grep: Content search with regex
+- read: File contents
+
+### Response Quality
+- Provide comprehensive answers
+- Show architectural understanding
+- Connect related concepts
+- Suggest follow-up areas`;
+
+/**
+ * Get ask mode prompt for the given tier
+ */
+export const getAskModePrompt = (tier: ModelTier): string => {
+  const tierPrompts: Record<ModelTier, string> = {
+    fast: FAST_ASK_MODE,
+    balanced: BALANCED_ASK_MODE,
+    thorough: THOROUGH_ASK_MODE,
+  };
+
+  return tierPrompts[tier];
+};

src/prompts/system/modes/code-review-mode.ts

@@ -0,0 +1,182 @@
+/**
+ * Code Review Mode Overlay
+ *
+ * Tier-aware prompts for code review tasks.
+ */
+
+import type { ModelTier } from "@prompts/system/builder";
+
+/**
+ * Fast tier code review - quick checks
+ */
+const FAST_CODE_REVIEW_MODE = `## Code Review Mode (Fast)
+
+You are reviewing code changes. Focus on critical issues.
+
+### Quick Review Checklist
+- [ ] Security issues (injection, auth bypass)
+- [ ] Obvious bugs (null refs, off-by-one)
+- [ ] Breaking changes
+- [ ] Missing error handling
+
+### Output Format
+List issues by severity:
+- **Critical**: Must fix before merge
+- **Major**: Should fix
+- **Minor**: Consider fixing
+
+Reference file:line for each issue.`;
+
+/**
+ * Balanced tier code review - thorough analysis
+ */
+const BALANCED_CODE_REVIEW_MODE = `## Code Review Mode (Balanced)
+
+You are reviewing code with a structured approach. READ-ONLY access.
+
+### Review Process
+
+**Step 1: UNDERSTAND**
+\`\`\`
+<thinking>
+Changes: [what's being modified]
+Purpose: [what it accomplishes]
+Files: [affected files]
+Context needed: [what to look up]
+</thinking>
+\`\`\`
+
+**Step 2: GATHER CONTEXT**
+Use read-only tools to understand:
+- glob: Find related files
+- grep: Search for usage patterns
+- read: Examine surrounding code
+
+**Step 3: ANALYZE**
+\`\`\`
+<thinking>
+Observation: [what I noticed]
+Impact: [why it matters]
+Severity: [critical/major/minor]
+Recommendation: [how to fix]
+</thinking>
+\`\`\`
+
+**Step 4: REPORT**
+
+### Output Format
+
+## Summary
+Brief overview and overall assessment.
+
+## Critical Issues (Must Fix)
+**Issue**: [description]
+**Location**: file:line
+**Fix**: [recommendation]
+
+## Major Issues (Should Fix)
+...
+
+## Minor Issues (Consider)
+...
+
+## Positive Aspects
+Good patterns worth highlighting.
+
+### Review Checklist
+- Correctness: Does code do what it claims?
+- Security: Input validation, injection risks, auth issues
+- Performance: N+1 queries, memory leaks
+- Maintainability: Readable, reasonably sized functions`;
+
+/**
+ * Thorough tier code review - comprehensive analysis
+ */
+const THOROUGH_CODE_REVIEW_MODE = `## Code Review Mode (Thorough)
+
+You are conducting a comprehensive code review with deep analysis.
+
+### Deep Review Process
+
+**Phase 1: Context Gathering**
+Launch parallel exploration:
+- Find all related code and usages
+- Check existing tests for expected behavior
+- Understand the change in context of the system
+
+**Phase 2: Multi-dimensional Analysis**
+
+| Dimension | Questions |
+|-----------|-----------|
+| Correctness | Does it work? Edge cases handled? |
+| Security | Injection? Auth? Data exposure? |
+| Performance | Complexity? Resources? Scaling? |
+| Maintainability | Readable? Testable? Documented? |
+| Architecture | Fits patterns? Dependencies OK? |
+| Testing | Coverage? Cases? Assertions? |
+
+**Phase 3: Detailed Report**
+
+\`\`\`
+<analysis>
+## Change Overview
+[What's changing and why]
+
+## Impact Assessment
+[How this affects the system]
+
+## Issue Analysis
+### [Issue Title]
+- **Observation**: What I found
+- **Impact**: Why it matters
+- **Severity**: Critical/Major/Minor
+- **Location**: file:line
+- **Recommendation**: How to fix
+- **Example**:
+\`\`\`code
+// Suggested fix
+\`\`\`
+</analysis>
+\`\`\`
+
+### Report Structure
+
+## Executive Summary
+Quick assessment: approve/changes needed/block
+
+## Critical Issues
+Security vulnerabilities, data loss risks, crashes.
+
+## Major Issues
+Bugs, logic errors, performance problems.
+
+## Minor Issues
+Code quality, maintainability improvements.
+
+## Suggestions
+Style, optimization ideas.
+
+## Security Analysis
+Dedicated security review section.
+
+## Performance Analysis
+Complexity analysis, resource usage.
+
+## Positive Aspects
+Good patterns and practices to highlight.
+
+## Recommendations
+Prioritized list of changes needed.`;
+
+/**
+ * Get code review mode prompt for the given tier
+ */
+export const getCodeReviewModePrompt = (tier: ModelTier): string => {
+  const tierPrompts: Record<ModelTier, string> = {
+    fast: FAST_CODE_REVIEW_MODE,
+    balanced: BALANCED_CODE_REVIEW_MODE,
+    thorough: THOROUGH_CODE_REVIEW_MODE,
+  };
+
+  return tierPrompts[tier];
+};

src/prompts/system/modes/composer.ts

@@ -0,0 +1,185 @@
+/**
+ * Mode Composer
+ *
+ * Composes tier-aware system prompts with mode-specific overlays.
+ * This is the main entry point for generating complete system prompts.
+ */
+
+import type { ModelTier, ModelProvider, PromptContext, ModelParams } from "@prompts/system/builder";
+import { buildSystemPrompt, detectModelTier, detectModelProvider, getModelParams } from "@prompts/system/builder";
+import type { PromptMode } from "@prompts/system/modes/mode-types";
+import { MODE_REGISTRY, isReadOnlyMode } from "@prompts/system/modes/mode-types";
+import { getAskModePrompt } from "@prompts/system/modes/ask-mode";
+import { getPlanModePrompt } from "@prompts/system/modes/plan-mode";
+import { getCodeReviewModePrompt } from "@prompts/system/modes/code-review-mode";
+import { getDebugModePrompt } from "@prompts/system/modes/debug-mode";
+import { getRefactorModePrompt } from "@prompts/system/modes/refactor-mode";
+import { getImplementModePrompt } from "@prompts/system/modes/implement-mode";
+
+/**
+ * Extended prompt context with mode
+ */
+export interface ModePromptContext extends PromptContext {
+  mode?: PromptMode;
+  planContext?: string;
+  prContext?: string;
+  debugContext?: string;
+}
+
+/**
+ * Result of prompt composition
+ */
+export interface ComposedPrompt {
+  prompt: string;
+  tier: ModelTier;
+  provider: ModelProvider;
+  mode: PromptMode;
+  params: ModelParams;
+  readOnly: boolean;
+}
+
+/**
+ * Get the mode-specific prompt overlay for a tier
+ */
+const getModeOverlay = (mode: PromptMode, tier: ModelTier): string => {
+  const modeOverlays: Record<PromptMode, (tier: ModelTier) => string> = {
+    agent: () => "",  // Agent mode uses tier prompt directly
+    ask: getAskModePrompt,
+    plan: getPlanModePrompt,
+    "code-review": getCodeReviewModePrompt,
+    debug: getDebugModePrompt,
+    refactor: getRefactorModePrompt,
+    implement: getImplementModePrompt,
+  };
+
+  return modeOverlays[mode](tier);
+};
+
+/**
+ * Build context section for specific modes
+ */
+const buildModeContext = (context: ModePromptContext): string => {
+  const sections: string[] = [];
+
+  if (context.mode === "plan" && context.planContext) {
+    sections.push(`
+# Plan Context
+
+${context.planContext}`);
+  }
+
+  if (context.mode === "code-review" && context.prContext) {
+    sections.push(`
+# PR Context
+
+${context.prContext}`);
+  }
+
+  if (context.mode === "debug" && context.debugContext) {
+    sections.push(`
+# Debug Context
+
+${context.debugContext}`);
+  }
+
+  return sections.join("\n\n");
+};
+
+/**
+ * Compose a complete system prompt with tier and mode
+ */
+export const composePrompt = (context: ModePromptContext): ComposedPrompt => {
+  const mode = context.mode || "agent";
+  const tier = detectModelTier(context.modelId);
+  const provider = detectModelProvider(context.modelId);
+  const params = getModelParams(context.modelId);
+
+  // Build base tier prompt
+  const basePrompt = buildSystemPrompt(context);
+
+  // Add mode overlay
+  const modeOverlay = getModeOverlay(mode, tier);
+
+  // Add mode-specific context
+  const modeContext = buildModeContext(context);
+
+  // Compose final prompt
+  const sections = [basePrompt];
+
+  if (modeOverlay) {
+    sections.push(modeOverlay);
+  }
+
+  if (modeContext) {
+    sections.push(modeContext);
+  }
+
+  // Add mode indicator
+  const modeIndicator = `
+# Current Mode
+
+Mode: ${mode}
+Read-only: ${isReadOnlyMode(mode) ? "Yes" : "No"}`;
+
+  sections.push(modeIndicator);
+
+  return {
+    prompt: sections.filter(Boolean).join("\n\n"),
+    tier,
+    provider,
+    mode,
+    params,
+    readOnly: isReadOnlyMode(mode),
+  };
+};
+
+/**
+ * Quick compose for common use cases
+ */
+export const composeAgentPrompt = (context: PromptContext): ComposedPrompt => {
+  return composePrompt({ ...context, mode: "agent" });
+};
+
+export const composeAskPrompt = (context: PromptContext): ComposedPrompt => {
+  return composePrompt({ ...context, mode: "ask" });
+};
+
+export const composePlanPrompt = (context: PromptContext, planContext?: string): ComposedPrompt => {
+  return composePrompt({ ...context, mode: "plan", planContext });
+};
+
+export const composeCodeReviewPrompt = (context: PromptContext, prContext?: string): ComposedPrompt => {
+  return composePrompt({ ...context, mode: "code-review", prContext });
+};
+
+export const composeDebugPrompt = (context: PromptContext, debugContext?: string): ComposedPrompt => {
+  return composePrompt({ ...context, mode: "debug", debugContext });
+};
+
+export const composeRefactorPrompt = (context: PromptContext): ComposedPrompt => {
+  return composePrompt({ ...context, mode: "refactor" });
+};
+
+export const composeImplementPrompt = (context: PromptContext, planContext?: string): ComposedPrompt => {
+  return composePrompt({ ...context, mode: "implement", planContext });
+};
+
+/**
+ * Get mode metadata for UI/logging
+ */
+export const getModeInfo = (mode: PromptMode) => {
+  return MODE_REGISTRY[mode];
+};
+
+/**
+ * Recommend a model tier for a mode
+ */
+export const recommendTierForMode = (mode: PromptMode): "fast" | "balanced" | "thorough" => {
+  const preferred = MODE_REGISTRY[mode].preferredTier;
+
+  if (preferred === "any") {
+    return "balanced";
+  }
+
+  return preferred;
+};

src/prompts/system/modes/debug-mode.ts

@@ -0,0 +1,177 @@
+/**
+ * Debug Mode Overlay
+ *
+ * Tier-aware prompts for debugging tasks.
+ */
+
+import type { ModelTier } from "@prompts/system/builder";
+
+/**
+ * Fast tier debug mode - quick diagnosis
+ */
+const FAST_DEBUG_MODE = `## Debug Mode (Fast)
+
+You are debugging an issue. Find and fix quickly.
+
+### Quick Debug Process
+
+1. **Read the error** - Understand what went wrong
+2. **Find the location** - Go to the file:line
+3. **Check the cause** - Look for common issues:
+   - Null/undefined
+   - Missing await
+   - Wrong comparison
+   - Type mismatch
+4. **Fix it** - Make the minimal change
+5. **Verify** - Run type check or tests
+
+### Common Fixes
+- Add null check: \`value?.property\`
+- Add await: \`await asyncFunction()\`
+- Fix comparison: \`===\` instead of \`==\`
+- Add type guard: \`if (isType(value))\``;
+
+/**
+ * Balanced tier debug mode - systematic debugging
+ */
+const BALANCED_DEBUG_MODE = `## Debug Mode (Balanced)
+
+You are debugging systematically. Understand before fixing.
+
+### Debugging Workflow
+
+**Step 1: Gather Information**
+\`\`\`
+<thinking>
+Error: [the error message or symptom]
+Location: [file:line if known]
+Trigger: [what causes the issue]
+</thinking>
+\`\`\`
+
+**Step 2: Reproduce**
+- Understand the steps that cause the error
+- Identify the input/state that triggers it
+
+**Step 3: Isolate**
+- Narrow to the specific function or block
+- Check recent changes
+- Look at connected code
+
+**Step 4: Analyze Root Cause**
+\`\`\`
+<thinking>
+Observation: [what I found]
+Root cause: [why it happens]
+Fix approach: [how to fix it]
+</thinking>
+\`\`\`
+
+Common issues:
+- Null/undefined access
+- Type mismatches
+- Race conditions
+- Missing error handling
+- Off-by-one errors
+
+**Step 5: Fix**
+- Make the minimal change needed
+- Add error handling if missing
+- Consider edge cases
+
+**Step 6: Verify**
+- Run type check: \`tsc --noEmit\`
+- Run tests if available
+- Check for regressions
+
+### Don't
+- Don't guess at fixes without understanding
+- Don't make unrelated changes
+- Don't modify tests to pass (unless test is wrong)`;
+
+/**
+ * Thorough tier debug mode - comprehensive analysis
+ */
+const THOROUGH_DEBUG_MODE = `## Debug Mode (Thorough)
+
+You are conducting comprehensive debugging with root cause analysis.
+
+### Deep Debugging Process
+
+**Phase 1: Evidence Collection**
+Gather all relevant information:
+- Error messages and stack traces
+- Affected files and functions
+- Recent changes in the area
+- Related test files
+
+**Phase 2: Hypothesis Formation**
+\`\`\`
+<analysis>
+## Observed Behavior
+[What happens vs what should happen]
+
+## Potential Causes
+1. [Hypothesis 1] - [evidence for/against]
+2. [Hypothesis 2] - [evidence for/against]
+
+## Most Likely Cause
+[Based on evidence]
+</analysis>
+\`\`\`
+
+**Phase 3: Root Cause Verification**
+- Trace the execution path
+- Verify the hypothesis with code inspection
+- Check if the issue exists elsewhere
+
+**Phase 4: Fix Design**
+\`\`\`
+<thinking>
+Root cause: [confirmed cause]
+Fix strategy: [approach]
+Files to modify: [list]
+Risk assessment: [potential side effects]
+</thinking>
+\`\`\`
+
+**Phase 5: Implementation**
+- Apply the minimal fix
+- Add appropriate error handling
+- Consider defensive coding
+
+**Phase 6: Comprehensive Verification**
+- Type check
+- Run affected tests
+- Run related tests
+- Check for similar issues elsewhere
+
+### Bug Pattern Reference
+
+| Pattern | Symptoms | Fix |
+|---------|----------|-----|
+| Null deref | "Cannot read X of undefined" | Add null check |
+| Race condition | Intermittent failures | Add await/lock |
+| Type mismatch | Unexpected behavior | Fix types |
+| Off-by-one | Wrong item selected | Adjust index |
+| Stale closure | Old value used | Use ref or deps |
+| Missing await | Promise returned | Add await |
+
+### Debugging Tools
+- Add logging: \`console.log('[DEBUG]', { vars })\`
+- Use debugger statement
+- Check network tab for API issues
+- Use profiler for performance bugs`;
+
+/**
+ * Get debug mode prompt for the given tier
+ */
+export const getDebugModePrompt = (tier: ModelTier): string => {
+  const tierPrompts: Record<ModelTier, string> = {
+    fast: FAST_DEBUG_MODE,
+    balanced: BALANCED_DEBUG_MODE,
+    thorough: THOROUGH_DEBUG_MODE,
+  };
+
+  return tierPrompts[tier];
+};

src/prompts/system/modes/implement-mode.ts

@@ -0,0 +1,164 @@
+/**
+ * Implement Mode Overlay
+ *
+ * Tier-aware prompts for implementation after plan approval.
+ */
+
+import type { ModelTier } from "@prompts/system/builder";
+
+/**
+ * Fast tier implement mode - direct execution
+ */
+const FAST_IMPLEMENT_MODE = `## Implement Mode (Fast)
+
+The plan has been approved. Execute directly.
+
+### Implementation Process
+
+1. Follow the plan steps in order
+2. Make one change at a time
+3. Verify after each change
+4. Report progress briefly
+
+### Execution Rules
+- Stick to the approved plan
+- Don't add features not in the plan
+- Verify: \`tsc --noEmit\` or tests
+- Report completion status`;
+
+/**
+ * Balanced tier implement mode - methodical execution
+ */
+const BALANCED_IMPLEMENT_MODE = `## Implement Mode (Balanced)
+
+The plan has been approved. Execute systematically.
+
+### Implementation Workflow
+
+**Step 1: Review Plan**
+Confirm understanding of the approved plan.
+
+**Step 2: Execute Steps**
+For each step in the plan:
+\`\`\`
+<progress>
+Step: [N of M]
+Action: [what I'm doing]
+File: [file being modified]
+</progress>
+\`\`\`
+
+**Step 3: Verify Each Change**
+- Run type check
+- Run relevant tests
+- Confirm behavior
+
+**Step 4: Report Completion**
+- Summary of what was done
+- Any deviations from plan (with justification)
+- Verification results
+
+### Execution Rules
+- Follow the approved plan exactly
+- If issues arise, report before deviating
+- Verify after each logical change
+- Keep changes atomic and reviewable`;
+
+/**
+ * Thorough tier implement mode - comprehensive execution
+ */
+const THOROUGH_IMPLEMENT_MODE = `## Implement Mode (Thorough)
+
+The plan has been approved. Execute with full autonomy.
+
+### Autonomous Implementation
+
+You have FULL AUTONOMY to execute the approved plan:
+- Make all necessary changes
+- Handle edge cases discovered during implementation
+- Add appropriate error handling
+- Write tests as you go
+
+### Multi-Phase Execution
+
+**Phase 1: Setup**
+\`\`\`
+<progress phase="setup">
+Preparing for implementation:
+- Reviewing affected files
+- Confirming test infrastructure
+- Setting up any required scaffolding
+</progress>
+\`\`\`
+
+**Phase 2: Core Implementation**
+Execute plan steps, potentially in parallel:
+\`\`\`
+<progress phase="core" step="N/M">
+Implementing: [step description]
+Files: [files being modified]
+Status: [in_progress/complete]
+</progress>
+\`\`\`
+
+**Phase 3: Edge Cases & Polish**
+- Handle edge cases discovered
+- Add error handling
+- Ensure type safety
+
+**Phase 4: Testing**
+\`\`\`
+<progress phase="testing">
+Running verification:
+- Type check: [result]
+- Unit tests: [result]
+- Integration: [result]
+</progress>
+\`\`\`
+
+**Phase 5: Final Report**
+\`\`\`
+<complete>
+## Implementation Complete
+
+### Changes Made
+- [File 1]: [summary of changes]
+- [File 2]: [summary of changes]
+
+### Verification
+- Type check: ✓
+- Tests: ✓ (X passed)
+
+### Deviations from Plan
+- [Any changes made and why, or "None"]
+
+### Next Steps
+- [Suggestions if any]
+</complete>
+\`\`\`
+
+### Deviation Protocol
+If the plan needs adjustment:
+1. Complete what can be done
+2. Report the blocking issue
+3. Suggest alternatives
+4. Wait for approval to deviate
+
+### Quality Standards
+- All changes must pass type check
+- Tests must pass
+- No regressions introduced
+- Code follows existing patterns`;
+
+/**
+ * Get implement mode prompt for the given tier
+ */
+export const getImplementModePrompt = (tier: ModelTier): string => {
+  const tierPrompts: Record<ModelTier, string> = {
+    fast: FAST_IMPLEMENT_MODE,
+    balanced: BALANCED_IMPLEMENT_MODE,
+    thorough: THOROUGH_IMPLEMENT_MODE,
+  };
+
+  return tierPrompts[tier];
+};

src/prompts/system/modes/mode-types.ts

@@ -0,0 +1,104 @@
+/**
+ * Mode Types for System Prompts
+ *
+ * Defines the available modes and their tier compatibility.
+ */
+
+/**
+ * Available prompt modes
+ */
+export type PromptMode =
+  | "agent"      // Default autonomous mode
+  | "ask"        // Read-only Q&A mode
+  | "plan"       // Planning mode with approval
+  | "code-review"// Code review mode
+  | "debug"      // Debugging mode
+  | "refactor"   // Refactoring mode
+  | "implement"; // Implementation mode (after plan approval)
+
+/**
+ * Mode metadata for routing
+ */
+export interface ModeMetadata {
+  name: PromptMode;
+  readOnly: boolean;
+  requiresApproval: boolean;
+  preferredTier: "fast" | "balanced" | "thorough" | "any";
+  description: string;
+}
+
+/**
+ * Mode registry with metadata
+ */
+export const MODE_REGISTRY: Record<PromptMode, ModeMetadata> = {
+  agent: {
+    name: "agent",
+    readOnly: false,
+    requiresApproval: false,
+    preferredTier: "any",
+    description: "Autonomous coding agent with full tool access",
+  },
+  ask: {
+    name: "ask",
+    readOnly: true,
+    requiresApproval: false,
+    preferredTier: "fast",
+    description: "Read-only mode for answering questions about code",
+  },
+  plan: {
+    name: "plan",
+    readOnly: true,
+    requiresApproval: true,
+    preferredTier: "balanced",
+    description: "Planning mode for designing implementation approaches",
+  },
+  "code-review": {
+    name: "code-review",
+    readOnly: true,
+    requiresApproval: false,
+    preferredTier: "balanced",
+    description: "Thorough code review with structured feedback",
+  },
+  debug: {
+    name: "debug",
+    readOnly: false,
+    requiresApproval: false,
+    preferredTier: "balanced",
+    description: "Systematic debugging with root cause analysis",
+  },
+  refactor: {
+    name: "refactor",
+    readOnly: false,
+    requiresApproval: false,
+    preferredTier: "balanced",
+    description: "Code refactoring preserving behavior",
+  },
+  implement: {
+    name: "implement",
+    readOnly: false,
+    requiresApproval: false,
+    preferredTier: "any",
+    description: "Implementation mode after plan approval",
+  },
+};
+
+/**
+ * Check if a mode is read-only
+ */
+export const isReadOnlyMode = (mode: PromptMode): boolean => {
+  return MODE_REGISTRY[mode].readOnly;
+};
+
+/**
+ * Check if a mode requires user approval
+ */
+export const requiresApproval = (mode: PromptMode): boolean => {
+  return MODE_REGISTRY[mode].requiresApproval;
+};
+
+/**
+ * Get the preferred tier for a mode
+ */
+export const getPreferredTier = (mode: PromptMode): "fast" | "balanced" | "thorough" | "any" => {
+  return MODE_REGISTRY[mode].preferredTier;
+};

src/prompts/system/modes/plan-mode.ts

@@ -0,0 +1,255 @@
+/**
+ * Plan Mode Overlay
+ *
+ * Tier-aware prompts for planning with approval workflow.
+ */
+
+import type { ModelTier } from "@prompts/system/builder";
+
+/**
+ * Fast tier plan mode - simple task breakdown
+ */
+const FAST_PLAN_MODE = `## Plan Mode (Fast)
+
+You are in PLANNING mode. Create a simple, actionable plan.
+
+### Planning Process
+
+1. **List files to modify** - What needs to change
+2. **Order the changes** - What order to make them
+3. **Describe each step** - What to do
+
+### Plan Format
+
+\`\`\`markdown
+# Plan: [Task]
+
+## Files
+- file1.ts - [change]
+- file2.ts - [change]
+
+## Steps
+1. [First step]
+2. [Second step]
+3. [Verify]
+\`\`\`
+
+### Rules
+- NO code edits in plan mode
+- Read files to understand context
+- Keep plan simple and direct
+- Signal when ready for approval`;
+
+/**
+ * Balanced tier plan mode - structured planning with rationale
+ */
+const BALANCED_PLAN_MODE = `## Plan Mode (Balanced)
+
+You are in PLANNING mode. Design a detailed, actionable plan.
+
+### Planning Workflow
+
+**Phase 1: Understanding**
+1. Explore the codebase to understand architecture
+2. Read relevant files to understand patterns
+3. Identify scope of changes
+
+**Phase 2: Design**
+1. List affected files and components
+2. Consider alternatives and trade-offs
+3. Choose the best approach
+
+**Phase 3: Document**
+Write a structured plan.
+
+### Plan Format
+
+\`\`\`markdown
+# Implementation Plan: [Feature Name]
+
+## Summary
+[1-2 sentence description]
+
+## Approach
+[Chosen solution and why]
+
+## Files to Modify
+- \`path/to/file.ts\` - [describe changes]
+
+## New Files (if any)
+- \`path/to/new.ts\` - [purpose]
+
+## Steps
+1. [First step]
+2. [Second step]
+3. [Verification step]
+
+## Testing
+- [ ] How to verify step 1
+- [ ] How to verify step 2
+
+## Risks
+- [Potential issue and mitigation]
+\`\`\`
+
+### Rules
+- NO code edits or non-read-only tools
+- Be specific - each step should be clear
+- Break large changes into small steps
+- Prefer minimal changes over rewrites
+- Signal completion for approval`;
+
+/**
+ * Thorough tier plan mode - comprehensive planning with analysis
+ */
+const THOROUGH_PLAN_MODE = `## Plan Mode (Thorough)
+
+You are in PLANNING mode with advanced analysis capabilities.
+
+### Comprehensive Planning Process
+
+**Phase 1: Deep Exploration**
+Launch parallel exploration:
+- Agent 1: Map affected files and dependencies
+- Agent 2: Understand existing patterns
+- Agent 3: Check test coverage and constraints
+
+Synthesize findings before proceeding.
+
+**Phase 2: Architecture Analysis**
+\`\`\`
+<analysis>
+## Current State
+[How the system works now]
+
+## Proposed Changes
+[What needs to change and why]
+
+## Impact Assessment
+[What else might be affected]
+
+## Alternatives Considered
+[Other approaches and why this one was chosen]
+</analysis>
+\`\`\`
+
+**Phase 3: Detailed Plan**
+
+### Plan Document Format
+
+\`\`\`markdown
+# Implementation Plan: [Feature Name]
+
+## Executive Summary
+[1-2 sentence overview]
+
+## Context Analysis
+
+### Files Analyzed
+- \`path/to/file.ts\`: [purpose and relevance]
+
+### Current Architecture
+[Brief description of existing patterns]
+
+### Dependencies
+- [External dependency 1]
+- [Internal module 1]
+
+## Implementation Strategy
+
+### Phase 1: [Name]
+**Objective**: [Goal]
+**Files affected**: [list]
+**Changes**:
+1. [Specific change]
+2. [Specific change]
+
+### Phase 2: [Name]
+...
+
+## Risk Assessment
+| Risk | Impact | Mitigation |
+|------|--------|------------|
+| [Risk 1] | [High/Med/Low] | [Strategy] |
+
+## Testing Strategy
+- Unit tests: [approach]
+- Integration tests: [approach]
+- Manual verification: [steps]
+
+## Rollback Plan
+[How to undo if needed]
+
+---
+**Awaiting approval to proceed with implementation.**
+\`\`\`
+
+### Approval Workflow
+1. Generate comprehensive plan
+2. Present with "Awaiting approval"
+3. User can:
+   - Approve: "proceed", "go ahead", "looks good"
+   - Modify: "change X to Y"
+   - Reject: "stop", "don't do this"
+4. On approval, switch to implementation with full autonomy
+
+### Rules
+- NO code edits in plan mode
+- Explore thoroughly before planning
+- Consider edge cases and risks
+- Plan for testability`;
+
+/**
+ * Get plan mode prompt for the given tier
+ */
+export const getPlanModePrompt = (tier: ModelTier): string => {
+  const tierPrompts: Record<ModelTier, string> = {
+    fast: FAST_PLAN_MODE,
+    balanced: BALANCED_PLAN_MODE,
+    thorough: THOROUGH_PLAN_MODE,
+  };
+
+  return tierPrompts[tier];
+};
+
+/**
+ * Plan approval detection patterns
+ */
+export const APPROVAL_PATTERNS = [
+  "proceed",
+  "go ahead",
+  "looks good",
+  "approved",
+  "lgtm",
+  "ship it",
+  "do it",
+  "yes",
+  "ok",
+  "continue",
+  "start",
+  "implement",
+  "execute",
+];
+
+export const REJECTION_PATTERNS = [
+  "stop",
+  "don't",
+  "cancel",
+  "abort",
+  "no",
+  "wait",
+  "hold",
+  "reject",
+  "not yet",
+];
+
+export const MODIFICATION_PATTERNS = [
+  "change",
+  "modify",
+  "update",
+  "instead",
+  "but",
+  "however",
+  "rather",
+  "prefer",
+];

src/prompts/system/modes/refactor-mode.ts

@@ -0,0 +1,221 @@
+/**
+ * Refactor Mode Overlay
+ *
+ * Tier-aware prompts for refactoring tasks.
+ */
+
+import type { ModelTier } from "@prompts/system/builder";
+
+/**
+ * Fast tier refactor mode - simple refactorings
+ */
+const FAST_REFACTOR_MODE = `## Refactor Mode (Fast)
+
+You are refactoring code. Change structure, preserve behavior.
+
+### Simple Refactoring Steps
+
+1. **Understand** - Read the code first
+2. **Identify** - What specific improvement?
+3. **Change** - One refactoring at a time
+4. **Verify** - Run type check / tests
+
+### Common Refactorings
+- Extract function: Move repeated code to a function
+- Rename: Use clearer names
+- Simplify: Use early returns to reduce nesting
+- Extract constant: Replace magic values
+
+### Rules
+- Behavior MUST stay the same
+- Don't change public interfaces
+- Verify after each change`;
+
+/**
+ * Balanced tier refactor mode - structured refactoring
+ */
+const BALANCED_REFACTOR_MODE = `## Refactor Mode (Balanced)
+
+You are refactoring code. Transform structure, preserve behavior.
+
+### Core Principle
+**Refactoring changes HOW code works, not WHAT it does.**
+
+### Refactoring Process
+
+**Step 1: Understand**
+\`\`\`
+<thinking>
+Current code: [what it does]
+Problem: [why refactor?]
+Goal: [desired outcome]
+</thinking>
+\`\`\`
+
+**Step 2: Plan**
+- Identify the specific refactoring
+- Check if tests exist
+- Break into atomic steps
+
+**Step 3: Execute**
+One refactoring at a time:
+
+| Refactoring | When to Use |
+|-------------|-------------|
+| Extract function | Repeated code, needs a name |
+| Extract variable | Complex expression |
+| Inline | Function is trivial wrapper |
+| Replace conditional with polymorphism | Switch on type |
+| Replace magic values | Literals with meaning |
+| Simplify conditionals | Deep nesting |
+
+**Step 4: Verify**
+- Run \`tsc --noEmit\`
+- Run tests
+- Check for regressions
+
+### Code Smells to Address
+- Long functions (> 30 lines)
+- Deep nesting (> 3 levels)
+- Long parameter lists (> 4 params)
+- Duplicate code
+- Primitive obsession
+
+### Safety Rules
+- One refactoring per commit
+- Run tests after each change
+- Don't mix refactoring with features
+- Keep changes reversible`;
+
+/**
+ * Thorough tier refactor mode - comprehensive refactoring
+ */
+const THOROUGH_REFACTOR_MODE = `## Refactor Mode (Thorough)
+
+You are conducting comprehensive refactoring with architectural awareness.
+
+### Deep Refactoring Process
+
+**Phase 1: Code Analysis**
+\`\`\`
+<analysis>
+## Current State
+[Code structure and patterns]
+
+## Code Smells Identified
+- [Smell 1]: Location, severity
+- [Smell 2]: Location, severity
+
+## Dependencies
+[What depends on this code]
+
+## Test Coverage
+[Existing tests that verify behavior]
+</analysis>
+\`\`\`
+
+**Phase 2: Refactoring Plan**
+\`\`\`
+<plan>
+## Goal
+[What improvement we're making]
+
+## Refactorings (in order)
+1. [Refactoring 1] - [target] - [rationale]
+2. [Refactoring 2] - [target] - [rationale]
+
+## Risks
+- [Risk and mitigation]
+
+## Verification Strategy
+- [How to verify each step]
+</plan>
+\`\`\`
+
+**Phase 3: Systematic Execution**
+For each refactoring:
+1. Apply the change
+2. Verify types: \`tsc --noEmit\`
+3. Run tests
+4. Confirm behavior unchanged
+
+### Refactoring Catalog
+
+#### Extract Function
+\`\`\`typescript
+// Before
+function process(data) {
+  // validation
+  // transformation
+  // save
+}
+
+// After
+function process(data) {
+  validate(data);
+  const result = transform(data);
+  save(result);
+}
+\`\`\`
+
+#### Replace Conditional with Polymorphism
+\`\`\`typescript
+// Before
+function getArea(shape) {
+  if (shape.type === 'circle') return Math.PI * shape.radius ** 2;
+  if (shape.type === 'rectangle') return shape.width * shape.height;
+}
+
+// After
+interface Shape { getArea(): number; }
+class Circle implements Shape { getArea() { return Math.PI * this.radius ** 2; } }
+\`\`\`
+
+#### Simplify with Guard Clauses
+\`\`\`typescript
+// Before
+function getDiscount(user) {
+  if (user.isPremium) {
+    if (user.years > 5) {
+      return 0.3;
+    } else {
+      return 0.2;
+    }
+  }
+  return 0;
+}
+
+// After
+function getDiscount(user) {
+  if (!user.isPremium) return 0;
+  if (user.years > 5) return 0.3;
+  return 0.2;
+}
+\`\`\`
+
+### Complexity Thresholds
+| Metric | Threshold | Action |
+|--------|-----------|--------|
+| Function length | > 50 lines | Extract functions |
+| File length | > 300 lines | Split file |
+| Cyclomatic complexity | > 10 | Simplify logic |
+| Nesting depth | > 3 | Use guard clauses |
+
+### Don't
+- Don't refactor and add features simultaneously
+- Don't refactor without understanding first
+- Don't refactor untested code (add tests first)
+- Don't over-engineer`;
+
+/**
+ * Get refactor mode prompt for the given tier
+ */
+export const getRefactorModePrompt = (tier: ModelTier): string => {
+  const tierPrompts: Record<ModelTier, string> = {
+    fast: FAST_REFACTOR_MODE,
+    balanced: BALANCED_REFACTOR_MODE,
+    thorough: THOROUGH_REFACTOR_MODE,
+  };
+
+  return tierPrompts[tier];
+};

src/prompts/system/providers/anthropic.ts

@@ -0,0 +1,185 @@
+/**
+ * Anthropic Provider-Specific Prompt Enhancements
+ *
+ * Models: Claude Haiku, Sonnet, Opus
+ *
+ * Claude models work best with:
+ * - XML-style structured blocks
+ * - Explicit thinking blocks
+ * - Artifact generation
+ * - Extended context windows
+ */
+
+export const ANTHROPIC_TOOL_PATTERNS = `## Claude Tool Usage Patterns
+
+### Structured Blocks
+Claude responds well to XML-style structure:
+\`\`\`
+<thinking>
+Analyzing the request...
+</thinking>
+
+<plan>
+1. First step
+2. Second step
+</plan>
+
+<execute>
+[tool calls here]
+</execute>
+\`\`\`
+
+### Tool Use
+- Claude can call multiple tools in sequence
+- Each tool result is processed before continuing
+- Use <result> blocks to summarize tool outputs
+
+### Extended Thinking (Opus)
+For Claude Opus, extended thinking is available:
+\`\`\`
+<extended_thinking>
+Deep analysis of the problem space...
+Considering multiple approaches...
+Evaluating trade-offs...
+</extended_thinking>
+\`\`\``;
+
+export const ANTHROPIC_CONTEXT_PATTERNS = `## Claude Context Handling
+
+### Large Context Windows
+Claude has 200K token context:
+- Can read entire codebases
+- Maintains consistency across long conversations
+- Use for complex multi-file understanding
+
+### Context Organization
+Structure context clearly:
+\`\`\`
+<context>
+  <file path="src/main.ts">
+    [file contents]
+  </file>
+  <file path="src/utils.ts">
+    [file contents]
+  </file>
+</context>
+\`\`\`
+
+### Memory Across Turns
+Claude maintains conversation context:
+- Reference previous findings by turn number
+- Build on earlier analysis
+- Avoid re-reading files unnecessarily`;
+
+export const ANTHROPIC_BEST_PRACTICES = `## Claude Best Practices
+
+### Prompt Structure
+Claude responds well to:
+1. Clear role definition
+2. Explicit constraints
+3. Structured output format
+4. Examples with XML blocks
+
+### Thinking Style
+- Use <thinking> for reasoning
+- Be thorough in analysis
+- Consider edge cases
+- Explain trade-offs
+
+### Response Quality
+Claude tends to:
+- Be more verbose - ask for conciseness
+- Over-explain - request brevity
+- Be cautious - encourage action
+
+### Model-Specific Notes
+
+**Haiku**: Fast but limited reasoning
+- Keep tasks simple
+- Break down complex requests
+- Verify outputs carefully
+
+**Sonnet**: Balanced performance
+- Good for most coding tasks
+- Can handle multi-file changes
+- Reliable tool usage
+
+**Opus**: Advanced reasoning
+- Complex architectural decisions
+- Deep codebase analysis
+- Multi-agent coordination`;
+
+/**
+ * Build Anthropic-specific enhancements
+ */
+export const buildAnthropicEnhancements = (): string => {
+  return [
+    ANTHROPIC_TOOL_PATTERNS,
+    ANTHROPIC_CONTEXT_PATTERNS,
+    ANTHROPIC_BEST_PRACTICES,
+  ].join("\n\n");
+};
+
+/**
+ * Check if model is from Anthropic
+ */
+export const isAnthropicModel = (modelId: string): boolean => {
+  const lowerModel = modelId.toLowerCase();
+  return (
+    lowerModel.includes("claude") ||
+    lowerModel.includes("anthropic") ||
+    lowerModel.includes("haiku") ||
+    lowerModel.includes("sonnet") ||
+    lowerModel.includes("opus")
+  );
+};
+
+/**
+ * Get Anthropic-specific parameters
+ */
+export const getAnthropicParams = (modelId: string): {
+  temperature: number;
+  topP: number;
+  topK: number;
+  maxTokens: number;
+} => {
+  const lowerModel = modelId.toLowerCase();
+
+  // Opus - extended thinking
+  if (lowerModel.includes("opus")) {
+    return {
+      temperature: 0.3,
+      topP: 0.95,
+      topK: 50,
+      maxTokens: 8192,
+    };
+  }
+
+  // Sonnet - balanced
+  if (lowerModel.includes("sonnet")) {
+    return {
+      temperature: 0.2,
+      topP: 0.95,
+      topK: 40,
+      maxTokens: 4096,
+    };
+  }
+
+  // Haiku - fast
+  if (lowerModel.includes("haiku")) {
+    return {
+      temperature: 0.1,
+      topP: 0.9,
+      topK: 30,
+      maxTokens: 2048,
+    };
+  }
+
+  // Default
+  return {
+    temperature: 0.2,
+    topP: 0.95,
+    topK: 40,
+    maxTokens: 4096,
+  };
+};

src/prompts/system/providers/copilot.ts

@@ -0,0 +1,175 @@
+/**
+ * GitHub Copilot Provider-Specific Prompt Enhancements
+ *
+ * Copilot provides access to multiple model families through a unified interface.
+ * This file handles Copilot-specific patterns and model cost optimization.
+ */
+
+/**
+ * Copilot model cost tiers
+ */
+export const COPILOT_MODEL_TIERS = {
+  // Unlimited (0x) - no rate limiting
+  unlimited: [
+    "gpt-4o",
+    "gpt-4o-mini",
+    "gpt-5-mini",
+    "grok-code-fast-1",
+    "raptor-mini",
+  ],
+
+  // Low cost (0.33x)
+  lowCost: [
+    "claude-haiku-4.5",
+    "gemini-3-flash-preview",
+    "gpt-5.1-codex-mini-preview",
+  ],
+
+  // Standard (1.0x)
+  standard: [
+    "claude-sonnet-4",
+    "claude-sonnet-4.5",
+    "gemini-2.5-pro",
+    "gemini-3-pro-preview",
+    "gpt-4.1",
+    "gpt-5",
+    "gpt-5-codex-preview",
+    "gpt-5.1",
+    "gpt-5.1-codex",
+    "gpt-5.1-codex-max",
+    "gpt-5.2",
+    "gpt-5.2-codex",
+  ],
+
+  // Premium (3.0x)
+  premium: [
+    "claude-opus-4.5",
+  ],
+} as const;
+
+export const COPILOT_TOOL_PATTERNS = `## Copilot Tool Usage Patterns
+
+### Model Selection
+Copilot provides multiple models with different cost/capability trade-offs:
+- **Unlimited**: gpt-4o, gpt-4o-mini, gpt-5-mini - no rate limits
+- **Low cost**: claude-haiku-4.5, gemini-3-flash - efficient
+- **Standard**: claude-sonnet, gemini-pro, gpt-5 - capable
+- **Premium**: claude-opus - maximum capability
+
+### Function Calling
+All Copilot models support function calling:
+- Structured tool calls
+- Parallel tool execution
+- JSON argument parsing
+
+### Context Handling
+Copilot manages context automatically:
+- Current file context
+- Workspace context
+- Recent conversation history`;
+
+export const COPILOT_BEST_PRACTICES = `## Copilot Best Practices
+
+### Model Recommendations by Task
+
+| Task Type | Recommended Model | Reason |
+|-----------|------------------|--------|
+| Simple edits | gpt-4o-mini | Fast, unlimited |
+| Code generation | gpt-4o | Balanced, unlimited |
+| Complex reasoning | claude-sonnet-4.5 | High quality |
+| Architecture | claude-opus-4.5 | Best reasoning |
+
+### Efficiency Tips
+- Use unlimited models for iterative work
+- Reserve premium models for complex decisions
+- Batch simple changes to reduce API calls
+
+### Code Style
+Copilot models:
+- Follow project conventions when visible
+- Match existing code patterns
+- Use TypeScript types from context`;
+
+/**
+ * Build Copilot-specific enhancements
+ */
+export const buildCopilotEnhancements = (): string => {
+  return [
+    COPILOT_TOOL_PATTERNS,
+    COPILOT_BEST_PRACTICES,
+  ].join("\n\n");
+};
+
+/**
+ * Check if model is accessed through Copilot
+ */
+export const isCopilotModel = (modelId: string): boolean => {
+  const allModels = [
+    ...COPILOT_MODEL_TIERS.unlimited,
+    ...COPILOT_MODEL_TIERS.lowCost,
+    ...COPILOT_MODEL_TIERS.standard,
+    ...COPILOT_MODEL_TIERS.premium,
+  ];
+
+  const lowerModel = modelId.toLowerCase();
+  return allModels.some(m => lowerModel.includes(m.toLowerCase()));
+};
+
+/**
+ * Get cost tier for a Copilot model
+ */
+export const getCopilotCostTier = (modelId: string): "unlimited" | "lowCost" | "standard" | "premium" | "unknown" => {
+  const lowerModel = modelId.toLowerCase();
+
+  if (COPILOT_MODEL_TIERS.unlimited.some(m => lowerModel.includes(m.toLowerCase()))) {
+    return "unlimited";
+  }
+  if (COPILOT_MODEL_TIERS.lowCost.some(m => lowerModel.includes(m.toLowerCase()))) {
+    return "lowCost";
+  }
+  if (COPILOT_MODEL_TIERS.standard.some(m => lowerModel.includes(m.toLowerCase()))) {
+    return "standard";
+  }
+  if (COPILOT_MODEL_TIERS.premium.some(m => lowerModel.includes(m.toLowerCase()))) {
+    return "premium";
+  }
+
+  return "unknown";
+};
+
+/**
+ * Get Copilot-specific parameters
+ */
+export const getCopilotParams = (modelId: string): {
+  temperature: number;
+  topP: number;
+  maxTokens: number;
+} => {
+  const costTier = getCopilotCostTier(modelId);
+  const lowerModel = modelId.toLowerCase();
+
+  // Premium models - allow more tokens, lower temperature for precision
+  if (costTier === "premium" || lowerModel.includes("opus")) {
+    return {
+      temperature: 0.2,
+      topP: 0.95,
+      maxTokens: 8192,
+    };
+  }
+
+  // Standard models - balanced settings
+  if (costTier === "standard") {
+    return {
+      temperature: 0.3,
+      topP: 0.95,
+      maxTokens: 4096,
+    };
+  }
+
+  // Unlimited/low-cost models - faster, more efficient
+  return {
+    temperature: 0.2,
+    topP: 0.9,
+    maxTokens: 2048,
+  };
+};

src/prompts/system/providers/google.ts

@@ -0,0 +1,195 @@
+/**
+ * Google Provider-Specific Prompt Enhancements
+ *
+ * Models: Gemini Flash, Pro, Ultra
+ *
+ * Gemini models work best with:
+ * - Multi-modal understanding
+ * - Grounded responses
+ * - Long context handling
+ * - Code execution capabilities
+ */
+
+export const GOOGLE_TOOL_PATTERNS = `## Gemini Tool Usage Patterns
+
+### Function Calling
+Gemini supports structured function calling:
+- Define tools with clear schemas
+- Use grounding for factual responses
+- Leverage code execution when available
+
+### Multi-Modal Capabilities
+Gemini can process:
+- Code files and syntax
+- Documentation and diagrams (if provided)
+- Error messages and logs
+
+### Grounding
+For factual queries:
+- Use Google Search grounding when available
+- Cite sources when making claims
+- Distinguish between knowledge and inference`;
+
+export const GOOGLE_CONTEXT_PATTERNS = `## Gemini Context Handling
+
+### Long Context (1M+ tokens)
+Gemini Pro supports very long contexts:
+- Can process entire repositories
+- Maintains coherence across many files
+- Use for comprehensive codebase analysis
+
+### Context Structure
+Organize context effectively:
+\`\`\`
+## Project Structure
+[directory tree]
+
+## Key Files
+### src/main.ts
+[contents]
+
+### src/config.ts
+[contents]
+\`\`\`
+
+### Memory Efficiency
+Despite large context:
+- Summarize when possible
+- Focus on relevant sections
+- Use file excerpts for large files`;
+
+export const GOOGLE_BEST_PRACTICES = `## Gemini Best Practices
+
+### Prompt Structure
+Gemini responds well to:
+1. Clear, direct instructions
+2. Structured markdown
+3. Examples with expected output
+4. Step-by-step guidance
+
+### Thinking Style
+Gemini tends to:
+- Be direct and action-oriented
+- Provide complete solutions
+- Follow instructions literally
+
+### Response Quality
+
+**Flash**: Speed-optimized
+- Quick responses
+- Good for simple tasks
+- May miss nuances
+- Verify complex logic
+
+**Pro**: Balanced reasoning
+- Strong code understanding
+- Good multi-step execution
+- Reliable for most tasks
+- Can handle refactoring
+
+**Ultra**: Maximum capability
+- Deep reasoning
+- Complex problem solving
+- Architectural decisions
+- Multi-agent coordination
+
+### Code Generation Style
+Gemini generates code that:
+- Follows modern patterns
+- May be verbose - trim as needed
+- Includes type annotations
+- Often adds extra features - focus on requirements`;
+
+export const GOOGLE_SPECIFIC_NOTES = `## Gemini-Specific Notes
+
+### Temperature Guidance
+- 0.0-0.2: Deterministic code generation
+- 0.3-0.5: Balanced creativity
+- 0.7+: Exploratory solutions
+
+### Safety Settings
+Gemini has safety filters:
+- Code that handles sensitive data may need context
+- Security-related code needs clear defensive framing
+- Explain the legitimate use case upfront
+
+### Rate Limits
+Be aware of:
+- Requests per minute limits
+- Token limits per request
+- Consider batching for large operations`;
+
+/**
+ * Build Google-specific enhancements
+ */
+export const buildGoogleEnhancements = (): string => {
+  return [
+    GOOGLE_TOOL_PATTERNS,
+    GOOGLE_CONTEXT_PATTERNS,
+    GOOGLE_BEST_PRACTICES,
+    GOOGLE_SPECIFIC_NOTES,
+  ].join("\n\n");
+};
+
+/**
+ * Check if model is from Google
+ */
+export const isGoogleModel = (modelId: string): boolean => {
+  const lowerModel = modelId.toLowerCase();
+  return (
+    lowerModel.includes("gemini") ||
+    lowerModel.includes("google") ||
+    lowerModel.includes("palm") ||
+    lowerModel.includes("bard")
+  );
+};
+
+/**
+ * Get Google-specific parameters
+ */
+export const getGoogleParams = (modelId: string): {
+  temperature: number;
+  topP: number;
+  topK: number;
+  maxOutputTokens: number;
+} => {
+  const lowerModel = modelId.toLowerCase();
+
+  // Ultra - maximum capability
+  if (lowerModel.includes("ultra")) {
+    return {
+      temperature: 0.3,
+      topP: 0.95,
+      topK: 64,
+      maxOutputTokens: 8192,
+    };
+  }
+
+  // Pro - balanced
+  if (lowerModel.includes("pro")) {
+    return {
+      temperature: 0.2,
+      topP: 0.95,
+      topK: 40,
+      maxOutputTokens: 4096,
+    };
+  }
+
+  // Flash - fast
+  if (lowerModel.includes("flash")) {
+    return {
+      temperature: 0.1,
+      topP: 0.9,
+      topK: 32,
+      maxOutputTokens: 2048,
+    };
+  }
+
+  // Default
+  return {
+    temperature: 0.2,
+    topP: 0.95,
+    topK: 40,
+    maxOutputTokens: 4096,
+  };
+};

src/prompts/system/providers/ollama.ts

@@ -0,0 +1,251 @@
+/**
+ * Ollama Provider-Specific Prompt Enhancements
+ *
+ * Models: Llama, Mistral, CodeLlama, Qwen, DeepSeek, Phi
+ *
+ * Local models work best with:
+ * - Explicit, structured prompts
+ * - Simpler instructions
+ * - Clear task boundaries
+ * - Fallback handling
+ */
+
+export const OLLAMA_TOOL_PATTERNS = `## Ollama Tool Usage Patterns
+
+### Tool Calling
+Local models have varying tool support:
+- Some models support function calling natively
+- Others need tool calls formatted in the prompt
+- Verify tool support for your specific model
+
+### Structured Output
+For models without native tool support:
+\`\`\`
+To use a tool, output in this format:
+<tool_call>
+{"name": "read", "arguments": {"file_path": "src/main.ts"}}
+</tool_call>
+\`\`\`
+
+### Response Parsing
+Expect varied output formats:
+- Parse tool calls flexibly
+- Handle partial JSON
+- Retry on malformed responses`;
+
+export const OLLAMA_CONTEXT_PATTERNS = `## Ollama Context Handling
+
+### Limited Context Windows
+Most local models have smaller contexts:
+- Llama 3.1: 128K tokens
+- Mistral: 32K tokens
+- Smaller models: 4K-8K tokens
+
+### Context Optimization
+Prioritize information:
+1. Current task requirements
+2. Directly relevant code
+3. Minimal supporting context
+
+### Chunking Strategy
+For large files:
+- Read in sections
+- Summarize before proceeding
+- Focus on relevant functions`;
+
+export const OLLAMA_BEST_PRACTICES = `## Ollama Best Practices
+
+### Prompt Structure
+Local models need clearer instructions:
+1. State the task explicitly
+2. Provide examples
+3. Define expected output format
+4. Set clear boundaries
+
+### Thinking Style
+Guide reasoning explicitly:
+\`\`\`
+Before responding:
+1. Read the file
+2. Identify the issue
+3. Plan the fix
+4. Make the change
+5. Verify
+
+Now proceed step by step.
+\`\`\`
+
+### Response Quality
+
+**CodeLlama**: Code-focused
+- Strong at code completion
+- Good syntax understanding
+- May struggle with context
+
+**Llama 3.x**: General purpose
+- Balanced capabilities
+- Good instruction following
+- Reliable for most tasks
+
+**Mistral**: Efficient
+- Fast responses
+- Good code generation
+- Smaller context window
+
+**Qwen/DeepSeek**: Advanced
+- Strong reasoning
+- Good code understanding
+- May have quirks with tool calling
+
+**Phi**: Compact
+- Very fast
+- Good for simple tasks
+- Limited complex reasoning`;
+
+export const OLLAMA_SPECIFIC_NOTES = `## Ollama-Specific Notes
+
+### Performance Optimization
+Local model considerations:
+- GPU memory limits batch size
+- Longer prompts = slower responses
+- Consider streaming for better UX
+
+### Temperature Guidance
+- 0.0-0.1: Most deterministic
+- 0.2-0.4: Balanced (recommended for code)
+- 0.5+: More variation
+
+### Common Issues
+
+**Repetition**: If model repeats itself
+- Lower temperature
+- Add "Do not repeat yourself" instruction
+- Use repeat_penalty parameter
+
+**Tool Call Failures**: If tools aren't called correctly
+- Provide more examples
+- Use simpler tool schemas
+- Parse output more flexibly
+
+**Context Overflow**: If responses degrade
+- Reduce context size
+- Summarize earlier conversation
+- Focus on current task only
+
+### Model-Specific Quirks
+
+| Model | Quirk | Mitigation |
+|-------|-------|------------|
+| Llama | Verbose | Ask for brevity |
+| Mistral | Fast but shallow | Break into steps |
+| CodeLlama | Code-only | Provide context |
+| Qwen | Chinese output | English-only instruction |
+| DeepSeek | Extended thinking | Be patient |`;
+
+export const OLLAMA_FALLBACK = `## Fallback Behavior
+
+When local model struggles:
+
+1. **Simplify the task**
+   - Break into smaller steps
+   - Reduce context
+   - Be more explicit
+
+2. **Retry with guidance**
+   - Provide an example
+   - Show expected format
+   - Give starting point
+
+3. **Escalate if needed**
+   - Complex tasks may need cloud models
+   - Suggest switching providers
+   - Save progress for continuation`;
+
+/**
+ * Build Ollama-specific enhancements
+ */
+export const buildOllamaEnhancements = (): string => {
+  return [
+    OLLAMA_TOOL_PATTERNS,
+    OLLAMA_CONTEXT_PATTERNS,
+    OLLAMA_BEST_PRACTICES,
+    OLLAMA_SPECIFIC_NOTES,
+    OLLAMA_FALLBACK,
+  ].join("\n\n");
+};
+
+/**
+ * Check if model is a local Ollama model
+ */
+export const isOllamaModel = (modelId: string): boolean => {
+  const lowerModel = modelId.toLowerCase();
+  return (
+    lowerModel.includes("llama") ||
+    lowerModel.includes("mistral") ||
+    lowerModel.includes("codellama") ||
+    lowerModel.includes("qwen") ||
+    lowerModel.includes("deepseek") ||
+    lowerModel.includes("phi") ||
+    lowerModel.includes("mixtral") ||
+    lowerModel.includes("vicuna") ||
+    lowerModel.includes("orca") ||
+    lowerModel.includes("neural") ||
+    lowerModel.includes("starcoder") ||
+    lowerModel.includes("wizardcoder")
+  );
+};
+
+/**
+ * Get Ollama-specific parameters
+ */
+export const getOllamaParams = (modelId: string): {
+  temperature: number;
+  topP: number;
+  topK: number;
+  repeatPenalty: number;
+  numPredict: number;
+} => {
+  const lowerModel = modelId.toLowerCase();
+
+  // Code-focused models
+  if (lowerModel.includes("code") || lowerModel.includes("starcoder") || lowerModel.includes("wizard")) {
+    return {
+      temperature: 0.1,
+      topP: 0.9,
+      topK: 40,
+      repeatPenalty: 1.1,
+      numPredict: 2048,
+    };
+  }
+
+  // Large models (70B+)
+  if (lowerModel.includes("70b") || lowerModel.includes("72b") || lowerModel.includes("405b")) {
+    return {
+      temperature: 0.2,
+      topP: 0.95,
+      topK: 50,
+      repeatPenalty: 1.05,
+      numPredict: 4096,
+    };
+  }
+
+  // Small models (7B and under)
+  if (lowerModel.includes("7b") || lowerModel.includes("3b") || lowerModel.includes("mini")) {
+    return {
+      temperature: 0.1,
+      topP: 0.85,
+      topK: 30,
+      repeatPenalty: 1.15,
+      numPredict: 1024,
+    };
+  }
+
+  // Default
+  return {
+    temperature: 0.2,
+    topP: 0.9,
+    topK: 40,
+    repeatPenalty: 1.1,
+    numPredict: 2048,
+  };
+};

src/prompts/system/providers/openai.ts

@@ -0,0 +1,145 @@
+/**
+ * OpenAI Provider-Specific Prompt Enhancements
+ *
+ * Models: GPT-4, GPT-4o, GPT-4-mini, GPT-5, o1, o3
+ *
+ * OpenAI models work best with:
+ * - Clear, structured instructions
+ * - JSON-formatted tool calls
+ * - System/user message separation
+ * - Function calling patterns
+ */
+
+export const OPENAI_TOOL_PATTERNS = `## OpenAI Tool Usage Patterns
+
+### Function Calling
+When using tools, structure calls clearly:
+- One tool call per action for clarity
+- Use parallel_tool_calls when operations are independent
+- Handle tool results before making decisions
+
+### JSON Mode
+For structured outputs, use JSON format:
+\`\`\`json
+{
+  "action": "edit",
+  "file": "src/utils.ts",
+  "change": "Add validation function"
+}
+\`\`\`
+
+### Reasoning Models (o1, o3)
+For o1/o3 models:
+- Extended thinking is built-in, don't use <thinking> blocks
+- Focus on the final answer
+- Complex reasoning happens internally
+- Be direct in responses`;
+
+export const OPENAI_COPILOT_PATTERNS = `## GitHub Copilot Integration
+
+When accessed via GitHub Copilot:
+
+### Context Awareness
+- Copilot provides file context automatically
+- Current file and cursor position are known
+- Nearby files may be included
+
+### Completion Style
+- Match the coding style of surrounding code
+- Use consistent naming conventions
+- Follow the project's patterns
+
+### Chat Mode
+In Copilot Chat:
+- Workspace context is available
+- @workspace queries search the codebase
+- @terminal context includes recent commands`;
+
+export const OPENAI_BEST_PRACTICES = `## OpenAI Best Practices
+
+### Prompt Structure
+1. System message: Role and capabilities
+2. User message: Current task
+3. Assistant: Execution
+
+### Token Efficiency
+- Be concise in reasoning
+- Use abbreviations in internal thinking
+- Summarize large file contents
+
+### Error Handling
+OpenAI models may:
+- Hallucinate function names - verify with grep first
+- Assume file structure - use glob to confirm
+- Generate outdated syntax - check project conventions
+
+### Temperature Guidance
+- Code generation: 0.0-0.3 (deterministic)
+- Creative solutions: 0.5-0.7
+- Exploration: 0.7-1.0`;
+
+/**
+ * Build OpenAI-specific enhancements
+ */
+export const buildOpenAIEnhancements = (): string => {
+  return [
+    OPENAI_TOOL_PATTERNS,
+    OPENAI_COPILOT_PATTERNS,
+    OPENAI_BEST_PRACTICES,
+  ].join("\n\n");
+};
+
+/**
+ * Check if model is from OpenAI
+ */
+export const isOpenAIModel = (modelId: string): boolean => {
+  const lowerModel = modelId.toLowerCase();
+  return (
+    lowerModel.includes("gpt") ||
+    lowerModel.includes("o1") ||
+    lowerModel.includes("o3") ||
+    lowerModel.includes("davinci") ||
+    lowerModel.includes("turbo") ||
+    lowerModel.startsWith("ft:gpt")
+  );
+};
+
+/**
+ * Get OpenAI-specific parameters
+ */
+export const getOpenAIParams = (modelId: string): {
+  temperature: number;
+  topP: number;
+  frequencyPenalty: number;
+  presencePenalty: number;
+} => {
+  const lowerModel = modelId.toLowerCase();
+
+  // Reasoning models
+  if (lowerModel.includes("o1") || lowerModel.includes("o3")) {
+    return {
+      temperature: 1, // o1/o3 ignore temperature
+      topP: 1,
+      frequencyPenalty: 0,
+      presencePenalty: 0,
+    };
+  }
+
+  // Code generation
+  if (lowerModel.includes("gpt-5") || lowerModel.includes("gpt-4")) {
+    return {
+      temperature: 0.2,
+      topP: 0.95,
+      frequencyPenalty: 0,
+      presencePenalty: 0,
+    };
+  }
+
+  // Default
+  return {
+    temperature: 0.3,
+    topP: 1,
+    frequencyPenalty: 0,
+    presencePenalty: 0,
+  };
+};

src/prompts/system/tiers/balanced.ts

@@ -0,0 +1,236 @@
+/**
+ * Balanced Tier Prompt - For standard capability models
+ *
+ * Models: gpt-4o, gpt-4-turbo, claude-sonnet, gemini-pro
+ *
+ * Strategy:
+ * - Full tool access
+ * - Chain-of-thought reasoning
+ * - Parallel tool execution allowed
+ * - Plan mode for complex tasks
+ * - Agent delegation for multi-step work
+ */
+
+import { buildBasePrompt } from "@prompts/system/base";
+
+export const BALANCED_TIER_INSTRUCTIONS = `## Balanced Model Instructions
+
+You are running on a BALANCED model with strong reasoning capabilities. You can handle complex tasks efficiently.
+
+### Core Principle: ACT, DON'T ASK
+
+- Execute tasks immediately without asking for confirmation
+- Make reasonable assumptions when details are missing
+- Only ask questions for truly ambiguous requirements
+- When given a task, START WORKING IMMEDIATELY
+- Use common conventions (TypeScript, modern frameworks, best practices)
+- Chain multiple tool calls to complete tasks efficiently
+
+### When to Ask
+
+ONLY ask when:
+- Multiple fundamentally different approaches exist AND the choice significantly affects the result
+- Critical information is genuinely missing (API keys, credentials, account IDs)
+- About to delete data or make irreversible changes
+
+If you must ask: do all non-blocked work first, ask ONE targeted question, include your recommended default.
+
+### Chain-of-Thought Process
+
+For complex tasks, use structured thinking:
+
+\`\`\`
+<thinking>
+Task: [what the user wants]
+Context needed: [what to explore first]
+Approach: [high-level strategy]
+</thinking>
+\`\`\`
+
+### Parallel Execution
+
+You CAN run multiple independent tool calls in parallel:
+
+<example>
+user: check if auth and database are working
+
+[Runs in parallel:]
+- bash: curl localhost:3000/health
+- bash: psql -c "SELECT 1"
+- read: src/config/database.ts
+</example>
+
+### Task Tracking
+
+For multi-step tasks (3+ steps), use todowrite to track progress:
+
+\`\`\`json
+{
+  "todos": [
+    { "id": "1", "title": "Find relevant files", "status": "completed" },
+    { "id": "2", "title": "Implement changes", "status": "in_progress" },
+    { "id": "3", "title": "Verify and test", "status": "pending" }
+  ]
+}
+\`\`\`
+
+### Doing Tasks
+
+1. **Understand first**: Read relevant files before making changes
+2. **Work incrementally**: Make logical changes step by step
+3. **Verify always**: Test your work after changes
+4. **Keep it simple**: Don't over-engineer solutions
+
+### Don't
+
+- Don't ask "should I proceed?" - just proceed
+- Don't list plans without executing them
+- Don't ask for paths if working directory is obvious
+- Don't add features beyond what was asked
+- Don't add comments to code you didn't change`;
+
+export const BALANCED_TIER_PLAN_GATE = `## Plan Mode (Balanced Tier)
+
+For COMPLEX tasks that meet these criteria, enter plan mode:
+- Multi-file refactoring
+- New feature implementation
+- Architectural changes
+- Tasks that could take 10+ tool calls
+
+### Plan Mode Workflow
+
+1. **Explore Phase** - Gather context with glob, grep, read
+2. **Plan Phase** - Create structured plan with steps
+3. **Approval Gate** - Present plan, wait for user signal to proceed
+4. **Execute Phase** - Implement the plan
+5. **Verify Phase** - Test and confirm
+
+### Plan Format
+
+\`\`\`
+## Plan: [Task Name]
+
+### Context
+- [Key file 1]: [purpose]
+- [Key file 2]: [purpose]
+
+### Steps
+1. [First change] - [file affected]
+2. [Second change] - [file affected]
+3. [Verification] - [command]
+
+### Risks
+- [Potential issue and mitigation]
+
+Ready to proceed? (Continue with implementation or provide feedback)
+\`\`\`
+
+### When to Skip Plan Mode
+
+Skip plan mode for:
+- Single file changes
+- Simple bug fixes
+- Adding a function or component
+- Configuration changes
+- Tasks with clear, limited scope`;
+
+export const BALANCED_TIER_AGENTS = `## Agent Delegation
+
+For complex tasks, you can delegate to specialized agents:
+
+### Available Agents
+
+- **explore**: Fast codebase exploration (read-only)
+- **implement**: Code writing and modification
+- **test**: Test creation and execution
+- **review**: Code review and suggestions
+
+### Delegation Format
+
+When delegating:
+\`\`\`
+<delegate agent="explore">
+Find all files related to authentication and understand the auth flow
+</delegate>
+\`\`\`
+
+### When to Delegate
+
+Delegate when:
+- Task requires deep exploration of unfamiliar code
+- Multiple parallel investigations would be faster
+- Specialized expertise would help (testing, security review)
+
+Don't delegate for:
+- Simple, straightforward tasks
+- Tasks you can complete in 2-3 tool calls`;
+
+/**
+ * Build the complete balanced tier prompt
+ */
+export const buildBalancedTierPrompt = (): string => {
+  return [
+    buildBasePrompt(),
+    BALANCED_TIER_INSTRUCTIONS,
+    BALANCED_TIER_PLAN_GATE,
+    BALANCED_TIER_AGENTS,
+  ].join("\n\n");
+};
+
+/**
+ * Models that should use this tier
+ * Based on Copilot's model cost multipliers:
+ * - Unlimited (0x): gpt-4o (flagship unlimited)
+ * - Standard (1.0x): most capable models
+ */
+export const BALANCED_TIER_MODELS = [
+  // Copilot Unlimited flagship
+  "gpt-4o",
+
+  // Copilot Standard (1.0x)
+  "claude-sonnet-4",
+  "claude-sonnet-4.5",
+  "gemini-2.5-pro",
+  "gemini-3-pro-preview",
+  "gpt-4.1",
+  "gpt-5",
+  "gpt-5-codex-preview",
+  "gpt-5.1",
+  "gpt-5.1-codex",
+
+  // Other balanced models
+  "gpt-4-turbo",
+  "gpt-4",
+  "claude-3-sonnet",
+  "claude-sonnet",
+  "claude-3.5-sonnet",
+  "gemini-pro",
+  "gemini-1.5-pro",
+  "gemini-2.0-pro",
+  "llama-3.1-70b",
+  "llama-3.2-70b",
+  "mistral-large",
+  "qwen-72b",
+  "deepseek-v2",
+] as const;
+
+export type BalancedTierModel = (typeof BALANCED_TIER_MODELS)[number];
+
+export const isBalancedTierModel = (modelId: string): boolean => {
+  const lowerModel = modelId.toLowerCase();
+
+  // Check for fast tier first (they often contain 'pro' in name too)
+  if (lowerModel.includes("mini") || lowerModel.includes("flash") || lowerModel.includes("raptor")) {
+    return false;
+  }
+
+  // Check for thorough tier
+  if (lowerModel.includes("opus") || lowerModel.includes("o1") || lowerModel.includes("ultra") ||
+      lowerModel.includes("codex-max") || lowerModel.includes("5.2")) {
+    return false;
+  }
+
+  return BALANCED_TIER_MODELS.some(
+    (m) => lowerModel.includes(m.toLowerCase())
+  ) || lowerModel.includes("pro") || lowerModel.includes("sonnet") || lowerModel.includes("turbo");
+};

src/prompts/system/tiers/fast.ts

@@ -0,0 +1,161 @@
+/**
+ * Fast Tier Prompt - For smaller, faster models
+ *
+ * Models: gpt-4-mini, gpt-5-mini, claude-haiku, gemini-flash
+ *
+ * Strategy:
+ * - Simpler, more explicit instructions
+ * - Step-by-step guidance
+ * - Fewer tools exposed
+ * - Mandatory task decomposition
+ * - No complex reasoning expected
+ */
+
+import { buildBasePrompt } from "@prompts/system/base";
+
+export const FAST_TIER_INSTRUCTIONS = `## Fast Model Instructions
+
+You are running on a FAST model optimized for quick responses. Follow these specific guidelines:
+
+### Execution Strategy
+
+1. **ALWAYS decompose tasks** - Break every task into numbered steps before starting
+2. **One action per turn** - Complete one tool call, verify, then proceed
+3. **Be explicit** - State exactly what you're doing and why
+4. **Keep context small** - Don't try to hold too much information at once
+
+### Task Decomposition (MANDATORY)
+
+Before ANY task, create a numbered plan:
+
+<example>
+user: Add a login button to the header
+
+assistant:
+**Plan:**
+1. Find the header component file
+2. Read the current header code
+3. Add the login button JSX
+4. Verify with tsc --noEmit
+
+Starting step 1...
+[uses glob to find header]
+</example>
+
+### Simplified Tool Usage
+
+Use tools in this order:
+1. **glob** - Find the file first
+2. **read** - Read the file
+3. **edit** - Make ONE change
+4. **bash** - Verify the change
+
+DO NOT:
+- Run multiple edits without verification between them
+- Try to understand large codebases at once
+- Make assumptions about code you haven't read
+
+### Response Format
+
+Keep responses SHORT and STRUCTURED:
+
+<example>
+**Step 1/3: Finding header file**
+Found: src/components/Header.tsx
+
+**Step 2/3: Reading header**
+[reads file]
+
+**Step 3/3: Adding button**
+[edits file]
+Done. Button added at line 24.
+</example>
+
+### Error Handling
+
+If something fails:
+1. State what failed
+2. State ONE alternative approach
+3. Try the alternative
+4. If it fails again, ask the user
+
+### Limitations
+
+You should NOT attempt:
+- Complex multi-file refactoring (ask for human help)
+- Architectural decisions (ask for guidance)
+- Tasks requiring deep codebase understanding
+- Parallel tool execution (do sequentially)`;
+
+export const FAST_TIER_PLAN_GATE = `## Plan Approval (Fast Tier)
+
+For tasks with 3+ steps, you MUST show your plan and wait for implicit approval:
+
+<example>
+user: refactor the auth system
+
+assistant:
+This is a complex task. Here's my plan:
+
+**Plan:**
+1. Find all auth-related files
+2. Read each file to understand current structure
+3. Identify refactoring opportunities
+4. Make changes file by file
+5. Verify after each change
+
+This will modify multiple files. Proceeding with step 1...
+</example>
+
+If the user interrupts or says "stop", halt immediately.`;
+
+/**
+ * Build the complete fast tier prompt
+ */
+export const buildFastTierPrompt = (): string => {
+  return [
+    buildBasePrompt(),
+    FAST_TIER_INSTRUCTIONS,
+    FAST_TIER_PLAN_GATE,
+  ].join("\n\n");
+};
+
+/**
+ * Models that should use this tier
+ * Based on Copilot's model cost multipliers:
+ * - Unlimited (0x): fast, cheap models
+ * - Low cost (0.33x): efficient models
+ */
+export const FAST_TIER_MODELS = [
+  // Copilot Unlimited (0x)
+  "gpt-4o-mini",
+  "gpt-5-mini",
+  "grok-code-fast-1",
+  "raptor-mini",
+
+  // Copilot Low cost (0.33x)
+  "claude-haiku-4.5",
+  "gemini-3-flash-preview",
+  "gpt-5.1-codex-mini-preview",
+
+  // Other fast models
+  "claude-3-haiku",
+  "claude-haiku",
+  "gemini-flash",
+  "gemini-1.5-flash",
+  "gemini-2.0-flash",
+  "llama-3.1-8b",
+  "llama-3.2-3b",
+  "mistral-7b",
+  "qwen-7b",
+  "phi-3-mini",
+] as const;
+
+export type FastTierModel = (typeof FAST_TIER_MODELS)[number];
+
+export const isFastTierModel = (modelId: string): boolean => {
+  const lowerModel = modelId.toLowerCase();
+  return FAST_TIER_MODELS.some(
+    (m) => lowerModel.includes(m.toLowerCase())
+  ) || lowerModel.includes("mini") || lowerModel.includes("flash") || lowerModel.includes("raptor");
+};

src/prompts/system/tiers/thorough.ts

@@ -0,0 +1,299 @@
+/**
+ * Thorough Tier Prompt - For most capable models
+ *
+ * Models: gpt-5, o1, o1-pro, claude-opus, gemini-ultra
+ *
+ * Strategy:
+ * - Full autonomy and complex reasoning
+ * - Multi-agent orchestration
+ * - Advanced planning with parallel exploration
+ * - Deep codebase understanding
+ * - Architectural decision making
+ */
+
+import { buildBasePrompt } from "@prompts/system/base";
+
+export const THOROUGH_TIER_INSTRUCTIONS = `## Thorough Model Instructions
+
+You are running on a THOROUGH model with advanced reasoning capabilities. You can handle complex, multi-step tasks with high autonomy.
+
+### Core Principle: AUTONOMOUS EXECUTION
+
+- You have FULL AUTONOMY to complete complex tasks
+- Make architectural decisions confidently
+- Orchestrate multiple agents for parallel work
+- Handle ambiguity through exploration, not questions
+- Complete entire features end-to-end
+
+### Advanced Reasoning
+
+Use extended thinking for complex problems:
+
+\`\`\`
+<thinking>
+## Analysis
+[Deep analysis of the problem space]
+
+## Architecture Considerations
+[Design decisions and trade-offs]
+
+## Implementation Strategy
+[Detailed approach with phases]
+
+## Risk Assessment
+[Potential issues and mitigations]
+</thinking>
+\`\`\`
+
+### Multi-Agent Orchestration
+
+You can spawn and coordinate multiple agents:
+
+\`\`\`
+<orchestrate>
+## Phase 1: Parallel Exploration
+- Agent 1 (explore): Find all API endpoints
+- Agent 2 (explore): Analyze database schema
+- Agent 3 (explore): Check authentication flow
+
+## Phase 2: Planning
+Synthesize findings into implementation plan
+
+## Phase 3: Parallel Implementation
+- Agent 1 (implement): Backend changes
+- Agent 2 (implement): Frontend changes
+- Agent 3 (test): Write tests as implementation proceeds
+</orchestrate>
+\`\`\`
+
+### Complex Task Handling
+
+For large tasks:
+
+1. **Discovery Phase**
+   - Launch 3+ explore agents in parallel
+   - Map the entire affected codebase
+   - Identify dependencies and constraints
+
+2. **Architecture Phase**
+   - Design the solution holistically
+   - Consider edge cases and error handling
+   - Plan for testability and maintainability
+
+3. **Implementation Phase**
+   - Execute changes systematically
+   - Maintain consistency across files
+   - Handle cross-cutting concerns
+
+4. **Verification Phase**
+   - Run comprehensive tests
+   - Check for regressions
+   - Validate against requirements
+
+### Decision Making
+
+You are empowered to make decisions:
+
+| Decision Type | Your Authority |
+|---------------|----------------|
+| Code style | Follow existing patterns |
+| Library choice | Use what's already in project |
+| Architecture | Propose and implement |
+| Refactoring | Do it if it improves the code |
+| Testing | Always add appropriate tests |
+
+### When to Consult User
+
+Only consult when:
+- Multiple valid architectural approaches with significant trade-offs
+- Business logic ambiguity that can't be inferred
+- Security/compliance decisions
+- Changes that affect external systems or users`;
+
+export const THOROUGH_TIER_PLAN_MODE = `## Advanced Plan Mode
+
+For complex tasks, use structured planning with approval:
+
+### Plan Document Format
+
+\`\`\`markdown
+# Implementation Plan: [Feature Name]
+
+## Executive Summary
+[1-2 sentence overview]
+
+## Context Analysis
+### Files Analyzed
+- \`path/to/file.ts\`: [purpose and relevance]
+
+### Current Architecture
+[Brief description of existing patterns]
+
+### Dependencies
+- [External dependency 1]
+- [Internal module 1]
+
+## Implementation Strategy
+
+### Phase 1: [Name]
+**Objective**: [Goal]
+**Files affected**: [list]
+**Changes**:
+1. [Specific change]
+2. [Specific change]
+
+### Phase 2: [Name]
+...
+
+## Risk Assessment
+| Risk | Impact | Mitigation |
+|------|--------|------------|
+| [Risk 1] | [High/Med/Low] | [Strategy] |
+
+## Testing Strategy
+- Unit tests: [approach]
+- Integration tests: [approach]
+- Manual verification: [steps]
+
+## Rollback Plan
+[How to undo if needed]
+
+---
+**Awaiting approval to proceed with implementation.**
+\`\`\`
+
+### Plan Approval Workflow
+
+1. Generate comprehensive plan
+2. Present to user with "Awaiting approval"
+3. User can:
+   - Approve: "proceed", "go ahead", "looks good"
+   - Modify: "change X to Y"
+   - Reject: "stop", "don't do this"
+4. On approval, execute with full autonomy`;
+
+export const THOROUGH_TIER_AGENTS = `## Agent Orchestration System
+
+### Spawning Agents
+
+\`\`\`
+<spawn-agents mode="parallel">
+  <agent type="explore" id="exp-1">
+    Search for all files containing "auth" and understand the authentication flow
+  </agent>
+  <agent type="explore" id="exp-2">
+    Find all API route definitions and document the endpoint structure
+  </agent>
+  <agent type="explore" id="exp-3">
+    Analyze the database models and their relationships
+  </agent>
+</spawn-agents>
+\`\`\`
+
+### Agent Types
+
+| Type | Capabilities | Use For |
+|------|-------------|---------|
+| explore | glob, grep, read | Codebase discovery |
+| implement | all tools | Code changes |
+| test | all tools | Test creation/execution |
+| review | read, grep | Code review |
+| refactor | all tools | Code improvement |
+
+### Coordination Patterns
+
+**Fan-out/Fan-in**: Multiple agents explore, results synthesized
+\`\`\`
+explore-1 ──┐
+explore-2 ──┼──> synthesize ──> plan ──> implement
+explore-3 ──┘
+\`\`\`
+
+**Pipeline**: Sequential agent handoff
+\`\`\`
+explore ──> plan ──> implement ──> test ──> review
+\`\`\`
+
+**Parallel Implementation**: Multiple agents implement different parts
+\`\`\`
+         ┌──> implement-backend ──┐
+plan ────┼──> implement-frontend ─┼──> integrate ──> test
+         └──> implement-tests ────┘
+\`\`\`
+
+### Result Aggregation
+
+After parallel agents complete:
+\`\`\`
+<aggregate>
+## Agent Results
+
+### exp-1: Authentication Flow
+[Summary of findings]
+
+### exp-2: API Endpoints
+[Summary of findings]
+
+### exp-3: Database Models
+[Summary of findings]
+
+## Synthesis
+[Combined understanding and next steps]
+</aggregate>
+\`\`\``;
+
+/**
+ * Build the complete thorough tier prompt
+ */
+export const buildThoroughTierPrompt = (): string => {
+  return [
+    buildBasePrompt(),
+    THOROUGH_TIER_INSTRUCTIONS,
+    THOROUGH_TIER_PLAN_MODE,
+    THOROUGH_TIER_AGENTS,
+  ].join("\n\n");
+};
+
+/**
+ * Models that should use this tier
+ * Based on Copilot's model cost multipliers:
+ * - Premium (3.0x): most capable, expensive models
+ * - Standard high-end: codex-max and 5.2 variants
+ */
+export const THOROUGH_TIER_MODELS = [
+  // Copilot Premium (3.0x)
+  "claude-opus-4.5",
+
+  // Copilot Standard high-end
+  "gpt-5.1-codex-max",
+  "gpt-5.2",
+  "gpt-5.2-codex",
+
+  // Reasoning models
+  "o1",
+  "o1-pro",
+  "o1-preview",
+  "o3",
+  "o3-mini",
+
+  // Other thorough models
+  "claude-opus",
+  "claude-3-opus",
+  "claude-4-opus",
+  "gemini-ultra",
+  "gemini-2.0-ultra",
+  "llama-3.1-405b",
+  "deepseek-r1",
+] as const;
+
+export type ThoroughTierModel = (typeof THOROUGH_TIER_MODELS)[number];
+
+export const isThoroughTierModel = (modelId: string): boolean => {
+  const lowerModel = modelId.toLowerCase();
+  return THOROUGH_TIER_MODELS.some(
+    (m) => lowerModel.includes(m.toLowerCase())
+  ) || lowerModel.includes("opus") || lowerModel.includes("ultra") ||
+    lowerModel.includes("o1") || lowerModel.includes("o3") ||
+    lowerModel.includes("405b") || lowerModel.includes("r1") ||
+    lowerModel.includes("codex-max") || lowerModel.includes("5.2");
+};

src/services/core/agent.ts

@@ -85,13 +85,15 @@ const callLLM = async (
     return msg;
   });
 
-  // Call provider with tools
+  // Call provider with tools and model-specific params
   const response = await providerChat(
     state.options.provider,
     providerMessages as Message[],
     {
       model: state.options.model,
       tools: toolDefs,
+      temperature: state.options.modelParams?.temperature,
+      maxTokens: state.options.modelParams?.maxTokens,
     },
   );
 

src/services/multi-agent/executor.ts

@@ -297,33 +297,157 @@ const executeSingleAgent = async (
 
 /**
  * Execute the actual agent task
- * This is a placeholder - actual implementation would integrate with
- * the chat/provider system
+ * Integrates with the core agent system for LLM interaction
  */
 const executeAgentTask = async (
   instance: AgentInstance,
   config: AgentSpawnConfig,
-  _options: MultiAgentExecutorOptions,
+  options: MultiAgentExecutorOptions,
 ): Promise<AgentExecutionResult> => {
   const startTime = Date.now();
 
-  // This is where the actual agent execution would happen
-  // For now, return a placeholder result
-  // In real implementation, this would:
-  // 1. Build system prompt from agent definition
-  // 2. Send task to LLM provider
-  // 3. Handle tool calls
-  // 4. Track file modifications
-  // 5. Return result
+  // Dynamic imports to avoid circular dependencies
+  const { runAgent } = await import("@services/core/agent");
+  const { buildSystemPromptWithInfo } = await import("@prompts/system/builder");
 
-  // Placeholder implementation
-  return {
-    success: true,
-    output: `Agent ${instance.definition.name} completed task: ${config.task}`,
-    filesModified: [],
-    toolCallCount: 0,
-    duration: Date.now() - startTime,
+  // Get model based on tier
+  const modelId = getModelForTier(instance.definition.tier);
+
+  // Build system prompt based on agent definition
+  const context = {
+    workingDir: process.cwd(),
+    isGitRepo: true,
+    platform: process.platform,
+    today: new Date().toISOString().split("T")[0],
+    modelId,
+    customInstructions: instance.definition.systemPrompt,
   };
+
+  // Get prompt with tier/provider info and model params
+  const { prompt: systemPrompt, params } = buildSystemPromptWithInfo(context);
+
+  // Log tier detection for debugging (only in verbose mode)
+  if (options.onEvent) {
+    options.onEvent({
+      type: "agent_started",
+      agentId: instance.id,
+      timestamp: Date.now(),
+    });
+  }
+
+  // Build enhanced task prompt with agent context
+  const enhancedTask = buildAgentTaskPrompt(instance, config);
+
+  const filesModified: string[] = [];
+  let toolCallCount = 0;
+
+  try {
+    const result = await runAgent(enhancedTask, systemPrompt, {
+      provider: "copilot",
+      model: modelId,
+      autoApprove: true,
+      maxIterations: instance.definition.maxTurns ?? 10,
+      verbose: false,
+      modelParams: {
+        temperature: params.temperature,
+        topP: params.topP,
+        maxTokens: params.maxTokens,
+      },
+      onToolCall: (toolCall) => {
+        toolCallCount++;
+        const agentToolCall = {
+          id: toolCall.id,
+          toolName: toolCall.name,
+          args: toolCall.arguments,
+          timestamp: Date.now(),
+        };
+        multiAgentStore.addToolCall(instance.id, agentToolCall);
+        options.onToolCall?.(instance.id, agentToolCall);
+      },
+      onToolResult: (_toolCallId, toolResult) => {
+        // Track file modifications
+        if (toolResult.success && toolResult.output?.includes("File written:")) {
+          const match = toolResult.output.match(/File written: (.+)/);
+          if (match) {
+            filesModified.push(match[1]);
+            multiAgentStore.addModifiedFile(instance.id, match[1]);
+          }
+        }
+      },
+      onText: (text) => {
+        const message = {
+          role: "assistant" as const,
+          content: text,
+          timestamp: Date.now(),
+        };
+        multiAgentStore.addAgentMessage(instance.id, message);
+        options.onAgentMessage?.(instance.id, message);
+      },
+    });
+
+    return {
+      success: result.success,
+      output: result.finalResponse,
+      filesModified,
+      toolCallCount,
+      duration: Date.now() - startTime,
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      error: errorMessage,
+      filesModified,
+      toolCallCount,
+      duration: Date.now() - startTime,
+    };
+  }
+};
+
+/**
+ * Build enhanced task prompt with agent context
+ */
+const buildAgentTaskPrompt = (
+  instance: AgentInstance,
+  config: AgentSpawnConfig,
+): string => {
+  const parts: string[] = [];
+
+  // Agent identity
+  parts.push(`## Agent: ${instance.definition.name}`);
+  parts.push(`Description: ${instance.definition.description}`);
+
+  // Available tools
+  if (instance.definition.tools.length > 0) {
+    parts.push(`\nAvailable tools: ${instance.definition.tools.join(", ")}`);
+  }
+
+  // Task
+  parts.push(`\n## Task\n${config.task}`);
+
+  // Context files
+  if (config.contextFiles?.length) {
+    parts.push(`\n## Context Files\n${config.contextFiles.map(f => `- ${f}`).join("\n")}`);
+  }
+
+  // System prompt override as additional instructions
+  if (config.systemPromptOverride) {
+    parts.push(`\n## Additional Instructions\n${config.systemPromptOverride}`);
+  }
+
+  return parts.join("\n");
+};
+
+/**
+ * Get model ID for agent tier
+ */
+const getModelForTier = (tier: string): string => {
+  const tierModels: Record<string, string> = {
+    fast: "gpt-4o-mini",
+    balanced: "gpt-4o",
+    thorough: "o1",
+  };
+  return tierModels[tier] ?? "gpt-4o";
 };
 
 /**

src/services/multi-agent/parallel-exploration.ts

@@ -0,0 +1,392 @@
+/**
+ * Parallel Exploration Service
+ *
+ * Launches multiple exploration agents in parallel to quickly
+ * understand a codebase before planning or implementing changes.
+ */
+
+import type { AgentResult } from "@interfaces/AgentResult";
+import { runAgent } from "@services/core/agent";
+import { buildSystemPromptWithInfo } from "@prompts/system/builder";
+import type { PromptContext } from "@prompts/system/builder";
+import type { ProviderName } from "@/types/providers";
+
+/**
+ * Exploration task definition
+ */
+export interface ExplorationTask {
+  id: string;
+  description: string;
+  searchPatterns?: string[];
+  filePatterns?: string[];
+  keywords?: string[];
+}
+
+/**
+ * Exploration result from a single agent
+ */
+export interface ExplorationResult {
+  taskId: string;
+  success: boolean;
+  findings: string;
+  filesExamined: string[];
+  relevantCode: Array<{
+    file: string;
+    line: number;
+    snippet: string;
+  }>;
+  duration: number;
+}
+
+/**
+ * Aggregated exploration results
+ */
+export interface ExplorationSummary {
+  tasks: ExplorationResult[];
+  synthesizedFindings: string;
+  keyFiles: string[];
+  totalDuration: number;
+}
+
+/**
+ * Options for parallel exploration
+ */
+export interface ParallelExplorationOptions {
+  maxConcurrent?: number;
+  timeout?: number;
+  modelId: string;
+  provider: ProviderName;
+  workingDir: string;
+  onProgress?: (completed: number, total: number) => void;
+  onTaskComplete?: (result: ExplorationResult) => void;
+}
+
+/**
+ * Default exploration tasks for understanding a codebase
+ */
+export const DEFAULT_EXPLORATION_TASKS: ExplorationTask[] = [
+  {
+    id: "structure",
+    description: "Analyze project structure and understand the directory layout",
+    filePatterns: ["package.json", "tsconfig.json", "*.config.*"],
+  },
+  {
+    id: "entry-points",
+    description: "Find main entry points and understand the application flow",
+    filePatterns: ["**/main.*", "**/index.*", "**/app.*"],
+    keywords: ["export", "main", "start"],
+  },
+  {
+    id: "types",
+    description: "Analyze type definitions and interfaces",
+    filePatterns: ["**/types/**", "**/interfaces/**", "**/*.d.ts"],
+  },
+];
+
+/**
+ * Build exploration prompt for a task
+ */
+const buildExplorationPrompt = (task: ExplorationTask): string => {
+  const parts = [`## Exploration Task: ${task.description}`];
+
+  if (task.searchPatterns?.length) {
+    parts.push(`\n### Search for patterns:\n${task.searchPatterns.map(p => `- ${p}`).join("\n")}`);
+  }
+
+  if (task.filePatterns?.length) {
+    parts.push(`\n### Look in files matching:\n${task.filePatterns.map(p => `- ${p}`).join("\n")}`);
+  }
+
+  if (task.keywords?.length) {
+    parts.push(`\n### Keywords to search:\n${task.keywords.map(k => `- ${k}`).join("\n")}`);
+  }
+
+  parts.push(`
+### Instructions:
+1. Use glob to find relevant files
+2. Use grep to search for patterns
+3. Use read to examine key files
+4. Summarize your findings concisely
+
+### Output Format:
+Provide a structured summary:
+- Key files found
+- Important patterns discovered
+- Relevant code locations (file:line)
+- Dependencies and relationships
+`);
+
+  return parts.join("\n");
+};
+
+/**
+ * Build exploration system prompt with params
+ */
+const buildExplorationSystemPrompt = (
+  context: PromptContext,
+): { prompt: string; params: { temperature?: number; topP?: number; maxTokens?: number } } => {
+  const { prompt: basePrompt, params } = buildSystemPromptWithInfo(context);
+
+  const fullPrompt = `${basePrompt}
+
+## Exploration Mode
+
+You are in EXPLORATION MODE. Your goal is to quickly understand the codebase.
+
+### Exploration Rules:
+1. USE ONLY read-only tools: glob, grep, read
+2. DO NOT modify any files
+3. DO NOT run bash commands that modify state
+4. Focus on understanding, not changing
+
+### Tool Usage:
+- glob: Find files by pattern
+- grep: Search file contents
+- read: Examine file contents
+
+### Output:
+Provide clear, structured findings that help understand:
+- What the code does
+- How it's organized
+- Key patterns and conventions
+- Dependencies and relationships`;
+
+  return { prompt: fullPrompt, params };
+};
+
+/**
+ * Run a single exploration task
+ */
+const runExplorationTask = async (
+  task: ExplorationTask,
+  options: ParallelExplorationOptions,
+): Promise<ExplorationResult> => {
+  const startTime = Date.now();
+
+  const context: PromptContext = {
+    workingDir: options.workingDir,
+    isGitRepo: true,
+    platform: process.platform,
+    today: new Date().toISOString().split("T")[0],
+    modelId: options.modelId,
+  };
+
+  const { prompt: systemPrompt, params } = buildExplorationSystemPrompt(context);
+  const userPrompt = buildExplorationPrompt(task);
+
+  try {
+    const result = await runAgent(userPrompt, systemPrompt, {
+      provider: options.provider,
+      model: options.modelId,
+      autoApprove: true,
+      maxIterations: 10,
+      modelParams: {
+        temperature: params.temperature,
+        topP: params.topP,
+        maxTokens: params.maxTokens,
+      },
+    });
+
+    // Extract findings from result
+    const filesExamined = extractFilesFromResult(result);
+    const relevantCode = extractCodeLocations(result);
+
+    return {
+      taskId: task.id,
+      success: result.success,
+      findings: result.finalResponse,
+      filesExamined,
+      relevantCode,
+      duration: Date.now() - startTime,
+    };
+  } catch (error) {
+    return {
+      taskId: task.id,
+      success: false,
+      findings: error instanceof Error ? error.message : String(error),
+      filesExamined: [],
+      relevantCode: [],
+      duration: Date.now() - startTime,
+    };
+  }
+};
+
+/**
+ * Extract file paths from agent result
+ */
+const extractFilesFromResult = (result: AgentResult): string[] => {
+  const files = new Set<string>();
+
+  for (const { call } of result.toolCalls) {
+    if (call.name === "read" && call.arguments.file_path) {
+      files.add(String(call.arguments.file_path));
+    }
+    if (call.name === "glob" && call.arguments.pattern) {
+      // Files are in the result, not the call
+    }
+  }
+
+  // Also try to extract from the response text
+  const filePattern = /(?:^|\s)([a-zA-Z0-9_\-/.]+\.[a-zA-Z]+)(?:\s|$|:)/g;
+  let match;
+  while ((match = filePattern.exec(result.finalResponse)) !== null) {
+    if (match[1] && !match[1].startsWith("http")) {
+      files.add(match[1]);
+    }
+  }
+
+  return Array.from(files);
+};
+
+/**
+ * Extract code locations from agent result
+ */
+const extractCodeLocations = (result: AgentResult): Array<{
+  file: string;
+  line: number;
+  snippet: string;
+}> => {
+  const locations: Array<{ file: string; line: number; snippet: string }> = [];
+
+  // Pattern: file.ts:123 or file.ts:123-456
+  const locationPattern = /([a-zA-Z0-9_\-/.]+\.[a-zA-Z]+):(\d+)/g;
+  let match;
+
+  while ((match = locationPattern.exec(result.finalResponse)) !== null) {
+    locations.push({
+      file: match[1],
+      line: parseInt(match[2], 10),
+      snippet: "",
+    });
+  }
+
+  return locations;
+};
+
+/**
+ * Synthesize findings from multiple exploration results
+ */
+const synthesizeFindings = (results: ExplorationResult[]): string => {
+  const sections: string[] = [];
+
+  sections.push("# Exploration Summary\n");
+
+  // Key findings from each task
+  for (const result of results) {
+    if (result.success) {
+      sections.push(`## ${result.taskId}\n`);
+      sections.push(result.findings);
+      sections.push("");
+    }
+  }
+
+  // Aggregate key files
+  const allFiles = new Set<string>();
+  for (const result of results) {
+    result.filesExamined.forEach(f => allFiles.add(f));
+  }
+
+  if (allFiles.size > 0) {
+    sections.push("## Key Files Discovered\n");
+    sections.push(Array.from(allFiles).map(f => `- ${f}`).join("\n"));
+  }
+
+  return sections.join("\n");
+};
+
+/**
+ * Run parallel exploration with multiple agents
+ */
+export const runParallelExploration = async (
+  tasks: ExplorationTask[],
+  options: ParallelExplorationOptions,
+): Promise<ExplorationSummary> => {
+  const startTime = Date.now();
+  const maxConcurrent = options.maxConcurrent ?? 3;
+
+  const results: ExplorationResult[] = [];
+  const pending = [...tasks];
+  const running: Promise<ExplorationResult>[] = [];
+
+  let completed = 0;
+
+  while (pending.length > 0 || running.length > 0) {
+    // Start new tasks up to maxConcurrent
+    while (pending.length > 0 && running.length < maxConcurrent) {
+      const task = pending.shift()!;
+      running.push(
+        runExplorationTask(task, options).then(result => {
+          completed++;
+          options.onProgress?.(completed, tasks.length);
+          options.onTaskComplete?.(result);
+          return result;
+        }),
+      );
+    }
+
+    // Wait for at least one to complete
+    if (running.length > 0) {
+      const result = await Promise.race(
+        running.map((p, i) => p.then(r => ({ result: r, index: i }))),
+      );
+
+      results.push(result.result);
+      running.splice(result.index, 1);
+    }
+  }
+
+  // Aggregate key files
+  const keyFiles = new Set<string>();
+  for (const result of results) {
+    result.filesExamined.forEach(f => keyFiles.add(f));
+  }
+
+  return {
+    tasks: results,
+    synthesizedFindings: synthesizeFindings(results),
+    keyFiles: Array.from(keyFiles),
+    totalDuration: Date.now() - startTime,
+  };
+};
+
+/**
+ * Create exploration tasks for a specific goal
+ */
+export const createExplorationTasks = (
+  goal: string,
+  keywords: string[] = [],
+): ExplorationTask[] => {
+  return [
+    {
+      id: "goal-search",
+      description: `Find code related to: ${goal}`,
+      keywords: [goal, ...keywords],
+    },
+    {
+      id: "related-files",
+      description: `Find files that might be affected by changes to: ${goal}`,
+      keywords: keywords.length > 0 ? keywords : [goal],
+    },
+    {
+      id: "dependencies",
+      description: `Understand dependencies and imports related to: ${goal}`,
+      keywords: ["import", "require", "from", goal],
+    },
+  ];
+};
+
+/**
+ * Quick exploration for a specific file or pattern
+ */
+export const quickExplore = async (
+  pattern: string,
+  options: Omit<ParallelExplorationOptions, "maxConcurrent">,
+): Promise<ExplorationResult> => {
+  const task: ExplorationTask = {
+    id: "quick-explore",
+    description: `Find and understand: ${pattern}`,
+    filePatterns: [pattern],
+  };
+
+  return runExplorationTask(task, { ...options, maxConcurrent: 1 });
+};

src/services/plan-mode/plan-service.ts

@@ -0,0 +1,534 @@
+/**
+ * Plan Mode Service
+ *
+ * Manages the plan approval workflow for complex tasks.
+ * Implements the pattern from claude-code and opencode where
+ * complex operations require user approval before execution.
+ */
+
+import { v4 as uuidv4 } from "uuid";
+import type {
+  ImplementationPlan,
+  PlanStep,
+  PlanApprovalCriteria,
+  TaskAnalysis,
+  TaskComplexity,
+} from "@/types/plan-mode";
+import { DEFAULT_PLAN_APPROVAL_CRITERIA } from "@/types/plan-mode";
+
+/**
+ * Active plans storage
+ */
+const activePlans = new Map<string, ImplementationPlan>();
+
+/**
+ * Plan event callbacks
+ */
+type PlanEventCallback = (plan: ImplementationPlan) => void;
+const planListeners = new Map<string, Set<PlanEventCallback>>();
+
+/**
+ * Keywords indicating complexity
+ */
+const COMPLEXITY_KEYWORDS = {
+  critical: [
+    "security",
+    "authentication",
+    "authorization",
+    "password",
+    "secret",
+    "database migration",
+    "production",
+    "deploy",
+  ],
+  complex: [
+    "refactor",
+    "architecture",
+    "restructure",
+    "redesign",
+    "multiple files",
+    "system",
+    "integration",
+  ],
+  moderate: [
+    "feature",
+    "component",
+    "service",
+    "api",
+    "endpoint",
+    "module",
+  ],
+};
+
+/**
+ * Analyze a task to determine if it needs plan approval
+ */
+export const analyzeTask = (
+  taskDescription: string,
+  criteria: PlanApprovalCriteria = DEFAULT_PLAN_APPROVAL_CRITERIA,
+): TaskAnalysis => {
+  const lowerTask = taskDescription.toLowerCase();
+  const reasons: string[] = [];
+
+  // Check for critical keywords
+  const hasCriticalKeyword = COMPLEXITY_KEYWORDS.critical.some(k =>
+    lowerTask.includes(k),
+  );
+  if (hasCriticalKeyword) {
+    reasons.push("Task involves critical/sensitive operations");
+  }
+
+  // Check for complex keywords
+  const hasComplexKeyword = COMPLEXITY_KEYWORDS.complex.some(k =>
+    lowerTask.includes(k),
+  );
+  if (hasComplexKeyword) {
+    reasons.push("Task involves architectural changes");
+  }
+
+  // Check for always-require operations
+  const matchesAlwaysRequire = criteria.alwaysRequireFor.some(op => {
+    const opKeywords: Record<string, string[]> = {
+      delete: ["delete", "remove", "drop"],
+      refactor: ["refactor", "restructure", "rewrite"],
+      architecture: ["architecture", "system design", "redesign"],
+      security: ["security", "auth", "permission", "access"],
+      database: ["database", "migration", "schema"],
+      config: ["config", "environment", "settings"],
+    };
+    return opKeywords[op]?.some(k => lowerTask.includes(k));
+  });
+  if (matchesAlwaysRequire) {
+    reasons.push("Task matches always-require-approval criteria");
+  }
+
+  // Check for skip-approval patterns
+  const matchesSkipApproval = criteria.skipApprovalFor.some(op => {
+    const skipPatterns: Record<string, RegExp> = {
+      single_file_edit: /^(fix|update|change|modify)\s+(the\s+)?(\w+\.\w+)$/i,
+      add_comment: /^add\s+(a\s+)?comment/i,
+      fix_typo: /^fix\s+(a\s+)?typo/i,
+      format: /^format\s+(the\s+)?(code|file)/i,
+    };
+    return skipPatterns[op]?.test(taskDescription);
+  });
+
+  // Determine complexity
+  let complexity: TaskComplexity;
+  if (hasCriticalKeyword) {
+    complexity = "critical";
+  } else if (hasComplexKeyword || matchesAlwaysRequire) {
+    complexity = "complex";
+  } else if (COMPLEXITY_KEYWORDS.moderate.some(k => lowerTask.includes(k))) {
+    complexity = "moderate";
+  } else {
+    complexity = "simple";
+  }
+
+  // Determine if plan approval is required
+  const requiresPlanApproval =
+    !matchesSkipApproval &&
+    (complexity === "critical" || complexity === "complex" || reasons.length > 0);
+
+  // Suggest approach
+  const suggestedApproach = requiresPlanApproval
+    ? "Create a detailed implementation plan for user approval before proceeding"
+    : "Execute directly with standard verification";
+
+  return {
+    complexity,
+    requiresPlanApproval,
+    reasons,
+    suggestedApproach,
+  };
+};
+
+/**
+ * Create a new implementation plan
+ */
+export const createPlan = (
+  title: string,
+  summary: string,
+): ImplementationPlan => {
+  const plan: ImplementationPlan = {
+    id: uuidv4(),
+    title,
+    summary,
+    context: {
+      filesAnalyzed: [],
+      currentArchitecture: "",
+      dependencies: [],
+    },
+    steps: [],
+    risks: [],
+    testingStrategy: "",
+    rollbackPlan: "",
+    estimatedChanges: {
+      filesCreated: 0,
+      filesModified: 0,
+      filesDeleted: 0,
+    },
+    status: "drafting",
+    createdAt: Date.now(),
+  };
+
+  activePlans.set(plan.id, plan);
+  emitPlanEvent(plan.id, plan);
+
+  return plan;
+};
+
+/**
+ * Add a step to a plan
+ */
+export const addPlanStep = (
+  planId: string,
+  step: Omit<PlanStep, "id" | "status">,
+): PlanStep | null => {
+  const plan = activePlans.get(planId);
+  if (!plan || plan.status !== "drafting") {
+    return null;
+  }
+
+  const newStep: PlanStep = {
+    ...step,
+    id: uuidv4(),
+    status: "pending",
+  };
+
+  plan.steps.push(newStep);
+  emitPlanEvent(planId, plan);
+
+  return newStep;
+};
+
+/**
+ * Update plan context
+ */
+export const updatePlanContext = (
+  planId: string,
+  context: Partial<ImplementationPlan["context"]>,
+): boolean => {
+  const plan = activePlans.get(planId);
+  if (!plan) {
+    return false;
+  }
+
+  plan.context = { ...plan.context, ...context };
+  emitPlanEvent(planId, plan);
+
+  return true;
+};
+
+/**
+ * Add a risk to the plan
+ */
+export const addPlanRisk = (
+  planId: string,
+  risk: ImplementationPlan["risks"][0],
+): boolean => {
+  const plan = activePlans.get(planId);
+  if (!plan) {
+    return false;
+  }
+
+  plan.risks.push(risk);
+  emitPlanEvent(planId, plan);
+
+  return true;
+};
+
+/**
+ * Finalize plan and submit for approval
+ */
+export const submitPlanForApproval = (
+  planId: string,
+  testingStrategy: string,
+  rollbackPlan: string,
+): boolean => {
+  const plan = activePlans.get(planId);
+  if (!plan || plan.status !== "drafting") {
+    return false;
+  }
+
+  plan.testingStrategy = testingStrategy;
+  plan.rollbackPlan = rollbackPlan;
+  plan.status = "pending";
+
+  // Calculate estimated changes
+  const filesCreated = new Set<string>();
+  const filesModified = new Set<string>();
+  const filesDeleted = new Set<string>();
+
+  for (const step of plan.steps) {
+    for (const file of step.filesAffected) {
+      if (step.title.toLowerCase().includes("create") || step.title.toLowerCase().includes("add")) {
+        filesCreated.add(file);
+      } else if (step.title.toLowerCase().includes("delete") || step.title.toLowerCase().includes("remove")) {
+        filesDeleted.add(file);
+      } else {
+        filesModified.add(file);
+      }
+    }
+  }
+
+  plan.estimatedChanges = {
+    filesCreated: filesCreated.size,
+    filesModified: filesModified.size,
+    filesDeleted: filesDeleted.size,
+  };
+
+  emitPlanEvent(planId, plan);
+
+  return true;
+};
+
+/**
+ * Approve a plan
+ */
+export const approvePlan = (
+  planId: string,
+  message?: string,
+): boolean => {
+  const plan = activePlans.get(planId);
+  if (!plan || plan.status !== "pending") {
+    return false;
+  }
+
+  plan.status = "approved";
+  plan.approvedAt = Date.now();
+  plan.approvalMessage = message;
+
+  emitPlanEvent(planId, plan);
+
+  return true;
+};
+
+/**
+ * Reject a plan
+ */
+export const rejectPlan = (
+  planId: string,
+  reason: string,
+): boolean => {
+  const plan = activePlans.get(planId);
+  if (!plan || plan.status !== "pending") {
+    return false;
+  }
+
+  plan.status = "rejected";
+  plan.rejectionReason = reason;
+
+  emitPlanEvent(planId, plan);
+
+  return true;
+};
+
+/**
+ * Start executing a plan
+ */
+export const startPlanExecution = (planId: string): boolean => {
+  const plan = activePlans.get(planId);
+  if (!plan || plan.status !== "approved") {
+    return false;
+  }
+
+  plan.status = "executing";
+  emitPlanEvent(planId, plan);
+
+  return true;
+};
+
+/**
+ * Update step status during execution
+ */
+export const updateStepStatus = (
+  planId: string,
+  stepId: string,
+  status: PlanStep["status"],
+  output?: string,
+  error?: string,
+): boolean => {
+  const plan = activePlans.get(planId);
+  if (!plan) {
+    return false;
+  }
+
+  const step = plan.steps.find(s => s.id === stepId);
+  if (!step) {
+    return false;
+  }
+
+  step.status = status;
+  if (output) step.output = output;
+  if (error) step.error = error;
+
+  emitPlanEvent(planId, plan);
+
+  return true;
+};
+
+/**
+ * Complete plan execution
+ */
+export const completePlanExecution = (
+  planId: string,
+  success: boolean,
+): boolean => {
+  const plan = activePlans.get(planId);
+  if (!plan || plan.status !== "executing") {
+    return false;
+  }
+
+  plan.status = success ? "completed" : "failed";
+  plan.completedAt = Date.now();
+
+  emitPlanEvent(planId, plan);
+
+  return true;
+};
+
+/**
+ * Get a plan by ID
+ */
+export const getPlan = (planId: string): ImplementationPlan | undefined => {
+  return activePlans.get(planId);
+};
+
+/**
+ * Get all active plans
+ */
+export const getActivePlans = (): ImplementationPlan[] => {
+  return Array.from(activePlans.values()).filter(
+    p => p.status !== "completed" && p.status !== "failed" && p.status !== "rejected",
+  );
+};
+
+/**
+ * Format a plan for display
+ */
+export const formatPlanForDisplay = (plan: ImplementationPlan): string => {
+  const lines: string[] = [];
+
+  lines.push(`# Implementation Plan: ${plan.title}`);
+  lines.push("");
+  lines.push(`## Summary`);
+  lines.push(plan.summary);
+  lines.push("");
+
+  if (plan.context.filesAnalyzed.length > 0) {
+    lines.push(`## Files Analyzed`);
+    plan.context.filesAnalyzed.forEach(f => lines.push(`- ${f}`));
+    lines.push("");
+  }
+
+  if (plan.context.currentArchitecture) {
+    lines.push(`## Current Architecture`);
+    lines.push(plan.context.currentArchitecture);
+    lines.push("");
+  }
+
+  lines.push(`## Implementation Steps`);
+  plan.steps.forEach((step, i) => {
+    const riskIcon = step.riskLevel === "high" ? "⚠️" : step.riskLevel === "medium" ? "⚡" : "✓";
+    lines.push(`${i + 1}. ${riskIcon} **${step.title}**`);
+    lines.push(`   ${step.description}`);
+    if (step.filesAffected.length > 0) {
+      lines.push(`   Files: ${step.filesAffected.join(", ")}`);
+    }
+  });
+  lines.push("");
+
+  if (plan.risks.length > 0) {
+    lines.push(`## Risks`);
+    plan.risks.forEach(risk => {
+      lines.push(`- **${risk.impact.toUpperCase()}**: ${risk.description}`);
+      lines.push(`  Mitigation: ${risk.mitigation}`);
+    });
+    lines.push("");
+  }
+
+  lines.push(`## Testing Strategy`);
+  lines.push(plan.testingStrategy || "TBD");
+  lines.push("");
+
+  lines.push(`## Rollback Plan`);
+  lines.push(plan.rollbackPlan || "TBD");
+  lines.push("");
+
+  lines.push(`## Estimated Changes`);
+  lines.push(`- Files to create: ${plan.estimatedChanges.filesCreated}`);
+  lines.push(`- Files to modify: ${plan.estimatedChanges.filesModified}`);
+  lines.push(`- Files to delete: ${plan.estimatedChanges.filesDeleted}`);
+  lines.push("");
+
+  lines.push("---");
+  lines.push("**Awaiting approval to proceed with implementation.**");
+  lines.push("Reply with 'proceed', 'approve', or 'go ahead' to start execution.");
+  lines.push("Reply with 'stop', 'cancel', or provide feedback to modify the plan.");
+
+  return lines.join("\n");
+};
+
+/**
+ * Check if a message approves a plan
+ */
+export const isApprovalMessage = (message: string): boolean => {
+  const approvalPatterns = [
+    /^(proceed|go\s*ahead|approve|yes|ok|lgtm|looks\s*good|do\s*it|start|execute)$/i,
+    /^(sounds\s*good|that\s*works|perfect|great)$/i,
+    /proceed\s*with/i,
+    /go\s*ahead\s*(with|and)/i,
+  ];
+
+  return approvalPatterns.some(p => p.test(message.trim()));
+};
+
+/**
+ * Check if a message rejects a plan
+ */
+export const isRejectionMessage = (message: string): boolean => {
+  const rejectionPatterns = [
+    /^(stop|cancel|no|abort|don't|wait)$/i,
+    /^(hold\s*on|not\s*yet|let\s*me)$/i,
+    /don't\s*(proceed|do|execute)/i,
+  ];
+
+  return rejectionPatterns.some(p => p.test(message.trim()));
+};
+
+/**
+ * Subscribe to plan events
+ */
+export const subscribeToPlan = (
+  planId: string,
+  callback: PlanEventCallback,
+): () => void => {
+  if (!planListeners.has(planId)) {
+    planListeners.set(planId, new Set());
+  }
+
+  planListeners.get(planId)!.add(callback);
+
+  return () => {
+    planListeners.get(planId)?.delete(callback);
+  };
+};
+
+/**
+ * Emit a plan event
+ */
+const emitPlanEvent = (planId: string, plan: ImplementationPlan): void => {
+  const listeners = planListeners.get(planId);
+  if (listeners) {
+    listeners.forEach(callback => callback(plan));
+  }
+};
+
+/**
+ * Clean up a completed/rejected plan
+ */
+export const cleanupPlan = (planId: string): void => {
+  activePlans.delete(planId);
+  planListeners.delete(planId);
+};

src/services/prompt-builder.ts

@@ -3,16 +3,30 @@
  *
  * Builds and manages system prompts based on interaction mode.
  * Handles mode switching and context injection.
+ * Uses tier-aware mode composer for model-specific prompts.
  */
 
-import { buildAgenticPrompt } from "@prompts/system/agent";
-import { buildAskPrompt } from "@prompts/system/ask";
-import { buildCodeReviewPrompt } from "@prompts/system/code-review";
+import {
+  composePrompt,
+  type ModePromptContext,
+  type ComposedPrompt,
+} from "@prompts/system/modes/composer";
+import type { PromptMode } from "@prompts/system/modes/mode-types";
+import type { ModelTier, ModelProvider, ModelParams } from "@prompts/system/builder";
 import { buildSystemPromptWithRules } from "@services/rules-service";
 import { projectConfig } from "@services/project-config";
 import { getProjectContextForAskMode } from "@services/context-gathering";
 import type { InteractionMode } from "@/types/tui";
 
+/**
+ * Map interaction mode to prompt mode
+ */
+const INTERACTION_TO_PROMPT_MODE: Record<InteractionMode, PromptMode> = {
+  agent: "agent",
+  ask: "ask",
+  "code-review": "code-review",
+};
+
 export interface PromptContext {
   workingDir: string;
   isGitRepo: boolean;
@@ -24,6 +38,8 @@ export interface PromptContext {
   recentCommits?: string[];
   projectContext?: string;
   prContext?: string;
+  debugContext?: string;
+  planContext?: string;
 }
 
 export interface PromptBuilderState {
@@ -31,46 +47,45 @@ export interface PromptBuilderState {
   basePrompt: string;
   fullPrompt: string;
   context: PromptContext;
+  tier: ModelTier;
+  provider: ModelProvider;
+  params: ModelParams;
 }
 
-const MODE_PROMPT_BUILDERS: Record<
-  InteractionMode,
-  (context: PromptContext) => string
-> = {
-  agent: (ctx) =>
-    buildAgenticPrompt({
-      workingDir: ctx.workingDir,
-      isGitRepo: ctx.isGitRepo,
-      platform: ctx.platform,
-      today: ctx.today,
-      model: ctx.model,
-      gitBranch: ctx.gitBranch,
-      gitStatus: ctx.gitStatus,
-      recentCommits: ctx.recentCommits,
-    }),
+/**
+ * Build mode prompt using tier-aware composer
+ */
+const buildModePromptWithTier = (
+  mode: InteractionMode,
+  context: PromptContext,
+): ComposedPrompt => {
+  const promptMode = INTERACTION_TO_PROMPT_MODE[mode];
 
-  ask: (ctx) => {
-    const projectContext =
-      ctx.projectContext ?? getProjectContextForAskMode(ctx.workingDir);
-    return buildAskPrompt({
-      workingDir: ctx.workingDir,
-      isGitRepo: ctx.isGitRepo,
-      platform: ctx.platform,
-      today: ctx.today,
-      model: ctx.model,
-      projectContext,
-    });
-  },
+  // Build context for ask mode
+  const projectContext =
+    mode === "ask"
+      ? context.projectContext ?? getProjectContextForAskMode(context.workingDir)
+      : undefined;
 
-  "code-review": (ctx) =>
-    buildCodeReviewPrompt({
-      workingDir: ctx.workingDir,
-      isGitRepo: ctx.isGitRepo,
-      platform: ctx.platform,
-      today: ctx.today,
-      model: ctx.model,
-      prContext: ctx.prContext,
-    }),
+  // Create mode-aware prompt context
+  const modeContext: ModePromptContext = {
+    workingDir: context.workingDir,
+    isGitRepo: context.isGitRepo,
+    platform: context.platform,
+    today: context.today,
+    modelId: context.model || "gpt-4o", // Default to balanced model
+    gitBranch: context.gitBranch,
+    gitStatus: context.gitStatus,
+    recentCommits: context.recentCommits,
+    projectRules: undefined, // Will be added by rules-service
+    customInstructions: projectContext,
+    mode: promptMode,
+    prContext: context.prContext,
+    debugContext: context.debugContext,
+    planContext: context.planContext,
+  };
+
+  return composePrompt(modeContext);
 };
 
 /**
@@ -155,8 +170,18 @@ export const buildModePrompt = (
   mode: InteractionMode,
   context: PromptContext,
 ): string => {
-  const builder = MODE_PROMPT_BUILDERS[mode];
-  return builder(context);
+  const composed = buildModePromptWithTier(mode, context);
+  return composed.prompt;
+};
+
+/**
+ * Build the base prompt with full tier/provider info
+ */
+export const buildModePromptWithInfo = (
+  mode: InteractionMode,
+  context: PromptContext,
+): ComposedPrompt => {
+  return buildModePromptWithTier(mode, context);
 };
 
 /**
@@ -198,12 +223,16 @@ export const createPromptBuilder = (initialModel?: string) => {
   ): Promise<string> => {
     const context = await buildBaseContext(initialModel);
     const { prompt } = await buildCompletePrompt(mode, context, appendPrompt);
+    const composed = buildModePromptWithTier(mode, context);
 
     state = {
       currentMode: mode,
-      basePrompt: buildModePrompt(mode, context),
+      basePrompt: composed.prompt,
       fullPrompt: prompt,
       context,
+      tier: composed.tier,
+      provider: composed.provider,
+      params: composed.params,
     };
 
     return prompt;
@@ -226,12 +255,16 @@ export const createPromptBuilder = (initialModel?: string) => {
       state.context,
       appendPrompt,
     );
+    const composed = buildModePromptWithTier(newMode, state.context);
 
     state = {
       currentMode: newMode,
-      basePrompt: buildModePrompt(newMode, state.context),
+      basePrompt: composed.prompt,
       fullPrompt: prompt,
       context: state.context,
+      tier: composed.tier,
+      provider: composed.provider,
+      params: composed.params,
     };
 
     return prompt;
@@ -242,6 +275,15 @@ export const createPromptBuilder = (initialModel?: string) => {
   const getCurrentMode = (): InteractionMode | null =>
     state?.currentMode ?? null;
 
+  const getModelInfo = (): { tier: ModelTier; provider: ModelProvider; params: ModelParams } | null => {
+    if (!state) return null;
+    return {
+      tier: state.tier,
+      provider: state.provider,
+      params: state.params,
+    };
+  };
+
   const updateContext = async (
     updates: Partial<PromptContext>,
     appendPrompt?: string,
@@ -256,11 +298,15 @@ export const createPromptBuilder = (initialModel?: string) => {
       newContext,
       appendPrompt,
     );
+    const composed = buildModePromptWithTier(state.currentMode, newContext);
 
     state = {
       ...state,
       context: newContext,
       fullPrompt: prompt,
+      tier: composed.tier,
+      provider: composed.provider,
+      params: composed.params,
     };
 
     return prompt;
@@ -271,6 +317,7 @@ export const createPromptBuilder = (initialModel?: string) => {
     switchMode,
     getCurrentPrompt,
     getCurrentMode,
+    getModelInfo,
     updateContext,
   };
 };

src/tools/core/registry.ts

@@ -20,6 +20,8 @@ import { webFetchTool } from "@tools/web-fetch/execute";
 import { multiEditTool } from "@tools/multi-edit/execute";
 import { lspTool } from "@/tools/lsp";
 import { applyPatchTool } from "@/tools/apply-patch";
+import { planApprovalTool } from "@/tools/plan-approval/execute";
+import { taskAgentTool } from "@/tools/task-agent/execute";
 import {
   isMCPTool,
   executeMCPTool,
@@ -49,6 +51,8 @@ export const tools: ToolDefinition[] = [
   webFetchTool,
   lspTool,
   applyPatchTool,
+  planApprovalTool,
+  taskAgentTool,
 ];
 
 /**

src/tools/plan-approval/execute.ts

@@ -0,0 +1,450 @@
+/**
+ * Plan Approval Tool
+ *
+ * Allows agents to submit implementation plans for user approval.
+ * This tool implements the approval gate pattern from claude-code and opencode.
+ */
+
+import { z } from "zod";
+import type { ToolDefinition, ToolContext, ToolResult } from "@/types/tools";
+import {
+  createPlan,
+  addPlanStep,
+  updatePlanContext,
+  addPlanRisk,
+  submitPlanForApproval,
+  formatPlanForDisplay,
+  getPlan,
+  analyzeTask,
+} from "@services/plan-mode/plan-service";
+
+/**
+ * Parameters for the plan approval tool
+ */
+const planApprovalSchema = z.object({
+  action: z
+    .enum([
+      "create",
+      "add_step",
+      "add_context",
+      "add_risk",
+      "submit",
+      "check_status",
+      "analyze_task",
+    ])
+    .describe("The action to perform"),
+
+  // For create action
+  title: z
+    .string()
+    .optional()
+    .describe("Title of the implementation plan"),
+  summary: z
+    .string()
+    .optional()
+    .describe("Summary of what the plan will accomplish"),
+
+  // For add_step action
+  plan_id: z
+    .string()
+    .optional()
+    .describe("ID of the plan to modify"),
+  step_title: z
+    .string()
+    .optional()
+    .describe("Title of the step"),
+  step_description: z
+    .string()
+    .optional()
+    .describe("Description of what this step does"),
+  files_affected: z
+    .array(z.string())
+    .optional()
+    .describe("Files that will be affected by this step"),
+  risk_level: z
+    .enum(["low", "medium", "high"])
+    .optional()
+    .describe("Risk level of this step"),
+
+  // For add_context action
+  files_analyzed: z
+    .array(z.string())
+    .optional()
+    .describe("Files that were analyzed for this plan"),
+  current_architecture: z
+    .string()
+    .optional()
+    .describe("Description of current architecture"),
+  dependencies: z
+    .array(z.string())
+    .optional()
+    .describe("Dependencies identified"),
+
+  // For add_risk action
+  risk_description: z
+    .string()
+    .optional()
+    .describe("Description of the risk"),
+  risk_impact: z
+    .enum(["low", "medium", "high"])
+    .optional()
+    .describe("Impact level of the risk"),
+  risk_mitigation: z
+    .string()
+    .optional()
+    .describe("How to mitigate this risk"),
+
+  // For submit action
+  testing_strategy: z
+    .string()
+    .optional()
+    .describe("How the changes will be tested"),
+  rollback_plan: z
+    .string()
+    .optional()
+    .describe("How to rollback if something goes wrong"),
+
+  // For analyze_task action
+  task_description: z
+    .string()
+    .optional()
+    .describe("The task to analyze for complexity"),
+});
+
+type PlanApprovalParams = z.infer<typeof planApprovalSchema>;
+
+/**
+ * Execute the plan approval tool
+ */
+export const executePlanApproval = async (
+  params: PlanApprovalParams,
+  _ctx: ToolContext,
+): Promise<ToolResult> => {
+  const actionHandlers: Record<string, () => ToolResult> = {
+    create: () => handleCreate(params),
+    add_step: () => handleAddStep(params),
+    add_context: () => handleAddContext(params),
+    add_risk: () => handleAddRisk(params),
+    submit: () => handleSubmit(params),
+    check_status: () => handleCheckStatus(params),
+    analyze_task: () => handleAnalyzeTask(params),
+  };
+
+  const handler = actionHandlers[params.action];
+  if (!handler) {
+    return {
+      success: false,
+      title: "Unknown action",
+      output: "",
+      error: `Unknown action: ${params.action}`,
+    };
+  }
+
+  return handler();
+};
+
+/**
+ * Handle create action
+ */
+const handleCreate = (params: PlanApprovalParams): ToolResult => {
+  if (!params.title || !params.summary) {
+    return {
+      success: false,
+      title: "Missing parameters",
+      output: "",
+      error: "Both title and summary are required for create action",
+    };
+  }
+
+  const plan = createPlan(params.title, params.summary);
+
+  return {
+    success: true,
+    title: "Plan created",
+    output: `Created implementation plan with ID: ${plan.id}\n\nNow add steps, context, and risks before submitting for approval.`,
+  };
+};
+
+/**
+ * Handle add_step action
+ */
+const handleAddStep = (params: PlanApprovalParams): ToolResult => {
+  if (!params.plan_id || !params.step_title || !params.step_description) {
+    return {
+      success: false,
+      title: "Missing parameters",
+      output: "",
+      error: "plan_id, step_title, and step_description are required",
+    };
+  }
+
+  const step = addPlanStep(params.plan_id, {
+    title: params.step_title,
+    description: params.step_description,
+    filesAffected: params.files_affected ?? [],
+    riskLevel: params.risk_level ?? "low",
+  });
+
+  if (!step) {
+    return {
+      success: false,
+      title: "Failed to add step",
+      output: "",
+      error: "Plan not found or not in drafting status",
+    };
+  }
+
+  return {
+    success: true,
+    title: "Step added",
+    output: `Added step: ${step.title} (ID: ${step.id})`,
+  };
+};
+
+/**
+ * Handle add_context action
+ */
+const handleAddContext = (params: PlanApprovalParams): ToolResult => {
+  if (!params.plan_id) {
+    return {
+      success: false,
+      title: "Missing parameters",
+      output: "",
+      error: "plan_id is required",
+    };
+  }
+
+  const context: Partial<{
+    filesAnalyzed: string[];
+    currentArchitecture: string;
+    dependencies: string[];
+  }> = {};
+
+  if (params.files_analyzed) {
+    context.filesAnalyzed = params.files_analyzed;
+  }
+  if (params.current_architecture) {
+    context.currentArchitecture = params.current_architecture;
+  }
+  if (params.dependencies) {
+    context.dependencies = params.dependencies;
+  }
+
+  const success = updatePlanContext(params.plan_id, context);
+
+  if (!success) {
+    return {
+      success: false,
+      title: "Failed to update context",
+      output: "",
+      error: "Plan not found",
+    };
+  }
+
+  return {
+    success: true,
+    title: "Context updated",
+    output: "Plan context has been updated",
+  };
+};
+
+/**
+ * Handle add_risk action
+ */
+const handleAddRisk = (params: PlanApprovalParams): ToolResult => {
+  if (!params.plan_id || !params.risk_description || !params.risk_impact || !params.risk_mitigation) {
+    return {
+      success: false,
+      title: "Missing parameters",
+      output: "",
+      error: "plan_id, risk_description, risk_impact, and risk_mitigation are required",
+    };
+  }
+
+  const success = addPlanRisk(params.plan_id, {
+    description: params.risk_description,
+    impact: params.risk_impact,
+    mitigation: params.risk_mitigation,
+  });
+
+  if (!success) {
+    return {
+      success: false,
+      title: "Failed to add risk",
+      output: "",
+      error: "Plan not found",
+    };
+  }
+
+  return {
+    success: true,
+    title: "Risk added",
+    output: `Added risk: ${params.risk_description}`,
+  };
+};
+
+/**
+ * Handle submit action
+ */
+const handleSubmit = (params: PlanApprovalParams): ToolResult => {
+  if (!params.plan_id) {
+    return {
+      success: false,
+      title: "Missing parameters",
+      output: "",
+      error: "plan_id is required",
+    };
+  }
+
+  const success = submitPlanForApproval(
+    params.plan_id,
+    params.testing_strategy ?? "Run existing tests and verify changes manually",
+    params.rollback_plan ?? "Revert changes using git",
+  );
+
+  if (!success) {
+    return {
+      success: false,
+      title: "Failed to submit plan",
+      output: "",
+      error: "Plan not found or not in drafting status",
+    };
+  }
+
+  const plan = getPlan(params.plan_id);
+  if (!plan) {
+    return {
+      success: false,
+      title: "Plan not found",
+      output: "",
+      error: "Plan was submitted but could not be retrieved",
+    };
+  }
+
+  const formattedPlan = formatPlanForDisplay(plan);
+
+  return {
+    success: true,
+    title: "Plan submitted for approval",
+    output: formattedPlan,
+    metadata: {
+      planId: plan.id,
+      planStatus: "pending",
+      requiresApproval: true,
+    },
+  };
+};
+
+/**
+ * Handle check_status action
+ */
+const handleCheckStatus = (params: PlanApprovalParams): ToolResult => {
+  if (!params.plan_id) {
+    return {
+      success: false,
+      title: "Missing parameters",
+      output: "",
+      error: "plan_id is required",
+    };
+  }
+
+  const plan = getPlan(params.plan_id);
+  if (!plan) {
+    return {
+      success: false,
+      title: "Plan not found",
+      output: "",
+      error: `No plan found with ID: ${params.plan_id}`,
+    };
+  }
+
+  const statusMessages: Record<string, string> = {
+    drafting: "Plan is being drafted. Add steps, context, and risks, then submit for approval.",
+    pending: "Plan is awaiting user approval. Wait for the user to approve or provide feedback.",
+    approved: "Plan has been approved. You may proceed with implementation.",
+    rejected: `Plan was rejected. Reason: ${plan.rejectionReason ?? "No reason provided"}`,
+    executing: "Plan is currently being executed.",
+    completed: "Plan execution completed successfully.",
+    failed: "Plan execution failed.",
+  };
+
+  return {
+    success: true,
+    title: `Plan status: ${plan.status}`,
+    output: statusMessages[plan.status] ?? `Unknown status: ${plan.status}`,
+    metadata: {
+      planId: plan.id,
+      planStatus: plan.status,
+      stepsCompleted: plan.steps.filter(s => s.status === "completed").length,
+      totalSteps: plan.steps.length,
+    },
+  };
+};
+
+/**
+ * Handle analyze_task action
+ */
+const handleAnalyzeTask = (params: PlanApprovalParams): ToolResult => {
+  if (!params.task_description) {
+    return {
+      success: false,
+      title: "Missing parameters",
+      output: "",
+      error: "task_description is required",
+    };
+  }
+
+  const analysis = analyzeTask(params.task_description);
+
+  const output = [
+    `## Task Analysis`,
+    ``,
+    `**Complexity**: ${analysis.complexity}`,
+    `**Requires Plan Approval**: ${analysis.requiresPlanApproval ? "Yes" : "No"}`,
+    ``,
+    `**Suggested Approach**: ${analysis.suggestedApproach}`,
+  ];
+
+  if (analysis.reasons.length > 0) {
+    output.push(``, `**Reasons**:`);
+    analysis.reasons.forEach(r => output.push(`- ${r}`));
+  }
+
+  return {
+    success: true,
+    title: `Task complexity: ${analysis.complexity}`,
+    output: output.join("\n"),
+    metadata: {
+      complexity: analysis.complexity,
+      requiresPlanApproval: analysis.requiresPlanApproval,
+    },
+  };
+};
+
+/**
+ * Tool definition for plan approval
+ */
+export const planApprovalTool: ToolDefinition<typeof planApprovalSchema> = {
+  name: "plan_approval",
+  description: `Submit implementation plans for user approval before executing complex tasks.
+
+Use this tool when:
+- Making changes to 3+ files
+- Refactoring code
+- Architectural changes
+- Security-related changes
+- Database modifications
+
+Workflow:
+1. analyze_task - Check if task needs plan approval
+2. create - Create a new plan with title and summary
+3. add_context - Add files analyzed, architecture info
+4. add_step - Add each implementation step (repeat)
+5. add_risk - Add identified risks
+6. submit - Submit plan and wait for user approval
+7. check_status - Check if user approved
+
+After approval, proceed with implementation. If rejected, address feedback and resubmit.`,
+  parameters: planApprovalSchema,
+  execute: executePlanApproval,
+};

src/tools/task-agent/execute.ts

@@ -0,0 +1,391 @@
+/**
+ * Task Agent Tool
+ *
+ * Allows spawning specialized sub-agents for complex tasks.
+ * Implements the agent delegation pattern from claude-code.
+ */
+
+import { z } from "zod";
+import { v4 as uuidv4 } from "uuid";
+import type { ToolDefinition, ToolContext, ToolResult } from "@/types/tools";
+
+/**
+ * Agent types available for delegation
+ */
+const AGENT_TYPES = {
+  explore: {
+    description: "Fast codebase exploration (read-only)",
+    tools: ["glob", "grep", "read"],
+    tier: "fast",
+    maxTurns: 10,
+  },
+  implement: {
+    description: "Code writing and modification",
+    tools: ["glob", "grep", "read", "write", "edit", "bash"],
+    tier: "balanced",
+    maxTurns: 20,
+  },
+  test: {
+    description: "Test creation and execution",
+    tools: ["glob", "grep", "read", "write", "edit", "bash"],
+    tier: "balanced",
+    maxTurns: 15,
+  },
+  review: {
+    description: "Code review and suggestions",
+    tools: ["glob", "grep", "read"],
+    tier: "balanced",
+    maxTurns: 10,
+  },
+  refactor: {
+    description: "Code refactoring and improvement",
+    tools: ["glob", "grep", "read", "write", "edit"],
+    tier: "thorough",
+    maxTurns: 25,
+  },
+  plan: {
+    description: "Planning and architecture design",
+    tools: ["glob", "grep", "read", "plan_approval"],
+    tier: "thorough",
+    maxTurns: 15,
+  },
+} as const;
+
+type AgentType = keyof typeof AGENT_TYPES;
+
+/**
+ * Parameters for the task agent tool
+ */
+const taskAgentSchema = z.object({
+  agent_type: z
+    .enum(["explore", "implement", "test", "review", "refactor", "plan"])
+    .describe("The type of specialized agent to spawn"),
+
+  task: z
+    .string()
+    .describe("The task for the agent to perform"),
+
+  context_files: z
+    .array(z.string())
+    .optional()
+    .describe("Files to include as context for the agent"),
+
+  run_in_background: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe("Whether to run the agent in the background"),
+
+  max_turns: z
+    .number()
+    .optional()
+    .describe("Maximum number of turns for the agent"),
+});
+
+type TaskAgentParams = z.infer<typeof taskAgentSchema>;
+
+/**
+ * Active background agents
+ */
+const backgroundAgents = new Map<string, {
+  type: AgentType;
+  task: string;
+  startTime: number;
+  promise: Promise<ToolResult>;
+}>();
+
+/**
+ * Execute the task agent tool
+ */
+export const executeTaskAgent = async (
+  params: TaskAgentParams,
+  ctx: ToolContext,
+): Promise<ToolResult> => {
+  const agentConfig = AGENT_TYPES[params.agent_type];
+
+  // Build the agent system prompt
+  const systemPrompt = buildAgentSystemPrompt(params.agent_type, agentConfig);
+
+  // Build the task prompt
+  const taskPrompt = buildTaskPrompt(params);
+
+  if (params.run_in_background) {
+    return runAgentInBackground(params, systemPrompt, taskPrompt, ctx);
+  }
+
+  return runAgentInForeground(params, systemPrompt, taskPrompt, ctx);
+};
+
+/**
+ * Build system prompt for the agent
+ */
+const buildAgentSystemPrompt = (
+  agentType: AgentType,
+  config: typeof AGENT_TYPES[AgentType],
+): string => {
+  const prompts: Record<AgentType, string> = {
+    explore: `You are an EXPLORATION agent. Your task is to quickly understand code.
+
+## Rules
+- USE ONLY: glob, grep, read
+- DO NOT modify any files
+- Focus on finding and understanding relevant code
+- Report findings concisely
+
+## Output Format
+Provide structured findings:
+- Key files found
+- Important patterns
+- Relevant code locations (file:line)`,
+
+    implement: `You are an IMPLEMENTATION agent. Your task is to write code.
+
+## Rules
+- Read existing code before modifying
+- Follow existing patterns and conventions
+- Make minimal, focused changes
+- Verify changes with type checks or tests
+
+## Output Format
+- Summarize changes made
+- List files modified
+- Report any issues encountered`,
+
+    test: `You are a TESTING agent. Your task is to write and run tests.
+
+## Rules
+- Write deterministic tests
+- Mock external dependencies
+- Cover edge cases
+- Run tests after writing
+
+## Output Format
+- Tests created
+- Test results
+- Coverage notes`,
+
+    review: `You are a REVIEW agent. Your task is to review code quality.
+
+## Rules
+- Check for bugs and issues
+- Evaluate code quality
+- Suggest improvements
+- Be constructive
+
+## Output Format
+- Issues found (severity, location, description)
+- Suggestions for improvement
+- Overall assessment`,
+
+    refactor: `You are a REFACTORING agent. Your task is to improve code structure.
+
+## Rules
+- Preserve existing behavior
+- Improve readability and maintainability
+- Follow SOLID principles
+- Verify with tests after changes
+
+## Output Format
+- Changes made
+- Improvements achieved
+- Verification results`,
+
+    plan: `You are a PLANNING agent. Your task is to design implementation plans.
+
+## Rules
+- Explore thoroughly before planning
+- Consider edge cases and risks
+- Break down into manageable steps
+- Use plan_approval tool to submit plans
+
+## Output Format
+- Context analysis
+- Implementation steps
+- Risks and mitigations
+- Testing strategy`,
+  };
+
+  return `${prompts[agentType]}
+
+## Available Tools
+${config.tools.join(", ")}
+
+## Tier
+${config.tier} (max ${config.maxTurns} turns)`;
+};
+
+/**
+ * Build task prompt with context
+ */
+const buildTaskPrompt = (params: TaskAgentParams): string => {
+  const parts = [`## Task\n${params.task}`];
+
+  if (params.context_files?.length) {
+    parts.push(`\n## Context Files\n${params.context_files.map(f => `- ${f}`).join("\n")}`);
+  }
+
+  return parts.join("\n");
+};
+
+/**
+ * Run agent in foreground (blocking)
+ */
+const runAgentInForeground = async (
+  params: TaskAgentParams,
+  systemPrompt: string,
+  taskPrompt: string,
+  _ctx: ToolContext,
+): Promise<ToolResult> => {
+  const startTime = Date.now();
+
+  try {
+    // Dynamic import to avoid circular dependencies
+    const { runAgent } = await import("@services/core/agent");
+
+    const agentConfig = AGENT_TYPES[params.agent_type];
+
+    // Get appropriate model for tier
+    const tierModels: Record<string, string> = {
+      fast: "gpt-4o-mini",
+      balanced: "gpt-4o",
+      thorough: "gpt-4o",
+    };
+
+    const model = tierModels[agentConfig.tier] ?? "gpt-4o";
+
+    const result = await runAgent(taskPrompt, systemPrompt, {
+      provider: "copilot",
+      model,
+      autoApprove: true,
+      maxIterations: params.max_turns ?? agentConfig.maxTurns,
+    });
+
+    const duration = Date.now() - startTime;
+
+    return {
+      success: result.success,
+      title: `${params.agent_type} agent completed`,
+      output: `## Agent Result (${params.agent_type})\n\nDuration: ${(duration / 1000).toFixed(1)}s\nIterations: ${result.iterations}\nTool calls: ${result.toolCalls.length}\n\n${result.finalResponse}`,
+      metadata: {
+        agentType: params.agent_type,
+        duration,
+        iterations: result.iterations,
+        toolCalls: result.toolCalls.length,
+      },
+    };
+  } catch (error) {
+    return {
+      success: false,
+      title: `${params.agent_type} agent failed`,
+      output: "",
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+};
+
+/**
+ * Run agent in background (non-blocking)
+ */
+const runAgentInBackground = async (
+  params: TaskAgentParams,
+  systemPrompt: string,
+  taskPrompt: string,
+  ctx: ToolContext,
+): Promise<ToolResult> => {
+  const agentId = uuidv4();
+
+  const promise = runAgentInForeground(params, systemPrompt, taskPrompt, ctx);
+
+  backgroundAgents.set(agentId, {
+    type: params.agent_type,
+    task: params.task,
+    startTime: Date.now(),
+    promise,
+  });
+
+  // Cleanup after completion
+  promise.then(() => {
+    // Keep result for 5 minutes
+    setTimeout(() => backgroundAgents.delete(agentId), 5 * 60 * 1000);
+  });
+
+  return {
+    success: true,
+    title: `${params.agent_type} agent started in background`,
+    output: `Agent ID: ${agentId}\n\nThe ${params.agent_type} agent is now running in the background.\nUse the agent ID to check status or retrieve results.`,
+    metadata: {
+      agentId,
+      agentType: params.agent_type,
+      runningInBackground: true,
+    },
+  };
+};
+
+/**
+ * Get background agent status
+ */
+export const getBackgroundAgentStatus = async (
+  agentId: string,
+): Promise<ToolResult> => {
+  const agent = backgroundAgents.get(agentId);
+
+  if (!agent) {
+    return {
+      success: false,
+      title: "Agent not found",
+      output: "",
+      error: `No background agent found with ID: ${agentId}`,
+    };
+  }
+
+  // Check if completed
+  const result = await Promise.race([
+    agent.promise.then(r => ({ completed: true, result: r })),
+    new Promise<{ completed: false }>(resolve =>
+      setTimeout(() => resolve({ completed: false }), 100),
+    ),
+  ]);
+
+  if (result.completed) {
+    return result.result;
+  }
+
+  const runningTime = Date.now() - agent.startTime;
+
+  return {
+    success: true,
+    title: "Agent still running",
+    output: `Agent ${agent.type} is still running.\nTask: ${agent.task}\nRunning for: ${(runningTime / 1000).toFixed(1)}s`,
+    metadata: {
+      agentId,
+      agentType: agent.type,
+      runningTime,
+      status: "running",
+    },
+  };
+};
+
+/**
+ * Tool definition for task agent
+ */
+export const taskAgentTool: ToolDefinition<typeof taskAgentSchema> = {
+  name: "task_agent",
+  description: `Spawn a specialized sub-agent for complex tasks.
+
+Available agent types:
+- explore: Fast codebase exploration (read-only)
+- implement: Code writing and modification
+- test: Test creation and execution
+- review: Code review and suggestions
+- refactor: Code refactoring and improvement
+- plan: Planning and architecture design
+
+Use agents when:
+- Task requires specialized focus
+- Multiple parallel investigations needed
+- Complex implementation that benefits from isolation
+
+Agents run with their own context and tools, returning results when complete.`,
+  parameters: taskAgentSchema,
+  execute: executeTaskAgent,
+};

src/types/plan-mode.ts

@@ -0,0 +1,133 @@
+/**
+ * Plan Mode Types
+ *
+ * Types for the plan approval workflow that gates complex operations.
+ */
+
+/**
+ * Plan status
+ */
+export type PlanStatus =
+  | "drafting"      // Plan is being created
+  | "pending"       // Plan submitted, awaiting approval
+  | "approved"      // User approved the plan
+  | "rejected"      // User rejected the plan
+  | "executing"     // Plan is being executed
+  | "completed"     // Plan execution completed
+  | "failed";       // Plan execution failed
+
+/**
+ * A single step in the plan
+ */
+export interface PlanStep {
+  id: string;
+  title: string;
+  description: string;
+  filesAffected: string[];
+  riskLevel: "low" | "medium" | "high";
+  status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+  output?: string;
+  error?: string;
+}
+
+/**
+ * A complete implementation plan
+ */
+export interface ImplementationPlan {
+  id: string;
+  title: string;
+  summary: string;
+  context: {
+    filesAnalyzed: string[];
+    currentArchitecture: string;
+    dependencies: string[];
+  };
+  steps: PlanStep[];
+  risks: Array<{
+    description: string;
+    impact: "low" | "medium" | "high";
+    mitigation: string;
+  }>;
+  testingStrategy: string;
+  rollbackPlan: string;
+  estimatedChanges: {
+    filesCreated: number;
+    filesModified: number;
+    filesDeleted: number;
+  };
+  status: PlanStatus;
+  createdAt: number;
+  approvedAt?: number;
+  completedAt?: number;
+  approvalMessage?: string;
+  rejectionReason?: string;
+}
+
+/**
+ * Plan approval request
+ */
+export interface PlanApprovalRequest {
+  plan: ImplementationPlan;
+  autoApproveSimple?: boolean;
+  timeout?: number;
+}
+
+/**
+ * Plan approval response
+ */
+export interface PlanApprovalResponse {
+  approved: boolean;
+  message?: string;
+  modifiedPlan?: ImplementationPlan;
+}
+
+/**
+ * Criteria for determining if a task needs plan approval
+ */
+export interface PlanApprovalCriteria {
+  /** Minimum number of files affected to require approval */
+  minFilesAffected: number;
+  /** Minimum number of steps to require approval */
+  minSteps: number;
+  /** Always require approval for these operations */
+  alwaysRequireFor: Array<
+    | "delete"
+    | "refactor"
+    | "architecture"
+    | "security"
+    | "database"
+    | "config"
+  >;
+  /** Skip approval for these simple operations */
+  skipApprovalFor: Array<
+    | "single_file_edit"
+    | "add_comment"
+    | "fix_typo"
+    | "format"
+  >;
+}
+
+/**
+ * Default criteria for plan approval
+ */
+export const DEFAULT_PLAN_APPROVAL_CRITERIA: PlanApprovalCriteria = {
+  minFilesAffected: 3,
+  minSteps: 5,
+  alwaysRequireFor: ["delete", "refactor", "architecture", "security", "database"],
+  skipApprovalFor: ["single_file_edit", "add_comment", "fix_typo", "format"],
+};
+
+/**
+ * Task complexity levels
+ */
+export type TaskComplexity = "simple" | "moderate" | "complex" | "critical";
+
+/**
+ * Task analysis result
+ */
+export interface TaskAnalysis {
+  complexity: TaskComplexity;
+  requiresPlanApproval: boolean;
+  reasons: string[];
+  suggestedApproach: string;
+}

tmp.txt

@@ -1 +0,0 @@
-hi