winter-super-cli 2026.6.6 → 2026.6.8

package/src/cli/repl.js

@@ -6,8 +6,17 @@
 import readline from 'readline';
 import { promises as fs, watch as fsWatch } from 'fs';
 import { homedir } from 'os';
-import { welcomeBanner, colors, applyColorTheme } from './snowflake-logo.js';
+import { colors, applyColorTheme, welcomeBanner } from './snowflake-logo.js';
 import { renderBox, supportsUnicodeUi, terminalWidth, stripAnsi, wrapText, padVisible } from './terminal-ui.js';
+import {
+  buildTuiSnapshot,
+  renderAssistantPanel,
+  renderConversationStartup,
+  renderLandingTui,
+  renderStartupTui,
+  renderStatusPanel,
+} from './tui.js';
+import { terminalManager } from './terminal-manager.js';
 import { WinterInputController } from './input-controller.js';
 import { ToolExecutor } from '../tools/executor.js';
 import { SessionManager } from '../session/manager.js';
@@ -30,7 +39,7 @@ import {
   buildPromptToolResultWithTokenJuice,
 } from './tool-runtime.js';
 import { TokenJuice } from '../context/token-juice.js';
-import { classifyModelTier } from '../ai/model-capabilities.js';
+import { classifyModelTier, getModelBudgetMultiplier } from '../ai/model-capabilities.js';
 import {
   addUsage as mergeUsage,
   buildToolCallSignature as buildToolCallSignatureText,
@@ -88,6 +97,7 @@ export class WinterREPL {
     this.taskQueue = [];
     this.isProcessing = false;
     this.isCancelled = false;
+    this.currentAbortController = null;
     this.sessionPermissionGrants = new Set();
     this.permissionManager = new PermissionManager(this.config, this.session);
     this.contextLoader = new ContextLoader({ projectPath: this.projectPath, session: this.session, tools: this.tools });
@@ -114,6 +124,10 @@ export class WinterREPL {
     this.useUnicodeUi = supportsUnicodeUi();
     this.inputController = new WinterInputController(this);
     this.watchers = [];
+    this.startupNotices = [];
+    this._fixedPanel = Boolean(process.stdout.isTTY) && process.env.WINTER_FIXED_PANEL_TUI !== '0';
+    
+    terminalManager.install();
   }
 
   async initCodebaseSearch() {
@@ -147,6 +161,15 @@ export class WinterREPL {
     });
   }
 
+  startupNotice(message) {
+    const text = String(message || '').trim();
+    if (!text) return;
+    this.startupNotices.push(text);
+    if (this.startupNotices.length > 6) {
+      this.startupNotices = this.startupNotices.slice(-6);
+    }
+  }
+
   async startCodebaseWatcher() {
     if (this.codebaseWatcher) return;
     await this.initCodebaseSearch();
@@ -240,6 +263,7 @@ export class WinterREPL {
 
   async buildCodebaseContext(task = '') {
     try {
+      const modelTier = this.getActiveModelTier();
       const stats = await this.ensureCodebaseIndex({ verbose: false });
       if (!stats.totalChunks) return '';
 
@@ -278,7 +302,7 @@ export class WinterREPL {
         }
       }
 
-      return this.compactText(lines.join('\n'), 4200, 'codebase context');
+      return this.compactText(lines.join('\n'), this.getCodebaseContextBudget(modelTier), 'codebase context');
     } catch (error) {
       return `[Codebase Index]\nUnavailable: ${error.message}`;
     }
@@ -326,18 +350,22 @@ export class WinterREPL {
       toolName,
       result,
       compact: this.shouldUseCompactPrompt(),
+      modelTier: this.getActiveModelTier(),
       compactText: (text, maxChars, label) => this.compactText(text, maxChars, label),
       summarizeToolResult: value => this.tools?.summarizeToolResult?.(value) || { ...value },
     });
   }
 
   async buildPromptToolResultForModel(toolName, result) {
+    const modelTier = this.getActiveModelTier();
+    const tokenJuice = this.getTokenJuiceForModelTier(modelTier);
     return buildPromptToolResultWithTokenJuice({
       toolName,
       result,
       projectPath: this.projectPath,
-      tokenJuice: this.tokenJuice,
+      tokenJuice,
       compact: this.shouldUseCompactPrompt(),
+      modelTier,
       compactText: (text, maxChars, label) => this.compactText(text, maxChars, label),
       summarizeToolResult: value => this.tools?.summarizeToolResult?.(value) || { ...value },
     });
@@ -471,7 +499,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}`);
+          this.startupNotice(`loaded ${fileName}`);
           continue;
         }
 
@@ -487,7 +515,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}`);
+                this.startupNotice(`loaded ${path.basename(targetPath)}/${c}`);
                 loaded = true;
                 break;
               }
