winter-super-cli 2026.6.6 → 2026.6.8

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.8",
   "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/diff-view.js

@@ -8,9 +8,16 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import readline from 'readline';
 import { spawn } from 'child_process';
+import { highlight } from 'cli-highlight';
 import { renderBox, terminalWidth, stripAnsi, wrapText, visibleWidth } from './terminal-ui.js';
 import { colors } from './snowflake-logo.js';
 
+// Setup background colors if not defined in snowflake-logo
+const bgRed = '\x1b[41m';
+const bgGreen = '\x1b[42m';
+const bgDarkRed = '\x1b[48;5;52m';
+const bgDarkGreen = '\x1b[48;5;22m';
+
 export class DiffView {
   constructor(options = {}) {
     this.projectPath = options.projectPath || process.cwd();
@@ -124,42 +131,91 @@ export class DiffView {
   // ── Private Methods ─────────────────────────────────
 
   _renderDiff(title, diff, width) {
-    const body = [];
-    const maxLines = Math.min(30, diff.additionsList.length + diff.removalsList.length);
-    let added = 0;
-    let removed = 0;
+    const innerWidth = Math.max(40, width - 6);
+    const header = `${colors.bright} ${title} ${colors.reset} ${colors.dim}— ${diff.additions} additions, ${diff.removals} deletions${colors.reset}`;
+
+    console.log(`\n${colors.magenta}┌${'─'.repeat(width - 2)}┐${colors.reset}`);
+    console.log(`${colors.magenta}│${colors.reset} ${header}${''.padEnd(Math.max(0, width - 4 - stripAnsi(header).length))}${colors.magenta}│${colors.reset}`);
+    console.log(`${colors.magenta}├${'─'.repeat(width - 2)}┤${colors.reset}`);
 
-    body.push(`  ${colors.dim}${path.basename(title)} — ${diff.additions} additions, ${diff.removals} deletions${colors.reset}`);
+    const maxLines = 40;
+    let printed = 0;
+    let lineNum = 0;
+    const contextLines = 2; // lines of context around changes
 
+    // Build display entries with context
+    const entries = [];
     for (const part of diff.raw) {
-      if (added + removed >= maxLines) {
-        body.push(`  ${colors.dim}... and ${diff.changes - maxLines} more changes${colors.reset}`);
-        break;
+      const lines = part.value.replace(/\n$/, '').split('\n');
+      for (const line of lines) {
+        lineNum++;
+        if (part.added) {
+          entries.push({ type: 'add', num: lineNum, text: line });
+        } else if (part.removed) {
+          entries.push({ type: 'del', num: lineNum, text: line });
+        } else {
+          entries.push({ type: 'ctx', num: lineNum, text: line });
+        }
       }
+    }
 
-      const lines = part.value.split('\n').filter(Boolean);
-      const isAdded = part.added;
-      const isRemoved = part.removed;
+    // Find which context lines to show (near changes)
+    const changeIndices = new Set();
+    entries.forEach((e, i) => {
+      if (e.type !== 'ctx') {
+        for (let j = Math.max(0, i - contextLines); j <= Math.min(entries.length - 1, i + contextLines); j++) {
+          changeIndices.add(j);
+        }
+      }
+    });
 
-      for (const line of lines) {
-        if (added + removed >= maxLines) break;
-        if (isAdded) {
-          added++;
-          body.push(`  ${colors.green}+ ${line}${colors.reset}`);
-        } else if (isRemoved) {
-          removed++;
-          body.push(`  ${colors.red}- ${line}${colors.reset}`);
+    let lastPrinted = -1;
+    for (let i = 0; i < entries.length && printed < maxLines; i++) {
+      const e = entries[i];
+      if (e.type === 'ctx' && !changeIndices.has(i)) continue;
+
+      // Show separator if there's a gap
+      if (lastPrinted >= 0 && i - lastPrinted > 1) {
+        console.log(`${colors.magenta}│${colors.reset} ${colors.dim}${'·'.repeat(Math.min(20, innerWidth))}${colors.reset}`);
+      }
+
+      const numStr = String(e.num).padStart(4);
+      const maxText = Math.max(10, innerWidth - 8);
+      const truncated = e.text.length > maxText ? e.text.slice(0, maxText - 3) + '...' : e.text;
+
+      // Detect language from file extension for highlight
+      const ext = path.extname(title).slice(1) || 'javascript';
+      const syntaxHighlight = (text) => {
+        try {
+          return highlight(text, { language: ext, ignoreIllegals: true });
+        } catch (e) {
+          return text;
         }
+      };
+
+      if (e.type === 'add') {
+        const lineContent = syntaxHighlight(truncated);
+        console.log(`${colors.magenta}│${colors.reset} ${bgDarkGreen}${colors.white}${numStr} + ${lineContent}${' '.repeat(Math.max(0, innerWidth - stripAnsi(truncated).length - 8))}${colors.reset}`);
+      } else if (e.type === 'del') {
+        const lineContent = syntaxHighlight(truncated);
+        console.log(`${colors.magenta}│${colors.reset} ${bgDarkRed}${colors.white}${numStr} - ${lineContent}${' '.repeat(Math.max(0, innerWidth - stripAnsi(truncated).length - 8))}${colors.reset}`);
+      } else {
+        const lineContent = syntaxHighlight(truncated);
+        console.log(`${colors.magenta}│${colors.reset} ${colors.dim}${numStr}   ${colors.reset}${lineContent}`);
+      }
+
+      printed++;
+      lastPrinted = i;
+    }
+
+    if (printed >= maxLines && entries.length > maxLines) {
+      const remaining = entries.filter(e => e.type !== 'ctx').length - printed;
+      if (remaining > 0) {
+        console.log(`${colors.magenta}│${colors.reset} ${colors.dim}  ... and ${remaining} more changes${colors.reset}`);
       }
     }
 
-    console.log(`\n${renderBox({
-      title: ` ${title} `,
-      width,
-      borderColor: colors.magenta,
-      titleColor: colors.bright,
-      body,
-    })}\n`);
+    console.log(`${colors.magenta}└${'─'.repeat(width - 2)}┘${colors.reset}\n`);
   }
 
   async _promptChoice() {
@@ -236,12 +292,12 @@ export class DiffView {
       };
 
       rl.question(
-        `\n${colors.cyan}Options:${colors.reset}\n` +
-        `  ${colors.green}[a]${colors.reset} — Accept all (apply full diff)\n` +
-        `  ${colors.red}[r]${colors.reset} — Reject all\n` +
-        `  ${colors.yellow}[m]${colors.reset} — Manual edit (opens file in $EDITOR)\n` +
-        `  ${colors.dim}[s]${colors.reset} — Skip\n` +
-        `${colors.yellow}Choose [a/r/m/s]: ${colors.reset}`,
+        `\n${colors.cyan}Edit Options:${colors.reset}\n` +
+        `  ${colors.green}[a]${colors.reset} Accept   — Apply the complete diff\n` +
+        `  ${colors.red}[r]${colors.reset} Reject   — Discard these changes\n` +
+        `  ${colors.yellow}[m]${colors.reset} Manual   — Open file in $EDITOR to manually resolve\n` +
+        `  ${colors.dim}[s]${colors.reset} Skip     — Skip for now\n` +
+        `${colors.yellow}👉 Choose [a/r/m/s]: ${colors.reset}`,
         onAnswer
       );