winter-super-cli 2026.5.32 → 2026.6.6

package/src/cli/repl.js

@@ -1,13 +1,14 @@
 /**
- * ❄️ WINTER REPL ❄️
+ * WINTER REPL
  * Claude Code / Codex style interactive REPL
  */
 
 import readline from 'readline';
 import { promises as fs, watch as fsWatch } from 'fs';
 import { homedir } from 'os';
-import { welcomeBanner, colors } from './snowflake-logo.js';
-import { renderBox, terminalWidth, stripAnsi, visibleWidth, wrapText, padVisible } from './terminal-ui.js';
+import { welcomeBanner, colors, applyColorTheme } from './snowflake-logo.js';
+import { renderBox, supportsUnicodeUi, terminalWidth, stripAnsi, wrapText, padVisible } from './terminal-ui.js';
+import { WinterInputController } from './input-controller.js';
 import { ToolExecutor } from '../tools/executor.js';
 import { SessionManager } from '../session/manager.js';
 import { AIProviderManager } from '../ai/providers.js';
@@ -16,13 +17,20 @@ import { PermissionManager } from '../tools/permission.js';
 import { compressConversation } from '../context/compress.js';
 import { getToolUsageSummary } from '../tools/analytics.js';
 import { SweAgent } from '../agent/swe-agent.js';
+import { AgentDefinitionRegistry } from '../agent/agent-definitions.js';
+import { AgentRuntime } from '../agent/runtime.js';
 import { SLASH_COMMANDS } from './slash-commands.js';
 import { formatMarkdown } from './markdown-format.js';
 import { Spinner } from './spinner.js';
 import { ContextLoader } from './context-loader.js';
 import { PromptBuilder } from './prompt-builder.js';
 import { buildProjectDocs, isWinterGeneratedProjectDoc } from './project-docs.js';
-import { classifyModelTier, isSmallModel } from '../ai/model-capabilities.js';
+import {
+  buildPromptToolResult as buildPromptToolResultForModel,
+  buildPromptToolResultWithTokenJuice,
+} from './tool-runtime.js';
+import { TokenJuice } from '../context/token-juice.js';
+import { classifyModelTier } from '../ai/model-capabilities.js';
 import {
   addUsage as mergeUsage,
   buildToolCallSignature as buildToolCallSignatureText,
@@ -39,7 +47,25 @@ import {
   parseToolArguments as parseArguments,
   summarizePromptList as summarizePrompts,
 } from './conversation-format.js';
+import { CodebaseSearch } from '../codebase-index/search.js';
+import { CodebaseWatcher } from '../codebase-index/watcher.js';
+import { AtContextResolver } from './at-context.js';
+import { DiffView } from './diff-view.js';
+import { Composer } from './composer.js';
+import { InlineComplete } from '../mcp/inline-complete.js';
+import { Orchestrator } from '../ai/orchestrator.js';
+import { ECCManager } from './ecc.js';
 import { handleSlashCommand } from './repl-commands.js';
+import { selectWorkflow } from '../ai/workflow-selector.js';
+import { buildSmallModelAmplification } from '../ai/small-model-amplifier.js';
+import { getProfileBlueprint } from '../ai/profile-blueprints.js';
+import {
+  getCapabilityScorecard as getCapabilityScorecardReport,
+  runFullDoctor as runFullDoctorDiagnostics,
+  runToolDoctor as runToolDoctorDiagnostics,
+  showCapabilityScorecard as showCapabilityScorecardDiagnostics,
+  showContextDiagnostics as showContextDiagnosticsReport,
+} from './diagnostics.js';
 import path from 'path';
 
 
@@ -74,9 +100,307 @@ export class WinterREPL {
       compactText: (text, maxChars, label) => this.compactText(text, maxChars, label),
       summarizePrompts: (items, opts) => this.summarizePromptList(items, opts),
     });
+    this.codebaseSearcher = null;
+    this.codebaseWatcher = null;
+    this.atContext = null;
+    this.diffView = null;
+    this.composer = null;
+    this.inlineComplete = null;
+    this.eccManager = null;
+    this.orchestrator = null;
+    this.tokenJuice = new TokenJuice({ projectPath: this.projectPath });
+    this.agentRegistry = new AgentDefinitionRegistry({ projectPath: this.projectPath });
+    this.agentRuntime = new AgentRuntime(this);
+    this.useUnicodeUi = supportsUnicodeUi();
+    this.inputController = new WinterInputController(this);
     this.watchers = [];
   }
 
