winter-super-cli 2026.6.6 → 2026.6.7

package/bin/winter.js

@@ -23,6 +23,7 @@ const COMMANDS = new Set([
   'autopilot', 'plan',
   'provider', 'providers', 'model', 'models', 'ecc', 'page-agent', 'pageagent',
   'resources', 'htmlfx', 'memory-vault', 'doctor', 'context', 'scorecard',
+  'tui',
 ]);
 
 function isInteractiveRequest(args) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "winter-super-cli",
-  "version": "2026.6.6",
+  "version": "2026.6.7",
   "description": "❄️ AI-Powered Development CLI with Interactive REPL",
   "type": "module",
   "main": "bin/winter.js",

package/src/agent/runtime.js

@@ -1,6 +1,6 @@
 import { Spinner } from '../cli/spinner.js';
 import { colors } from '../cli/snowflake-logo.js';
-import { renderBox, terminalWidth, wrapText } from '../cli/terminal-ui.js';
+import { renderToolPanel } from '../cli/tui.js';
 import { getMutatingToolNames, recordToolCallAdapterStats } from '../cli/tool-runtime.js';
 import { buildSmallModelAmplification } from '../ai/small-model-amplifier.js';
 
@@ -38,6 +38,9 @@ export class AgentRuntime {
       depth,
     });
     const maxToolTurns = amplifier.maxToolTurns || 8;
+    // Keep self-critique as prompt discipline only. A second runtime model turn
+    // duplicates the final answer because the first answer is already rendered.
+    amplifier.enforceSelfCritique = false;
     let forceTextToolFallback = false;
 
     try {
@@ -116,7 +119,6 @@ export class AgentRuntime {
           }
         }
 