@@ -512,7 +540,7 @@ 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}`);
+          this.startupNotice(`rules ${file.relativePath}`);
         }
       }
     } catch (e) {
@@ -551,8 +579,8 @@ export class WinterREPL {
       try {
         const projectWinterMd = path.join(this.projectPath, 'winter.md');
         await fsPromises.writeFile(projectWinterMd, template, 'utf8');
-        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`);
+        this.startupNotice('created winter.md');
+
         
         // Nạp luôn vào memory.
         await this.session.replaceMemory(`[Quy tắc dự án từ winter.md]`, template);
@@ -577,13 +605,13 @@ export class WinterREPL {
         if (!isWinterGeneratedProjectDoc(existing)) continue;
 
         await fsPromises.writeFile(filePath, doc.content, 'utf8');
-        console.log(`${colors.green}✓ Đã nâng cấp file ${doc.filename} từ local resources.${colors.reset}`);
+        this.startupNotice(`updated ${doc.filename}`);
         const memoryKey = `[Quy tắc dự án từ ${doc.filename}]`;
         await this.session.replaceMemory(memoryKey, doc.content);
       } catch {
         try {
           await fsPromises.writeFile(filePath, doc.content, 'utf8');
-          console.log(`${colors.green}✓ Đã tự động tạo file ${doc.filename} từ local resources!${colors.reset}`);
+          this.startupNotice(`created ${doc.filename}`);
           const memoryKey = `[Quy tắc dự án từ ${doc.filename}]`;
           await this.session.replaceMemory(memoryKey, doc.content);
         } catch (err) {
@@ -596,51 +624,19 @@ export class WinterREPL {
     await this.compactStartupMemories({ projectInstructionFiles, autoCreateDocs });
 
     // Codebase Index: warm in background, then inject summaries into model context on demand.
-    this.codebaseWarmup = this.ensureCodebaseIndex({ verbose: true })
+    this.codebaseWarmup = this.ensureCodebaseIndex({ verbose: false })
       .then(() => this.startCodebaseWatcher())
       .catch((error) => {
-        console.log(`${colors.yellow}Codebase index disabled: ${error.message}${colors.reset}`);
+        this.startupNotice(`codebase disabled: ${error.message}`);
       });
 
-    const activeProvider = this.ai.getActiveProvider();
-    const info = {
-      project: this.projectPath,
-      provider: activeProvider,
-      model: this.ai.providers[activeProvider]?.model,
-      session: this.session.getSessionId().substring(0, 8)
-    };
-
-    // Show banner only if not already shown
-    if (!process.env.WINTER_BANNER_SHOWN) {
-      console.log(welcomeBanner(this.version, info));
-      this.showCommandMenu();
-      process.env.WINTER_BANNER_SHOWN = '1';
-    } else {
-      this.showStatus();
-    }
-
-    // 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 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} ${text}`);
-        } else if (msg.role === 'assistant') {
-          console.log(`\n${colors.bright}${colors.magenta}Winter:${colors.reset} ${text}`);
-        }
-      }
-      console.log(`\n${colors.dim}${bottomLine}${colors.reset}\n`);
+      this.startupNotice(`${sessionHistory.length} recent messages`);
     }
 