+  async initCodebaseSearch() {
+    if (this.codebaseSearcher) return;
+    this.codebaseSearcher = new CodebaseSearch({ projectPath: this.projectPath, enableCodeGraph: true });
+    await this.codebaseSearcher.init();
+    this.atContext = new AtContextResolver({
+      projectPath: this.projectPath,
+      codebaseSearch: this.codebaseSearcher,
+      tools: this.tools,
+    });
+    this.diffView = new DiffView({ projectPath: this.projectPath });
+    this.composer = new Composer({
+      repl: this,
+      projectPath: this.projectPath,
+      diffView: this.diffView,
+    });
+    this.inlineComplete = new InlineComplete({
+      repl: this,
+      projectPath: this.projectPath,
+    });
+    this.orchestrator = new Orchestrator({
+      ai: this.ai,
+      tools: this.tools,
+      projectPath: this.projectPath,
+    });
+    this.eccManager = new ECCManager({
+      projectPath: this.projectPath,
+      tools: this.tools,
+      config: this.config,
+    });
+  }
+
+  async startCodebaseWatcher() {
+    if (this.codebaseWatcher) return;
+    await this.initCodebaseSearch();
+    this.codebaseWatcher = new CodebaseWatcher({
+      projectPath: this.projectPath,
+      indexer: this.codebaseSearcher.indexer,
+    });
+    this.codebaseWatcher.onChange(({ filePath }) => {
+      // Re-index on change (handled by watcher internally)
+    });
+    this.codebaseWatcher.start({ debounce: true });
+  }
+
+  async codebaseIndex(full = false) {
+    await this.initCodebaseSearch();
+    if (full) {
+      await this.codebaseSearcher.clear();
+    }
+    const stats = await this.codebaseSearcher.reindex();
+    console.log(`${colors.green}✓ Codebase indexed:${colors.reset}`);
+    console.log(`  ${colors.dim}Files: ${stats.totalFiles}, Chunks: ${stats.totalChunks}, Indexed: ${stats.indexedFiles}, Skipped: ${stats.skipped}${colors.reset}`);
+  }
+
+  async codebaseSearch(query) {
+    await this.initCodebaseSearch();
+    this.spinner = new Spinner('Searching codebase...');
+    this.spinner.start();
+    try {
+      const results = await this.codebaseSearcher.query(query, { limit: 15 });
+      if (this.spinner) this.spinner.stop();
+
+      if (results.totalResults === 0) {
+        console.log(`${colors.yellow}No results found for "${query}"${colors.reset}`);
+        return;
+      }
+
+      console.log(`${colors.cyan}Codebase Search: "${query}" ${colors.dim}(${results.totalResults} matches in ${results.totalFiles} files)${colors.reset}\n`);
+      for (const file of results.byFile.slice(0, 10)) {
+        console.log(`  ${colors.green}${file.filePath}${colors.reset} ${colors.dim}(score: ${file.score.toFixed(0)})${colors.reset}`);
+        for (const chunk of file.chunks.slice(0, 3)) {
+          const snippet = chunk.content.split('\n').slice(0, 3).join('\n  ');
+          console.log(`    ${colors.dim}lines ${chunk.startLine}-${chunk.endLine}:${colors.reset}`);
+          console.log(`    ${colors.dim}  ${snippet}${colors.reset}`);
+        }
+        if (file.chunks.length > 3) {
+          console.log(`    ${colors.dim}... and ${file.chunks.length - 3} more chunks${colors.reset}`);
+        }
+        console.log('');
+      }
+      if (results.byFile.length > 10) {
+        console.log(`${colors.dim}... and ${results.byFile.length - 10} more files${colors.reset}`);
+      }
+    } catch (e) {
+      if (this.spinner) this.spinner.stop();
+      console.log(`${colors.red}Search error: ${e.message}${colors.reset}`);
+    }
+  }
+
+  async codebaseFindDef(name) {
+    await this.initCodebaseSearch();
+    const matches = await this.codebaseSearcher.findSymbol(name, { limit: 10 });
+
+    if (matches.length === 0) {
+      console.log(`${colors.yellow}No definition found for "${name}"${colors.reset}`);
+      return;
+    }
+
+    console.log(`${colors.cyan}Definitions for "${name}"${colors.reset}\n`);
+    for (const m of matches) {
+      console.log(`  ${colors.green}${m.filePath}:${m.line}${colors.reset} ${colors.dim}${m.type}:${m.name}${colors.reset}`);
+      if (m.content) {
+        console.log(`    ${colors.dim}${m.content}${colors.reset}`);
+      }
+    }
+  }
+
+  async ensureCodebaseIndex({ verbose = false } = {}) {
+    await this.initCodebaseSearch();
+    const before = this.codebaseSearcher.indexer.getStats();
+    if (before.totalChunks > 0) return before;
+
+    if (verbose) {
+      console.log(`${colors.dim}Indexing codebase for semantic search...${colors.reset}`);
+    }
+    const indexedStats = await this.codebaseSearcher.reindex();
+    if (verbose) {
+      console.log(`${colors.green}✓ Codebase indexed: ${indexedStats.totalFiles} files, ${indexedStats.totalChunks} chunks${colors.reset}`);
+    }
+    return this.codebaseSearcher.indexer.getStats();
+  }
+
+  async buildCodebaseContext(task = '') {
+    try {
+      const stats = await this.ensureCodebaseIndex({ verbose: false });
+      if (!stats.totalChunks) return '';
+
+      const summary = this.codebaseSearcher.getSummary();
+      const lines = [
+        '[Codebase Index]',
+        `Project: ${this.projectPath}`,
+        `Indexed files: ${summary.totalFiles}, chunks: ${summary.totalChunks}`,
+      ];
+
+      if (summary.languages?.length) {
+        lines.push(`Languages: ${summary.languages.map(([lang, count]) => `${lang}:${count}`).join(', ')}`);
+      }
+
+      if (summary.topSymbols?.length) {
+        lines.push('Top symbol files:');
+        for (const file of summary.topSymbols.slice(0, 8)) {
+          lines.push(`- ${file.filePath}: ${file.symbols.join(', ')}`);
+        }
+      }
+
+      const query = String(task || '').trim();
+      if (query.length >= 3) {
+        const results = await this.codebaseSearcher.query(query, { limit: 8 });
+        if (results.byFile.length > 0) {
+          lines.push('');
+          lines.push('[Relevant Codebase Matches]');
+          for (const file of results.byFile.slice(0, 5)) {
+            const snippets = file.chunks.slice(0, 2).map(chunk => {
+              const snippet = chunk.content.split(/\r?\n/).slice(0, 4).join(' ').replace(/\s+/g, ' ');
+              return `lines ${chunk.startLine}-${chunk.endLine}: ${this.compactText(snippet, 240, 'codebase match')}`;
+            });
+            lines.push(`- ${file.filePath} (score ${file.score.toFixed(0)})`);
+            for (const snippet of snippets) lines.push(`  ${snippet}`);
+          }
+        }
+      }
+
+      return this.compactText(lines.join('\n'), 4200, 'codebase context');
+    } catch (error) {
+      return `[Codebase Index]\nUnavailable: ${error.message}`;
+    }
+  }
+
+  async undoLastChange(filePath = '') {
+    await this.initCodebaseSearch();
+    const backups = await this.diffView.getUndoHistory(filePath);
+
+    if (backups.length === 0) {
+      console.log(`${colors.yellow}No backups found${filePath ? ` for ${filePath}` : ''}${colors.reset}`);
+      return;
+    }
+
+    console.log(`${colors.cyan}Recent backups:${colors.reset}\n`);
+    for (const b of backups.slice(0, 10)) {
+      const time = new Date(b.time).toLocaleString();
+      console.log(`  ${colors.dim}${b.backup}${colors.reset}`);
+      console.log(`    ${colors.dim}Original: ${b.original}, ${time}${colors.reset}`);
+    }
+
+    // Offer to undo the most recent one
+    const latest = backups[0];
+    console.log(`\n${colors.yellow}Restore ${latest.original} from backup? ${colors.reset}`);
+    console.log(`  ${colors.dim}Backup: ${latest.backup}${colors.reset}`);
+
+    const { default: rl } = await import('readline');
+    const rli = rl.createInterface({ input: process.stdin, output: process.stdout });
+    rli.question(`${colors.cyan}[y/N]: ${colors.reset}`, async (ans) => {
+      rli.close();
+      if (ans.trim().toLowerCase() === 'y') {
+        const ok = await this.diffView.restoreFromBackup(latest.backup, latest.original);
+        if (ok) {
+          console.log(`${colors.green}✓ Restored ${latest.original} from backup${colors.reset}`);
+        } else {
+          console.log(`${colors.red}Failed to restore${colors.reset}`);
+        }
+      }
+      if (!this.readlineClosed) this.showInputPrompt();
+    });
+  }
+
+  buildPromptToolResult(toolName, result) {
+    return buildPromptToolResultForModel({
+      toolName,
+      result,
+      compact: this.shouldUseCompactPrompt(),
+      compactText: (text, maxChars, label) => this.compactText(text, maxChars, label),
+      summarizeToolResult: value => this.tools?.summarizeToolResult?.(value) || { ...value },
+    });
+  }
+
+  async buildPromptToolResultForModel(toolName, result) {
+    return buildPromptToolResultWithTokenJuice({
+      toolName,
+      result,
+      projectPath: this.projectPath,
+      tokenJuice: this.tokenJuice,
+      compact: this.shouldUseCompactPrompt(),
+      compactText: (text, maxChars, label) => this.compactText(text, maxChars, label),
+      summarizeToolResult: value => this.tools?.summarizeToolResult?.(value) || { ...value },
+    });
+  }
+
+  async compactStartupMemories({ projectInstructionFiles = [], autoCreateDocs = [] } = {}) {
+    const memory = Array.isArray(this.session?.memory) ? this.session.memory : [];
+    const shouldDrop = (entry) => {
+      const text = typeof entry === 'string' ? entry : entry?.text || '';
+      return text.startsWith('[Required local resources]')
+        || text.startsWith('[Auto-applied skills]')
+        || text.startsWith('[Project rule file')
+        || text.startsWith('[Startup local resource index]')
+        || (text.startsWith('[T') && text.includes('ghi nh'))
+        || text.startsWith('[Quy');
+    };
+
+    this.session.memory = memory.filter(entry => !shouldDrop(entry));
+
+    const resourcePaths = this.getResourcePaths();
+    const resourceIndex = [
+      `agents.md: ${resourcePaths.agents}`,
+      `awesome-design-md: ${resourcePaths.designs}`,
+      `karpathy-tools: ${resourcePaths.karpathy}`,
+      `page-agent: ${resourcePaths.pageAgent}`,
+      `ecc: ${resourcePaths.ecc}`,
+    ];
+    await this.session.replaceMemory(
+      '[Startup local resource index]',
+      [
+        'Resources are indexed by path only to save tokens.',
+        ...resourceIndex.map(item => `- ${item}`),
+        'Use Read/Grep/Glob to inspect exact resource files when a task needs detail.',
+      ].join('\n'),
+      'resource'
+    );
+
+    const docs = [
+      ...projectInstructionFiles.map(file => ({
+        filename: file.relativePath,
+        filePath: file.filePath,
+        content: file.content,
+      })),
+      ...autoCreateDocs.map(doc => ({
+        filename: doc.filename,
+        filePath: path.join(this.projectPath, doc.filename),
+        content: doc.content,
+      })),
+    ];
+
+    const seen = new Set();
+    for (const doc of docs) {
+      if (!doc?.filename || seen.has(doc.filename)) continue;
+      seen.add(doc.filename);
+      const summary = this.compactText(String(doc.content || '').replace(/\s+/g, ' ').trim(), 700, doc.filename);
+      await this.session.replaceMemory(
+        `[Project rule file ${doc.filename}]`,
+        `Path: ${doc.filePath}\nSummary: ${summary}`,
+        'rule'
+      );
+    }
+  }
+
   getSessionToolPermissionStore() {
     const context = this.session?.getContext?.() || {};
     const value = context.toolPermissions?.value;
@@ -115,8 +439,14 @@ export class WinterREPL {
     return this.contextLoader.readProjectInstructionFiles();
   }
 
+  applyUiTheme(theme = 'dark') {
+    return applyColorTheme(theme);
+  }
+
   async start() {
     await this.session.init({ project: this.projectPath, sessionId: this.sessionId });
+    const startupConfig = await this.config.load();
+    this.applyUiTheme(startupConfig.ui?.theme || 'dark');
     await this.ai.init();
 
     await this.session.updateContext('projectAnchor', {
@@ -126,10 +456,10 @@ export class WinterREPL {
     });
     await this.session.replaceMemory('[Project Anchor]', `Current project is ${this.projectPath}. Treat this path as the canonical working directory for the session.`, 'info');
 
-    // Tự động đọc và ghi nhớ một số tài nguyên cục bộ (an toàn): chỉ nạp file hoặc README trong thư mục
+    // Tự động đọc và ghi nhớ một số tài nguyên cục bộ an toàn.
     const fsPromises = await import('fs/promises');
     const resourcePaths = this.getResourcePaths();
-    const autoLoadTargets = [resourcePaths.agents, resourcePaths.designs, resourcePaths.karpathy];
+    const autoLoadTargets = [resourcePaths.agents, resourcePaths.designs, resourcePaths.karpathy, resourcePaths.pageAgent];
 
     for (const targetPath of autoLoadTargets) {
       try {
@@ -141,7 +471,7 @@ export class WinterREPL {
           const fileName = path.basename(targetPath);
           const memoryKey = `[Tự động ghi nhớ file ${fileName}]`;
           await this.session.replaceMemory(memoryKey, content);
-          console.log(`${colors.dim}ℹ Đã tự động nạp và ghi nhớ file ${fileName}${colors.reset}`);
+          console.log(`${colors.dim}✓ Đã tự động nạp và ghi nhớ file ${fileName}${colors.reset}`);
           continue;
         }
 
@@ -157,7 +487,7 @@ export class WinterREPL {
                 const content = await fsPromises.readFile(p, 'utf8');
                 const memoryKey = `[Tự động ghi nhớ file ${path.basename(targetPath)}/${c}]`;
                 await this.session.replaceMemory(memoryKey, content);
-                console.log(`${colors.dim}ℹ Đã tự động nạp và ghi nhớ ${path.basename(targetPath)}/${c}${colors.reset}`);
+                console.log(`${colors.dim}✓ Đã tự động nạp và ghi nhớ ${path.basename(targetPath)}/${c}${colors.reset}`);
                 loaded = true;
                 break;
               }
@@ -182,39 +512,39 @@ export class WinterREPL {
         for (const file of projectInstructionFiles) {
           const memoryKey = `[Quy tắc dự án từ ${file.relativePath}]`;
           await this.session.replaceMemory(memoryKey, file.content);
-          console.log(`${colors.dim}ℹ Đã nạp quy tắc dự án từ ${file.relativePath}${colors.reset}`);
+          console.log(`${colors.dim}✓ Đã nạp quy tắc dự án từ ${file.relativePath}${colors.reset}`);
         }
       }
     } catch (e) {
-      // Nếu không có, tự động tạo file mẫu!
+      // Nếu không có, tự động tạo file mẫu.
       const template = `# Winter Project Rules
 
-## 📝 Project Overview
+## Project Overview
 - **Name**: [Tên dự án]
 - **Description**: [Mô tả ngắn về dự án]
 
-## 🛠 Tech Stack
+## Tech Stack
 - **Languages**: JavaScript / TypeScript
 - **Runtime**: Node.js
 - **Frameworks**: [Tự điền nếu có, VD: Express, React...]
 
-## 🎯 AI Behavior & Coding Guidelines
+## AI Behavior & Coding Guidelines
 
-### 1. Nguyên Tắc Code (Coding Standards)
+### 1. Nguyên tắc Code (Coding Standards)
 - Luôn ưu tiên viết code sạch (Clean Code), dễ đọc và dễ bảo trì.
 - Sử dụng ES Modules (\`import/export\`) thay vì CommonJS (\`require\`) trừ khi có lý do đặc biệt.
 - Giữ nguyên các comment và JSDoc hiện có trong file trừ khi được yêu cầu sửa.
 
-### 2. Tương Tác Với Người Dùng (User Interaction)
-- Luôn giải thích NGẮN GỌN lý do thực hiện thay đổi trước khi sửa file.
+### 2. Tương tác với người dùng (User Interaction)
+- Luôn giải thích ngắn gọn lý do thực hiện thay đổi trước khi sửa file.
 - Khi gặp lỗi, hãy đề xuất giải pháp thay vì chỉ báo lỗi.
-- KHÔNG tự tiện xóa code cũ của user trừ khi chắc chắn nó không còn dùng hoặc được yêu cầu.
+- Không tự tiện xóa code cũ của user trừ khi chắc chắn không còn dùng hoặc được yêu cầu.
 
 ### 3. Git & Commits
 - Viết commit message theo chuẩn Conventional Commits (VD: \`feat:\`, \`fix:\`, \`docs:\`).
 - Luôn kiểm tra \`git status\` trước khi thực hiện thay đổi lớn.
 
-### 4. Xử Lý File (File Operations)
+### 4. Xử lý File (File Operations)
 - Chỉ sửa những dòng cần thiết, tránh viết lại toàn bộ file nếu không cần.
 - Luôn đảm bảo file không bị lỗi cú pháp sau khi sửa.
 `;
@@ -224,14 +554,14 @@ export class WinterREPL {
         console.log(`\n${colors.green}✓ Đã tự động tạo file winter.md mẫu cho dự án mới!${colors.reset}`);
         console.log(`${colors.dim}Bạn có thể chỉnh sửa file này để dạy AI các quy tắc riêng của dự án.${colors.reset}\n`);
         
-        // Nạp luôn vào memory
+        // Nạp luôn vào memory.
         await this.session.replaceMemory(`[Quy tắc dự án từ winter.md]`, template);
       } catch (err) {
-        // Bỏ qua nếu không ghi được file
+        // Bỏ qua nếu không ghi được file.
       }
     }
 
-    // ── Tự động tạo design.md, skill.md, rule.md nếu chưa có ──────────────
+    // Tự động tạo design.md, skill.md, rule.md nếu chưa có.
     const autoCreateDocs = await buildProjectDocs({
       projectPath: this.projectPath,
       resourcePaths: this.getResourcePaths(),
@@ -257,12 +587,20 @@ export class WinterREPL {
           const memoryKey = `[Quy tắc dự án từ ${doc.filename}]`;
           await this.session.replaceMemory(memoryKey, doc.content);
         } catch (err) {
-          // Bỏ qua nếu không tạo được
+          // Bỏ qua nếu không tạo được.
         }
       }
     }
 
     await this.bootstrapProjectCapabilities();
+    await this.compactStartupMemories({ projectInstructionFiles, autoCreateDocs });
+
+    // Codebase Index: warm in background, then inject summaries into model context on demand.
+    this.codebaseWarmup = this.ensureCodebaseIndex({ verbose: true })
+      .then(() => this.startCodebaseWatcher())
+      .catch((error) => {
+        console.log(`${colors.yellow}Codebase index disabled: ${error.message}${colors.reset}`);
+      });
 
     const activeProvider = this.ai.getActiveProvider();
     const info = {
@@ -281,22 +619,23 @@ export class WinterREPL {
       this.showStatus();
     }
 
-    // Hiển thị lịch sử chat nếu đang load lại session cũ
-    const sessionHistory = this.session.getHistory(10); // Lấy tối đa 10 câu gần nhất cho đỡ rác màn hình
+    // Hiển thị lịch sử chat nếu đang load lại session cũ, nhưng chỉ replay bản tóm tắt.
+    const sessionHistory = this.session.getHistory(4);
     if (sessionHistory.length > 0) {
       const columns = process.stdout.columns || 80;
       const W = Math.max(60, Math.min(Math.floor(columns * 0.95), 100));
       const titleStr = ' Lịch sử phiên làm việc ';
-      const sideLine = '─'.repeat(Math.max(0, Math.floor((W - titleStr.length) / 2)));
-      const bottomLine = '─'.repeat(W);
+      const ruleChar = this.useUnicodeUi ? '─' : '-';
+      const sideLine = ruleChar.repeat(Math.max(0, Math.floor((W - titleStr.length) / 2)));
+      const bottomLine = ruleChar.repeat(W);
 
       console.log(`\n${colors.dim}${sideLine}${titleStr}${sideLine}${colors.reset}`);
       for (const msg of sessionHistory) {
+        const text = this.formatStartupHistoryEntry(msg.content);
         if (msg.role === 'user') {
-          console.log(`\n${colors.cyan}Bạn:${colors.reset} ${msg.content}`);
+          console.log(`\n${colors.cyan}Bạn:${colors.reset} ${text}`);
         } else if (msg.role === 'assistant') {
-          const formatted = formatMarkdown(msg.content);
-          console.log(`\n${colors.bright}${colors.magenta}Winter:${colors.reset}${formatted}`);
+          console.log(`\n${colors.bright}${colors.magenta}Winter:${colors.reset} ${text}`);
         }
       }
       console.log(`\n${colors.dim}${bottomLine}${colors.reset}\n`);
@@ -306,20 +645,20 @@ export class WinterREPL {
     this.rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
-      prompt: `${colors.bright}${colors.cyan}winter❄️:  ${colors.reset}`,
+      prompt: `${colors.bright}${colors.cyan}winter > ${colors.reset}`,
       completer: this.completer.bind(this),
     });
-    this.installSlashSuggestions();
+    this.inputController.installSlashSuggestions();
 
-    // Bắt sự kiện Ctrl+C để in ra lệnh tiếp tục session
+    // Bắt sự kiện Ctrl+C để in ra lệnh tiếp tục session.
     this.rl.on('SIGINT', () => {
-      console.log(`\n\n${colors.cyan}❄ Cảm ơn bạn đã sử dụng Winter!${colors.reset}`);
-      console.log(`${colors.yellow}Để tiếp tục phiên làm việc này sau này, hãy chạy:${colors.reset}`);
+      console.log(`\n\n${colors.cyan}Cảm ơn đã sử dụng Winter!${colors.reset}`);
+      console.log(`${colors.yellow}Tiếp tục phiên làm việc:${colors.reset}`);
       console.log(`${colors.bright}${colors.green}winter --session ${this.session.getSessionId()}${colors.reset}\n`);
       process.exit(0);
     });
 
-    // Hiển thị prompt lần đầu tiên ngay khi khởi động xong
+    // Hiển thị prompt lần đầu tiên ngay khi khởi động xong.
     this.showInputPrompt();
 
     this.rl.on('line', (line) => {
@@ -335,7 +674,7 @@ export class WinterREPL {
         })
         .catch((error) => {
           this.closeInputBox();
-          console.log(`\n${colors.red}✖ Error: ${error.message}${colors.reset}\n`);
+          console.log(`\n${colors.red}? Error: ${error.message}${colors.reset}\n`);
           if (this.running && !this.readlineClosed) this.showInputPrompt();
         });
     });
@@ -348,26 +687,32 @@ export class WinterREPL {
     });
   }
 
+  formatStartupHistoryEntry(content, maxChars = 420) {
+    let text = stripAnsi(String(content ?? ''))
+      .replace(/\r?\n/g, ' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+    if (!this.useUnicodeUi) {
+      text = text
+        .replace(/\p{Extended_Pictographic}/gu, '')
+        .replace(/[─━—–]/g, '-')
+        .replace(/\s+/g, ' ')
+        .trim();
+    }
+    if (text.length <= maxChars) return text;
+    return `${text.slice(0, maxChars - 32).trimEnd()} ... (${text.length - maxChars + 32} chars hidden)`;
+  }
+
   showInputPrompt() {
-    if (!this.running || this.readlineClosed) return;
-    const w = Math.max(20, terminalWidth() - 2);
-    process.stdout.write(`
-${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
-`);
-    process.stdout.write(`${colors.magenta}│${colors.reset} `);
-    this.rl.setPrompt(`${colors.bright}${colors.cyan}winter❄️: ${colors.reset}`);
-    this.rl.prompt();
+    return this.inputController.showInputPrompt();
   }
 
   closeInputBox() {
-    const w = Math.max(20, terminalWidth() - 2);
-    readline.moveCursor(process.stdout, 0, -1);
-    readline.cursorTo(process.stdout, terminalWidth() - 1);
-    process.stdout.write(`${colors.magenta}│${colors.reset}`);
-    process.stdout.write(`
-`);
-    process.stdout.write(`${colors.magenta}╰${'─'.repeat(w)}╯${colors.reset}
-`);
+    return this.inputController.closeInputBox();
+  }
+
+  buildInputPanel() {
+    return this.inputController.buildInputPanel();
   }
 
   showStatus() {
@@ -418,6 +763,46 @@ ${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
     await this.printPathPreview(this.getResourcePaths().karpathy, 'karpathy-tools');
   }
 
+  async showPageAgentResources(args = []) {
+    const root = this.getResourcePaths().pageAgent;
+    const [action = 'info', ...rest] = args;
+
+    if (action === 'search') {
+      const query = rest.join(' ');
+      if (!query) {
+        console.log(`${colors.yellow}Usage: /page-agent search <query>${colors.reset}`);
+        return;
+      }
+      const matches = await this.searchResourceFiles(root, query, 30);
+      console.log(`${colors.cyan}Page Agent search "${query}":${colors.reset}`);
+      if (matches.length === 0) {
+        console.log(`  ${colors.dim}No results${colors.reset}`);
+        return;
+      }
+      matches.forEach(match => console.log(`  ${match.isDirectory ? '[dir] ' : '[file]'} ${match.relativePath}`));
+      return;
+    }
+
+    if (action === 'read') {
+      const requestedPath = rest.join(' ') || 'README.md';
+      const target = path.resolve(root, requestedPath);
+      if (!target.startsWith(path.resolve(root))) {
+        console.log(`${colors.red}Path must stay inside page-agent resources.${colors.reset}`);
+        return;
+      }
+      await this.printPathPreview(target, `page-agent/${requestedPath}`);
+      return;
+    }
+
+    if (action === 'docs') {
+      await this.printPathPreview(path.join(root, 'docs'), 'page-agent/docs');
+      return;
+    }
+
+    await this.printPathPreview(root, 'page-agent');
+    console.log(`${colors.dim}Commands: /page-agent search <query>, /page-agent read <path>, /page-agent docs${colors.reset}`);
+  }
+
   async showAgentsFile() {
     await this.printPathPreview(this.getResourcePaths().agents, 'agents.md');
   }
@@ -503,10 +888,36 @@ ${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
     return this.contextLoader.listPathEntries(target, limit);
   }
 
+  async searchResourceFiles(root, query, limit = 30) {
+    const matches = [];
+    const needle = String(query || '').toLowerCase();
+    if (!needle) return matches;
+
+    const walk = async (dir) => {
+      if (matches.length >= limit) return;
+      const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+      for (const entry of entries) {
+        if (matches.length >= limit) break;
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(root, fullPath).replace(/\\/g, '/');
+        if (entry.isDirectory()) {
+          if (['node_modules', '.git', 'dist', 'build', '.next'].includes(entry.name)) continue;
+          if (entry.name.toLowerCase().includes(needle)) matches.push({ relativePath, isDirectory: true });
+          await walk(fullPath);
+        } else if (entry.isFile() && entry.name.toLowerCase().includes(needle)) {
+          matches.push({ relativePath, isDirectory: false });
+        }
+      }
+    };
+
+    await walk(root);
+    return matches;
+  }
+
   async handleInput(input) {
     if (this.isProcessing) {
       const pos = this.taskQueue.length + 1;
-      console.log(`${colors.magenta}◎${colors.reset} ${colors.dim}Đã xếp hàng chờ (vị trí #${pos})${colors.reset}`);
+      console.log(`${colors.magenta}•${colors.reset} ${colors.dim}Đã xếp hàng chờ (vị trí #${pos})${colors.reset}`);
       this.taskQueue.push(input);
       return;
     }
@@ -522,11 +933,53 @@ ${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
         this.history = this.history.slice(-this.maxHistory);
       }
 
+      if (input.startsWith('!')) {
+        const command = input.slice(1).trim();
+        if (!command) {
+          console.log(`${colors.yellow}Usage: !<command>${colors.reset}`);
+          return;
+        }
+        await this.handleSlashCommand(`/bash ${command}`);
+        return;
+      }
+
+      const agentMention = await this.parseAgentMention(input);
+      if (agentMention) {
+        const result = await this.runAgent(agentMention.agentId, agentMention.task);
+        console.log(result);
+        return;
+      }
+
+      // Parse @-symbols for non-command input
+      if (!input.startsWith('/')) {
+        await this.initCodebaseSearch();
+        if (this.atContext && this.atContext.hasAtReferences(input)) {
+          try {
+            const parsed = await this.atContext.parse(input);
+            if (parsed.hasAtReferences) {
+              const atContextPrompt = this.atContext.formatContextPrompt(parsed.contexts);
+              if (atContextPrompt) {
+                this._pendingAtContext = atContextPrompt;
+              }
+              input = parsed.input; // Remove @-symbols from input
+            }
+          } catch {
+            // Silently continue if @ parsing fails
+          }
+        }
+      }
+
       if (input.startsWith('/')) {
         await this.handleSlashCommand(input);
         return;
       }
 
+      const pastedDataImage = this.parseDataUrlImage(input);
+      if (pastedDataImage) {
+        await this.chat('Analyze this pasted image.', [pastedDataImage]);
+        return;
+      }
+
       const imageMatch = input.match(/(\S+\.(?:png|jpg|jpeg|gif|webp|bmp|svg))/i);
       let handled = false;
       if (imageMatch) {
@@ -563,6 +1016,17 @@ ${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
     }
   }
 
+  async parseAgentMention(input = '') {
+    const match = String(input || '').match(/^\s*@([A-Za-z][\w-]*)\s+([\s\S]+)$/);
+    if (!match) return null;
+    const agentId = match[1];
+    const task = match[2].trim();
+    if (!task) return null;
+    const agents = await this.listAgentDefinitions();
+    if (!agents.some(agent => agent.id.toLowerCase() === agentId.toLowerCase())) return null;
+    return { agentId, task };
+  }
+
   async loadImageAsBase64(filePath) {
     try {
       const fs = await import('fs/promises');
@@ -583,6 +1047,13 @@ ${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
     }
   }
 
+  parseDataUrlImage(value = '') {
+    const match = String(value || '').match(/data:(image\/(?:png|jpeg|jpg|gif|webp|bmp|svg\+xml));base64,([a-z0-9+/=]+)/i);
+    if (!match) return null;
+    const mime = match[1].toLowerCase() === 'image/jpg' ? 'image/jpeg' : match[1].toLowerCase();
+    return { mime, base64: match[2] };
+  }
+
   async showInteractiveChecklist(title, items) {
     if (!items || items.length === 0) return [];
 
@@ -592,7 +1063,7 @@ ${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
 
       let printedLines = 0;
       const render = () => {
-        // Xóa những dòng đã in trước đó
+        // Xóa những dòng đã in trước đó.
         if (printedLines > 0) {
           process.stdout.write('\x1b[' + printedLines + 'A\x1b[J');
         }
@@ -652,7 +1123,7 @@ ${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
     this.spinner.start();
 
     const messages = [
-      { role: 'system', content: 'Bạn là chuyên gia lập kế hoạch. Hãy chia nhỏ yêu cầu của người dùng thành các bước cụ thể, hành động được, rất ngắn gọn (dưới 15 chữ mỗi bước). CHỈ TRẢ VỀ MỘT MẢNG JSON CÁC CHUỖI, KHÔNG GIẢI THÍCH GÌ THÊM. Ví dụ: ["Tạo file index.html", "Thêm CSS styling", "Viết script.js"]' },
+      { role: 'system', content: 'Bạn là chuyên gia lập kế hoạch. Hãy chia nhỏ yêu cầu của người dùng thành các bước cụ thể, hành động được, rất ngắn gọn (dưới 15 chữ mỗi bước). Chỉ trả về một mảng JSON các chuỗi, không giải thích gì thêm. Ví dụ: ["Tạo file index.html", "Thêm CSS styling", "Viết script.js"]' },
       { role: 'user', content: task }
     ];
 
@@ -703,26 +1174,28 @@ ${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
 
 
   async runAutoHealing(task) {
-    console.log(`\n\x1b[35m[ TDD AUTO-HEALING MODE ]\x1b[0m Kích hoạt vòng lặp chữa lành lỗi tự động.`);
+    console.log(`\n\x1b[35m[ TDD AUTO-HEALING MODE ]\x1b[0m Kích hoạt vòng lặp tự sửa lỗi.`);
 
-    // Tăng giới hạn loop lên 15 để cho phép AI tự sửa lỗi nhiều lần
+    // Tăng giới hạn loop lên 15 để cho phép AI tự sửa lỗi nhiều lần.
     const originalRequestAssistantTurn = this.requestAssistantTurn;
 
-    // Chèn prompt đặc biệt ép AI phải verify
+    // Chèn prompt đặc biệt ép AI phải verify.
+    const verifyCommands = await this.inferVerificationCommands(task);
     const autoPrompt = `TASK: ${task}
-    
-    CRITICAL TDD RULES:
-    1. Write code to solve the task.
-    2. IMMEDIATELY use the Bash tool to run the code (e.g., 'node file.js', 'npm run build', or 'tsc').
-    3. If the Bash tool returns ANY errors, read the error, Edit the code to fix it, and RUN IT AGAIN.
-    4. DO NOT STOP AND DO NOT ASK FOR PERMISSION. KEEP FIXING AND RUNNING UNTIL THERE ARE NO ERRORS.
-    5. Only return your final answer when the bash execution shows SUCCESS.`;
+
+CRITICAL DEBUG/AGENT RULES:
+1. Inspect the project before changing anything. Read the failing file, related caller, config, and logs.
+2. Reproduce or locate the first hard failure. For frontend/runtime UI issues, use BrowserDebug when a URL/dev server is available.
+3. Patch the smallest root cause with Write/Edit.
+4. Run the closest verification command(s): ${verifyCommands.join(' && ')}.
+5. If verification fails, read the new error, patch again, and run verification again.
+6. Do not claim success until a tool result proves it.`;
 
     await this.chat(autoPrompt);
   }
 
   async runAutoCommit(context = '') {
-    console.log(`\n${colors.cyan}❄ Tạo commit message tự động...${colors.reset}`);
+    console.log(`\n${colors.cyan}✓ Tạo commit message tự động...${colors.reset}`);
     const diffResult = await this.tools.execute('Bash', { command: 'git diff --cached' }, { cwd: this.projectPath });
 
     let diff = diffResult.stdout;
@@ -734,7 +1207,7 @@ ${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
     }
 
     if (!diff || diff.trim() === '') {
-      console.log(`${colors.yellow}⚠ Không có thay đổi nào để commit.${colors.reset}`);
+      console.log(`${colors.yellow}Không có thay đổi nào để commit.${colors.reset}`);
       if (this.running && !this.readlineClosed) this.rl.prompt();
       return;
     }
@@ -783,16 +1256,16 @@ ${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
   }
 
   async runCodeReview(context = '') {
-    console.log(`\n${colors.cyan}❄ AI đang soi code của bạn...${colors.reset}`);
+    console.log(`\n${colors.cyan}AI đang soi code của bạn...${colors.reset}`);
     const diffResult = await this.tools.execute('Bash', { command: 'git diff HEAD' }, { cwd: this.projectPath });
     const diff = diffResult.stdout;
 
     if (!diff || diff.trim() === '') {
-      console.log(`${colors.yellow}⚠ Không có thay đổi nào để review.${colors.reset}`);
+      console.log(`${colors.yellow}Không có thay đổi nào để review.${colors.reset}`);
       return;
     }
 
-    const prompt = `Hãy đóng vai một Senior Developer khó tính. Review nhanh các thay đổi sau đây. Chỉ ra bug (nếu có), vấn đề bảo mật, hoặc những chỗ cần clean code. Không cần khen ngợi, hãy nói thẳng vào vấn đề. Trình bày dạng Markdown đẹp mắt. \n\n${context ? `Ngữ cảnh: ${context}\n` : ''}Diff:\n${diff.slice(0, 8000)}`;
+    const prompt = `Hãy đóng vai một Senior Developer khó tính. Review nhanh các thay đổi sau đây. Chỉ ra bug nếu có, vấn đề bảo mật, hoặc những chỗ cần clean code. Không cần khen ngợi, hãy nói thẳng vào vấn đề. Trình bày dạng Markdown đẹp mắt.\n\n${context ? `Ngữ cảnh: ${context}\n` : ''}Diff:\n${diff.slice(0, 8000)}`;
 
     await this.chat(prompt);
   }
@@ -813,7 +1286,8 @@ ${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
     };
 
     const body = [
-      `${c.bright}${c.cyan}❄ WINTER COMMANDS${c.reset}`,
+      `${c.bright}${c.cyan}${this.useUnicodeUi ? '❄ ' : ''}WINTER COMMANDS${c.reset}`,
+      `${c.dim}@file context | @Agent task | !cmd bash | /theme:toggle${c.reset}`,
       '',
       `${c.bright}Dự án & Phiên làm việc${c.reset}`,
       row(`${c.yellow}/pwd${c.reset}     Thư mục hiện tại`, `${c.yellow}/session${c.reset}  Phiên làm việc`),
@@ -821,12 +1295,18 @@ ${colors.magenta}╭${'─'.repeat(w)}╮${colors.reset}
       row(`${c.yellow}/config${c.reset}  Xem cấu hình`, `${c.yellow}/exit${c.reset}     Thoát`),
       '',
       `${c.bright}AI & Công cụ${c.reset}`,
-      row(`${c.yellow}/auto${c.reset}    TDD t? s?a l?i`, `${c.yellow}/debug${c.reset}   Auto debug l?i`),
-      row(`${c.yellow}/agent${c.reset}   Ch?y sub-agent`, `${c.yellow}/swe${c.reset}     SWE workflow`),
+      row(`${c.yellow}/auto${c.reset}    TDD tự sửa lỗi`, `${c.yellow}/debug${c.reset}   Auto debug lỗi`),
+      row(`${c.yellow}/doctor${c.reset}  Kiểm tra tool-call`, `${c.yellow}/agent${c.reset}   Chạy sub-agent`),
+      row(`${c.yellow}/swe${c.reset}     SWE workflow`, `${c.yellow}/plan${c.reset}    Lập kế hoạch`),
       row(`${c.yellow}/read${c.reset}    Đọc file`, `${c.yellow}/write${c.reset}   Ghi file`),
       row(`${c.yellow}/bash${c.reset}    Chạy lệnh terminal`, `${c.yellow}/grep${c.reset}    Tìm trong file`),
-      row(`${c.yellow}/glob${c.reset}    Tìm file theo pattern`, `${c.yellow}/image${c.reset}   Phân tích UI`),
-      row(`${c.yellow}/paste${c.reset}   Dán từ clipboard`, `${c.yellow}/plan${c.reset}    Lập kế hoạch`),
+      row(`${c.yellow}/glob${c.reset}    Tìm file theo pattern`, `${c.yellow}/image${c.reset}   Ảnh/file/clipboard`),
+      row(`${c.yellow}/paste${c.reset}   Dán text/ảnh clipboard`, `${c.yellow}/composer${c.reset}  Multi-file edit`),
+      row(`${c.yellow}/complete${c.reset} Gợi ý code`, `${c.yellow}/search${c.reset}   Tìm kiếm code`),
+      row(`${c.yellow}/browse${c.reset}   Mở URL trong trình duyệt`, `${c.yellow}/page-agent${c.reset} GUI Agent resources`),
+      row(`${c.yellow}/ensemble${c.reset} Chạy nhiều AI`, `${c.yellow}/vote${c.reset}     Bình chọn hay nhất`),
+      row(`${c.yellow}/orchestrate${c.reset} Pipeline đa model`, `${c.yellow}/undo${c.reset}     Undo backup`),
+      row(`${c.yellow}/ecc${c.reset}      ECC resource browser`, `${c.yellow}/codex${c.reset}    Codex resources`),
       '',
       `${c.bright}Git Auto-Pilot${c.reset}`,
       row(`${c.yellow}/commit${c.reset}  AI tự viết commit`, `${c.yellow}/review${c.reset}  AI review code thay đổi`),
@@ -849,14 +1329,14 @@ ${renderBox({
       titleColor: c.cyan,
       body,
     })}
-${c.dim}Gõ tin nhắn trực tiếp để chat · ESC để hủy · Prompt tự xếp hàng chờ${c.reset}
+${c.dim}Gửi tin nhắn trực tiếp để chat, ESC để hủy${c.reset}
 `);
   }
 
   showHelp() {
     console.log(`
-${colors.cyan}❄ WINTER COMMANDS${colors.reset}
-${colors.dim}${''.padEnd(50, '─')}${colors.reset}
+${colors.cyan}${this.useUnicodeUi ? '❄ ' : ''}WINTER COMMANDS${colors.reset}
+${colors.dim}${''.padEnd(50, this.useUnicodeUi ? '─' : '-')}${colors.reset}
 
 ${colors.white}Project:${colors.reset}
   /project, /pwd    Show current project
@@ -866,6 +1346,9 @@ ${colors.white}Session:${colors.reset}
   /session          Current session info
   /sessions         List all sessions
   /clear            Clear screen
+  /undo             Undo last change from backup
+  /composer <task>  Multi-file editing mode (like Cursor Composer)
+  /complete <file>  Trigger inline code completion
 
 ${colors.white}Memory:${colors.reset}
   /remember <text>  Store in memory
@@ -879,6 +1362,7 @@ ${colors.white}Plans & Tasks:${colors.reset}
   /agent [role] <task>  Run a subagent
   /auto [task]      Auto-heal with test/build loop
   /debug [error]    Auto-debug and verify a failure
+  /doctor tools     Test whether current provider/model can call tools
 
 ${colors.white}Tools:${colors.reset}
   /read <file>      Read file
@@ -904,6 +1388,7 @@ ${colors.white}Design & Skills:${colors.reset}
   /plugin          Plugin management
 
 ${colors.white}Local Sources:${colors.reset}
+  /ecc [sub]       Browse ECC resources (info, browse, search, sync)
   /codex [section]  Browse ~/.codex resources
   /claude [section] Browse ~/.claude resources
   /karpathy        Browse ~/karpathy-tools
@@ -913,7 +1398,7 @@ ${colors.white}Other:${colors.reset}
   /help, /?        Show this help
   /exit, /quit     Exit Winter
 
-${colors.dim}${''.padEnd(50, '─')}${colors.reset}
+${colors.dim}${''.padEnd(50, '?')}${colors.reset}
 Just type your message to chat with Winter!
 ${colors.reset}
 `);
@@ -932,7 +1417,7 @@ ${colors.reset}
       }
       console.log(`${colors.cyan}Design Systems:${colors.reset}`);
       filtered.forEach(e => {
-        const icon = e.isDirectory ? '📁' : '📄';
+        const icon = e.isDirectory ? '[dir]' : '[file]';
         console.log(`  ${icon} ${e.name}`);
       });
     } catch (error) {
@@ -952,7 +1437,7 @@ ${colors.reset}
           const entries = await this.listPathEntries(section.path, 50);
           if (entries.length > 0) {
             console.log(`${colors.cyan}${section.label}:${colors.reset}`);
-            entries.forEach(e => console.log(`  ${e.isDirectory ? '📂' : '📄'} ${e.name}`));
+            entries.forEach(e => console.log(`  ${e.isDirectory ? '[dir]' : '[file]'} ${e.name}`));
           }
         } catch { }
       }
@@ -966,8 +1451,8 @@ ${colors.reset}
       const providers = this.ai.listProviders();
       console.log(`${colors.cyan}Configured Models:${colors.reset}`);
       providers.forEach(p => {
-        const active = p.name === this.ai.getActiveProvider() ? ` ${colors.green}◀ active${colors.reset}` : '';
-        const status = p.ready ? `${colors.green}●${colors.reset}` : `${colors.red}○${colors.reset}`;
+        const active = p.name === this.ai.getActiveProvider() ? ` ${colors.green}< active${colors.reset}` : '';
+        const status = p.ready ? `${colors.green}ok${colors.reset}` : `${colors.red}off${colors.reset}`;
         console.log(`  ${status} ${colors.bright}${p.name}${colors.reset}: ${p.model}${active}`);
       });
 
@@ -976,7 +1461,7 @@ ${colors.reset}
       const cached = await this.readCachedModels(cachePath);
       if (cached.length > 0) {
         console.log(`\n${colors.cyan}Cached Models (${cached.length}):${colors.reset}`);
-        cached.slice(0, 20).forEach(m => console.log(`  ${colors.dim}•${colors.reset} ${m}`));
+        cached.slice(0, 20).forEach(m => console.log(`  ${colors.dim}?${colors.reset} ${m}`));
         if (cached.length > 20) console.log(`  ${colors.dim}... and ${cached.length - 20} more${colors.reset}`);
       }
     } catch (error) {
@@ -1001,13 +1486,16 @@ ${colors.reset}
       case 'plan':
         return byName(['Read', 'Grep', 'Glob', 'TaskCreate', 'TaskUpdate', 'TaskList']);
       case 'review':
-        return byName(['Read', 'Grep', 'Glob']);
+        return byName(['Read', 'Grep', 'Glob', 'Bash', 'WebFetch']);
       case 'debug':
-        return byName(['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob']);
+        return byName(['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'BrowserDebug', 'WebFetch', 'Parallel']);
       case 'research':
-        return byName(['Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch']);
+        return byName(['Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch', 'Parallel']);
+      case 'design':
+      case 'ui':
+        return byName(['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'BrowserDebug', 'WebFetch']);
       default:
-        return byName(['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep']);
+        return byName(['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'BrowserDebug', 'WebFetch', 'WebSearch', 'Parallel', 'Agent']);
     }
   }
 
@@ -1018,7 +1506,7 @@ ${colors.reset}
   }
 
   shouldUseCompactPrompt() {
-    return isSmallModel(this.getActiveModelTier());
+    return false;
   }
 
   selectExecutionProfile(messages = [], options = {}) {
@@ -1064,196 +1552,7 @@ ${colors.reset}
 
 
   async runConversation(messages, label = 'Thinking', tools = null) {
-    this.spinner = new Spinner(label + '...');
-    this.spinner.start();
-    this.hydrateSessionToolPermissions();
-
-    const startedAt = Date.now();
-    const previousTools = this.ai.tools;
-    if (tools) this.ai.setTools(tools);
-
-    let finalContent = '';
-    let reachedToolLimit = true;
-    let usedTools = false;
-    let verified = false;
-    const toolSummaries = [];
-    const totalUsage = {};
-    const toolSignatureHistory = [];
-    const executionProfile = this.selectExecutionProfile(messages, { enableTools: true });
-    const requireToolEvidence = this.actionRequiresTools(messages);
-    let noToolActionRetries = 0;
-    try {
-      for (let i = 0; i < 8; i++) {
-        if (this.isCancelled) throw new Error('AbortError');
-        const turn = await this.requestAssistantTurn(messages, {
-          provider: executionProfile.provider,
-          model: executionProfile.model,
-          enableTools: true,
-          requireToolEvidence: requireToolEvidence && !usedTools,
-        }, startedAt, totalUsage);
-
-        const assistantMsg = turn.assistantMsg || {};
-        const toolCalls = turn.toolCalls || [];
-
-        if (turn.finalContent && toolCalls.length === 0) {
-          finalContent = turn.finalContent;
-        }
-
-        if (toolCalls.length === 0) {
-          if (turn.finishReason === 'tool_evidence_required') {
-            noToolActionRetries++;
-            if (noToolActionRetries > 2) {
-              finalContent = 'Chưa thực hiện được: model trả lời mà không dùng tool nên Winter đã chặn để tránh báo xạo.';
-              console.log(`\n${colors.yellow}${finalContent}${colors.reset}\n`);
-              reachedToolLimit = false;
-              break;
-            }
-            messages.push({
-              role: 'assistant',
-              content: assistantMsg.content || '',
-            });
-            messages.push({
-              role: 'user',
-              content: this.buildToolEvidenceCorrection(messages),
-            });
-            finalContent = '';
-            continue;
-          }
-          if (turn.finishReason === 'length') {
-            console.log(`\n${colors.yellow}ℹ Phản hồi bị cắt cụt do hết token. Đang tự động tiếp tục...${colors.reset}`);
-            messages.push({
-              role: 'assistant',
-              content: turn.finalContent || '',
-            });
-            messages.push({
-              role: 'user',
-              content: 'Continue generating the rest of the response.',
-            });
-            continue;
-          }
-          reachedToolLimit = false;
-          break;
-        }
-
-        usedTools = true;
-        if (this.spinner) this.spinner.stop();
-
-        const currentToolSignature = this.buildToolCallSignature(toolCalls);
-        if (currentToolSignature) {
-          toolSignatureHistory.push(currentToolSignature);
-          if (toolSignatureHistory.length > 3) {
-            toolSignatureHistory.shift();
-          }
-          // Only break if 3+ consecutive identical signatures — 2 repeats is normal iteration
-          if (toolSignatureHistory.length === 3 &&
-              toolSignatureHistory[0] === currentToolSignature &&
-              toolSignatureHistory[1] === currentToolSignature) {
-            console.log(`
-${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls). Breaking out.${colors.reset}`);
-            reachedToolLimit = false;
-            break;
-          }
-        }
-
-        const BOX_WIDTH = terminalWidth(76, 116, 92);
-        messages.push({
-          role: 'assistant',
-          content: assistantMsg.content || '',
-          tool_calls: this.formatToolCallsForMessage(toolCalls),
-        });
-
-        for (const tc of toolCalls) {
-          const { toolName, toolArgs } = tc;
-          const canonicalToolName = this.tools.normalizeToolName(toolName);
-          const argParseError = toolArgs?.__toolArgParseError;
-          const recoveredArgs = argParseError ? this.recoverToolArgs(canonicalToolName, toolArgs.__rawToolArgs) : null;
-          const canUseRecoveredArgs = recoveredArgs && Object.keys(recoveredArgs).length > 0;
-          const normalizedArgs = argParseError && !canUseRecoveredArgs
-            ? {}
-            : this.tools.normalizeToolInput?.(canonicalToolName, canUseRecoveredArgs ? recoveredArgs : toolArgs) ?? toolArgs;
-          const enrichedArgs = argParseError && !canUseRecoveredArgs ? {} : this.enrichToolArgs(canonicalToolName, normalizedArgs, messages);
-
-          const icon = canonicalToolName === 'Bash' ? '⚙' : canonicalToolName === 'Read' ? '📖' : canonicalToolName === 'Write' ? '✏️' : canonicalToolName === 'Edit' ? '🔧' : canonicalToolName === 'Grep' ? '🔍' : canonicalToolName === 'Glob' ? '📂' : '⚡';
-
-          let proceed = true;
-          if (await this.shouldPromptForToolPermission(canonicalToolName) && (!argParseError || canUseRecoveredArgs)) {
-            const cmd = enrichedArgs.command || enrichedArgs.cmd || 'unknown';
-            if (this.sessionPermissionGrants.has(canonicalToolName)) {
-              proceed = true;
-            } else {
-              proceed = await this.promptToolPermission(cmd);
-              if (proceed === 'session') {
-                await this.rememberSessionToolPermission(canonicalToolName);
-                proceed = true;
-              }
-
-              if (proceed === true) {
-                await this.permissionManager.allowTool(canonicalToolName);
-              }
-
-              if (!proceed) {
-                console.log(`${colors.magenta}│${colors.reset}   ${colors.dim}Đã hủy lệnh.${colors.reset}`);
-              }
-            }
-          }
-
-          let result;
-          if (argParseError && !canUseRecoveredArgs) {
-            result = {
-              success: false,
-              error: `Invalid ${canonicalToolName} tool arguments JSON: ${toolArgs.__toolArgParseError}`,
-              rawArgs: toolArgs.__rawToolArgs,
-              recovery: 'Use valid JSON object arguments, for example {"file_path":"README.md"} for Read or {"command":"npm test"} for Bash.',
-            };
-          } else if (!proceed) {
-            result = { success: false, error: 'User denied permission to execute this command.' };
-          } else {
-            result = toolName
-              ? await this.tools.execute(canonicalToolName, enrichedArgs, { cwd: this.projectPath })
-              : { success: false, error: 'Tool call is missing a tool name' };
-          }
-          messages.push({
-            role: 'tool',
-            tool_call_id: tc.id || `tool-${Date.now()}`,
-            content: JSON.stringify(result),
-          });
-
-          const summary = this.formatToolResultForConsole(canonicalToolName, result);
-          if (summary) {
-            toolSummaries.push(`${canonicalToolName}: ${summary}`);
-            const statusIcon = result.success === false ? `${colors.red}✖${colors.reset}` : `${colors.green}✓${colors.reset}`;
-            const toolLine = `${icon} ${colors.cyan}${colors.bright}${toolName}${colors.reset}`;
-            const summaryLines = summary.split('\n').flatMap(line => wrapText(line, BOX_WIDTH - 8));
-            console.log(renderBox({
-              title: 'AGENT TOOLS EXECUTION',
-              width: BOX_WIDTH,
-              borderColor: colors.magenta,
-              titleColor: colors.bright,
-              body: [
-                toolLine,
-                ...summaryLines.map((line, index) => index === 0 ? `${statusIcon} ${colors.dim}${line}${colors.reset}` : `${colors.dim}${line}${colors.reset}`),
-              ],
-            }));
-          }
-        }
-        console.log('');
-      }
-
-      if (usedTools && !finalContent) {
-        finalContent = await this.requestFinalAnswer(messages, toolSummaries, startedAt, totalUsage);
-      }
-    } finally {
-      if (tools) this.ai.setTools(previousTools);
-      if (this.spinner) this.spinner.stop();
-    }
-
-    if ((reachedToolLimit || usedTools) && !finalContent) {
-      if (this.spinner) this.spinner.stop();
-      finalContent = this.buildToolFallbackAnswer(toolSummaries);
-      console.log(`\n${colors.yellow}${finalContent}${colors.reset}\n`);
-    }
-
-    return { finalContent, usedTools };
+    return this.agentRuntime.runConversation(messages, label, tools);
   }
 
   getLatestUserText(messages = []) {
@@ -1274,19 +1573,29 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
     const text = this.getLatestUserText(messages).toLowerCase();
     if (!text.trim()) return false;
 
-    const actionPattern = /\b(fix|repair|bug|debug|implement|create|write|edit|modify|update|delete|remove|refactor|run|test|build|commit|push|publish|install|check|inspect|read|scan|grep|search|change|apply|patch)\b|(?:sửa|fix|làm|tạo|ghi|đọc|xóa|xoá|chạy|test|build|commit|push|publish|kiểm tra|check|cài|thêm|đổi|sửa lỗi|refactor|review|soát|quét|tìm|áp dụng)/i;
-    const targetPattern = /\b(file|repo|project|code|src|test|build|git|npm|node|folder|directory|cli|tool|provider|model|config|readme|package\.json)\b|[A-Za-z]:[\\/]|\.js\b|\.ts\b|\.tsx\b|\.json\b|\.md\b|(?:dự án|mã|thư mục|tệp|file|cấu hình|lỗi|chức năng|tool|provider|model)/i;
-    const pureQuestionPattern = /^(what|why|how|when|where|is|are|can|could|should|would|tại sao|vì sao|là gì|có nên|có phải)\b/i;
+    const actionPattern = /\b(fix|repair|bug|debug|implement|create|write|edit|modify|update|delete|remove|refactor|run|test|build|commit|push|publish|install|check|inspect|read|scan|grep|search|change|apply|patch|sua|lam|tao|ghi|doc|xoa|chay|kiem tra|cai|them|doi|review|tim|sửa|làm|tạo|đọc|xóa|xoá|chạy|kiểm tra|cài|thêm|đổi|tìm)\b/i;
+    const targetPattern = /\b(file|repo|project|code|src|test|build|git|npm|node|folder|directory|cli|tool|provider|model|config|readme|package\.json|du an|thu muc|tap tin|loi|chuc nang|dự án|thư mục|tập tin|lỗi|chức năng)\b|[A-Za-z]:[\\/]|\.js\b|\.ts\b|\.tsx\b|\.json\b|\.md\b/i;
+    const pureQuestionPattern = /^(what|why|how|when|where|is|are|can|could|should|would|tai sao|vi sao|la gi|co nen|co phai|tại sao|vì sao|là gì|có nên|có phải)\b/i;
 
     if (pureQuestionPattern.test(text) && !actionPattern.test(text)) return false;
     return actionPattern.test(text) && targetPattern.test(text);
   }
 
+  shouldAutoVerifyAfterTools(originalMessage = '', usedMutatingTools = false) {
+    if (!usedMutatingTools) return false;
+    const text = String(originalMessage || '').toLowerCase();
+    if (!text.trim()) return false;
+    if (/\b(skip tests?|no verify|don't verify|khong test|khong verify|bo qua test|không test|không verify|bỏ qua test)\b/i.test(text)) {
+      return false;
+    }
+    return /\b(fix|bug|error|test|build|lint|typecheck|compile|refactor|implement|edit|write|change|patch|debug|sua|loi|kiem tra|bien dich|trien khai|lam|doi|viet|sửa|lỗi|kiểm tra|biên dịch|triển khai|làm|đổi|viết)\b/i.test(text);
+  }
+
   responseNeedsToolEvidence(content = '') {
     const text = String(content || '').toLowerCase();
     if (!text.trim()) return false;
 
-    const clarification = /(?:cần thêm|cho mình|vui lòng|please provide|which file|what file|need more|clarify|không rõ|chưa rõ|file nào|thư mục nào)/i;
+    const clarification = /(?:cần thêm|cho mình|vui lòng|please provide|which file|what file|need more|clarify|không rõ|chưa rõ|file nào|thư mục nào|c?n th?m|cho m?nh|vui l?ng|kh?ng r?|ch?a r?|file n?o|th? m?c n?o)/i;
     if (clarification.test(text)) return false;
     return true;
   }
@@ -1297,6 +1606,10 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
       'Runtime correction: the user requested an action that requires tool evidence.',
       'Your previous response did not use any tool, so it was blocked to avoid falsely claiming completion.',
       'Now use the available tools to inspect/edit/run/check as needed. Do not say the task is done until a tool result proves it.',
+      'If native tool calls are not supported by this model/provider, output exactly one fallback tool call and no prose, for example:',
+      '<invoke name="Read"><parameter name="path">README.md</parameter></invoke>',
+      '{"tool":"Read","arguments":{"path":"README.md"}}',
+      'CALL_TOOL Read {"path":"README.md"}',
       `Original user request: ${request}`,
     ].join('\n');
   }
@@ -1315,8 +1628,12 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
     this.addUsage(totalUsage, response.usage);
     const assistantMsg = response.choices?.[0]?.message || {};
     const inlineToolExtraction = this.extractInlineToolCalls(assistantMsg.content || '');
+    const legacyFunctionCall = assistantMsg.function_call
+      ? [{ id: 'function-call-0', source: 'legacy-function-call', type: 'function', function: assistantMsg.function_call }]
+      : [];
     const toolCalls = this.normalizeToolCalls([
-      ...(assistantMsg.tool_calls || []),
+      ...(assistantMsg.tool_calls || []).map(call => ({ source: 'native-tool-calls', ...call })),
+      ...legacyFunctionCall,
       ...inlineToolExtraction.toolCalls,
     ]);
     if (inlineToolExtraction.toolCalls.length > 0) {
@@ -1354,6 +1671,7 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
         const index = deltaToolCall.index ?? toolCallParts.length;
         toolCallParts[index] = toolCallParts[index] || {
           id: '',
+          source: 'stream-native-tool-calls',
           type: 'function',
           function: { name: '', arguments: '' },
         };
@@ -1366,6 +1684,29 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
           toolCallParts[index].function.arguments += deltaToolCall.function.arguments;
         }
       }
+      if (choice.delta?.function_call || choice.message?.function_call) {
+        const functionCall = choice.delta?.function_call || choice.message?.function_call;
+        toolCallParts[0] = toolCallParts[0] || {
+          id: 'function-call-0',
+          source: 'stream-legacy-function-call',
+          type: 'function',
+          function: { name: '', arguments: '' },
+        };
+        if (functionCall.name) toolCallParts[0].function.name += functionCall.name;
+        if (functionCall.arguments) toolCallParts[0].function.arguments += functionCall.arguments;
+      }
+      for (const messageToolCall of choice.message?.tool_calls || []) {
+        const index = messageToolCall.index ?? toolCallParts.length;
+        toolCallParts[index] = {
+          id: messageToolCall.id || `message-call-${index}`,
+          source: 'message-tool-calls',
+          type: messageToolCall.type || 'function',
+          function: {
+            name: messageToolCall.function?.name || '',
+            arguments: messageToolCall.function?.arguments || '',
+          },
+        };
+      }
 
       if (chunk.content) {
         if (!printed) {
@@ -1448,6 +1789,10 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
     readline.emitKeypressEvents(process.stdin, this.rl);
 
     process.stdin.on('keypress', (str, key = {}) => {
+      if (key.ctrl && key.name === 'v') {
+        void this.handleDirectClipboardPaste();
+        return;
+      }
       if (key.ctrl || key.meta) return;
 
       if (typeof str === 'string' && str.length > 1) {
@@ -1477,6 +1822,51 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
     });
   }
 
+  async handleDirectClipboardPaste() {
+    if (this._handlingDirectClipboardPaste || this.readlineClosed || !this.running) return false;
+    this._handlingDirectClipboardPaste = true;
+    try {
+      const image = await this.getClipboardImage();
+      if (!image) return false;
+
+      const prompt = (this.rl?.line || '').trim() || 'Analyze this pasted clipboard image.';
+      this.closeSlashMenu();
+      if (this.rl?.write) {
+        this.rl.write(null, { ctrl: true, name: 'u' });
+      }
+
+      this.inputQueue = this.inputQueue
+        .then(async () => {
+          this.closeInputBox();
+          await this.processPastedImageTask(prompt, image);
+        })
+        .catch((error) => {
+          this.closeInputBox();
+          console.log(`\n${colors.red}✖ Paste image error: ${error.message}${colors.reset}\n`);
+          if (this.running && !this.readlineClosed) this.showInputPrompt();
+        });
+      return true;
+    } finally {
+      this._handlingDirectClipboardPaste = false;
+    }
+  }
+
+  async processPastedImageTask(prompt, image) {
+    this.isProcessing = true;
+    this.isCancelled = false;
+    try {
+      await this.chat(prompt, [image]);
+    } finally {
+      this.isProcessing = false;
+      if (this.taskQueue.length > 0) {
+        const nextTask = this.taskQueue.shift();
+        setTimeout(() => this.processInputTask(nextTask), 0);
+      } else if (!this.readlineClosed) {
+        this.showInputPrompt();
+      }
+    }
+  }
+
   openSlashMenu(line) {
     const matches = this.getSlashSuggestions(line);
     if (matches.length === 0) {
@@ -1572,7 +1962,7 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
     readline.clearLine(process.stdout, 1);
     process.stdout.write(`${colors.dim}↑/↓ chọn · Enter/Tab dùng · Esc đóng${colors.reset}\n`);
 
-    // Xóa các dòng thừa nếu số lượng dòng mới ít hơn số lượng dòng cũ
+    // Xóa các dòng thừa nếu số lượng dòng mới ít hơn số lượng dòng cũ.
     const currentLines = Math.min(matches.length, maxDisplay) + 3 + (matches.length > maxDisplay ? 1 : 0);
     if (this.slashMenu.printedLines > currentLines) {
       for (let i = 0; i < this.slashMenu.printedLines - currentLines; i++) {
@@ -1589,20 +1979,44 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
   getSlashSuggestions(line) {
     const query = String(line || '').trim();
     if (!query.startsWith('/')) return [];
+    const enrich = item => this.enrichSlashSuggestion(item);
     if (query === '/') {
       const preferred = [
-        '/help', '/exit', '/pwd', '/cd',
+        '/help', '/new', '/history', '/exit', '/pwd', '/cd',
           '/provider', '/model', '/models', '/providers',
-          '/auto', '/debug', '/swe',
+          '/theme:toggle',
+          '/auto', '/debug', '/doctor', '/context', '/scorecard', '/swe',
           '/read', '/write', '/glob', '/grep', '/bash',
         '/codex', '/claude', '/karpathy', '/agents',
         '/resources', '/designs', '/skills',
+        '/ecc',
+        '/composer', '/complete', '/ensemble', '/vote', '/orchestrate', '/search', '/undo',
       ];
       return preferred
         .map(cmd => SLASH_COMMANDS.find(item => item.cmd === cmd))
-        .filter(Boolean);
+        .filter(Boolean)
+        .map(enrich);
     }
-    return SLASH_COMMANDS.filter(item => item.cmd.startsWith(query)).slice(0, 12);
+    return SLASH_COMMANDS
+      .filter(item => item.cmd.startsWith(query))
+      .slice(0, 12)
+      .map(enrich);
+  }
+
+  enrichSlashSuggestion(item) {
+    if (!item) return item;
+    if (item.cmd !== '/provider') return item;
+
+    const providerNames = typeof this.ai?.listProviders === 'function'
+      ? this.ai.listProviders().map(provider => provider.name).filter(Boolean)
+      : Object.keys(this.ai?.providers || {});
+    const uniqueProviders = [...new Set(providerNames)];
+    if (uniqueProviders.length === 0) return item;
+
+    return {
+      ...item,
+      usage: `/provider <${uniqueProviders.join('|')}>`,
+    };
   }
 
   enrichToolArgs(toolName, toolArgs = {}, messages = []) {
@@ -1750,8 +2164,17 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
 
   printAssistantAnswer(content, startedAt, usage = {}) {
     const formatted = formatMarkdown(content);
-    console.log(`\n${colors.white}${formatted}${colors.reset}`);
-    console.log(`${colors.dim}${'─'.repeat(50)}${colors.reset}`);
+    const footer = this.formatAnswerFooter(startedAt, usage);
+    const body = String(formatted || '').split(/\r?\n/);
+    console.log(`\n${renderBox({
+      title: 'Assistant',
+      width: terminalWidth(72, 120, 92),
+      borderColor: colors.blue,
+      titleColor: colors.cyan,
+      body: [...body, '', `${colors.dim}${footer}${colors.reset}`],
+    })}\n`);
+    return;
+    console.log(`${colors.dim}${(this.useUnicodeUi ? '─' : '-').repeat(50)}${colors.reset}`);
     console.log(`${colors.dim}${this.formatAnswerFooter(startedAt, usage)}${colors.reset}\n`);
   }
 
@@ -1800,14 +2223,16 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
   }
 
   async promptToolPermission(commandText) {
-    process.stdout.write(`${colors.magenta}│${colors.reset}   ${colors.yellow}⚠  AI muốn chạy: ${colors.bright}${commandText}${colors.reset}\n`);
-    process.stdout.write(`${colors.magenta}│${colors.reset}   ${colors.cyan}1.${colors.reset} Cho phép\n`);
-    process.stdout.write(`${colors.magenta}│${colors.reset}   ${colors.cyan}2.${colors.reset} Cho phép trong phiên\n`);
-    process.stdout.write(`${colors.magenta}│${colors.reset}   ${colors.cyan}3.${colors.reset} Không cho phép\n`);
+    const side = this.useUnicodeUi ? '│' : '|';
+    const warn = this.useUnicodeUi ? '!' : '!';
+    process.stdout.write(`${colors.magenta}${side}${colors.reset}   ${colors.yellow}${warn}  AI muốn chạy: ${colors.bright}${commandText}${colors.reset}\n`);
+    process.stdout.write(`${colors.magenta}${side}${colors.reset}   ${colors.cyan}1.${colors.reset} Cho phép\n`);
+    process.stdout.write(`${colors.magenta}${side}${colors.reset}   ${colors.cyan}2.${colors.reset} Cho phép trong phiên\n`);
+    process.stdout.write(`${colors.magenta}${side}${colors.reset}   ${colors.cyan}3.${colors.reset} Không cho phép\n`);
 
     while (true) {
       const answer = await new Promise(resolve => {
-        this.rl.question(`${colors.magenta}│${colors.reset}   ${colors.yellow}Chọn [1/2/3]: ${colors.reset}`, resolve);
+        this.rl.question(`${colors.magenta}${side}${colors.reset}   ${colors.yellow}Chọn [1/2/3]: ${colors.reset}`, resolve);
       });
 
       const choice = String(answer || '').trim().toLowerCase();
@@ -1821,7 +2246,7 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
         return false;
       }
 
-      process.stdout.write(`${colors.magenta}│${colors.reset}   ${colors.dim}Vui lòng chọn 1, 2 hoặc 3.${colors.reset}\n`);
+      process.stdout.write(`${colors.magenta}${side}${colors.reset}   ${colors.dim}Vui lòng chọn 1, 2 hoặc 3.${colors.reset}\n`);
     }
   }
 
@@ -1888,6 +2313,16 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
     for (const item of summary) {
       console.log(`  ${item.tool}: ${item.calls} call(s), ${item.failures} failure(s), avg ${item.avgMs}ms`);
     }
+    const context = this.session?.getContext?.() || {};
+    const adapterStats = context.toolCallAdapterStats?.value || context.toolCallAdapterStats;
+    if (adapterStats?.total) {
+      console.log(`${colors.cyan}Tool Call Adapter:${colors.reset}`);
+      console.log(`  total parsed: ${adapterStats.total}`);
+      const sources = Object.entries(adapterStats.bySource || {}).sort((a, b) => b[1] - a[1]);
+      if (sources.length > 0) {
+        console.log(`  sources: ${sources.map(([name, count]) => `${name}=${count}`).join(', ')}`);
+      }
+    }
   }
 
   showReplay(limit = 20) {
@@ -1983,17 +2418,27 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
 
   async chat(message, imageAttachments = []) {
     try {
+      await this.autoApplyWorkflowForTask(message);
       const needsTools = true;
       const context = await this.getProjectContext(message);
+      const systemPrompt = this.getSystemPrompt(context);
+
+      // Inject @-context if any
+      const atContextStr = this._pendingAtContext || '';
+      this._pendingAtContext = '';
+      const finalSystemPrompt = atContextStr
+        ? systemPrompt + '\n\n' + atContextStr
+        : systemPrompt;
+
       const messages = [
-        { role: 'system', content: this.getSystemPrompt(context) }
+        { role: 'system', content: finalSystemPrompt }
       ];
 
       await this.compressSessionContext(false);
       const promptHistory = this.getCompressedPromptHistory({
         limit: 20,
         keepRecent: 14,
-        maxTotalChars: this.shouldUseCompactPrompt() ? 5000 : 12000,
+        maxTotalChars: 16000,
       });
       if (promptHistory.summary) {
         messages.push({ role: 'system', content: `Compressed prior conversation:\n${promptHistory.summary}` });
@@ -2018,14 +2463,19 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
       }
 
       const tools = this.getAgentTools('general');
-      const { finalContent, usedTools } = await this.runConversation(messages, 'Thinking', tools);
+      const { finalContent, usedMutatingTools } = await this.runConversation(messages, 'Thinking', tools);
 
       await this.session.addToHistory({ role: 'user', content: message });
       await this.session.addToHistory({ role: 'assistant', content: finalContent });
 
-      // Tự động verify: nếu AI đã dùng tools (sửa code), chạy test/build
-      if (usedTools && finalContent) {
-        await this.verifyAndHeal(messages, tools, 5);
+      // Tự động verify: nếu AI đã dùng tools (sửa code), chạy test/build.
+      if (finalContent && this.shouldAutoVerifyAfterTools(message, usedMutatingTools)) {
+        const sessionContext = this.session?.getContext?.() || {};
+        const profile = String(sessionContext.workflowProfile || 'general');
+        const amplifier = sessionContext.smallModelAmplifier || {};
+        const baseAttempts = /debug|backend|data|devops|ai/.test(profile) ? 4 : 3;
+        const boostedAttempts = amplifier?.weak ? Math.max(baseAttempts, 5) : baseAttempts;
+        await this.verifyAndHeal(messages, tools, boostedAttempts);
       }
 
     } catch (error) {
@@ -2033,10 +2483,91 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
     }
   }
 
+  async autoApplyWorkflowForTask(taskText = '') {
+    const text = String(taskText || '').trim();
+    if (!text) return;
+
+    const sessionContext = this.session?.getContext?.() || {};
+    const cached = sessionContext.workflowLastTask || '';
+    if (cached && cached === text) return;
+
+    const [signals, catalog] = await Promise.all([
+      this.getProjectSignals?.() || [],
+      this.getStartupSkillCatalog?.() || new Set(),
+    ]);
+    const workflow = selectWorkflow({
+      taskText: text,
+      projectSignals: signals,
+      skillCatalog: Array.isArray(catalog) ? catalog : [...catalog],
+    });
+
+    const existingSkills = Array.isArray(sessionContext.activeSkills?.value)
+      ? sessionContext.activeSkills.value
+      : (Array.isArray(sessionContext.activeSkills) ? sessionContext.activeSkills : []);
+    const mergedSkills = [...new Set([...(existingSkills || []), ...(workflow.recommendedSkills || [])])];
+
+    const hints = [
+      `Task category/type: ${workflow.taskInfo?.category || 'unknown'} / ${workflow.taskInfo?.type || 'unknown'}`,
+      `Workflow profile: ${workflow.profile} (depth=${workflow.depth})`,
+      workflow.technologySuggestions?.length ? `Technology suggestions: ${workflow.technologySuggestions.join(' | ')}` : '',
+      workflow.verificationStrategy?.length ? `Verification strategy: ${workflow.verificationStrategy.join(', ')}` : '',
+      workflow.recommendedSkills?.length ? `Recommended skills: ${workflow.recommendedSkills.join(', ')}` : '',
+      workflow.recommendedResources?.length ? `Recommended resources: ${workflow.recommendedResources.join(', ')}` : '',
+      workflow.recommendedPlugins?.length ? `Recommended plugins: ${workflow.recommendedPlugins.join(', ')}` : '',
+      workflow.recommendedRules?.length ? `Recommended rules: ${workflow.recommendedRules.join('; ')}` : '',
+      'Execution: plan first (success criteria), then act with tools, then verify (test/build/lint). For UI/webapp: consult awesome-design-md before writing UI.',
+    ].filter(Boolean).join('\n');
+
+    const amplifier = buildSmallModelAmplification({
+      modelTier: this.ai?._modelTier || 'medium',
+      workflowProfile: workflow.profile,
+      depth: workflow.depth,
+    });
+    const blueprint = getProfileBlueprint(workflow.profile);
+    const finalHints = [
+      hints,
+      blueprint?.asText || '',
+      amplifier.hint || '',
+    ].filter(Boolean).join('\n\n');
+
+    await this.session.updateContext('workflowLastTask', text);
+    await this.session.updateContext('workflowProfile', workflow.profile);
+    await this.session.updateContext('workflowDetectedTechnologies', workflow.detectedTechnologies || {});
+    await this.session.updateContext('workflowVerificationStrategy', workflow.verificationStrategy || []);
+    await this.session.updateContext('workflowBlueprint', blueprint?.asText || '');
+    await this.session.updateContext('workflowHints', finalHints);
+    await this.session.updateContext('smallModelAmplifier', amplifier);
+    await this.session.updateContext('activeSkills', mergedSkills);
+  }
+
   /**
-   * Chạy verification commands (test, build) và trả về kết quả
+   * Chạy verification commands (test, build) và trả về kết quả.
    */
-  async runVerification(commands = ['npm test']) {
+  async inferVerificationCommands(task = '') {
+    const fs = await import('fs/promises');
+    const candidates = [];
+    const packagePath = path.join(this.projectPath, 'package.json');
+    try {
+      const pkg = JSON.parse(await fs.readFile(packagePath, 'utf8'));
+      const scripts = pkg.scripts || {};
+      if (scripts.test) candidates.push('npm test');
+      if (scripts.build && /\b(build|compile|type|typescript|tsc|frontend|ui|design|next|vite|react|debug|fix|bug|error|loi|lỗi)\b/i.test(task)) {
+        candidates.push('npm run build');
+      }
+      if (scripts.lint && /\b(lint|style|eslint|quality|review)\b/i.test(task)) candidates.push('npm run lint');
+      if (scripts.typecheck) candidates.push('npm run typecheck');
+    } catch {
+      // Not a Node project.
+    }
+
+    if (candidates.length === 0) return ['npm test'];
+    return [...new Set(candidates)].slice(0, 3);
+  }
+
+  async runVerification(commands = null) {
+    commands = Array.isArray(commands) && commands.length > 0
+      ? commands
+      : await this.inferVerificationCommands();
     const { execSync } = await import('child_process');
     const results = [];
 
@@ -2064,11 +2595,11 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
   /**
    * Vòng lặp tự động verify + sửa lỗi:
    * - Chạy test/build
-   * - Nếu fail, gửi lỗi cho AI fix
+   * - Nếu fail, gửi lại cho AI fix
    * - Lặp đến khi pass hết hoặc hết số lần thử
    */
   async verifyAndHeal(messages, tools, maxAttempts = 5) {
-    const verifCommands = ['npm test'];
+    const verifCommands = await this.inferVerificationCommands(this.getLatestUserText(messages));
 
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
       console.log(`\n${colors.cyan}=== Verification Attempt ${attempt}/${maxAttempts} ===${colors.reset}`);
@@ -2076,7 +2607,7 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
       const result = await this.runVerification(verifCommands);
 
       if (result.passed) {
-        console.log(`\n${colors.green}✅ All verifications passed!${colors.reset}\n`);
+        console.log(`\n${colors.green}✓ All verifications passed!${colors.reset}\n`);
         return;
       }
 
@@ -2086,7 +2617,7 @@ ${colors.yellow}ℹ AI tool loop detected (3 consecutive identical tool calls).
         .map(r => `Command: ${r.cmd}\n${r.output}`)
         .join('\n\n---\n\n');
 
-      console.log(`\n${colors.yellow}⚠ Verification failed. Sending errors back to AI for fix...${colors.reset}\n`);
+      console.log(`\n${colors.yellow}Verification failed. Sending errors back to AI for fix...${colors.reset}\n`);
 
       // Push error output as user message for AI to fix
       const fixPrompt = `VERIFICATION FAILED (attempt ${attempt}/${maxAttempts}):
@@ -2104,12 +2635,12 @@ Do NOT stop until all errors are resolved.`;
       const { usedTools: fixUsedTools } = await this.runConversation(messages, 'Fixing', tools);
 
       if (!fixUsedTools) {
-        console.log(`\n${colors.red}⚠ AI did not attempt to fix the errors. Stopping.${colors.reset}\n`);
+        console.log(`\n${colors.red}AI did not attempt to fix the errors. Stopping.${colors.reset}\n`);
         break;
       }
     }
 
-    console.log(`\n${colors.red}⚠ Max verification attempts (${maxAttempts}) reached. Some issues may remain.${colors.reset}\n`);
+    console.log(`\n${colors.red}Max verification attempts (${maxAttempts}) reached. Some issues may remain.${colors.reset}\n`);
   }
 
   shouldUseTools(message = '', imageAttachments = []) {
@@ -2138,15 +2669,16 @@ Do NOT stop until all errors are resolved.`;
   }
 
   async runAgent(role, task) {
+    const agentDefinition = await this.agentRegistry.get(role || 'general');
     const context = await this.getProjectContext(task);
     const messages = [
-      { role: 'system', content: this.getAgentSystemPrompt(role, context) }
+      { role: 'system', content: this.getAgentDefinitionSystemPrompt(agentDefinition, context) }
     ];
 
     const promptHistory = this.getCompressedPromptHistory({
-      limit: this.shouldUseCompactPrompt() ? 14 : 30,
-      keepRecent: this.shouldUseCompactPrompt() ? 8 : 14,
-      maxTotalChars: this.shouldUseCompactPrompt() ? 5000 : 12000,
+      limit: 40,
+      keepRecent: 16,
+      maxTotalChars: 16000,
     });
     if (promptHistory.summary) {
       messages.push({ role: 'system', content: `Compressed prior conversation:\n${promptHistory.summary}` });
@@ -2157,15 +2689,172 @@ Do NOT stop until all errors are resolved.`;
 
     messages.push({ role: 'user', content: `Task: ${task}` });
 
-    const agentTools = this.getAgentTools(role);
-    const { finalContent, usedTools } = await this.runConversation(messages, `Subagent [${role}]`, agentTools);
+    const agentTools = this.getAgentToolsForDefinition(agentDefinition);
+    const { finalContent, usedMutatingTools } = await this.runConversation(messages, `Subagent [${agentDefinition.id}]`, agentTools);
 
-    await this.session.addToHistory({ role: 'user', content: `[subagent:${role}] ${task}` });
+    await this.session.addToHistory({ role: 'user', content: `[subagent:${agentDefinition.id}] ${task}` });
     await this.session.addToHistory({ role: 'assistant', content: finalContent });
 
-    if (usedTools && finalContent) {
-      await this.verifyAndHeal(messages, agentTools, 3);
+    if (finalContent && this.shouldAutoVerifyAfterTools(task, usedMutatingTools)) {
+      await this.verifyAndHeal(messages, agentTools, 2);
+    }
+  }
+
+  async listAgentDefinitions() {
+    return this.agentRegistry.list();
+  }
+
+  getAgentToolsForDefinition(agentDefinition = {}) {
+    const base = this.tools.getToolDefinitions();
+    const allowed = Array.isArray(agentDefinition.tools) ? agentDefinition.tools : [];
+    if (allowed.length === 0) return this.getAgentTools(agentDefinition.id || 'general');
+    return base.filter(tool => allowed.includes(tool.name));
+  }
+
+  getAgentDefinitionSystemPrompt(agentDefinition = {}, context = '') {
+    const fallback = this.getAgentSystemPrompt(agentDefinition.id || 'general', context);
+    const instructions = String(agentDefinition.instructionsPrompt || '').trim();
+    const custom = instructions
+      ? [
+          `You are ${agentDefinition.displayName || agentDefinition.id}, a Winter custom agent.`,
+          instructions,
+          '',
+          'AGENT CONTRACT:',
+          '- Inspect real project state before editing.',
+          '- Use only the provided tools and cite tool evidence in the final answer.',
+          '- Patch the smallest root cause and verify when the task changes code.',
+          '- Do not claim success without tool evidence.',
+        ].join('\n')
+      : fallback;
+
+    const metadata = [
+      `Agent id: ${agentDefinition.id || 'general'}`,
+      `Agent source: ${agentDefinition.source || 'builtin'}`,
+      Array.isArray(agentDefinition.tools) && agentDefinition.tools.length
+        ? `Allowed tools: ${agentDefinition.tools.join(', ')}`
+        : '',
+    ].filter(Boolean).join('\n');
+
+    return [custom, metadata ? `\nAGENT METADATA:\n${metadata}` : '', context ? `\nPROJECT CONTEXT:\n${context}` : ''].join('\n');
+  }
+
+  async runToolDoctor() {
+    const provider = this.ai?.getActiveProvider?.() || 'unknown';
+    const model = this.ai?.providers?.[provider]?.model || 'unknown';
+    const tools = this.getAgentTools('plan').filter(tool => tool.name === 'Read');
+    const probePath = 'README.md';
+    const messages = [
+      {
+        role: 'system',
+        content: [
+          'You are Winter tool-call doctor.',
+          'You must diagnose whether this provider/model can trigger a real tool execution.',
+          'Call the Read tool for README.md now. Do not answer in prose before the tool call.',
+          'If native tool calls are unavailable, output exactly one fallback call:',
+          '<invoke name="Read"><parameter name="path">README.md</parameter></invoke>',
+          '{"tool":"Read","arguments":{"path":"README.md"}}',
+          'CALL_TOOL Read {"path":"README.md"}',
+        ].join('\n'),
+      },
+      {
+        role: 'user',
+        content: `TOOL DOCTOR: call Read on ${probePath}.`,
+      },
+    ];
+
+    console.log(`${colors.cyan}Tool doctor:${colors.reset} provider=${provider}, model=${model}`);
+    const beforeEvents = this.session?.getToolEvents?.(1)?.length || 0;
+    const result = await this.runConversation(messages, 'Tool doctor', tools);
+    const recentEvents = this.session?.getToolEvents?.(5) || [];
+    const readEvent = recentEvents.find(event => event.tool === 'Read' && event.success !== false);
+    const passed = result.usedTools && Boolean(readEvent || /readme\.md/i.test(result.finalContent || ''));
+
+    if (passed) {
+      console.log(`${colors.green}✓ Tool calling works for ${provider}/${model}.${colors.reset}`);
+      if (readEvent) {
+        console.log(`${colors.dim}  Last Read result: ${readEvent.result?.path || probePath}${colors.reset}`);
+      }
+      return { success: true, provider, model, usedTools: result.usedTools, beforeEvents };
+    }
+
+    console.log(`${colors.red}✖ Tool calling did not execute for ${provider}/${model}.${colors.reset}`);
+    console.log(`${colors.yellow}  Try a stronger model or use a provider that supports OpenAI-compatible tools/fallback text output.${colors.reset}`);
+    return { success: false, provider, model, usedTools: result.usedTools, beforeEvents };
+  }
+
+  async getCapabilityScorecard() {
+    return assessWinterCapabilities(this);
+  }
+
+  async showCapabilityScorecard() {
+    const report = await this.getCapabilityScorecard();
+    console.log(formatCapabilityScorecard(report, { colors }));
+    return report;
+  }
+
+  async showContextDiagnostics(task = '') {
+    const provider = this.ai?.getActiveProvider?.() || 'unknown';
+    const model = this.ai?.providers?.[provider]?.model || 'unknown';
+    const context = await this.getProjectContext(task);
+    let codebaseStats = null;
+    try {
+      codebaseStats = await this.ensureCodebaseIndex({ verbose: false });
+    } catch {
+      codebaseStats = null;
+    }
+
+    const sectionNames = Array.from(context.matchAll(/^\[([^\]]+)\]/gm)).map(match => match[1]);
+    const lines = [
+      `${colors.cyan}${colors.bright}Winter context diagnostics${colors.reset}`,
+      `Project: ${this.projectPath}`,
+      `Provider/model: ${provider}/${model}`,
+      `Context chars: ${context.length}`,
+      `Sections: ${sectionNames.length ? sectionNames.join(', ') : 'none'}`,
+    ];
+
+    if (codebaseStats) {
+      lines.push(`Codebase index: ${codebaseStats.totalFiles || 0} files, ${codebaseStats.totalChunks || 0} chunks`);
+    } else {
+      lines.push('Codebase index: unavailable');
     }
+
+    lines.push('');
+    lines.push(colors.dim + this.compactText(context, 3200, 'context diagnostics') + colors.reset);
+    console.log(lines.join('\n'));
+    return { provider, model, contextLength: context.length, sections: sectionNames, codebaseStats };
+  }
+
+  async runFullDoctor() {
+    const report = await this.showCapabilityScorecard();
+    console.log('');
+    await this.showContextDiagnostics('doctor full codebase provider tool debug workflow');
+    console.log('');
+    const toolResult = await this.runToolDoctor();
+    return {
+      success: report.overall >= report.target && toolResult.success,
+      scorecard: report,
+      toolResult,
+    };
+  }
+
+  async runToolDoctor() {
+    return runToolDoctorDiagnostics(this);
+  }
+
+  async getCapabilityScorecard() {
+    return getCapabilityScorecardReport(this);
+  }
+
+  async showCapabilityScorecard() {
+    return showCapabilityScorecardDiagnostics(this);
+  }
+
+  async showContextDiagnostics(task = '') {
+    return showContextDiagnosticsReport(this, task);
+  }
+
+  async runFullDoctor() {
+    return runFullDoctorDiagnostics(this);
   }
 
   async getProjectContext(task = '') {
@@ -2175,11 +2864,17 @@ Do NOT stop until all errors are resolved.`;
       context.push(requiredLocalResources);
     }
 
+    const shouldIncludeResources = /\b(resource|resources|skill|skills|plugin|plugins|claude|codex|agent|agents|design|ui|figma|brand|mcp)\b/i.test(String(task || ''));
+    const localResources = shouldIncludeResources ? await this.getLocalResourceContext() : '';
+    if (localResources) {
+      context.push(localResources);
+    }
+
     const projectInstructionFiles = await this.readProjectInstructionFiles();
 
     for (const file of projectInstructionFiles) {
       try {
-        const preview = this.compactText(file.content, this.shouldUseCompactPrompt() ? 450 : 900, 'project instruction');
+        const preview = this.compactText(file.content, 1200, 'project instruction');
         context.push(`[${file.relativePath}]\n${preview}`);
       } catch { }
     }
@@ -2189,14 +2884,22 @@ Do NOT stop until all errors are resolved.`;
       const stat = await fs.stat(packageJsonPath);
       if (stat.isFile()) {
         const content = await fs.readFile(packageJsonPath, 'utf-8');
-        context.push(`[package.json]\n${this.compactText(content, this.shouldUseCompactPrompt() ? 650 : 1200, 'package.json')}`);
+        context.push(`[package.json]\n${this.compactText(content, 1600, 'package.json')}`);
       }
     } catch { }
 
-    const shouldIncludeResources = /\b(resource|resources|skill|skills|plugin|plugins|claude|codex|agent|agents|design|ui|figma|brand|mcp)\b/i.test(String(task || ''));
-    const localResources = shouldIncludeResources ? await this.getLocalResourceContext() : '';
-    if (localResources) {
-      context.push(localResources);
+    const codebaseContext = await this.buildCodebaseContext(task);
+    if (codebaseContext) {
+      context.push(codebaseContext);
+    }
+
+    const graphContext = await this.codebaseSearcher?.buildGraphContext?.(task, {
+      maxNodes: 24,
+      maxCodeBlocks: 8,
+      maxCodeBlockSize: 1800,
+    });
+    if (graphContext) {
+      context.push(`[CodeGraph Context]\n${this.compactText(graphContext, 5200, 'codegraph context')}`);
     }
 
     // Git Context
@@ -2208,20 +2911,20 @@ Do NOT stop until all errors are resolved.`;
 
         const gitSummary = execSync('git diff --stat --summary', { cwd: this.projectPath, encoding: 'utf8', stdio: 'pipe', maxBuffer: 1024 * 50 }).trim();
         if (gitSummary) {
-          context.push(`[Git Summary]\n${this.compactText(gitSummary, this.shouldUseCompactPrompt() ? 650 : 1200, 'git summary')}`);
+          context.push(`[Git Summary]\n${this.compactText(gitSummary, 1200, 'git summary')}`);
         }
 
         // Get brief git diff for context
         const gitDiff = execSync('git diff', { cwd: this.projectPath, encoding: 'utf8', stdio: 'pipe', maxBuffer: 1024 * 50 }).trim().split('\n').slice(0, 30).join('\n');
         if (gitDiff) {
-          context.push(`[Git Diff]\n${this.compactText(gitDiff, this.shouldUseCompactPrompt() ? 900 : 1800, 'git diff')}`);
+          context.push(`[Git Diff]\n${this.compactText(gitDiff, 2200, 'git diff')}`);
         }
       }
     } catch (e) {
       // Not a git repo or git not installed
     }
 
-    return this.compactText(context.join('\n\n') || 'No project context found.', this.shouldUseCompactPrompt() ? 4200 : 9000, 'project context');
+    return this.compactText(context.join('\n\n') || 'No project context found.', 14000, 'project context');
   }
 
   async getLocalResourceContext() {
@@ -2323,7 +3026,7 @@ Do NOT stop until all errors are resolved.`;
     this.promptBuilder.tools = this.tools;
     this.promptBuilder.sessionPermissionGrants = this.sessionPermissionGrants;
     return this.promptBuilder.buildSystemPrompt(context, {
-      projectContextBudget: this.shouldUseCompactPrompt() ? 2200 : 3200,
+      projectContextBudget: 5200,
     });
   }
 
@@ -2370,7 +3073,7 @@ Do NOT stop until all errors are resolved.`;
         }
         config.mcp.servers.forEach(server => {
           const enabled = server.enabled === false ? `${colors.red}disabled${colors.reset}` : `${colors.green}enabled${colors.reset}`;
-          console.log(`  • ${server.name} (${enabled}) -> ${server.command}${server.args?.length ? ` ${server.args.join(' ')}` : ''}`);
+          console.log(`  - ${server.name} (${enabled}) -> ${server.command}${server.args?.length ? ` ${server.args.join(' ')}` : ''}`);
         });
         break;
       case 'add': {
@@ -2484,4 +3187,41 @@ Do NOT stop until all errors are resolved.`;
       return null;
     }
   }
+
+  async getClipboardImage() {
+    if (process.platform !== 'win32') return null;
+    try {
+      const { execSync } = await import('child_process');
+      const script = [
+        'Add-Type -AssemblyName System.Windows.Forms',
+        'Add-Type -AssemblyName System.Drawing',
+        '$img = [System.Windows.Forms.Clipboard]::GetImage()',
+        'if ($null -ne $img) {',
+        '  $ms = New-Object System.IO.MemoryStream',
+        '  $img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)',
+        '  [Convert]::ToBase64String($ms.ToArray())',
+        '}',
+      ].join('; ');
+      const base64 = execSync('powershell.exe -NoProfile -NonInteractive -Command -', {
+        input: script,
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'ignore'],
+        timeout: 10000,
+      }).trim();
+      return base64 ? { mime: 'image/png', base64 } : null;
+    } catch {
+      return null;
+    }
+  }
+
+  async getClipboardPayload() {
+    const image = await this.getClipboardImage();
+    if (image) return { type: 'image', image };
+
+    const text = await this.getClipboardContent();
+    if (!text) return null;
+    const dataImage = this.parseDataUrlImage(text);
+    if (dataImage) return { type: 'image', image: dataImage };
+    return { type: 'text', text };
+  }
 }