-        const BOX_WIDTH = terminalWidth(76, 116, 92);
         messages.push({
           role: 'assistant',
           content: assistantMsg.content || '',
@@ -189,20 +191,12 @@ export class AgentRuntime {
           const summary = repl.formatToolResultForConsole(canonicalToolName, result);
           if (summary) {
             toolSummaries.push(`${canonicalToolName}: ${summary}`);
-            const statusIcon = result.success === false
-              ? `${colors.red}${repl.useUnicodeUi ? '✖' : 'x'}${colors.reset}`
-              : `${colors.green}${repl.useUnicodeUi ? '✓' : 'ok'}${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(renderToolPanel({
+              toolName: `${icon} ${toolName}`,
+              summary,
+              success: result.success !== false,
+              colors,
+              title: 'Agent Tools',
             }));
           }
         }

package/src/ai/model-capabilities.js

@@ -171,6 +171,21 @@ export function getReasoningBump(tier) {
   }
 }
 
+/**
+ * Get a budget multiplier for prompt/context sizing.
+ * Bigger models can safely absorb more context and larger tool outputs.
+ */
+export function getModelBudgetMultiplier(tier) {
+  switch (tier) {
+    case MODEL_TIERS.TINY: return 0.5;
+    case MODEL_TIERS.SMALL: return 0.75;
+    case MODEL_TIERS.MEDIUM: return 1;
+    case MODEL_TIERS.LARGE: return 2;
+    case MODEL_TIERS.FLAGSHIP: return 4;
+    default: return 1;
+  }
+}
+
 /**
  * Build a short string describing model capability for system prompt injection.
  */

package/src/ai/prompts/system-prompt.js

@@ -5,6 +5,7 @@
  */
 
 import { formatRuntimeEnvironmentSummary, getRuntimeEnvironment } from '../../cli/runtime-env.js';
+import { getModelBudgetMultiplier } from '../model-capabilities.js';
 
 const BASE_PRINCIPLES = [
   'Execute, don\'t describe - Do the work, don\'t write plans about doing the work',
@@ -34,11 +35,22 @@ function buildEnvironmentSummary() {
   ].join('\n');
 }
 
+function getPromptBudgets(modelTier = '') {
+  const scale = getModelBudgetMultiplier(modelTier);
+  const compactSystemPrompt = scale <= 0.75;
+
+  return {
+    compactSystemPrompt,
+    projectContextBudget: Math.round(3200 * scale),
+    resourceContextBudget: Math.round(1200 * scale),
+  };
+}
+
 function formatToolList(tools = []) {
   return tools.length > 0 ? tools.slice(0, 10).join(', ') : '';
 }
 
-function appendSharedContext(parts, { environment, session, design, resourceContext, context, includeResources = false } = {}) {
+function appendSharedContext(parts, { environment, session, design, resourceContext, context, includeResources = false, resourceContextBudget = 1200 } = {}) {
   parts.push('## Runtime Environment', environment || buildEnvironmentSummary(), '');
 
   if (session?.memory?.length) {
@@ -65,7 +77,7 @@ function appendSharedContext(parts, { environment, session, design, resourceCont
   }
 
   if (includeResources && resourceContext) {
-    parts.push(resourceContext.trim().slice(0, 1200), '');
+    parts.push(resourceContext.trim().slice(0, resourceContextBudget), '');
   }
 
   if (context && typeof context === 'object') {
@@ -74,7 +86,10 @@ function appendSharedContext(parts, { environment, session, design, resourceCont
 }
 
 function buildStandardSystemPrompt(options = {}) {
-  const { role = 'coding', tools = [], resourceContext } = options;
+  const { role = 'coding', tools = [], resourceContext, modelTier = '' } = options;
+  const budgets = getPromptBudgets(modelTier);
+  const projectContextBudget = options.projectContextBudget ?? budgets.projectContextBudget;
+  const compactSystemPrompt = options.compactSystemPrompt ?? budgets.compactSystemPrompt;
   const parts = [
     'You are Winter, an expert AI coding assistant.',
     '',
@@ -93,7 +108,11 @@ function buildStandardSystemPrompt(options = {}) {
 
   const toolList = formatToolList(tools);
   if (toolList) parts.push('## Tools', toolList, '');
-  appendSharedContext(parts, { ...options, includeResources: Boolean(resourceContext) && (role === 'design' || role === 'ui') });
+  appendSharedContext(parts, {
+    ...options,
+    includeResources: Boolean(resourceContext) && (role === 'design' || role === 'ui'),
+    resourceContextBudget: budgets.resourceContextBudget,
+  });
 
   parts.push('Always respond in Vietnamese.');
   return parts.filter(Boolean).join('\n');
@@ -109,7 +128,10 @@ export function buildSystemPrompt({
   resourceContext,
   modelTier,
 } = {}) {
+  const budgets = getPromptBudgets(modelTier);
   const options = { role, context, tools, session, environment, design, resourceContext, modelTier };
+  options.projectContextBudget = options.projectContextBudget ?? budgets.projectContextBudget;
+  options.compactSystemPrompt = options.compactSystemPrompt ?? budgets.compactSystemPrompt;
   return buildStandardSystemPrompt(options);
 }
 

package/src/ai/providers.js

@@ -25,11 +25,64 @@ const RESERVED_CONFIG_SECTIONS = new Set([
   'ui',
 ]);
 
+const DEFAULT_REQUEST_TIMEOUT_MS = 120000;
+
 function isAuthError(error) {
   const msg = String(error?.message || error || '');
   return /\b(401|403)\b/.test(msg) || /authentication_error|invalid_api_key|unauthorized|auth\s*failed/i.test(msg);
 }
 
+function isRateLimitError(error) {
+  const msg = String(error?.message || error || '');
+  return error?.status === 429 || /\b429\b|rate[_ -]?limit|tokens per minute|\bTPM\b/i.test(msg);
+}
+
+function getRequestTimeoutMs(options = {}) {
+  const raw = options.timeoutMs ?? process.env.WINTER_REQUEST_TIMEOUT_MS;
+  const value = Number(raw);
+  if (Number.isFinite(value) && value > 0) return value;
+  return DEFAULT_REQUEST_TIMEOUT_MS;
+}
+
+function createTimeoutSignal(timeoutMs, externalSignal = null) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const onAbort = () => {
+    controller.abort(externalSignal?.reason || new DOMException('The operation was aborted.', 'AbortError'));
+  };
+  if (externalSignal?.aborted) {
+    onAbort();
+  } else if (externalSignal) {
+    externalSignal.addEventListener('abort', onAbort, { once: true });
+  }
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort(new Error(`Winter request timed out after ${timeoutMs}ms`));
+  }, timeoutMs);
+  if (typeof timer.unref === 'function') timer.unref();
+  return {
+    signal: controller.signal,
+    timedOut: () => timedOut,
+    cleanup: () => {
+      clearTimeout(timer);
+      if (externalSignal) externalSignal.removeEventListener('abort', onAbort);
+    },
+  };
+}
+
+function normalizeFetchError(error, provider, timeoutMs, stream = false, timedOut = false) {
+  if (timedOut || /timed out/i.test(String(error?.message || ''))) {
+    const label = stream ? 'stream' : 'request';
+    return new Error(`${provider?.name || 'Provider'} ${label} timed out after ${Math.ceil(timeoutMs / 1000)}s`);
+  }
+  if (error?.name === 'AbortError' || /abort/i.test(String(error?.message || ''))) {
+    const abortError = new Error('AbortError');
+    abortError.name = 'AbortError';
+    return abortError;
+  }
+  return error;
+}
+
 export class AIProviderManager {
   constructor(config) {
     this.config = config;
@@ -365,7 +418,7 @@ export class AIProviderManager {
         model: routingModel,
         reasoning: routingReasoning,
         reasoningLevel: options.reasoningLevel || executionProfile.reasoningLevel,
-      }), { maxAttempts: 3, baseDelayMs: 150 });
+      }), { maxAttempts: 3, baseDelayMs: 150, retryable: error => !isRateLimitError(error) && !/\b(400|404)\b/.test(String(error?.message || error || '')) });
     } catch (error) {
       if (isAuthError(error) && routedProvider !== defaultProvider && defaultProvider) {
         if (!this._fallbackWarned) {
@@ -377,7 +430,7 @@ export class AIProviderManager {
           model: options.model || defaultProvider.model,
           reasoning: routingReasoning,
           reasoningLevel: options.reasoningLevel || executionProfile.reasoningLevel,
-        }), { maxAttempts: 1, baseDelayMs: 0 });
+        }), { maxAttempts: 1, baseDelayMs: 0, retryable: error => !isRateLimitError(error) && !/\b(400|404)\b/.test(String(error?.message || error || '')) });
       }
       throw error;
     }
@@ -426,6 +479,7 @@ export class AIProviderManager {
     if (!provider) {
       throw new Error('No active provider is configured');
     }
+    const timeoutMs = getRequestTimeoutMs(options);
 
     const body = {
       model: options.model || provider.model,
@@ -459,15 +513,26 @@ export class AIProviderManager {
       headers['Authorization'] = `Bearer ${provider.apiKey}`;
     }
 
-    const response = await fetch(`${provider.baseURL}/chat/completions`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(body),
-    });
+    const timeout = createTimeoutSignal(timeoutMs, options.signal || options.abortSignal);
+    let response;
+    try {
+      response = await fetch(`${provider.baseURL}/chat/completions`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+        signal: timeout.signal,
+      });
+    } catch (error) {
+      throw normalizeFetchError(error, provider, timeoutMs, false, timeout.timedOut());
+    } finally {
+      timeout.cleanup();
+    }
 
     if (!response.ok) {
       const error = await response.text();
-      throw new Error(`${provider.name} error (${response.status}): ${error}`);
+      const requestError = new Error(`${provider.name} error (${response.status}): ${error}`);
+      requestError.status = response.status;
+      throw requestError;
     }
 
     return await response.json();
@@ -477,6 +542,7 @@ export class AIProviderManager {
     if (!provider) {
       throw new Error('No active provider is configured');
     }
+    const timeoutMs = getRequestTimeoutMs(options);
 
     const body = {
       model: options.model || provider.model,
@@ -515,67 +581,78 @@ export class AIProviderManager {
       headers['Authorization'] = `Bearer ${provider.apiKey}`;
     }
 
-    const response = await fetch(`${provider.baseURL}/chat/completions`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`${provider.name} stream error (${response.status}): ${error}`);
-    }
+    const timeout = createTimeoutSignal(timeoutMs, options.signal || options.abortSignal);
+    let response;
+    try {
+      response = await fetch(`${provider.baseURL}/chat/completions`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+        signal: timeout.signal,
+      });
 
-    if (!response.body) {
-      throw new Error(`${provider.name} did not return a stream body`);
-    }
+      if (!response.ok) {
+        const error = await response.text();
+        const streamError = new Error(`${provider.name} stream error (${response.status}): ${error}`);
+        streamError.status = response.status;
+        throw streamError;
+      }
 
-    const decoder = new TextDecoder();
-    let buffer = '';
+      if (!response.body) {
+        throw new Error(`${provider.name} did not return a stream body`);
+      }
 
-    for await (const chunk of response.body) {
-      buffer += decoder.decode(chunk, { stream: true });
-      const lines = buffer.split(/\r?\n/);
-      buffer = lines.pop() || '';
+      const decoder = new TextDecoder();
+      let buffer = '';
 
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed || !trimmed.startsWith('data:')) continue;
+      for await (const chunk of response.body) {
+        buffer += decoder.decode(chunk, { stream: true });
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() || '';
 
-        const payload = trimmed.slice(5).trim();
-        if (!payload || payload === '[DONE]') continue;
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith('data:')) continue;
 
-        let data;
-        try {
-          data = JSON.parse(payload);
-        } catch {
-          continue;
-        }
+          const payload = trimmed.slice(5).trim();
+          if (!payload || payload === '[DONE]') continue;
 
-        const choice = data.choices?.[0] || {};
-        const content = choice.delta?.content ?? choice.message?.content ?? choice.text ?? '';
-        yield {
-          content,
-          usage: data.usage,
-          raw: data,
-        };
-      }
-    }
+          let data;
+          try {
+            data = JSON.parse(payload);
+          } catch {
+            continue;
+          }
 
-    const tail = buffer.trim();
-    if (tail.startsWith('data:')) {
-      const payload = tail.slice(5).trim();
-      if (payload && payload !== '[DONE]') {
-        try {
-          const data = JSON.parse(payload);
           const choice = data.choices?.[0] || {};
+          const content = choice.delta?.content ?? choice.message?.content ?? choice.text ?? '';
           yield {
-            content: choice.delta?.content ?? choice.message?.content ?? choice.text ?? '',
+            content,
             usage: data.usage,
             raw: data,
           };
-        } catch {}
+        }
+      }
+
+      const tail = buffer.trim();
+      if (tail.startsWith('data:')) {
+        const payload = tail.slice(5).trim();
+        if (payload && payload !== '[DONE]') {
+          try {
+            const data = JSON.parse(payload);
+            const choice = data.choices?.[0] || {};
+            yield {
+              content: choice.delta?.content ?? choice.message?.content ?? choice.text ?? '',
+              usage: data.usage,
+              raw: data,
+            };
+          } catch {}
+        }
       }
+    } catch (error) {
+      throw normalizeFetchError(error, provider, timeoutMs, true, timeout.timedOut());
+    } finally {
+      timeout.cleanup();
     }
   }
 

package/src/ai/small-model-amplifier.js

@@ -9,9 +9,9 @@ export function buildSmallModelAmplification({ modelTier = '', workflowProfile =
   const hint = [
     '[Winter Strength Amplifier]',
     '- Every model, including tiny/local/free models, must run at Winter maximum capability.',
-    '- Mandatory loop: PLAN (requirements + files + risks) -> TOOL ACTIONS -> VERIFY -> SELF-CHECK -> FINAL.',
+    '- Mandatory internal loop: PLAN (requirements + files + risks) -> TOOL ACTIONS -> VERIFY -> PRIVATE SELF-CHECK -> FINAL.',
     '- Do not skip verification. If verification fails, iterate until max loops.',
-    '- Before final answer, run a private self-critique: missing edge cases, missing tests, over-claims, and incorrect assumptions.',
+    '- Before final answer, run a private self-critique silently; do not print the self-check or an improved-answer preface.',
     '- Prefer concrete evidence from tool outputs over reasoning guesses.',
     '- Use CodeGraph/codebase index context before broad file reads when available.',
   ].join('\n');

package/src/cli/commands.js

@@ -15,6 +15,7 @@ import { redactSecrets } from './secret-env.js';
 import { formatRuntimeEnvironmentSummary, getRuntimeEnvironment } from './runtime-env.js';
 import { ContextLoader } from './context-loader.js';
 import { ECCManager } from './ecc.js';
+import { buildTuiSnapshot, renderLandingTui } from './tui.js';
 import { HtmlFxManager } from '../integrations/htmlfx-manager.js';
 import { selectWorkflow } from '../ai/workflow-selector.js';
 import { getProfileBlueprint } from '../ai/profile-blueprints.js';
@@ -73,6 +74,7 @@ export class CommandParser {
       resources: this.handleResources.bind(this),
       htmlfx: this.handleHtmlFx.bind(this),
       'memory-vault': this.handleMemoryVault.bind(this),
+      tui: this.handleTui.bind(this),
       provider: this.handleProvider.bind(this),
       providers: this.showProviders.bind(this),
       model: this.handleModel.bind(this),
@@ -121,6 +123,7 @@ export class CommandParser {
       '/forget': (args) => this.session.clearMemory(args.length > 0 ? args.join(' ') : null),
       '/memories': () => this.showMemories(),
       '/memory-vault': () => this.handleMemoryVault(args),
+      '/tui': () => this.handleTui(args),
       '/plans': () => this.showPlans(),
       '/plan': () => this.handlePlan(args),
       '/cache': () => this.handleCache(args),
@@ -220,6 +223,15 @@ export class CommandParser {
     }
   }
 
+  async handleTui() {
+    await this.ai.init?.();
+    const snapshot = buildTuiSnapshot(this);
+    console.log(`\n${renderLandingTui(snapshot, {
+      colors,
+      title: 'Winter Dashboard',
+    })}\n`);
+  }
+
   async searchResourceFiles(root, query, limit = 30) {
     const matches = [];
     const needle = String(query || '').toLowerCase();

package/src/cli/context-loader.js

@@ -226,7 +226,7 @@ export class ContextLoader {
       this.readTextIfExists(pageAgentAgentsPath, 2200),
     ]);
 
-    const hasRequired = Boolean(karpathy || agents || designReadme || designBrands.length > 0 || pageAgentWinter);
+    const hasRequired = Boolean(karpathy || agents || designReadme || designBrands.length > 0 || pageAgentWinter || pageAgentAgents);
     if (!hasRequired) return '';
 
     const lines = [];

package/src/cli/input-controller.js

@@ -1,6 +1,7 @@
 import readline from 'readline';
 import { colors } from './snowflake-logo.js';
-import { padVisible, renderBox, terminalWidth, visibleWidth } from './terminal-ui.js';
+import { drawInFixedArea, enableFixedPanel, moveToPromptRow, moveToScrollRegion, padVisible, renderBox, terminalWidth } from './terminal-ui.js';
+import { buildTuiSnapshot, renderInputPanel } from './tui.js';
 
 export class WinterInputController {
   constructor(repl) {
@@ -11,9 +12,20 @@ export class WinterInputController {
     const repl = this.repl;
     if (!repl.running || repl.readlineClosed) return;
     const panel = this.buildInputPanel();
-    process.stdout.write(`\n${panel.top}\n${panel.status}\n${panel.hint}\n`);
-    repl.rl.setPrompt(panel.prompt);
-    repl.rl.prompt();
+    
+    // Queue indicator
+    const queueCount = repl.taskQueue?.length || 0;
+    const queueTag = queueCount > 0
+      ? `  ${colors.yellow}⧗ ${queueCount} pending${colors.reset}`
+      : '';
+    
+    const lines = [panel.top + queueTag, panel.status, panel.hint].filter(l => l && l.trim() !== '');
+    process.stdout.write('\n' + lines.join('\n') + '\n');
+    
+    if (typeof repl.rl?.setPrompt === 'function') {
+      repl.rl.setPrompt(panel.prompt);
+    }
+    repl.rl?.prompt?.();
   }
 
   closeInputBox() {
@@ -25,38 +37,10 @@ export class WinterInputController {
 
   buildInputPanel() {
     const repl = this.repl;
-    const width = Math.max(64, terminalWidth(66, 124) - 2);
-    const box = repl.useUnicodeUi
-      ? { topLeft: '╭', topRight: '╮', bottomLeft: '╰', bottomRight: '╯', horizontal: '─', vertical: '│' }
-      : { topLeft: '+', topRight: '+', bottomLeft: '+', bottomRight: '+', horizontal: '-', vertical: '|' };
-    const provider = repl.ai?.getActiveProvider?.() || 'provider';
-    const model = repl.ai?.providers?.[provider]?.model || 'model';
-    const sessionId = repl.session?.getSessionId?.()?.slice(0, 8) || 'session';
-    const projectName = repl.projectPath ? repl.projectPath.split(/[\\/]/).filter(Boolean).pop() : 'project';
-    const queueText = repl.taskQueue?.length > 0 ? `queue:${repl.taskQueue.length}` : 'ready';
-    const title = ' Winter CLI ';
-    const titleWidth = visibleWidth(title);
-    const topFill = Math.max(0, width - titleWidth);
-    const leftFill = Math.floor(topFill / 2);
-    const rightFill = topFill - leftFill;
-    const statusText = [
-      `model ${provider}/${model}`,
-      `project ${projectName}`,
-      `session ${sessionId}`,
-      queueText,
-    ].join('  ');
-    const hintText = '@file  @Agent task  !cmd  Ctrl+V image  /context  /doctor full';
-    const hintInnerWidth = Math.max(20, width - 2);
-    const status = `${colors.magenta}${box.vertical}${colors.reset} ${colors.dim}${padVisible(statusText, hintInnerWidth)}${colors.reset} ${colors.magenta}${box.vertical}${colors.reset}`;
-    const hint = `${colors.magenta}${box.vertical}${colors.reset} ${colors.dim}${padVisible(hintText, hintInnerWidth)}${colors.reset} ${colors.magenta}${box.vertical}${colors.reset}`;
-    const prompt = `${colors.magenta}${box.vertical}${colors.reset} ${colors.bright}${colors.cyan}winter${colors.reset}${colors.dim} > ${colors.reset}`;
-    return {
-      top: `${colors.magenta}${box.topLeft}${box.horizontal.repeat(leftFill)}${title}${box.horizontal.repeat(rightFill)}${box.topRight}${colors.reset}`,
-      status,
-      hint,
-      prompt,
-      bottom: `${colors.magenta}${box.bottomLeft}${box.horizontal.repeat(width)}${box.bottomRight}${colors.reset}`,
-    };
+    return renderInputPanel(buildTuiSnapshot(repl), {
+      colors,
+      width: terminalWidth(66, 124),
+    });
   }
 
   installSlashSuggestions() {
@@ -80,10 +64,24 @@ export class WinterInputController {
         return;
       }
 
-      if (key.name === 'escape' && repl.isProcessing) {
-        repl.isCancelled = true;
-        if (repl.spinner) repl.spinner.stop();
-        console.log(`\n${colors.red}[ Đã nhận lệnh HỦY... AI sẽ kết thúc ở thao tác tiếp theo ]${colors.reset}`);
+      if (key.name === 'escape') {
+        if (repl.isProcessing) {
+          // Cancel current AI turn
+          repl.isCancelled = true;
+          if (repl.spinner) repl.spinner.stop();
+          console.log(`\n${colors.red}[ Đã nhận lệnh HỦY... AI sẽ kết thúc ở thao tác tiếp theo ]${colors.reset}`);
+        } else {
+          // Double-ESC to end session
+          const now = Date.now();
+          if (this._lastEscTime && (now - this._lastEscTime) < 500) {
+            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 ${repl.session?.getSessionId?.() || ''}${colors.reset}\n`);
+            process.exit(0);
+          }
+          this._lastEscTime = now;
+          console.log(`${colors.dim}Press ESC again to end session${colors.reset}`);
+        }
         return;
       }
 
