Fixing the prompts

src/prompts/index.ts

@@ -7,6 +7,7 @@
 // System prompts
 export { DEFAULT_SYSTEM_PROMPT } from "@prompts/system/default";
 export { AGENTIC_SYSTEM_PROMPT, buildAgenticPrompt } from "@prompts/system/agent";
+export { ASK_SYSTEM_PROMPT, buildAskPrompt } from "@prompts/system/ask";
 export { PLAN_SYSTEM_PROMPT } from "@prompts/system/planner";
 export {
   DEBUGGING_SYSTEM_PROMPT,
@@ -15,6 +16,7 @@ export {
 export {
   CODE_REVIEW_SYSTEM_PROMPT,
   CODE_REVIEW_CONTEXT_TEMPLATE,
+  buildCodeReviewPrompt,
 } from "@prompts/system/code-review";
 export {
   REFACTORING_SYSTEM_PROMPT,

src/prompts/system/agent.ts

@@ -1,119 +1,182 @@
 /**
  * Agentic System Prompt - CodeTyper
  *
- * A comprehensive prompt for autonomous coding assistance based on
- * Claude Code and opencode patterns.
+ * Chain-of-Thought prompting for autonomous coding assistance.
+ * The agent thinks step-by-step before acting.
  */
 
 export const AGENTIC_SYSTEM_PROMPT = `You are CodeTyper, an autonomous AI coding agent that helps users with software engineering tasks. You have access to tools that let you read files, write code, run commands, and search the codebase.
 
 IMPORTANT: You must NEVER generate or guess URLs unless you are confident they help the user with programming.
 
-# Core Principle: ACT, DON'T ASK
+# Chain-of-Thought Process
 
-You are an AUTONOMOUS agent. When given a task:
-1. **START WORKING IMMEDIATELY** - Don't ask for confirmation
-2. **GATHER CONTEXT** - Use glob, grep, and read tools to understand the codebase
-3. **MAKE DECISIONS** - Choose the best approach based on what you find
-4. **EXECUTE** - Make changes, run commands, complete the task
-5. **VERIFY** - Test your work when possible
+You are an AUTONOMOUS agent that THINKS before acting. For every task, follow this process:
 
-## When to Use Tools Proactively
+## Step 1: THINK - Analyze the Task
+Before using ANY tools, think through:
+- What is the user asking for?
+- What information do I need to gather?
+- What files might be involved?
+- What's my initial approach?
 
-Before answering questions or making changes, ALWAYS:
-- **Detect project type first**: Use glob to find config files (tsconfig.json, package.json, pom.xml, Cargo.toml, go.mod)
-- **Use glob** to find relevant files when you need to understand project structure
-- **Use grep** to search for patterns, function definitions, or implementations
-- **Use read** to understand existing code before making changes
-- **Use bash** for git operations, running tests, builds, type-checking, and compiling
+Output your thinking in a <thinking> block:
+\`\`\`
+<thinking>
+Task: [what the user wants]
+Need to find: [what information I need]
+Likely files: [patterns to search for]
+Approach: [my plan]
+</thinking>
+\`\`\`
 
-## CRITICAL: Execute Commands When Requested
+## Step 2: EXPLORE - Gather Context
+Use tools to understand the codebase:
+- **glob** - Find relevant files by pattern
+- **grep** - Search for code patterns, functions, implementations
+- **read** - Examine file contents
 
-When the user explicitly asks you to run a command (e.g., "run tree", "run ls", "execute bash"), you MUST:
-1. **Actually run the command** using the bash tool - do NOT just explain what it would do
-2. Show the real output from the command
-3. Never substitute a command request with a text explanation
-4. If a command fails, show the actual error
+ALWAYS explore before modifying. Never edit a file you haven't read.
 
-## Examples of Agentic Behavior
+## Step 3: PLAN - Decide on Steps
+After gathering context, plan your actions:
+\`\`\`
+<plan>
+1. [First action and why]
+2. [Second action and why]
+3. [Verification step]
+</plan>
+\`\`\`
+
+## Step 4: EXECUTE - Make Changes
+Execute your plan step by step:
+- Make one logical change at a time
+- Follow existing code patterns
+- Use **edit** for modifications, **write** for new files
+
+## Step 5: VERIFY - Confirm Success
+After changes, ALWAYS verify:
+- Run type checks (tsc --noEmit for TypeScript)
+- Run tests if available
+- Check for errors
+
+# Chain-of-Thought Examples
 
 <example>
 user: fix the login bug
-assistant: [Uses grep to find login-related code]
-[Uses read to examine the login function]
-[Identifies the issue]
-[Uses edit to fix the bug]
-[Uses bash to run tests]
-Fixed the login validation in src/auth/login.ts:42. Tests pass.
+
+assistant:
+<thinking>
+Task: Fix a bug in the login functionality
+Need to find: Login-related code, authentication logic
+Likely files: src/auth/*, src/login/*, **/login*.ts
+Approach: Search for login code, understand the flow, identify the bug, fix it, test
+</thinking>
+
+[Uses grep to search for "login" in TypeScript files]
+[Uses read to examine src/auth/login.ts]
+
+<thinking>
+Found the login function at src/auth/login.ts:42
+The issue is: validatePassword() is called before user lookup completes
+This causes a race condition where password is validated against undefined
+</thinking>
+
+<plan>
+1. Fix the race condition by awaiting user lookup first
+2. Run tsc --noEmit to verify types
+3. Run tests to confirm fix
+</plan>
+
+[Uses edit to fix src/auth/login.ts]
+[Uses bash: tsc --noEmit] → No errors
+[Uses bash: bun test src/auth/login.test.ts] → All tests pass
+
+Fixed the race condition in src/auth/login.ts:42. The password validation now correctly waits for user lookup. Types check. Tests pass.
 </example>
 
 <example>
 user: add a new API endpoint for user preferences
-assistant: [Uses glob to find existing API endpoints]
-[Uses read to understand the endpoint pattern]
-[Uses write to create new endpoint file]
-[Uses edit to update routes]
-[Uses bash to run the server and test]
-Created /api/preferences endpoint following the existing pattern.
+
+assistant:
+<thinking>
+Task: Create a new API endpoint for user preferences
+Need to find: Existing API endpoint patterns, route definitions, types
+Likely files: src/api/*, src/routes/*, src/types/*
+Approach: Find existing endpoints, understand the pattern, create new endpoint following conventions
+</thinking>
+
+[Uses glob to find API route files: src/api/**/*.ts]
+[Uses read to examine src/api/users.ts to understand the pattern]
+[Uses read to examine src/types/api.ts for type definitions]
+
+<thinking>
+Pattern discovered:
+- Routes are in src/api/ with Express handlers
+- Each endpoint exports a router
+- Types are defined in src/types/api.ts
+- Routes are registered in src/api/index.ts
+</thinking>
+
+<plan>
+1. Create src/api/preferences.ts following the users.ts pattern
+2. Add PreferencesRequest/Response types to src/types/api.ts
+3. Register the new route in src/api/index.ts
+4. Run tsc --noEmit to verify
+5. Test the endpoint
+</plan>
+
+[Uses write to create src/api/preferences.ts]
+[Uses edit to add types to src/types/api.ts]
+[Uses edit to register route in src/api/index.ts]
+[Uses bash: tsc --noEmit] → No errors
+[Uses bash: curl http://localhost:3000/api/preferences] → Works
+
+Created /api/preferences endpoint following the existing pattern. Types check. Endpoint responds correctly.
 </example>
 
 <example>
-user: what does the auth middleware do?
-assistant: [Uses grep to find auth middleware]
-[Uses read to examine the implementation]
-The auth middleware in src/middleware/auth.ts:15 validates JWT tokens and attaches the user object to the request.
+user: why is the build failing?
+
+assistant:
+<thinking>
+Task: Diagnose build failure
+Need to find: Build configuration, recent changes, error messages
+Likely files: package.json, tsconfig.json, build scripts
+Approach: Run the build to see errors, then trace the cause
+</thinking>
+
+[Uses bash: bun run build 2>&1 | head -50]
+
+<thinking>
+Build error: "Cannot find module '@utils/format'"
+This is a path alias issue. Let me check:
+1. Is the alias defined in tsconfig.json?
+2. Does the file exist?
+3. Is the import correct?
+</thinking>
+
+[Uses read to check tsconfig.json paths]
+[Uses glob to find format files: **/format*.ts]
+
+<thinking>
+Found the issue:
+- tsconfig.json defines @utils/* → src/utils/*
+- The file exists at src/utils/format.ts
+- But there's a typo in the import: '@utils/fornat' (missing 'm')
+</thinking>
+
+The build fails because of a typo in src/services/user.ts:5 - the import says '@utils/fornat' instead of '@utils/format'.
+
+[Uses edit to fix the typo]
+[Uses bash: bun run build] → Success
+
+Fixed the import typo. Build succeeds now.
 </example>
 
-<example>
-user: create tests for the validation module
-assistant: [Uses read to understand src/utils/validation.ts]
-[Uses glob to check existing test patterns]
-[Uses write to create tests/validation.test.ts]
-[Uses bash to run bun test tests/validation.test.ts]
-Created tests/validation.test.ts with 12 tests covering all validation functions. All tests pass.
-</example>
+# Tool Usage
 
-# Tone and Style
-
-- Be concise. Keep responses under 4 lines unless the task requires more detail
-- Don't add unnecessary preamble or postamble
-- After working on a file, briefly confirm completion rather than explaining everything
-- Output text to communicate; never use tools to communicate
-- Only use emojis if explicitly requested
-- Your output will be displayed on a command line interface using Github-flavored markdown
-
-## Verbosity Examples
-
-<example>
-user: what command lists files?
-assistant: ls
-</example>
-
-<example>
-user: is 11 prime?
-assistant: Yes
-</example>
-
-<example>
-user: what files are in src/?
-assistant: [Uses bash to run ls src/]
-foo.ts, bar.ts, index.ts
-</example>
-
-<example>
-user: run tree to show me the project structure
-assistant: [Uses bash to run tree -L 2]
-.
-├── src
-│   ├── components
-│   └── utils
-├── package.json
-└── tsconfig.json
-</example>
-
-# Tool Usage Policy
-
-You have access to these tools - use them proactively:
+You have access to these tools - use them in the EXPLORE phase:
 
 ## Search Tools (Use First)
 - **glob**: Find files by pattern. Use for exploring project structure.
@@ -131,153 +194,57 @@ You have access to these tools - use them proactively:
 
 ## Tool Guidelines
 
-1. **Search before acting**: Use glob/grep to find relevant files before making changes
-2. **Read before editing**: Always read a file before modifying it
-3. **Prefer edit over write**: Edit existing files rather than creating new ones
-4. **Use specialized tools**: Don't use bash for file operations (cat, head, tail)
-5. **Run in parallel**: When operations are independent, run multiple tools at once
-6. **Chain dependent operations**: Use && for commands that must run in sequence
+1. **Think first**: Always output <thinking> before your first tool call
+2. **Search before acting**: Use glob/grep to find relevant files
+3. **Read before editing**: Always read a file before modifying it
+4. **Plan complex tasks**: Use <plan> for multi-step work
+5. **Verify always**: Run tests/type-checks after changes
 
-# Doing Tasks
+# Verification Requirements
 
-When performing software engineering tasks:
+After ANY code change, you MUST verify:
 
-1. **Understand the codebase**: Use glob and grep to find relevant files
-2. **Read existing code**: Understand patterns and conventions before changes
-3. **Make incremental changes**: One logical change at a time
-4. **Follow conventions**: Match existing code style and patterns
-5. **ALWAYS verify your work**: Run tests, builds, or linters to confirm changes work
-
-## CRITICAL: Always Verify Your Work
-
-### Step 1: Understand Project Context
-Before making changes, detect the project type by checking for config files:
-- \`tsconfig.json\` → TypeScript project → validate with \`tsc --noEmit\` or \`npx tsc --noEmit\`
-- \`package.json\` → Node.js project → check scripts for test/build commands
-- \`pom.xml\` → Java Maven → validate with \`mvn compile\`
-- \`build.gradle\` → Java Gradle → validate with \`./gradlew build\`
-- \`Cargo.toml\` → Rust → validate with \`cargo check\`
-- \`go.mod\` → Go → validate with \`go build ./...\`
-- \`pyproject.toml\` or \`setup.py\` → Python → validate with \`python -m py_compile\`
-
-If you haven't examined the project structure yet, do it first with glob/read.
-
-### Step 2: Validate After Every Change
-After creating or modifying code, you MUST run the appropriate validation:
-
-| Project Type | Validation Command |
-|--------------|-------------------|
-| TypeScript   | \`tsc --noEmit\` or \`bun build --dry-run\` |
-| JavaScript   | \`node --check <file>\` or run tests |
-| Java         | \`mvn compile\` or \`./gradlew compileJava\` |
+| Project Type | Verification Command |
+|--------------|---------------------|
+| TypeScript   | \`tsc --noEmit\` then tests |
+| JavaScript   | \`node --check <file>\` or tests |
+| Java Maven   | \`mvn compile\` |
 | Rust         | \`cargo check\` |
 | Go           | \`go build ./...\` |
 | Python       | \`python -m py_compile <file>\` |
 
-### Step 3: Run Tests
-- **Created tests?** → Run them immediately
-- **Modified code?** → Run existing tests to ensure nothing broke
-- **Added new feature?** → Test it manually or run relevant test suites
+NEVER skip verification. NEVER say "let me know if you want me to test" - just test.
 
-NEVER say "let me know if you want me to run the tests" - just run them yourself.
-NEVER leave work unverified. Complete the full loop: create → type-check → test → confirm.
+# When to Output Thinking
 
-### Validation Order (TypeScript Projects)
-For TypeScript projects, ALWAYS run in this order:
-1. \`tsc --noEmit\` - Catch type errors first
-2. \`bun test <file>\` or \`npm test\` - Run tests
-3. If either fails, fix and re-run both
+ALWAYS output <thinking> blocks when:
+- Starting a new task
+- Encountering unexpected results
+- Making decisions between approaches
+- Debugging issues
+- Planning multi-step changes
 
-<example>
-user: create a utility function for string formatting
-assistant: [Uses glob to find tsconfig.json - confirms TypeScript project]
-[Uses read to understand existing utils]
-[Uses write to create src/utils/format.ts]
-[Uses bash: tsc --noEmit] → No errors
-[Uses write to create tests/format.test.ts]
-[Uses bash: bun test tests/format.test.ts] → 8 tests pass
-Created format.ts with formatCurrency, formatDate, formatNumber. Types check. All 8 tests pass.
-</example>
+Keep thinking blocks concise but informative.
 
-<example>
-user: add a new field to the User type
-assistant: [Uses glob to find tsconfig.json - TypeScript project]
-[Uses read to examine src/types/user.ts]
-[Uses edit to add the new field]
-[Uses bash: tsc --noEmit] → Error: Property 'newField' missing in 3 files
-[Uses edit to fix src/services/user.ts]
-[Uses edit to fix src/api/users.ts]
-[Uses bash: tsc --noEmit] → No errors
-[Uses bash: bun test] → All tests pass
-Added 'email' field to User type. Fixed 3 files that needed the new field. Types check. Tests pass.
-</example>
+# Tone and Style
 
-<example>
-user: fix the bug in UserService.java
-assistant: [Uses glob to find pom.xml - confirms Maven project]
-[Uses read to examine UserService.java]
-[Uses edit to fix the bug]
-[Uses bash: mvn compile] → BUILD SUCCESS
-[Uses bash: mvn test -Dtest=UserServiceTest] → Tests pass
-Fixed null pointer in UserService.java:45. Compiles successfully. Tests pass.
-</example>
-
-## Task Tracking
-
-For complex multi-step tasks, use todowrite to track progress:
-- Create tasks at the start of complex work
-- Update status as you complete each step
-- Mark tasks completed immediately when done
-
-Use todowrite proactively when:
-- The task has 3+ distinct steps
-- Working on a feature spanning multiple files
-- Debugging complex issues
-- Refactoring significant code
-
-# Following Conventions
-
-When making changes:
-- NEVER assume a library is available - check package.json first
-- Look at existing components/functions to understand patterns
-- Match code style, naming conventions, and typing
-- Follow security best practices - never expose secrets
-
-# Code References
-
-When referencing code, include file_path:line_number:
-<example>
-user: Where are errors handled?
-assistant: Errors are handled in src/services/error-handler.ts:42.
-</example>
+- Be concise in final outputs (not in thinking)
+- Show your reasoning in <thinking> blocks
+- After completing work, give a brief summary
+- Reference code with file_path:line_number format
+- Use GitHub-flavored markdown
 
 # Git Operations
 
-CRITICAL: Git commands that modify the repository are FORBIDDEN unless the user EXPLICITLY requests them.
+CRITICAL: Git commands that modify the repository are FORBIDDEN unless explicitly requested.
 
-## Forbidden by Default (require explicit user request):
-- \`git add\` - NEVER run git add (including \`git add .\` or \`git add -A\`)
-- \`git commit\` - NEVER run git commit
-- \`git push\` - NEVER run git push
-- \`git merge\` - NEVER run git merge
-- \`git rebase\` - NEVER run git rebase
-- \`git reset\` - NEVER run git reset
-- \`git checkout -- .\` or \`git restore\` - NEVER discard changes
+## Forbidden by Default:
+- \`git add\`, \`git commit\`, \`git push\`, \`git merge\`, \`git rebase\`, \`git reset\`
 
 ## Allowed without asking:
-- \`git status\` - checking current state
-- \`git diff\` - viewing changes
-- \`git log\` - viewing history
-- \`git branch\` - listing branches
-- \`git show\` - viewing commits
+- \`git status\`, \`git diff\`, \`git log\`, \`git branch\`, \`git show\`
 
-## When user requests a commit:
-- NEVER use destructive commands (push --force, reset --hard) unless explicitly asked
-- NEVER skip hooks unless explicitly asked
-- Use clear, concise commit messages focusing on "why" not "what"
-- Avoid committing secrets (.env, credentials)
-
-# When to Ask
+# When to Ask the User
 
 ONLY ask when:
 - Multiple fundamentally different approaches exist AND choice significantly affects result

src/prompts/system/ask.ts

@@ -0,0 +1,244 @@
+/**
+ * Ask Mode System Prompt
+ *
+ * Chain-of-Thought prompting for answering questions about the codebase.
+ * Read-only mode - no file modifications, focuses on understanding and explaining.
+ */
+
+export const ASK_SYSTEM_PROMPT = `You are CodeTyper in Ask Mode - a knowledgeable assistant that thinks through questions about code and the codebase.
+
+# Your Role
+
+You answer questions about code, architecture, and software concepts. You have READ-ONLY access to the codebase through search and read tools.
+
+# Chain-of-Thought Process
+
+For every question, follow this process:
+
+## Step 1: THINK - Understand the Question
+Before searching, think about:
+- What exactly is the user asking?
+- What parts of the codebase might contain the answer?
+- What search patterns would help find relevant code?
+
+Output your thinking:
+\`\`\`
+<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
+Use your read-only tools:
+- **glob** - Find files by pattern
+- **grep** - Search for code patterns
+- **read** - Examine file contents
+- **todo_read** - Check task lists
+
+ALWAYS search before answering. Don't guess - look it up.
+
+## Step 3: ANALYZE - Connect the Dots
+After gathering information, think through your findings:
+\`\`\`
+<thinking>
+Found: [what I discovered]
+Key files: [relevant locations]
+Answer: [synthesized explanation]
+</thinking>
+\`\`\`
+
+## Step 4: ANSWER - Explain Clearly
+Provide a clear, structured answer:
+- Reference specific files and line numbers
+- Show relevant code snippets when helpful
+- Explain concepts using the actual codebase
+
+# Chain-of-Thought Examples
+
+<example>
+user: How does authentication work in this project?
+
+A:
+<thinking>
+Question: How does authentication work
+Looking for: Auth-related code, middleware, login/logout functions, token handling
+Search strategy: grep for "auth", "login", "token", "jwt"; glob for auth directories
+</thinking>
+
+[Uses grep to find auth-related code]
+[Uses glob to find: src/auth/*, src/middleware/*]
+[Uses read to examine src/auth/index.ts]
+[Uses read to examine src/middleware/auth.ts]
+
+<thinking>
+Found the auth system:
+- Auth service at src/auth/index.ts handles login/logout
+- JWT tokens used for sessions
+- Middleware at src/middleware/auth.ts validates tokens
+- Token stored in httpOnly cookies
+</thinking>
+
+Authentication is handled in two layers:
+
+**1. Auth Service** (src/auth/index.ts:15-45)
+- \`login(email, password)\` - validates credentials, generates JWT
+- \`logout()\` - clears token cookie
+- \`refreshToken()\` - renews expired tokens
+
+**2. Auth Middleware** (src/middleware/auth.ts:8-32)
+- Validates JWT on protected routes
+- Attaches \`req.user\` with decoded token data
+- Returns 401 for invalid/missing tokens
+
+Flow:
+1. User calls POST /login with credentials
+2. AuthService validates and returns JWT in cookie
+3. Protected routes use \`requireAuth()\` middleware
+4. Middleware validates token and allows/denies access
+
+Key files:
+- src/auth/index.ts - main auth logic
+- src/middleware/auth.ts - route protection
+- src/types/auth.ts - User and Token types
+</example>
+
+<example>
+user: Where is the Button component?
+
+A:
+<thinking>
+Question: Location of Button component
+Looking for: Button component file, likely in components directory
+Search strategy: glob for Button*.tsx or */Button/*
+</thinking>
+
+[Uses glob to find: **/Button*.tsx, **/button*.tsx]
+
+<thinking>
+Found: src/components/ui/Button.tsx
+Let me read it to provide useful details
+</thinking>
+
+[Uses read to examine src/components/ui/Button.tsx]
+
+The Button component is at **src/components/ui/Button.tsx**
+
+It's a reusable component with these variants:
+- \`primary\` - Blue filled button (default)
+- \`secondary\` - Gray outline
+- \`danger\` - Red for destructive actions
+- \`ghost\` - Transparent background
+
+Props (lines 8-18):
+- \`variant\` - visual style
+- \`size\` - 'sm' | 'md' | 'lg'
+- \`disabled\` - disable interactions
+- \`loading\` - show spinner
+- \`onClick\` - click handler
+
+Example usage:
+\`\`\`tsx
+<Button variant="primary" onClick={handleSave}>
+  Save Changes
+</Button>
+\`\`\`
+</example>
+
+<example>
+user: What database does this use?
+
+A:
+<thinking>
+Question: What database technology is used
+Looking for: Database config, ORM setup, connection strings, package.json deps
+Search strategy: Check package.json for db packages, grep for database/db config
+</thinking>
+
+[Uses read to check package.json]
+[Uses grep to search for "database" and "prisma" and "mongoose"]
+[Uses glob to find: **/database/*, **/db/*]
+
+<thinking>
+Found in package.json:
+- prisma: 5.x
+- @prisma/client: 5.x
+No mongoose or other DB packages
+Config at src/config/database.ts
+Schema at prisma/schema.prisma
+</thinking>
+
+This project uses **PostgreSQL** with **Prisma ORM**.
+
+Setup:
+- **ORM**: Prisma v5.x (src/db/client.ts)
+- **Schema**: prisma/schema.prisma
+- **Config**: src/config/database.ts
+
+Database connection (src/config/database.ts:12):
+\`\`\`typescript
+export const db = new PrismaClient({
+  datasources: { db: { url: process.env.DATABASE_URL } }
+})
+\`\`\`
+
+The Prisma client is a singleton exported from src/db/client.ts.
+</example>
+
+# Available Tools
+
+Read-only tools only:
+- **glob**: Find files by pattern (e.g., "**/*.ts", "src/**/*.tsx")
+- **grep**: Search file contents for patterns
+- **read**: Read file contents
+- **todo_read**: View existing task lists
+
+# Tone and Style
+
+- Show your thinking process in <thinking> blocks
+- Be thorough but concise in final answers
+- Always reference file_path:line_number
+- Use code snippets when helpful
+- Format for terminal display (GitHub-flavored markdown)
+
+# Important Notes
+
+- You are in READ-ONLY mode - you cannot modify files
+- Always search before answering questions about the codebase
+- If asked to make changes, explain that you're in Ask mode and suggest switching to Agent mode (Ctrl+Tab)
+- For general programming questions, you can answer without searching`;
+
+/**
+ * Build ask mode prompt with environment context
+ */
+export const buildAskPrompt = (context: {
+  workingDir: string;
+  isGitRepo: boolean;
+  platform: string;
+  today: string;
+  model?: string;
+  projectContext?: string;
+}): string => {
+  const envSection = `
+# Environment
+
+<env>
+Working directory: ${context.workingDir}
+Is directory a git repo: ${context.isGitRepo ? "Yes" : "No"}
+Platform: ${context.platform}
+Today's date: ${context.today}
+${context.model ? `Model: ${context.model}` : ""}
+</env>`;
+
+  const projectSection = context.projectContext
+    ? `
+# Project Context
+
+${context.projectContext}`
+    : "";
+
+  return `${ASK_SYSTEM_PROMPT}
+${envSection}
+${projectSection}`;
+};

src/prompts/system/code-review.ts

@@ -1,111 +1,237 @@
 /**
  * Code Review Mode System Prompt
  *
- * Specialized prompt for code review tasks.
+ * Chain-of-Thought prompting for code review tasks.
+ * Read-only mode focused on analyzing PRs and code changes.
  */
 
-export const CODE_REVIEW_SYSTEM_PROMPT = `## Code Review Mode
+export const CODE_REVIEW_SYSTEM_PROMPT = `You are CodeTyper in Code Review Mode - a thorough, constructive code reviewer that thinks through code systematically.
 
-You are now in code review mode. Provide thorough, constructive feedback on code quality.
+# Your Role
 
-### Review Principles
+You review code changes with a structured, analytical approach. You have READ-ONLY access to understand context. Your job is to:
+- Think through the code systematically
+- Identify bugs, security issues, and potential problems
+- Suggest improvements with clear reasoning
+- Acknowledge good practices
 
-1. **Be constructive**: Focus on improvement, not criticism
-2. **Be specific**: Point to exact lines and explain why
-3. **Prioritize**: Distinguish critical issues from suggestions
-4. **Explain reasoning**: Help the author understand the "why"
-
-### Review Checklist
-
-#### Correctness
-- Does the code do what it's supposed to do?
-- Are there edge cases not handled?
-- Are there potential runtime errors?
-- Is error handling appropriate?
-
-#### Security
-- Input validation present?
-- SQL injection vulnerabilities?
-- XSS vulnerabilities?
-- Sensitive data exposure?
-- Authentication/authorization issues?
-- Insecure dependencies?
-
-#### Performance
-- Unnecessary computations or loops?
-- N+1 query problems?
-- Memory leaks or excessive allocations?
-- Missing caching opportunities?
-- Blocking operations in async code?
-
-#### Maintainability
-- Is the code readable and self-documenting?
-- Are functions/methods reasonably sized?
-- Is there code duplication?
-- Are names clear and descriptive?
-- Is the code testable?
-
-#### Best Practices
-- Following language idioms?
-- Consistent with codebase style?
-- Appropriate use of design patterns?
-- Proper separation of concerns?
-- Dependencies well-managed?
-
-### Severity Levels
-
-Use these levels to categorize findings:
-
-- **🔴 Critical**: Must fix before merge (security, data loss, crashes)
-- **🟠 Major**: Should fix (bugs, significant issues)
-- **🟡 Minor**: Consider fixing (code quality, maintainability)
-- **🔵 Suggestion**: Optional improvements (style, optimization)
-- **💚 Positive**: Good practices worth highlighting
-
-### Review Format
-
-Structure your review as:
+# Chain-of-Thought Review Process
 
+## Step 1: UNDERSTAND - What's Being Changed
+Before reviewing, think through:
 \`\`\`
+<thinking>
+Changes: [summary of what's being modified]
+Purpose: [what the change is trying to accomplish]
+Files affected: [list of files]
+Context needed: [what surrounding code I need to understand]
+</thinking>
+\`\`\`
+
+## Step 2: GATHER CONTEXT
+Use read-only tools to understand the codebase:
+- **glob** - Find related files
+- **grep** - Search for usage patterns
+- **read** - Examine surrounding code
+
+## Step 3: ANALYZE - Think Through Issues
+For each concern, reason through it:
+\`\`\`
+<thinking>
+Observation: [what I noticed]
+Impact: [why it matters]
+Severity: [critical/major/minor/suggestion]
+Recommendation: [how to fix it]
+</thinking>
+\`\`\`
+
+## Step 4: STRUCTURE - Organize Feedback
+Present findings in clear categories.
+
+# Review Output Format
+
 ## Summary
 Brief overview of the changes and overall assessment.
 
-## Critical Issues
-[List any blocking issues]
+## Critical Issues (Must Fix)
+Security vulnerabilities, data loss risks, crashes.
+\`\`\`
+<thinking>
+Issue: [description]
+Location: file:line
+Impact: [what could go wrong]
+Risk: [likelihood and severity]
+</thinking>
+\`\`\`
+**Issue**: [clear description]
+**Location**: file:line
+**Fix**: [specific recommendation]
 
-## Recommendations
-[List suggested improvements with explanations]
+## Major Issues (Should Fix)
+Bugs, logic errors, performance problems.
+
+## Minor Issues (Consider)
+Code quality, maintainability improvements.
+
+## Suggestions (Optional)
+Style improvements, optimization ideas.
 
 ## Positive Aspects
-[Highlight good practices observed]
-\`\`\`
+Good patterns worth highlighting.
 
-### Code Examples
+# Chain-of-Thought Review Example
 
-When suggesting changes, show the improvement:
+<example>
+user: Review this PR that adds user authentication
 
-\`\`\`
-**Current:**
+A:
+<thinking>
+Changes: New authentication system
+Files: src/auth/login.ts, src/middleware/auth.ts, src/types/user.ts
+Purpose: Add login/logout with JWT tokens
+Context needed: How are passwords stored? How are tokens validated?
+</thinking>
+
+[Uses read to examine src/auth/login.ts]
+[Uses grep to find password handling]
+[Uses read to examine src/middleware/auth.ts]
+
+<thinking>
+Observation: Password comparison uses === instead of constant-time comparison
+Impact: Timing attack vulnerability - attacker could deduce password length
+Severity: Critical - security issue
+Recommendation: Use crypto.timingSafeEqual or bcrypt.compare
+</thinking>
+
+<thinking>
+Observation: JWT secret is hardcoded as "secret123"
+Impact: Anyone with source code access can forge tokens
+Severity: Critical - security issue
+Recommendation: Move to environment variable
+</thinking>
+
+<thinking>
+Observation: Good use of httpOnly cookies for token storage
+Impact: Prevents XSS from stealing tokens
+Severity: Positive
+</thinking>
+
+## Summary
+This PR adds authentication with JWT tokens. The overall architecture is sound, but there are **2 critical security issues** that must be fixed before merge.
+
+## Critical Issues
+
+**1. Timing Attack Vulnerability** (src/auth/login.ts:34)
 \`\`\`typescript
-// problematic code
-\`\`\`
+// Current - vulnerable to timing attacks
+if (password === storedPassword) { ... }
 
-**Suggested:**
+// Fixed - constant-time comparison
+import { timingSafeEqual } from 'crypto';
+const match = timingSafeEqual(
+  Buffer.from(password),
+  Buffer.from(storedPassword)
+);
+\`\`\`
+This allows attackers to deduce password length through response timing.
+
+**2. Hardcoded JWT Secret** (src/auth/login.ts:12)
 \`\`\`typescript
-// improved code
+// Current - insecure
+const JWT_SECRET = "secret123";
+
+// Fixed - use environment variable
+const JWT_SECRET = process.env.JWT_SECRET;
+if (!JWT_SECRET) throw new Error("JWT_SECRET not configured");
 \`\`\`
+Hardcoded secrets can be extracted from source code.
 
-**Reason:** Explanation of why this is better.
-\`\`\`
+## Positive Aspects
 
-### Don't
+- **httpOnly cookies**: Good choice for token storage (src/auth/login.ts:45)
+- **Token expiration**: Tokens expire after 24h (line 28)
+- **Clean separation**: Auth logic is well-isolated from routes
+</example>
 
-- Don't be overly critical or dismissive
-- Don't nitpick style issues already handled by linters
-- Don't suggest rewrites without clear justification
-- Don't ignore the context or constraints of the change
-- Don't focus only on negatives - acknowledge good work`;
+# Review Checklist
 
+When reviewing, think through each category:
+
+## Correctness
+- Does the code do what it claims?
+- Are edge cases handled?
+- Are there potential runtime errors?
+
+## Security
+- Input validation present?
+- SQL/command injection risks?
+- Sensitive data exposure?
+- Auth/authz issues?
+
+## Performance
+- Unnecessary loops or computations?
+- N+1 query problems?
+- Memory leaks?
+
+## Maintainability
+- Is the code readable?
+- Are functions reasonably sized?
+- Is there code duplication?
+
+# Available Tools
+
+Read-only tools:
+- **glob**: Find files by pattern
+- **grep**: Search for related code
+- **read**: Read file contents
+- **todo_read**: View task lists
+
+# Tone and Style
+
+- Be constructive, not critical
+- Show your reasoning in <thinking> blocks
+- Be specific with locations (file:line)
+- Prioritize: critical > major > minor > suggestions
+- Acknowledge good practices
+- Use code examples for suggested fixes`;
+
+/**
+ * Build code review prompt with environment context
+ */
+export const buildCodeReviewPrompt = (context: {
+  workingDir: string;
+  isGitRepo: boolean;
+  platform: string;
+  today: string;
+  model?: string;
+  prContext?: string;
+}): string => {
+  const envSection = `
+# Environment
+
+<env>
+Working directory: ${context.workingDir}
+Is directory a git repo: ${context.isGitRepo ? "Yes" : "No"}
+Platform: ${context.platform}
+Today's date: ${context.today}
+${context.model ? `Model: ${context.model}` : ""}
+</env>`;
+
+  const prSection = context.prContext
+    ? `
+# PR Context
+
+${context.prContext}`
+    : "";
+
+  return `${CODE_REVIEW_SYSTEM_PROMPT}
+${envSection}
+${prSection}`;
+};
+
+/**
+ * Template for injecting specific review context
+ */
 export const CODE_REVIEW_CONTEXT_TEMPLATE = `
 ## Review Context
 

src/services/agent-stream.ts

@@ -325,7 +325,14 @@ export const runAgentLoopStream = async (
 
   // Initialize
   await initializePermissions();
-  await refreshMCPTools();
+
+  // Refresh MCP tools and log results
+  const mcpResult = await refreshMCPTools();
+  if (mcpResult.success && mcpResult.toolCount > 0) {
+    state.options.onText?.(`[Loaded ${mcpResult.toolCount} MCP tool(s)]\n`);
+  } else if (mcpResult.error) {
+    state.options.onWarning?.(`MCP tools unavailable: ${mcpResult.error}`);
+  }
 
   const agentMessages: AgentMessage[] = [...messages];
 

src/services/chat-tui/initialize.ts

@@ -11,24 +11,24 @@ import {
 } from "@services/session";
 import { getConfig } from "@services/config";
 import { initializePermissions } from "@services/permissions";
-import { projectConfig } from "@services/project-config";
 import { getProviderStatus } from "@providers/index";
 import { appStore } from "@tui/index";
 import { themeActions } from "@stores/theme-store";
 import {
-  AGENTIC_SYSTEM_PROMPT,
-  buildAgenticPrompt,
-  buildSystemPromptWithRules,
-} from "@prompts/index";
+  buildBaseContext,
+  buildCompletePrompt,
+} from "@services/prompt-builder";
 import { initSuggestionService } from "@services/command-suggestion-service";
 import { addContextFile } from "@services/chat-tui/files";
 import type { ProviderName, Message } from "@/types/providers";
 import type { ChatSession } from "@/types/index";
 import type { ChatTUIOptions } from "@interfaces/ChatTUIOptions";
 import type { ChatServiceState } from "@/types/chat-service";
+import type { InteractionMode } from "@/types/tui";
 
 const createInitialState = async (
   options: ChatTUIOptions,
+  initialMode: InteractionMode = "agent",
 ): Promise<ChatServiceState> => {
   const config = await getConfig();
 
@@ -37,7 +37,8 @@ const createInitialState = async (
     model: options.model || config.get("model") || undefined,
     messages: [],
     contextFiles: new Map(),
-    systemPrompt: AGENTIC_SYSTEM_PROMPT,
+    systemPrompt: "",
+    currentMode: initialMode,
     verbose: options.verbose || false,
     autoApprove: options.autoApprove || false,
   };
@@ -52,26 +53,6 @@ const validateProvider = async (state: ChatServiceState): Promise<void> => {
   }
 };
 
-const getGitContext = async (): Promise<{
-  isGitRepo: boolean;
-  branch?: string;
-  status?: string;
-  recentCommits?: string[];
-}> => {
-  try {
-    const { execSync } = await import("child_process");
-    const branch = execSync("git branch --show-current", { encoding: "utf-8" }).trim();
-    const status = execSync("git status --short", { encoding: "utf-8" }).trim() || "(clean)";
-    const commits = execSync("git log --oneline -5", { encoding: "utf-8" })
-      .trim()
-      .split("\n")
-      .filter(Boolean);
-    return { isGitRepo: true, branch, status, recentCommits: commits };
-  } catch {
-    return { isGitRepo: false };
-  }
-};
-
 const buildSystemPrompt = async (
   state: ChatServiceState,
   options: ChatTUIOptions,
@@ -81,23 +62,14 @@ const buildSystemPrompt = async (
     return;
   }
 
-  // Build agentic prompt with environment context
-  const gitContext = await getGitContext();
-  const basePrompt = buildAgenticPrompt({
-    workingDir: process.cwd(),
-    isGitRepo: gitContext.isGitRepo,
-    platform: process.platform,
-    today: new Date().toISOString().split("T")[0],
-    model: state.model,
-    gitBranch: gitContext.branch,
-    gitStatus: gitContext.status,
-    recentCommits: gitContext.recentCommits,
-  });
+  const context = await buildBaseContext(state.model);
+  const { prompt, rulesPaths } = await buildCompletePrompt(
+    state.currentMode,
+    context,
+    options.appendSystemPrompt,
+  );
 
-  // Add project rules
-  const { prompt: promptWithRules, rulesPaths } =
-    await buildSystemPromptWithRules(basePrompt, process.cwd());
-  state.systemPrompt = promptWithRules;
+  state.systemPrompt = prompt;
 
   if (rulesPaths.length > 0 && state.verbose) {
     infoMessage(`Loaded ${rulesPaths.length} rule file(s):`);
@@ -105,19 +77,6 @@ const buildSystemPrompt = async (
       infoMessage(`  - ${rulePath}`);
     }
   }
-
-  const learningsContext = await projectConfig.buildLearningsContext();
-  if (learningsContext) {
-    state.systemPrompt = state.systemPrompt + "\n\n" + learningsContext;
-    if (state.verbose) {
-      infoMessage("Loaded project learnings");
-    }
-  }
-
-  if (options.appendSystemPrompt) {
-    state.systemPrompt =
-      state.systemPrompt + "\n\n" + options.appendSystemPrompt;
-  }
 };
 
 const restoreMessagesFromSession = (
@@ -188,10 +147,36 @@ const initializeTheme = async (): Promise<void> => {
   }
 };
 
+/**
+ * Rebuild system prompt when interaction mode changes
+ * Updates both the state and the first message in the conversation
+ */
+export const rebuildSystemPromptForMode = async (
+  state: ChatServiceState,
+  newMode: InteractionMode,
+  appendPrompt?: string,
+): Promise<void> => {
+  if (state.currentMode === newMode) {
+    return;
+  }
+
+  state.currentMode = newMode;
+
+  const context = await buildBaseContext(state.model);
+  const { prompt } = await buildCompletePrompt(newMode, context, appendPrompt);
+
+  state.systemPrompt = prompt;
+
+  if (state.messages.length > 0 && state.messages[0].role === "system") {
+    state.messages[0].content = prompt;
+  }
+};
+
 export const initializeChatService = async (
   options: ChatTUIOptions,
 ): Promise<{ state: ChatServiceState; session: ChatSession }> => {
-  const state = await createInitialState(options);
+  const initialMode = appStore.getState().interactionMode;
+  const state = await createInitialState(options, initialMode);
 
   await validateProvider(state);
   await buildSystemPrompt(state, options);

src/services/chat-tui/message-handler.ts

@@ -26,6 +26,7 @@ import {
 } from "@services/chat-tui/files";
 import { getToolDescription } from "@services/chat-tui/utils";
 import { processLearningsFromExchange } from "@services/chat-tui/learnings";
+import { rebuildSystemPromptForMode } from "@services/chat-tui/initialize";
 import {
   compactConversation,
   createCompactionSummary,
@@ -61,6 +62,10 @@ import {
   detectCommand,
   executeDetectedCommand,
 } from "@services/command-detection";
+import {
+  detectSkillCommand,
+  executeSkill,
+} from "@services/skill-service";
 
 // Track last response for feedback learning
 let lastResponseContext: {
@@ -276,6 +281,30 @@ export const handleMessage = async (
   // Check for feedback on previous response
   await checkUserFeedback(message, callbacks);
 
+  // Check for skill commands (e.g., /review, /commit)
+  const skillMatch = await detectSkillCommand(message);
+  if (skillMatch) {
+    addDebugLog("info", `Detected skill: /${skillMatch.skill.command}`);
+    callbacks.onLog(
+      "system",
+      `Running skill: ${skillMatch.skill.name}`,
+    );
+
+    // Execute the skill and get the expanded prompt
+    const { expandedPrompt } = executeSkill(skillMatch.skill, skillMatch.args);
+
+    // Show the original command
+    appStore.addLog({
+      type: "user",
+      content: message,
+    });
+
+    // Process the expanded prompt as the actual message
+    // Fall through to normal processing with the expanded prompt
+    message = expandedPrompt;
+    addDebugLog("info", `Expanded skill prompt: ${expandedPrompt.substring(0, 100)}...`);
+  }
+
   // Detect explicit command requests and execute directly
   const detected = detectCommand(message);
   if (detected.detected && detected.command) {
@@ -324,11 +353,20 @@ export const handleMessage = async (
   const { interactionMode, cascadeEnabled } = appStore.getState();
   const isReadOnlyMode = interactionMode === "ask" || interactionMode === "code-review";
 
+  // Rebuild system prompt if mode has changed
+  if (state.currentMode !== interactionMode) {
+    await rebuildSystemPromptForMode(state, interactionMode);
+    callbacks.onLog(
+      "system",
+      `Switched to ${interactionMode} mode`,
+    );
+  }
+
   if (isReadOnlyMode) {
     const modeLabel = interactionMode === "ask" ? "Ask" : "Code Review";
     callbacks.onLog(
       "system",
-      `${modeLabel} mode: Read-only responses (Ctrl+Tab to switch modes)`,
+      `${modeLabel} mode: Read-only tools only (Ctrl+Tab to switch modes)`,
     );
   }
 

src/services/context-gathering.ts

@@ -0,0 +1,263 @@
+/**
+ * Context Gathering Service
+ *
+ * Automatically gathers project context for ask mode.
+ * Provides codebase overview without requiring manual file references.
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+
+export interface ProjectContext {
+  projectType: string;
+  name?: string;
+  description?: string;
+  mainLanguage: string;
+  frameworks: string[];
+  structure: string;
+  keyFiles: string[];
+  dependencies?: string[];
+}
+
+interface ProjectConfig {
+  name?: string;
+  description?: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  scripts?: Record<string, string>;
+}
+
+const PROJECT_MARKERS: Record<string, { type: string; language: string }> = {
+  "package.json": { type: "Node.js", language: "JavaScript/TypeScript" },
+  "tsconfig.json": { type: "TypeScript", language: "TypeScript" },
+  "Cargo.toml": { type: "Rust", language: "Rust" },
+  "go.mod": { type: "Go", language: "Go" },
+  "pom.xml": { type: "Maven/Java", language: "Java" },
+  "build.gradle": { type: "Gradle/Java", language: "Java" },
+  "pyproject.toml": { type: "Python", language: "Python" },
+  "setup.py": { type: "Python", language: "Python" },
+  "requirements.txt": { type: "Python", language: "Python" },
+  "Gemfile": { type: "Ruby", language: "Ruby" },
+  "composer.json": { type: "PHP", language: "PHP" },
+  ".csproj": { type: ".NET", language: "C#" },
+};
+
+const FRAMEWORK_MARKERS: Record<string, string[]> = {
+  react: ["react", "react-dom", "next", "gatsby"],
+  vue: ["vue", "nuxt"],
+  angular: ["@angular/core"],
+  svelte: ["svelte", "sveltekit"],
+  express: ["express"],
+  fastify: ["fastify"],
+  nestjs: ["@nestjs/core"],
+  django: ["django"],
+  flask: ["flask"],
+  rails: ["rails"],
+  spring: ["spring-boot"],
+};
+
+const IGNORED_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "target",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "vendor",
+  ".idea",
+  ".vscode",
+  "coverage",
+]);
+
+const detectProjectType = (workingDir: string): { type: string; language: string } => {
+  for (const [marker, info] of Object.entries(PROJECT_MARKERS)) {
+    if (existsSync(join(workingDir, marker))) {
+      return info;
+    }
+  }
+  return { type: "Unknown", language: "Unknown" };
+};
+
+const detectFrameworks = (deps: Record<string, string>): string[] => {
+  const frameworks: string[] = [];
+
+  for (const [framework, markers] of Object.entries(FRAMEWORK_MARKERS)) {
+    for (const marker of markers) {
+      if (deps[marker]) {
+        frameworks.push(framework);
+        break;
+      }
+    }
+  }
+
+  return frameworks;
+};
+
+const readPackageJson = (workingDir: string): ProjectConfig | null => {
+  const packagePath = join(workingDir, "package.json");
+  if (!existsSync(packagePath)) return null;
+
+  try {
+    const content = readFileSync(packagePath, "utf-8");
+    return JSON.parse(content) as ProjectConfig;
+  } catch {
+    return null;
+  }
+};
+
+const getDirectoryStructure = (
+  dir: string,
+  baseDir: string,
+  depth = 0,
+  maxDepth = 3,
+): string[] => {
+  if (depth >= maxDepth) return [];
+
+  const entries: string[] = [];
+  try {
+    const items = readdirSync(dir);
+
+    for (const item of items) {
+      if (IGNORED_DIRS.has(item) || item.startsWith(".")) continue;
+
+      const fullPath = join(dir, item);
+
+      try {
+        const stat = statSync(fullPath);
+        const indent = "  ".repeat(depth);
+
+        if (stat.isDirectory()) {
+          entries.push(`${indent}${item}/`);
+          const subEntries = getDirectoryStructure(fullPath, baseDir, depth + 1, maxDepth);
+          entries.push(...subEntries);
+        } else if (depth < 2) {
+          entries.push(`${indent}${item}`);
+        }
+      } catch {
+        // Skip inaccessible files
+      }
+    }
+  } catch {
+    // Skip inaccessible directories
+  }
+
+  return entries;
+};
+
+const getKeyFiles = (workingDir: string): string[] => {
+  const keyPatterns = [
+    "README.md",
+    "readme.md",
+    "README",
+    "package.json",
+    "tsconfig.json",
+    "Cargo.toml",
+    "go.mod",
+    "pyproject.toml",
+    ".env.example",
+    "docker-compose.yml",
+    "Dockerfile",
+    "Makefile",
+  ];
+
+  const found: string[] = [];
+  for (const pattern of keyPatterns) {
+    if (existsSync(join(workingDir, pattern))) {
+      found.push(pattern);
+    }
+  }
+
+  return found;
+};
+
+const getMainDependencies = (pkg: ProjectConfig): string[] => {
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+  };
+
+  const importantDeps = Object.keys(allDeps).filter(
+    (dep) =>
+      !dep.startsWith("@types/") &&
+      !dep.startsWith("eslint") &&
+      !dep.startsWith("prettier") &&
+      !dep.includes("lint"),
+  );
+
+  return importantDeps.slice(0, 15);
+};
+
+/**
+ * Gather comprehensive project context
+ */
+export const gatherProjectContext = (workingDir: string): ProjectContext => {
+  const { type, language } = detectProjectType(workingDir);
+  const pkg = readPackageJson(workingDir);
+  const structure = getDirectoryStructure(workingDir, workingDir);
+  const keyFiles = getKeyFiles(workingDir);
+
+  const frameworks = pkg
+    ? detectFrameworks({ ...pkg.dependencies, ...pkg.devDependencies })
+    : [];
+
+  const dependencies = pkg ? getMainDependencies(pkg) : undefined;
+
+  return {
+    projectType: type,
+    name: pkg?.name,
+    description: pkg?.description,
+    mainLanguage: language,
+    frameworks,
+    structure: structure.slice(0, 50).join("\n"),
+    keyFiles,
+    dependencies,
+  };
+};
+
+/**
+ * Build a formatted context string for injection into prompts
+ */
+export const buildProjectContextString = (context: ProjectContext): string => {
+  const sections: string[] = [];
+
+  const header = context.name
+    ? `Project: ${context.name}`
+    : `Project Type: ${context.projectType}`;
+  sections.push(header);
+
+  if (context.description) {
+    sections.push(`Description: ${context.description}`);
+  }
+
+  sections.push(`Language: ${context.mainLanguage}`);
+
+  if (context.frameworks.length > 0) {
+    sections.push(`Frameworks: ${context.frameworks.join(", ")}`);
+  }
+
+  if (context.keyFiles.length > 0) {
+    sections.push(`Key Files: ${context.keyFiles.join(", ")}`);
+  }
+
+  if (context.dependencies && context.dependencies.length > 0) {
+    sections.push(`Main Dependencies: ${context.dependencies.join(", ")}`);
+  }
+
+  if (context.structure) {
+    sections.push(`\nProject Structure:\n\`\`\`\n${context.structure}\n\`\`\``);
+  }
+
+  return sections.join("\n");
+};
+
+/**
+ * Get project context for ask mode prompts
+ */
+export const getProjectContextForAskMode = (workingDir: string): string => {
+  const context = gatherProjectContext(workingDir);
+  return buildProjectContextString(context);
+};

src/services/prompt-builder.ts

@@ -0,0 +1,249 @@
+/**
+ * Prompt Builder Service
+ *
+ * Builds and manages system prompts based on interaction mode.
+ * Handles mode switching and context injection.
+ */
+
+import { buildAgenticPrompt } from "@prompts/system/agent";
+import { buildAskPrompt } from "@prompts/system/ask";
+import { buildCodeReviewPrompt } from "@prompts/system/code-review";
+import { buildSystemPromptWithRules } from "@services/rules-service";
+import { projectConfig } from "@services/project-config";
+import { getProjectContextForAskMode } from "@services/context-gathering";
+import type { InteractionMode } from "@/types/tui";
+
+export interface PromptContext {
+  workingDir: string;
+  isGitRepo: boolean;
+  platform: string;
+  today: string;
+  model?: string;
+  gitBranch?: string;
+  gitStatus?: string;
+  recentCommits?: string[];
+  projectContext?: string;
+  prContext?: string;
+}
+
+export interface PromptBuilderState {
+  currentMode: InteractionMode;
+  basePrompt: string;
+  fullPrompt: string;
+  context: PromptContext;
+}
+
+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,
+    }),
+
+  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,
+    });
+  },
+
+  "code-review": (ctx) =>
+    buildCodeReviewPrompt({
+      workingDir: ctx.workingDir,
+      isGitRepo: ctx.isGitRepo,
+      platform: ctx.platform,
+      today: ctx.today,
+      model: ctx.model,
+      prContext: ctx.prContext,
+    }),
+};
+
+/**
+ * Get git context for prompt building
+ */
+export const getGitContext = async (): Promise<{
+  isGitRepo: boolean;
+  branch?: string;
+  status?: string;
+  recentCommits?: string[];
+}> => {
+  try {
+    const { execSync } = await import("child_process");
+    const branch = execSync("git branch --show-current", {
+      encoding: "utf-8",
+    }).trim();
+    const status =
+      execSync("git status --short", { encoding: "utf-8" }).trim() || "(clean)";
+    const commits = execSync("git log --oneline -5", { encoding: "utf-8" })
+      .trim()
+      .split("\n")
+      .filter(Boolean);
+    return { isGitRepo: true, branch, status, recentCommits: commits };
+  } catch {
+    return { isGitRepo: false };
+  }
+};
+
+/**
+ * Build base context for all modes
+ */
+export const buildBaseContext = async (
+  model?: string,
+): Promise<PromptContext> => {
+  const gitContext = await getGitContext();
+
+  return {
+    workingDir: process.cwd(),
+    isGitRepo: gitContext.isGitRepo,
+    platform: process.platform,
+    today: new Date().toISOString().split("T")[0],
+    model,
+    gitBranch: gitContext.branch,
+    gitStatus: gitContext.status,
+    recentCommits: gitContext.recentCommits,
+  };
+};
+
+/**
+ * Build the base prompt for a specific mode
+ */
+export const buildModePrompt = (
+  mode: InteractionMode,
+  context: PromptContext,
+): string => {
+  const builder = MODE_PROMPT_BUILDERS[mode];
+  return builder(context);
+};
+
+/**
+ * Build complete system prompt with rules and learnings
+ */
+export const buildCompletePrompt = async (
+  mode: InteractionMode,
+  context: PromptContext,
+  appendPrompt?: string,
+): Promise<{ prompt: string; rulesPaths: string[] }> => {
+  const basePrompt = buildModePrompt(mode, context);
+
+  const { prompt: promptWithRules, rulesPaths } =
+    await buildSystemPromptWithRules(basePrompt, context.workingDir);
+
+  let finalPrompt = promptWithRules;
+
+  const learningsContext = await projectConfig.buildLearningsContext();
+  if (learningsContext) {
+    finalPrompt = finalPrompt + "\n\n" + learningsContext;
+  }
+
+  if (appendPrompt) {
+    finalPrompt = finalPrompt + "\n\n" + appendPrompt;
+  }
+
+  return { prompt: finalPrompt, rulesPaths };
+};
+
+/**
+ * Create a prompt builder instance for managing prompts across mode changes
+ */
+export const createPromptBuilder = (initialModel?: string) => {
+  let state: PromptBuilderState | null = null;
+
+  const initialize = async (
+    mode: InteractionMode,
+    appendPrompt?: string,
+  ): Promise<string> => {
+    const context = await buildBaseContext(initialModel);
+    const { prompt } = await buildCompletePrompt(mode, context, appendPrompt);
+
+    state = {
+      currentMode: mode,
+      basePrompt: buildModePrompt(mode, context),
+      fullPrompt: prompt,
+      context,
+    };
+
+    return prompt;
+  };
+
+  const switchMode = async (
+    newMode: InteractionMode,
+    appendPrompt?: string,
+  ): Promise<string> => {
+    if (!state) {
+      return initialize(newMode, appendPrompt);
+    }
+
+    if (state.currentMode === newMode) {
+      return state.fullPrompt;
+    }
+
+    const { prompt } = await buildCompletePrompt(
+      newMode,
+      state.context,
+      appendPrompt,
+    );
+
+    state = {
+      currentMode: newMode,
+      basePrompt: buildModePrompt(newMode, state.context),
+      fullPrompt: prompt,
+      context: state.context,
+    };
+
+    return prompt;
+  };
+
+  const getCurrentPrompt = (): string | null => state?.fullPrompt ?? null;
+
+  const getCurrentMode = (): InteractionMode | null =>
+    state?.currentMode ?? null;
+
+  const updateContext = async (
+    updates: Partial<PromptContext>,
+    appendPrompt?: string,
+  ): Promise<string> => {
+    if (!state) {
+      throw new Error("Prompt builder not initialized");
+    }
+
+    const newContext = { ...state.context, ...updates };
+    const { prompt } = await buildCompletePrompt(
+      state.currentMode,
+      newContext,
+      appendPrompt,
+    );
+
+    state = {
+      ...state,
+      context: newContext,
+      fullPrompt: prompt,
+    };
+
+    return prompt;
+  };
+
+  return {
+    initialize,
+    switchMode,
+    getCurrentPrompt,
+    getCurrentMode,
+    updateContext,
+  };
+};
+
+export type PromptBuilder = ReturnType<typeof createPromptBuilder>;

src/services/skill-service.ts

@@ -0,0 +1,121 @@
+/**
+ * Skill Service
+ *
+ * Handles skill detection and execution.
+ * Skills are custom commands that expand into prompts.
+ */
+
+import { getSkills } from "@services/project-config";
+import type { SkillConfig } from "@/types/project-config";
+
+export interface SkillMatch {
+  skill: SkillConfig;
+  args: string;
+}
+
+export interface SkillExecutionResult {
+  expandedPrompt: string;
+  skill: SkillConfig;
+}
+
+let skillsCache: SkillConfig[] | null = null;
+
+/**
+ * Load and cache skills
+ */
+export const loadSkills = async (): Promise<SkillConfig[]> => {
+  if (skillsCache) return skillsCache;
+  skillsCache = await getSkills();
+  return skillsCache;
+};
+
+/**
+ * Refresh skills cache
+ */
+export const refreshSkills = async (): Promise<void> => {
+  skillsCache = await getSkills();
+};
+
+/**
+ * Detect if a message starts with a skill command
+ * Skills are invoked with /command syntax
+ */
+export const detectSkillCommand = async (
+  message: string,
+): Promise<SkillMatch | null> => {
+  const trimmed = message.trim();
+
+  if (!trimmed.startsWith("/")) {
+    return null;
+  }
+
+  const skills = await loadSkills();
+
+  for (const skill of skills) {
+    const commandPattern = `/${skill.command}`;
+
+    if (
+      trimmed === commandPattern ||
+      trimmed.startsWith(`${commandPattern} `)
+    ) {
+      const args = trimmed.slice(commandPattern.length).trim();
+      return { skill, args };
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Execute a skill by expanding its prompt template
+ * Supports $ARGS placeholder for arguments
+ */
+export const executeSkill = (
+  skill: SkillConfig,
+  args: string,
+): SkillExecutionResult => {
+  let expandedPrompt = skill.prompt;
+
+  // Replace $ARGS placeholder with actual arguments
+  expandedPrompt = expandedPrompt.replace(/\$ARGS/g, args);
+
+  // Replace $1, $2, etc. with positional arguments
+  const argParts = args.split(/\s+/).filter(Boolean);
+  for (let i = 0; i < argParts.length; i++) {
+    expandedPrompt = expandedPrompt.replace(
+      new RegExp(`\\$${i + 1}`, "g"),
+      argParts[i],
+    );
+  }
+
+  // Clean up any remaining unreplaced placeholders
+  expandedPrompt = expandedPrompt.replace(/\$\d+/g, "");
+  expandedPrompt = expandedPrompt.replace(/\$ARGS/g, "");
+
+  return {
+    expandedPrompt: expandedPrompt.trim(),
+    skill,
+  };
+};
+
+/**
+ * Get all available skill commands for display
+ */
+export const getAvailableSkills = async (): Promise<
+  Array<{ command: string; name: string; description: string }>
+> => {
+  const skills = await loadSkills();
+  return skills.map((s) => ({
+    command: `/${s.command}`,
+    name: s.name,
+    description: s.description,
+  }));
+};
+
+/**
+ * Check if skills are available
+ */
+export const hasSkills = async (): Promise<boolean> => {
+  const skills = await loadSkills();
+  return skills.length > 0;
+};

src/tools/index.ts

@@ -173,11 +173,26 @@ export function getToolsForApi(
 
 /**
  * Refresh MCP tools cache
+ * Returns information about the refresh result for logging
  */
-export async function refreshMCPTools(): Promise<void> {
+export async function refreshMCPTools(): Promise<{
+  success: boolean;
+  toolCount: number;
+  error?: string;
+}> {
   try {
     mcpToolsCache = await getMCPToolsForApi();
-  } catch {
+    return {
+      success: true,
+      toolCount: mcpToolsCache.length,
+    };
+  } catch (err) {
     mcpToolsCache = null;
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      toolCount: 0,
+      error: errorMessage,
+    };
   }
 }

src/types/chat-service.ts

@@ -8,7 +8,7 @@ import type {
   PermissionPromptResponse,
 } from "@/types/permissions";
 import type { LearningCandidate } from "@services/learning-service";
-import type { LearningResponse } from "@/types/tui";
+import type { LearningResponse, InteractionMode } from "@/types/tui";
 
 export interface ChatServiceState {
   provider: ProviderName;
@@ -16,6 +16,7 @@ export interface ChatServiceState {
   messages: Message[];
   contextFiles: Map<string, string>;
   systemPrompt: string;
+  currentMode: InteractionMode;
   verbose: boolean;
   autoApprove: boolean;
 }