+    this.showStatus();
+
     // Setup readline
     this.rl = readline.createInterface({
       input: process.stdin,
@@ -661,22 +657,106 @@ export class WinterREPL {
     // Hiển thị prompt lần đầu tiên ngay khi khởi động xong.
     this.showInputPrompt();
 
-    this.rl.on('line', (line) => {
+    // Paste buffer: gom nhiều dòng paste nhanh thành 1 tin nhắn
+    this._multilineBuffer = [];
+    this._pasteBuffer = [];
+    this._pasteTimer = null;
+    this._isPasteChunk = false;
+    this._pasteChunkTimer = null;
+    const PASTE_DELAY = 80;
+
+    process.stdin.on('data', (chunk) => {
+      // If a large chunk or chunk with newlines arrives, it's definitely a paste.
+      if (chunk.length > 3 || chunk.includes('\n')) {
+        this._isPasteChunk = true;
+        if (this._pasteChunkTimer) clearTimeout(this._pasteChunkTimer);
+        this._pasteChunkTimer = setTimeout(() => {
+          this._isPasteChunk = false;
+        }, 150);
+      }
+    });
+
+    const flushPasteBuffer = () => {
+      this._pasteTimer = null;
+      if (this._pasteBuffer.length === 0) return;
+
+      const isSingleLineInput = this._pasteBuffer.length === 1 && !this._isPasteChunk;
+      const isJustEmptyEnter = this._pasteBuffer.length === 1 && this._pasteBuffer[0].trim() === '';
+
+      // Normal single-line submit
+      if (isSingleLineInput && this._multilineBuffer.length === 0) {
+        const line = this._pasteBuffer[0].trim();
+        this._pasteBuffer = [];
+        if (!line) {
+          if (this.running && !this.readlineClosed) {
+            readline.moveCursor(process.stdout, 0, -1);
+            readline.clearLine(process.stdout, 0);
+            this.rl.prompt(true);
+          }
+          return;
+        }
+        
+        // Command to enter multiline mode manually
+        if (line === '/multi' || line === '/m') {
+          this._multilineBuffer.push('');
+          console.log(`${colors.cyan}│ ${colors.dim}[ Đã bật chế độ gõ nhiều dòng. Nhấn Enter 2 lần (dòng trống) để gửi. ]${colors.reset}`);
+          if (this.running && !this.readlineClosed) this.rl.prompt(true);
+          return;
+        }
+
+        this.submitInputQueue(line);
+        return;
+      }
+
+      // We are in multiline/paste mode
+      this._multilineBuffer.push(...this._pasteBuffer);
+      this._pasteBuffer = [];
+
+      // If they pressed Enter on an empty line, submit the multiline buffer!
+      if (isJustEmptyEnter && this._multilineBuffer.length > 1) {
+        // Remove the trailing empty line
+        this._multilineBuffer.pop();
+        const combined = this._multilineBuffer.join('\n').trim();
+        this._multilineBuffer = [];
+        this._isPasteChunk = false;
+        
+        if (!combined) {
+          if (this.running && !this.readlineClosed) {
+            this.closeInputBox();
+            this.showInputPrompt();
+          }
+          return;
+        }
+        
+        this.submitInputQueue(combined);
+        return;
+      }
+
+      // Otherwise, we are still collecting! Wait for user to submit.
+      readline.clearLine(process.stdout, 0);
+      readline.cursorTo(process.stdout, 0);
+      const linesCount = this._multilineBuffer.length;
+      console.log(`${colors.cyan}│ ${colors.dim}[ Đang nhập nhiều dòng (${linesCount} dòng)... Nhấn Enter ở dòng trống để gửi ]${colors.reset}`);
+      if (this.running && !this.readlineClosed) this.rl.prompt(true);
+    };
+
+    this.submitInputQueue = (combined) => {
       this.inputQueue = this.inputQueue
         .then(async () => {
           this.closeInputBox();
-          const input = line.trim();
-          if (input) {
-            await this.handleInput(input);
-          } else {
-            if (this.running && !this.readlineClosed) this.showInputPrompt();
-          }
+          await this.handleInput(combined);
         })
         .catch((error) => {
           this.closeInputBox();
           console.log(`\n${colors.red}? Error: ${error.message}${colors.reset}\n`);
           if (this.running && !this.readlineClosed) this.showInputPrompt();
         });
+    };
+
+    this.rl.on('line', (line) => {
+      this._pasteBuffer.push(line);
+      if (this._pasteTimer) clearTimeout(this._pasteTimer);
+      this._pasteTimer = setTimeout(flushPasteBuffer, PASTE_DELAY);
     });
 
     this.rl.on('close', async () => {
@@ -711,16 +791,39 @@ export class WinterREPL {
     return this.inputController.closeInputBox();
   }
 
+  closeSlashMenu() {
+    return this.inputController.closeSlashMenu();
+  }
+
+  handleSlashMenuKey(key = {}) {
+    return this.inputController.handleSlashMenuKey(key);
+  }
+
+  handleDirectClipboardPaste() {
+    return this.inputController.handleDirectClipboardPaste();
+  }
+
   buildInputPanel() {
     return this.inputController.buildInputPanel();
   }
 
   showStatus() {
-    console.log(`${colors.dim}Project: ${this.projectPath}${colors.reset}`);
-    console.log(`${colors.dim}Provider: ${this.ai.getActiveProvider()}${colors.reset}`);
-    console.log(`${colors.dim}Session: ${this.session.getSessionId().substring(0, 8)}${colors.reset}`);
-    console.log(`${colors.dim}Type ${colors.cyan}/help${colors.dim} for commands or ${colors.cyan}/${colors.dim} for menu${colors.reset}`);
-    console.log('');
+    const snapshot = buildTuiSnapshot(this);
+    if (process.stdout.isTTY) {
+      console.log(`\n${welcomeBanner(this.version, {
+        project: snapshot.projectPath,
+        session: snapshot.sessionShort,
+        provider: snapshot.provider,
+        model: snapshot.model,
+      })}\n`);
+      return;
+    }
+    console.log(`\n${renderConversationStartup(snapshot, { colors })}\n`);
+  }
+
+  showTuiDashboard() {
+    const snapshot = buildTuiSnapshot(this);
+    console.log(`\n${renderLandingTui(snapshot, { colors, title: 'Winter Dashboard' })}\n`);
   }
 
   getResourcePaths() {
@@ -917,22 +1020,34 @@ export class WinterREPL {
   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}`);
+      const preview = input.length > 40 ? input.slice(0, 37) + '...' : input;
+      console.log(`${colors.yellow}⧗${colors.reset} ${colors.bright}Queued #${pos}${colors.reset} ${colors.dim}› ${preview}${colors.reset}`);
       this.taskQueue.push(input);
+      if (!this.readlineClosed) this.showInputPrompt();
       return;
     }
-    await this.processInputTask(input);
+    this.processInputTask(input).catch(err => {
+      console.log(colors.red + '\nLỗi xử lý hàng đợi: ' + err.message + colors.reset);
+    });
   }
 
   async processInputTask(input) {
     this.isProcessing = true;
     this.isCancelled = false;
+    this.currentAbortController = new AbortController();
     try {
+      this.closeSlashMenu();
       this.history.push(input);
       if (this.history.length > this.maxHistory) {
         this.history = this.history.slice(-this.maxHistory);
       }
 
+      // Echo tin nhắn user để xác nhận đã nhận
+      if (!input.startsWith('/') && !input.startsWith('!')) {
+        const preview = input.length > 120 ? input.slice(0, 117) + '...' : input;
+        console.log(`\n${colors.bright}${colors.green}You${colors.reset} ${colors.dim}›${colors.reset} ${colors.white}${preview}${colors.reset}`);
+      }
+
       if (input.startsWith('!')) {
         const command = input.slice(1).trim();
         if (!command) {
@@ -998,16 +1113,20 @@ export class WinterREPL {
       }
     } catch (error) {
       if (error.message === 'AbortError') {
-        console.log(colors.red + '\nĐã hủy công việc hiện tại.' + colors.reset);
+        if (!this.isCancelled) {
+          console.log(colors.red + '\nĐã hủy công việc hiện tại.' + colors.reset);
+        }
       } else {
         console.log(colors.red + '\nLỗi: ' + error.message + colors.reset);
       }
     } finally {
       this.isProcessing = false;
       this.isCancelled = false;
+      this.currentAbortController = null;
       if (this.spinner) this.spinner.stop();
 
       if (this.taskQueue.length > 0) {
+        this.closeInputBox();
         const nextTask = this.taskQueue.shift();
         setTimeout(() => this.processInputTask(nextTask), 0);
       } else {
@@ -1277,60 +1396,13 @@ CRITICAL DEBUG/AGENT RULES:
   showCommandMenu() {
     const c = colors;
     const width = terminalWidth(72, 112, 92);
-    const innerWidth = width - 4;
-    const split = Math.floor(innerWidth * 0.54);
-    const rightWidth = innerWidth - split - 1;
-    const row = (left, right = '') => {
-      if (!right) return left;
-      return `${padVisible(left, split)} ${padVisible(right, rightWidth)}`;
-    };
-
-    const body = [
-      `${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`),
-      row(`${c.yellow}/cd${c.reset}      Đổi thư mục`, `${c.yellow}/clear${c.reset}    Xóa màn hình`),
-      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}/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}   Ả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`),
-      '',
-      `${c.bright}Cấu hình Model${c.reset}`,
-      row(`${c.yellow}/provider${c.reset} Đổi provider AI`, `${c.yellow}/model${c.reset}    Đổi model`),
-      row(`${c.yellow}/providers${c.reset} Danh sách provider`, `${c.yellow}/models${c.reset}   Danh sách model`),
-      row(`${c.yellow}/mcp${c.reset}      MCP server mgmt`, `${c.yellow}/permissions${c.reset} Quyền/allowlist`),
-      '',
-      `${c.bright}Bộ nhớ & Kỹ năng${c.reset}`,
-      row(`${c.yellow}/remember${c.reset} Lưu vào bộ nhớ`, `${c.yellow}/memories${c.reset} Xem bộ nhớ`),
-      row(`${c.yellow}/skills${c.reset}  Danh sách kỹ năng`, `${c.yellow}/designs${c.reset}  Hệ thống thiết kế`),
-    ];
-
-    console.log(`
-${renderBox({
-      title: `${c.bright}${c.cyan}WINTER COMMANDS${c.reset}`,
+    const snapshot = buildTuiSnapshot(this);
+    console.log(`\n${renderLandingTui(snapshot, {
+      colors: c,
+      title: 'Winter Agent Console',
       width,
-      borderColor: c.magenta,
-      titleColor: c.cyan,
-      body,
-    })}
-${c.dim}Gửi tin nhắn trực tiếp để chat, ESC để hủy${c.reset}
-`);
+    })}`);
+    console.log(`${c.dim}Type ${c.cyan}/${c.dim} for palette, ${c.cyan}/help${c.dim} for the full command list.${c.reset}\n`);
   }
 
   showHelp() {
@@ -1500,13 +1572,42 @@ ${colors.reset}
   }
 
   getActiveModelTier() {
+    if (typeof this.ai?._modelTier === 'string' && this.ai._modelTier) {
+      return this.ai._modelTier;
+    }
     const providerName = this.ai?.getActiveProvider?.();
     const model = this.ai?.providers?.[providerName]?.model || '';
     return classifyModelTier(model, providerName);
   }
 
+  getBudgetScale(modelTier = this.getActiveModelTier()) {
+    return getModelBudgetMultiplier(modelTier);
+  }
+
+  getProjectContextBudget(modelTier = this.getActiveModelTier()) {
+    return Math.round(6000 * this.getBudgetScale(modelTier));
+  }
+
+  getCodebaseContextBudget(modelTier = this.getActiveModelTier()) {
+    return Math.round(4200 * this.getBudgetScale(modelTier));
+  }
+
+  getTokenJuiceInlineBudget(modelTier = this.getActiveModelTier()) {
+    return Math.max(800, Math.round(1400 * this.getBudgetScale(modelTier)));
+  }
+
+  getTokenJuiceForModelTier(modelTier = this.getActiveModelTier()) {
+    const tokenJuice = new TokenJuice({
+      projectPath: this.projectPath,
+      inlineBudgetTokens: this.getTokenJuiceInlineBudget(modelTier),
+    });
+    this.tokenJuice = tokenJuice;
+    return tokenJuice;
+  }
+
   shouldUseCompactPrompt() {
-    return false;
+    const tier = this.getActiveModelTier();
+    return tier === 'tiny' || tier === 'small';
   }
 
   selectExecutionProfile(messages = [], options = {}) {
@@ -1614,17 +1715,52 @@ ${colors.reset}
     ].join('\n');
   }
 
+  withCurrentAbortSignal(options = {}) {
+    const signal = options.signal || options.abortSignal || this.currentAbortController?.signal;
+    return signal ? { ...options, signal } : options;
+  }
+
+  isAbortError(error) {
+    return error?.name === 'AbortError' || error?.message === 'AbortError';
+  }
+
+  isRateLimitError(error) {
+    const message = String(error?.message || error || '');
+    return error?.status === 429 || /\b429\b|rate[_ -]?limit|tokens per minute|\bTPM\b/i.test(message);
+  }
+
+  isTimeoutError(error) {
+    const message = String(error?.message || error || '');
+    return error?.name === 'TimeoutError'
+      || error?.code === 'ETIMEDOUT'
+      || /timed out|timeout|request aborted/i.test(message);
+  }
+
+  cancelCurrentTask() {
+    if (this.isCancelled) return;
+    this.isCancelled = true;
+    if (this.spinner) this.spinner.stop();
+    if (this.currentAbortController && !this.currentAbortController.signal.aborted) {
+      this.currentAbortController.abort(new DOMException('The operation was aborted.', 'AbortError'));
+    }
+    console.log(`\n\x1b[31m[ Đã hủy công việc hiện tại ]\x1b[0m`);
+  }
+
   async requestAssistantTurn(messages, options, startedAt, totalUsage) {
+    const requestOptions = this.withCurrentAbortSignal(options);
     if (typeof this.ai.streamRequest === 'function') {
       try {
-        const streamed = await this.collectAssistantStream(messages, options, startedAt, totalUsage);
+        const streamed = await this.collectAssistantStream(messages, requestOptions, startedAt, totalUsage);
         if (streamed) return streamed;
       } catch (error) {
+        if (this.isAbortError(error)) throw new Error('AbortError');
+        if (this.isRateLimitError(error)) throw error;
+        if (this.isTimeoutError(error)) throw error;
         console.log(`${colors.dim}Streaming failed, retrying normal response: ${error.message}${colors.reset}`);
       }
     }
 
-    const response = await this.ai.sendRequest(messages, options);
+    const response = await this.ai.sendRequest(messages, requestOptions);
     this.addUsage(totalUsage, response.usage);
     const assistantMsg = response.choices?.[0]?.message || {};
     const inlineToolExtraction = this.extractInlineToolCalls(assistantMsg.content || '');
@@ -1709,22 +1845,11 @@ ${colors.reset}
       }
 
       if (chunk.content) {
-        if (!printed) {
-          if (this.spinner) this.spinner.stop();
-          if (!bufferToolModeContent) {
-            process.stdout.write(`\n${colors.white}`);
-            printed = true;
-          }
-        }
         content += chunk.content;
-        if (!bufferToolModeContent) {
-          process.stdout.write(chunk.content);
-        }
       }
     }
 
     if (this.spinner) this.spinner.stop();
-    if (printed) process.stdout.write(colors.reset);
 
     const inlineToolExtraction = this.extractInlineToolCalls(content);
     const rawToolCalls = [
@@ -1737,7 +1862,7 @@ ${colors.reset}
     const toolCalls = this.normalizeToolCalls(rawToolCalls);
     const visibleContent = inlineToolExtraction.content || content;
 
-    if (bufferToolModeContent && toolCalls.length === 0 && visibleContent) {
+    if (toolCalls.length === 0 && visibleContent) {
       if (options?.requireToolEvidence && this.responseNeedsToolEvidence(visibleContent)) {
         return {
           assistantMsg: { content: visibleContent },
@@ -1755,18 +1880,6 @@ ${colors.reset}
       };
     }
 
-    if (toolCalls.length === 0 && visibleContent) {
-      console.log(`\n${colors.dim}${this.formatAnswerFooter(startedAt, totalUsage)}${colors.reset}\n`);
-      return {
-        assistantMsg: { content: visibleContent },
-        toolCalls,
-        finalContent: visibleContent,
-        finishReason,
-      };
-    } else if (printed && visibleContent) {
-      process.stdout.write('\n');
-    }
-
     return {
       assistantMsg: {
         content: visibleContent,
@@ -1783,198 +1896,6 @@ ${colors.reset}
     process.stdout.write(colors.reset);
   }
 
-  installSlashSuggestions() {
-    if (!process.stdin.isTTY) return;
-
-    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) {
-        return;
-      }
-
-      if (this.slashMenu.open && this.handleSlashMenuKey(key)) {
-        return;
-      }
-
-      if (key.name === 'escape' && this.isProcessing) {
-        this.isCancelled = true;
-        if (this.spinner) this.spinner.stop();
-        console.log(`\n\x1b[31m[ Đã nhận lệnh HỦY... AI sẽ kết thúc ở thao tác tiếp theo ]\x1b[0m`);
-        return;
-      }
-
-      queueMicrotask(() => {
-        const line = this.rl?.line || '';
-        if (!line.startsWith('/')) {
-          this.closeSlashMenu();
-          return;
-        }
-
-        this.openSlashMenu(line);
-      });
-    });
-  }
-
-  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) {
-      this.closeSlashMenu();
-      return;
-    }
-    if (this.slashMenu.open && this.slashMenu.line === line) return;
-
-    this.slashMenu = { open: true, line, items: matches, selected: 0, printedLines: this.slashMenu?.printedLines || 0 };
-    this.renderSlashMenu();
-  }
-
-  closeSlashMenu() {
-    if (this.slashMenu && this.slashMenu.printedLines) {
-      readline.moveCursor(process.stdout, 0, -this.slashMenu.printedLines);
-      readline.clearScreenDown(process.stdout);
-    }
-    this.slashMenu = { open: false, line: '', items: [], selected: 0, printedLines: 0 };
-  }
-
-  handleSlashMenuKey(key = {}) {
-    if (key.name === 'up') {
-      this.moveSlashSelection(-1);
-      return true;
-    }
-    if (key.name === 'down') {
-      this.moveSlashSelection(1);
-      return true;
-    }
-    if (key.name === 'tab') {
-      this.acceptSlashSelection();
-      return true;
-    }
-    if (key.name === 'escape') {
-      this.closeSlashMenu();
-      this.rl.prompt(true);
-      return true;
-    }
-    return false;
-  }
-
-  moveSlashSelection(delta) {
-    if (!this.slashMenu.items.length) return;
-    const count = this.slashMenu.items.length;
-    this.slashMenu.selected = (this.slashMenu.selected + delta + count) % count;
-    this.renderSlashMenu();
-  }
-
-  acceptSlashSelection() {
-    const item = this.slashMenu.items[this.slashMenu.selected];
-    if (!item) return;
-
-    const currentLine = String(this.rl?.line ?? this.slashMenu.line ?? '');
-    const slashPrefixMatch = currentLine.match(/^\s*(\/\S*)(.*)$/);
-    const prefix = slashPrefixMatch ? slashPrefixMatch[1] : currentLine.trim();
-    const suffixText = slashPrefixMatch ? slashPrefixMatch[2] : '';
-    const needsSpace = item.usage && suffixText && !/^\s/.test(suffixText);
-    const replacement = `${item.cmd}${needsSpace ? ' ' : ''}${suffixText}`.trimEnd();
-
-    this.rl.write(null, { ctrl: true, name: 'u' });
-    this.rl.write(replacement || prefix || item.cmd);
-    this.closeSlashMenu();
-    this.rl.prompt(true);
-  }
-
-  renderSlashMenu() {
-    const matches = this.slashMenu.items;
-    if (!matches.length) return;
-
-    if (this.slashMenu.printedLines) {
-      readline.moveCursor(process.stdout, 0, -this.slashMenu.printedLines);
-    }
-
-    process.stdout.write('\n');
-    readline.clearLine(process.stdout, 1);
-    process.stdout.write(`${colors.dim}Commands${colors.reset}\n`);
-    
-    const maxDisplay = 5;
-    const displayedMatches = matches.slice(0, maxDisplay);
-
-    displayedMatches.forEach((item, index) => {
-      readline.clearLine(process.stdout, 1);
-      const usage = item.usage ? ` ${colors.dim}${item.usage}${colors.reset}` : '';
-      const pointer = index === this.slashMenu.selected ? `${colors.green}>${colors.reset}` : ' ';
-      process.stdout.write(`${pointer} ${colors.cyan}${item.cmd}${colors.reset} ${colors.dim}${item.desc}${colors.reset}${usage}\n`);
-    });
-
-    if (matches.length > maxDisplay) {
-      readline.clearLine(process.stdout, 1);
-      process.stdout.write(`  ${colors.dim}... và ${matches.length - maxDisplay} lệnh khác (gõ tiếp để lọc)${colors.reset}\n`);
-    }
-
-    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ũ.
-    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++) {
-        readline.clearLine(process.stdout, 1);
-        process.stdout.write('\n');
-      }
-      readline.moveCursor(process.stdout, 0, -(this.slashMenu.printedLines - currentLines));
-    }
-
-    this.slashMenu.printedLines = currentLines;
-    this.rl.prompt(true);
-  }
 
   getSlashSuggestions(line) {
     const query = String(line || '').trim();
@@ -1984,7 +1905,7 @@ ${colors.reset}
       const preferred = [
         '/help', '/new', '/history', '/exit', '/pwd', '/cd',
           '/provider', '/model', '/models', '/providers',
-          '/theme:toggle',
+          '/theme:toggle', '/tui',
           '/auto', '/debug', '/doctor', '/context', '/scorecard', '/swe',
           '/read', '/write', '/glob', '/grep', '/bash',
         '/codex', '/claude', '/karpathy', '/agents',
@@ -2106,6 +2027,7 @@ ${colors.reset}
         provider: executionProfile.provider,
         model: executionProfile.model,
         enableTools: false,
+        signal: this.currentAbortController?.signal,
       });
       this.addUsage(totalUsage, response.usage);
       const content = response.choices?.[0]?.message?.content || '';
@@ -2114,6 +2036,7 @@ ${colors.reset}
       }
       return content;
     } catch (error) {
+      if (this.isAbortError(error)) throw new Error('AbortError');
       const fallback = this.buildToolFallbackAnswer(toolSummaries, error.message);
       console.log(`\n${colors.yellow}${fallback}${colors.reset}\n`);
       return fallback;
@@ -2125,27 +2048,33 @@ ${colors.reset}
     const profile = executionProfile || this.selectExecutionProfile(messages, { enableTools: false });
 
     try {
-      process.stdout.write(`\n${colors.white}`);
       let isFirst = true;
       for await (const chunk of this.ai.streamRequest(messages, {
         provider: profile.provider,
         model: profile.model,
         enableTools: false,
+        signal: this.currentAbortController?.signal,
       })) {
+        if (isFirst) {
+          isFirst = false;
+        }
         if (chunk.usage) this.addUsage(totalUsage, chunk.usage);
         if (chunk.content) {
           content += chunk.content;
-          process.stdout.write(chunk.content);
         }
       }
-      process.stdout.write(colors.reset);
+
+      if (this.spinner) this.spinner.stop();
 
       if (content) {
-        console.log(`\n${colors.dim}${this.formatAnswerFooter(startedAt, totalUsage)}${colors.reset}\n`);
+        this.printAssistantAnswer(content, startedAt, totalUsage);
         return content;
       }
     } catch (error) {
       process.stdout.write(colors.reset);
+      if (this.isAbortError(error)) throw new Error('AbortError');
+      if (this.isRateLimitError(error)) throw error;
+      if (this.isTimeoutError(error)) throw error;
       console.log(`${colors.dim}Streaming failed, retrying normal response: ${error.message}${colors.reset}`);
     }
 
@@ -2153,6 +2082,7 @@ ${colors.reset}
       provider: profile.provider,
       model: profile.model,
       enableTools: false,
+      signal: this.currentAbortController?.signal,
     });
     this.addUsage(totalUsage, response.usage);
     content = response.choices?.[0]?.message?.content || '';
@@ -2165,17 +2095,13 @@ ${colors.reset}
   printAssistantAnswer(content, startedAt, usage = {}) {
     const formatted = formatMarkdown(content);
     const footer = this.formatAnswerFooter(startedAt, usage);
-    const body = String(formatted || '').split(/\r?\n/);
-    console.log(`\n${renderBox({
-      title: 'Assistant',
+    console.log(`\n${renderAssistantPanel({
+      content: formatted,
+      footer,
+      colors,
       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`);
   }
 
   formatAnswerFooter(startedAt, usage = {}) {
@@ -2223,16 +2149,29 @@ ${colors.reset}
   }
 
   async promptToolPermission(commandText) {
-    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`);
+    const c = colors;
+    const width = terminalWidth(68, 100, 80);
+    const body = [
+      `${c.yellow}${this.useUnicodeUi ? '⚠' : '!'}  AI wants to run${c.reset}`,
+      `${c.bright}${c.white}${commandText}${c.reset}`,
+      '',
+      `${c.cyan}1.${c.reset} Allow once`,
+      `${c.cyan}2.${c.reset} Allow for session`,
+      `${c.cyan}3.${c.reset} Deny`,
+    ];
+
+    console.log(renderBox({
+      title: 'Tool Permission',
+      width,
+      borderColor: c.magenta,
+      titleColor: c.yellow,
+      body,
+      boxChars: { topLeft: '+', topRight: '+', bottomLeft: '+', bottomRight: '+', horizontal: '-', vertical: '|', teeLeft: '+', teeRight: '+' },
+    }));
 
     while (true) {
       const answer = await new Promise(resolve => {
-        this.rl.question(`${colors.magenta}${side}${colors.reset}   ${colors.yellow}Chọn [1/2/3]: ${colors.reset}`, resolve);
+        this.rl.question(`${c.yellow}Choice [1/2/3]: ${c.reset}`, resolve);
       });
 
       const choice = String(answer || '').trim().toLowerCase();
@@ -2246,7 +2185,7 @@ ${colors.reset}
         return false;
       }
 
-      process.stdout.write(`${colors.magenta}${side}${colors.reset}   ${colors.dim}Vui lòng chọn 1, 2 hoặc 3.${colors.reset}\n`);
+      console.log(`${c.dim}Please choose 1, 2, or 3.${c.reset}`);
     }
   }
 
@@ -2479,6 +2418,7 @@ ${colors.reset}
       }
 
     } catch (error) {
+      if (this.isAbortError(error)) throw error;
       console.log(`\n${colors.red}✖ Error: ${error.message}${colors.reset}\n`);
     }
   }
@@ -2858,6 +2798,7 @@ Do NOT stop until all errors are resolved.`;
   }
 
   async getProjectContext(task = '') {
+    const modelTier = this.getActiveModelTier();
     const context = [];
     const requiredLocalResources = await this.getRequiredLocalResourceSummary();
     if (requiredLocalResources) {
@@ -2924,7 +2865,7 @@ Do NOT stop until all errors are resolved.`;
       // Not a git repo or git not installed
     }
 
-    return this.compactText(context.join('\n\n') || 'No project context found.', 14000, 'project context');
+    return this.compactText(context.join('\n\n') || 'No project context found.', this.getProjectContextBudget(modelTier), 'project context');
   }
 
   async getLocalResourceContext() {
@@ -3026,7 +2967,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: 5200,
+      modelTier: this.getActiveModelTier(),
     });
   }