@@ -116,13 +114,13 @@ export class WinterInputController {
 
       repl.inputQueue = repl.inputQueue
         .then(async () => {
-          this.closeInputBox();
+          repl.closeInputBox?.();
           await this.processPastedImageTask(prompt, image);
         })
         .catch((error) => {
-          this.closeInputBox();
+          repl.closeInputBox?.();
           console.log(`\n${colors.red}✖ Paste image error: ${error.message}${colors.reset}\n`);
-          if (repl.running && !repl.readlineClosed) this.showInputPrompt();
+          if (repl.running && !repl.readlineClosed) repl.showInputPrompt?.();
         });
       return true;
     } finally {
@@ -134,15 +132,17 @@ export class WinterInputController {
     const repl = this.repl;
     repl.isProcessing = true;
     repl.isCancelled = false;
+    repl.currentAbortController = new AbortController();
     try {
       await repl.chat(prompt, [image]);
     } finally {
       repl.isProcessing = false;
+      repl.currentAbortController = null;
       if (repl.taskQueue.length > 0) {
         const nextTask = repl.taskQueue.shift();
         setTimeout(() => repl.processInputTask(nextTask), 0);
       } else if (!repl.readlineClosed) {
-        this.showInputPrompt();
+        repl.showInputPrompt?.();
       }
     }
   }
@@ -247,12 +247,23 @@ export class WinterInputController {
 
     this.clearSlashMenuRender();
 
+    const ASCII_BOX = {
+      topLeft: '+',
+      topRight: '+',
+      bottomLeft: '+',
+      bottomRight: '+',
+      horizontal: '-',
+      vertical: '|',
+      teeLeft: '+',
+      teeRight: '+',
+    };
     const rendered = renderBox({
       title: 'Command Palette',
       width: terminalWidth(66, 110, 88),
       borderColor: colors.magenta,
       titleColor: colors.cyan,
       body,
+      boxChars: ASCII_BOX,
     });
 
     process.stdout.write(`\n${rendered}\n`);