winter-super-cli 2026.6.7 → 2026.6.8

package/package.json

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

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
       );
 

package/src/cli/input-controller.js

@@ -1,7 +1,8 @@
 import readline from 'readline';
 import { colors } from './snowflake-logo.js';
-import { drawInFixedArea, enableFixedPanel, moveToPromptRow, moveToScrollRegion, padVisible, renderBox, terminalWidth } from './terminal-ui.js';
+import { padVisible, renderBox, terminalWidth } from './terminal-ui.js';
 import { buildTuiSnapshot, renderInputPanel } from './tui.js';
+import { terminalManager } from './terminal-manager.js';
 
 export class WinterInputController {
   constructor(repl) {
@@ -20,17 +21,48 @@ export class WinterInputController {
       : '';
     
     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?.();
+    const redrawFn = () => {
+      // Don't redraw if it shouldn't be visible anymore
+      if (!terminalManager.isPromptVisible) return;
+      process.stdout.write('\n' + lines.join('\n') + '\n');
+      if (typeof repl.rl?.setPrompt === 'function') {
+        repl.rl.setPrompt(panel.prompt);
+      }
+      if (repl.slashMenu?.open) {
+        this.renderSlashMenu();
+      } else {
+        if (repl.running && !repl.readlineClosed) {
+          repl.rl?.prompt?.(true);
+        }
+      }
+    };
+
+    const getLinesCountFn = () => {
+      let count = lines.length + 2; // empty line + lines + prompt line
+      if (repl.slashMenu?.open && repl.slashMenu?.printedLines) {
+        count += repl.slashMenu.printedLines;
+      }
+      return count;
+    };
+
+    const onHideFn = () => {
+      if (repl.slashMenu) {
+        repl.slashMenu.printedLines = 0;
+      }
+    };
+
+    terminalManager.setPromptState(true, getLinesCountFn, redrawFn, onHideFn);
+    redrawFn();
   }
 
   closeInputBox() {
     const repl = this.repl;
     if (!repl.running || repl.readlineClosed) return;
+    
+    terminalManager.hidePrompt();
+    terminalManager.setPromptState(false);
+    
     const panel = this.buildInputPanel();
     process.stdout.write(`${panel.bottom}\n`);
   }
@@ -174,6 +206,7 @@ export class WinterInputController {
 
     readline.moveCursor(process.stdout, 0, -printedLines);
     readline.clearScreenDown(process.stdout);
+    repl.slashMenu.printedLines = 0;
   }
 
   handleSlashMenuKey(key = {}) {
@@ -247,23 +280,12 @@ 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`);

package/src/cli/markdown-format.js

@@ -1,7 +1,7 @@
 import { highlight } from 'cli-highlight';
 
 import { colors } from './snowflake-logo.js';
-import { renderBox, terminalWidth, visibleWidth, wrapText, padVisible } from './terminal-ui.js';
+import { renderBox, terminalWidth, visibleWidth, wrapText, padVisible, getBoxChars } from './terminal-ui.js';
 
 export function formatMarkdown(text) {
   if (!text) return '';
@@ -98,19 +98,24 @@ function renderMarkdownTableBlock(tableLines) {
   const columnCount = Math.max(...rows.map(row => row.length), 0);
   if (columnCount === 0) return tableLines.join('\n');
 
-  const boxWidth = Math.max(60, Math.min(terminalWidth(60, 100, 84), 100));
-  const innerWidth = boxWidth - 4;
-  const separatorWidth = (columnCount - 1) * 3;
-  const availableWidth = Math.max(columnCount * 8, innerWidth - separatorWidth);
-
   const widestCells = Array.from({ length: columnCount }, (_, columnIndex) => {
     return Math.max(8, ...rows.map(row => visibleWidth(row[columnIndex] || '')));
   });
 
+  const separatorWidth = (columnCount - 1) * 3;
   const widestTotal = widestCells.reduce((sum, width) => sum + width, 0);
+  const requiredInnerWidth = widestTotal + separatorWidth;
+  
+  const maxAllowedWidth = terminalWidth(60, 160, 120);
+  const innerWidth = Math.min(requiredInnerWidth, maxAllowedWidth - 4);
+  const availableWidth = Math.max(columnCount * 8, innerWidth - separatorWidth);
+  const boxWidth = innerWidth + 4;
+
   const scale = widestTotal > availableWidth ? availableWidth / widestTotal : 1;
   const columnWidths = widestCells.map(width => Math.max(8, Math.floor(width * scale)));
 
+  const verticalChar = getBoxChars().vertical;
+
   const renderRow = (cells) => {
     const wrappedCells = cells.map((cell, index) => wrapText(cell || '', columnWidths[index]));
     const lineCount = Math.max(...wrappedCells.map(lines => lines.length), 1);
@@ -122,7 +127,7 @@ function renderMarkdownTableBlock(tableLines) {
         const cellLine = wrappedCells[columnIndex][lineIndex] || '';
         parts.push(padVisible(cellLine, columnWidths[columnIndex]));
       }
-      rendered.push(parts.join(' │ '));
+      rendered.push(parts.join(` ${colors.dim}${verticalChar}${colors.reset} `));
     }
 
     return rendered;

package/src/cli/repl.js

@@ -16,6 +16,7 @@ import {
   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';
@@ -125,6 +126,8 @@ export class WinterREPL {
     this.watchers = [];
     this.startupNotices = [];
     this._fixedPanel = Boolean(process.stdout.isTTY) && process.env.WINTER_FIXED_PANEL_TUI !== '0';
+    
+    terminalManager.install();
   }
 
   async initCodebaseSearch() {
@@ -654,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 () => {
@@ -936,9 +1023,12 @@ export class WinterREPL {
       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) {
@@ -952,6 +1042,12 @@ export class WinterREPL {
         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) {
@@ -1030,6 +1126,7 @@ export class WinterREPL {
       if (this.spinner) this.spinner.stop();
 
       if (this.taskQueue.length > 0) {
+        this.closeInputBox();
         const nextTask = this.taskQueue.shift();
         setTimeout(() => this.processInputTask(nextTask), 0);
       } else {
@@ -1748,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 = [
@@ -1776,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 },
@@ -1794,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,
@@ -1974,7 +2048,6 @@ ${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,
@@ -1982,16 +2055,19 @@ ${colors.reset}
         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) {

package/src/cli/terminal-manager.js

@@ -0,0 +1,74 @@
+import readline from 'readline';
+
+class TerminalManager {
+  constructor() {
+    this.isPromptVisible = false;
+    this.getLinesCountFn = null;
+    this.redrawFn = null;
+    this.onHideFn = null;
+    this._originalLog = console.log;
+    this._originalError = console.error;
+    this._isIntercepting = false;
+  }
+
+  install() {
+    if (this._isIntercepting) return;
+    this._isIntercepting = true;
+
+    console.log = (...args) => this._interceptLog(this._originalLog, args);
+    console.error = (...args) => this._interceptLog(this._originalError, args);
+  }
+
+  uninstall() {
+    if (!this._isIntercepting) return;
+    this._isIntercepting = false;
+    console.log = this._originalLog;
+    console.error = this._originalError;
+  }
+
+  setPromptState(isVisible, getLinesCountFn = null, redrawFn = null, onHideFn = null) {
+    this.isPromptVisible = isVisible;
+    this.getLinesCountFn = getLinesCountFn;
+    this.redrawFn = redrawFn;
+    this.onHideFn = onHideFn;
+  }
+
+  hidePrompt() {
+    if (!this.isPromptVisible || !process.stdout.isTTY) return;
+    
+    // Clear the current line first (the readline prompt itself)
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+    
+    // If the prompt panel has multiple lines above it, move up and clear
+    const linesCount = this.getLinesCountFn ? this.getLinesCountFn() : 0;
+    if (linesCount > 1) {
+      readline.moveCursor(process.stdout, 0, -(linesCount - 1));
+      readline.clearScreenDown(process.stdout);
+    }
+    
+    if (this.onHideFn) {
+      this.onHideFn();
+    }
+  }
+
+  _interceptLog(originalFn, args) {
+    if (!this.isPromptVisible) {
+      originalFn.apply(console, args);
+      return;
+    }
+
+    // Hide prompt
+    this.hidePrompt();
+
+    // Print the actual log
+    originalFn.apply(console, args);
+
+    // Redraw prompt
+    if (this.redrawFn) {
+      this.redrawFn();
+    }
+  }
+}
+
+export const terminalManager = new TerminalManager();

package/src/cli/terminal-ui.js

@@ -70,12 +70,11 @@ export function terminalWidth(min = 72, max = 120, fallback = 88) {
 
 export function supportsUnicodeUi(env = process.env, platform = process.platform) {
   if (env.WINTER_ASCII_UI === '1' || env.WINTER_ASCII_UI === 'true') return false;
-  if (env.WINTER_UNICODE_UI === '1' || env.WINTER_UNICODE_UI === 'true') return platform !== 'win32';
-  if (platform !== 'win32') return true;
-  return false;
+  return true;
 }
 
 export function getBoxChars() {
+  if (supportsUnicodeUi()) return UNICODE_BOX;
   return ASCII_BOX;
 }
 

package/src/cli/tui.js

@@ -176,6 +176,20 @@ export function renderAssistantPanel({ content = '', footer = '', colors, title
 export function renderToolPanel({ toolName = 'Tool', summary = '', success = true, colors } = {}) {
   const c = colors || {};
   const status = success ? `${c.brightGreen}✓${c.reset}` : `${c.red}✖${c.reset}`;
-  const plainSummary = String(summary || '').replace(/\n/g, ' ');
-  return `${status} ${c.bright}${c.cyan}${toolName}${c.reset} ${c.dim}· ${plainSummary}${c.reset}`;
+  
+  if (!summary.includes('\n')) {
+    return `${status} ${c.bright}${c.cyan}${toolName}${c.reset} ${c.dim}· ${summary}${c.reset}`;
+  }
+
+  const lines = summary.split('\n');
+  const firstLine = lines.shift();
+  
+  const formattedRest = lines.map(line => {
+    if (line.startsWith('+')) return `    ${c.green}${line}${c.reset}`;
+    if (line.startsWith('-')) return `    ${c.red}${line}${c.reset}`;
+    if (line.startsWith('@@')) return `    ${c.cyan}${line}${c.reset}`;
+    return `    ${c.dim}${line}${c.reset}`;
+  }).join('\n');
+
+  return `${status} ${c.bright}${c.cyan}${toolName}${c.reset} ${c.dim}· ${firstLine}${c.reset}\n${formattedRest}`;
 }