dave-code 1.1.0 → 1.2.0

package/bin/terminalRenderer.js

@@ -1,69 +1,88 @@
-const ANSI_RE = /\x1b\[[0-9;?]*[a-zA-Z]/g;
-const OSC_RE = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
-const STRING_CONTROL_RE = /\x1b[PX^_][\s\S]*?\x1b\\/g;
-const ESCAPE_RE = /\x1b(?:\[[0-?]*[ -/]*[@-~]|.)/g;
+import { renderTerminalMarkdown } from './markdownRenderer.js';
+import {
+  charWidth,
+  displayWidth,
+  padCenter,
+  padEnd,
+  sanitizeUntrustedText,
+  stripAnsi,
+  truncateEnd,
+  truncateMiddle,
+  wrapText
+} from './textWidth.js';
+
+export { displayWidth, sanitizeUntrustedText, stripAnsi, truncateMiddle };
 
 const COLORS = {
   brand: '\x1b[1;38;2;250;100;30m',
   active: '\x1b[36m',
+  userBackground: '\x1b[48;5;236m',
   success: '\x1b[32m',
   warning: '\x1b[33m',
   error: '\x1b[31m',
   muted: '\x1b[90m',
+  accent: '\x1b[38;2;250;100;30m',
   reset: '\x1b[0m'
 };
 
-export function stripAnsi(text) {
-  return String(text || '').replace(ANSI_RE, '');
-}
+const PHASE_ORDER = ['scan', 'read', 'act', 'verify'];
+const PHASE_TITLES = {
+  cn: { scan: '扫描', read: '读取', act: '执行', verify: '验证' },
+  en: { scan: 'SCAN', read: 'READ', act: 'ACT', verify: 'VERIFY' }
+};
 
-export function sanitizeUntrustedText(text) {
-  return String(text ?? '')
-    .replace(OSC_RE, '')
-    .replace(STRING_CONTROL_RE, '')
-    .replace(ESCAPE_RE, '')
-    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, '');
-}
+/**
+ * Format a conversation using a shape-based role hierarchy. The markers stay
+ * distinct without colour and continuation lines keep a hanging indent so a
+ * multi-line message reads as one block.
+ */
+export function formatConversationMessage(message, { color = true, width = 0 } = {}) {
+  const role = message?.role === 'user' ? 'user' : 'assistant';
+  const content = sanitizeUntrustedText(message?.displayContent || message?.content || '');
+  if (!content) return '';
 
-export function displayWidth(text) {
-  let width = 0;
-  for (const char of stripAnsi(text)) {
-    const code = char.codePointAt(0);
-    if (
-      (code >= 0x1100 && code <= 0x115f) ||
-      (code >= 0x2e80 && code <= 0xa4cf) ||
-      (code >= 0xac00 && code <= 0xd7a3) ||
-      (code >= 0xf900 && code <= 0xfaff) ||
-      (code >= 0xfe10 && code <= 0xfe6f) ||
-      (code >= 0xff00 && code <= 0xff60) ||
-      (code >= 0x1f300 && code <= 0x1faff)
-    ) {
-      width += 2;
-    } else {
-      width += 1;
-    }
+  const marker = role === 'user' ? '>' : '●';
+  const tone = role === 'user' ? COLORS.active : COLORS.brand;
+  const lines = content.split('\n');
+  if (role === 'assistant') {
+    const rendered = renderTerminalMarkdown(content, { color, width: width > 0 ? Math.max(20, width - 2) : 80 });
+    const renderedLines = rendered.split('\n');
+    const prefix = color ? `${tone}${marker}${COLORS.reset}` : marker;
+    return `${prefix} ${renderedLines[0]}${renderedLines.slice(1).map(line => `\n  ${line}`).join('')}`;
   }
-  return width;
-}
 
-export function truncateMiddle(text, maxWidth) {
-  const value = String(text || '');
-  if (displayWidth(value) <= maxWidth) return value;
-  if (maxWidth <= 3) return '.'.repeat(Math.max(0, maxWidth));
-  const target = maxWidth - 3;
-  const leftTarget = Math.ceil(target / 2);
-  const rightTarget = Math.floor(target / 2);
-  let left = '';
-  let right = '';
-  for (const char of value) {
-    if (displayWidth(left + char) > leftTarget) break;
-    left += char;
-  }
-  for (const char of [...value].reverse()) {
-    if (displayWidth(char + right) > rightTarget) break;
-    right = char + right;
+  const blockWidth = Number.isFinite(width) && width > 0
+    ? Math.max(4, Math.floor(width))
+    : Math.max(...lines.map(line => displayWidth(line) + 2));
+  const contentWidth = Math.max(2, blockWidth - 2);
+  const logicalLines = [];
+  let firstLine = true;
+  for (const sourceLine of lines) {
+    const chunks = [];
+    let chunk = '';
+    for (const char of sourceLine) {
+      if (chunk && displayWidth(chunk + char) > contentWidth) {
+        chunks.push(chunk);
+        chunk = char;
+      } else {
+        chunk += char;
+      }
+    }
+    chunks.push(chunk);
+    for (const value of chunks) {
+      logicalLines.push(`${firstLine ? '> ' : '  '}${value}`);
+      firstLine = false;
+    }
   }
-  return `${left}...${right}`;
+
+  if (!color) return logicalLines.join('\n');
+  return logicalLines.map((line, index) => {
+    const padding = ' '.repeat(Math.max(0, blockWidth - displayWidth(line)));
+    const coloredLine = index === 0
+      ? `${COLORS.active}>\x1b[39m${line.slice(1)}`
+      : `\x1b[39m${line}`;
+    return `${COLORS.userBackground}${coloredLine}${padding}${COLORS.reset}`;
+  }).join('\n');
 }
 
 function formatDuration(ms) {
@@ -72,6 +91,35 @@ function formatDuration(ms) {
   return `${(ms / 1000).toFixed(ms < 10000 ? 1 : 0)}s`;
 }
 
+function formatTokens(value) {
+  const count = Number(value) || 0;
+  if (count < 1000) return String(count);
+  return `${(count / 1000).toFixed(count < 10000 ? 1 : 0)}k`;
+}
+
+/** Short label for a tool, so parallel rows align in a narrow column. */
+function toolTag(tool = '') {
+  const name = String(tool).toUpperCase();
+  const tags = {
+    READ_FILE: 'READ',
+    INSPECT_FILE: 'OUTLINE',
+    LIST_DIR: 'LIST',
+    SEARCH_GREP: 'SEARCH',
+    GLOB_FILES: 'GLOB',
+    READ_NOTEBOOK: 'NOTE',
+    EDIT_FILE: 'EDIT',
+    WRITE_FILE: 'WRITE',
+    MAKE_DIR: 'MKDIR',
+    MOVE_PATH: 'MOVE',
+    DELETE_PATH: 'DELETE',
+    RUN_COMMAND: 'RUN',
+    READ_TASK_OUTPUT: 'TASK',
+    KILL_TASK: 'KILL',
+    UPDATE_TODOS: 'TODO'
+  };
+  return tags[name] || name.slice(0, 7) || 'TOOL';
+}
+
 export function createTerminalRenderer({
   stdout = process.stdout,
   lang = 'cn',
@@ -86,9 +134,10 @@ export function createTerminalRenderer({
     ? ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
     : ['-', '\\', '|', '/'];
   const symbols = useUnicode
-    ? { done: '✓', failed: '×', warning: '!', more: '…' }
-    : { done: '+', failed: 'x', warning: '!', more: '...' };
-  const labels = lang === 'cn'
+    ? { done: '✓', failed: '×', warning: '!', more: '…', pending: '○', running: '●', branch: '├', last: '└', bar: '│' }
+    : { done: '+', failed: 'x', warning: '!', more: '...', pending: 'o', running: '*', branch: '|', last: '\\', bar: '|' };
+  const cn = lang === 'cn';
+  const labels = cn
     ? {
         analyzing: '思考中',
         organizing: '正在整理结果',
@@ -96,7 +145,11 @@ export function createTerminalRenderer({
         compacted: '已压缩上下文',
         cancelled: '操作已取消',
         failed: '执行失败',
-        extra: '另有步骤已完成'
+        extra: '另有步骤已完成',
+        parallel: '并行执行',
+        tools: '个工具',
+        todos: '任务清单',
+        cache: '缓存'
       }
     : {
         analyzing: 'Thinking',
@@ -105,11 +158,14 @@ export function createTerminalRenderer({
         compacted: 'Context compacted',
         cancelled: 'Operation cancelled',
         failed: 'Turn failed',
-        extra: 'additional steps completed'
+        extra: 'additional steps completed',
+        parallel: 'Running',
+        tools: 'tools in parallel',
+        todos: 'Task checklist',
+        cache: 'cache'
       };
 
   let frameIndex = 0;
-  let active = null;
   let timer = null;
   let paused = false;
   let disposed = false;
@@ -117,30 +173,162 @@ export function createTerminalRenderer({
   let answerEndsWithNewline = true;
   let completedCount = 0;
   let hiddenCount = 0;
+  let renderedRows = 0;
+  let lastPainted = '';
+
+  // Narrative slot: the single "what is Dave thinking" line.
+  let status = null;
+  // Parallel slots keyed by toolCallId, so concurrent tools each keep a row.
+  const slots = new Map();
+  // Phase track state and the live context/cache gauge.
+  let phase = null;
+  const phaseDone = new Set();
+  let gauge = null;
+  let todos = [];
 
   const paint = (name, text) => useColor ? `${COLORS[name]}${text}${COLORS.reset}` : text;
-  const write = (text) => stdout.write(String(text));
+  const write = text => stdout.write(String(text));
 
   function terminalWidth() {
     return Math.max(24, stdout.columns || 80);
   }
 
-  function elapsedText() {
-    if (!active || terminalWidth() < 58) return '';
-    return formatDuration(now() - active.startedAt);
+  function phaseTrackLine() {
+    if (!phase && phaseDone.size === 0) return '';
+    const titles = PHASE_TITLES[cn ? 'cn' : 'en'];
+    const width = terminalWidth();
+    const segments = PHASE_ORDER.map(name => {
+      const title = titles[name];
+      if (phaseDone.has(name) && phase !== name) return paint('success', `${symbols.done} ${title}`);
+      if (phase === name) return paint('active', `${symbols.running} ${title}`);
+      return paint('muted', `${symbols.pending} ${title}`);
+    });
+    const connector = paint('muted', useUnicode ? ' ── ' : ' -- ');
+    // Two leading spaces keep the track from reading as another "✓ log" row.
+    const track = `  ${segments.join(connector)}`;
+    const gaugeText = gauge ? paint('muted', gauge) : '';
+    if (!gaugeText) return track;
+    const spacing = width - displayWidth(track) - displayWidth(gaugeText);
+    if (spacing < 2) return track;
+    return `${track}${' '.repeat(spacing)}${gaugeText}`;
   }
 
-  function buildActiveText() {
-    if (!active) return '';
-    const elapsed = elapsedText();
-    const suffix = elapsed ? ` · ${elapsed}` : '';
-    const available = Math.max(10, terminalWidth() - displayWidth(frames[frameIndex]) - 2);
-    return `${frames[frameIndex]} ${truncateMiddle(`${active.label}${suffix}`, available)}`;
+  function slotLine(slot, { isLast = true, tree = true } = {}) {
+    const mark = slot.status === 'done'
+      ? paint('success', symbols.done)
+      : slot.status === 'failed'
+        ? paint('error', symbols.failed)
+        : paint('active', frames[frameIndex]);
+    const tag = padEnd(toolTag(slot.tool), 7);
+    const elapsed = slot.status === 'running' ? formatDuration(now() - slot.startedAt) : slot.duration;
+    const suffix = elapsed ? paint('muted', ` · ${elapsed}`) : '';
+    // Tree rows sit one level deeper than the "running N tools" header; a lone
+    // tool is the primary line and shares the header's indentation.
+    const branch = tree ? `  ${paint('muted', isLast ? symbols.last : symbols.branch)} ` : '';
+    const head = `  ${branch}${mark} ${paint('muted', tag)} `;
+    const available = Math.max(8, terminalWidth() - displayWidth(head) - displayWidth(suffix));
+    return `${head}${truncateEnd(slot.label, available)}${suffix}`;
+  }
+
+  function todoLines() {
+    if (todos.length === 0) return [];
+    const done = todos.filter(todo => todo.status === 'completed').length;
+    const lines = [`  ${paint('accent', labels.todos)} ${paint('muted', `${done}/${todos.length}`)}`];
+    for (const todo of todos) {
+      const mark = todo.status === 'completed'
+        ? paint('success', symbols.done)
+        : todo.status === 'in_progress'
+          ? paint('active', useUnicode ? '▶' : '>')
+          : paint('muted', symbols.pending);
+      const text = sanitizeUntrustedText(todo.content);
+      const body = todo.status === 'completed' && useColor ? `\x1b[9m${paint('muted', text)}\x1b[29m` : text;
+      lines.push(`    ${mark} ${truncateEnd(body, Math.max(10, terminalWidth() - 6))}`);
+    }
+    return lines;
+  }
+
+  /**
+   * The live region is a fixed block redrawn in place: phase track, narrative
+   * status, one row per in-flight tool, and the task checklist. Completed log
+   * lines scroll above it untouched, so history and scrollback stay intact.
+   */
+  function liveRegionLines() {
+    const lines = [];
+    const track = phaseTrackLine();
+    if (track) lines.push(track);
+
+    const running = [...slots.values()]
+      .filter(slot => slot.status === 'running')
+      .sort((a, b) => a.seq - b.seq);
+
+    if (status) {
+      const elapsed = terminalWidth() >= 58 && status.startedAt ? formatDuration(now() - status.startedAt) : '';
+      const spinner = paint('active', frames[frameIndex]);
+      const suffix = elapsed ? paint('muted', ` · ${elapsed}`) : '';
+      const head = `  ${spinner} `;
+      const available = Math.max(10, terminalWidth() - displayWidth(head) - displayWidth(suffix));
+      lines.push(`${head}${paint('active', truncateEnd(status.label, available))}${suffix}`);
+      running.forEach((slot, index) => lines.push(slotLine(slot, { isLast: index === running.length - 1 })));
+    } else if (running.length === 1) {
+      // A single tool needs no tree: it reads better as the primary line.
+      lines.push(slotLine(running[0], { tree: false }));
+    } else if (running.length > 1) {
+      const spinner = paint('active', frames[frameIndex]);
+      lines.push(`  ${spinner} ${paint('active', `${labels.parallel} ${running.length} ${labels.tools}`)}`);
+      running.forEach((slot, index) => lines.push(slotLine(slot, { isLast: index === running.length - 1 })));
+    }
+
+    lines.push(...todoLines());
+    return lines;
+  }
+
+  /** Cursor sequence that moves back to the first row of the live block. */
+  function cursorToBlockStart() {
+    let sequence = '\r';
+    for (let row = 1; row < renderedRows; row++) sequence += '\x1b[1A';
+    return sequence;
+  }
+
+  function clearLive() {
+    if (!isTTY || renderedRows === 0) return;
+    write(`${cursorToBlockStart()}\x1b[J`);
+    renderedRows = 0;
+    lastPainted = '';
+  }
+
+  /**
+   * Repaint the block in a single write. Erasing and rewriting as two separate
+   * writes let the terminal present the blank intermediate state, which read as
+   * a flicker on every 90ms spinner frame. Each row is overwritten in place with
+   * an inline erase instead, and only genuinely surplus rows are cleared.
+   */
+  function drawLive() {
+    if (!isTTY || paused || disposed) return;
+    const lines = liveRegionLines();
+    if (lines.length === 0) {
+      clearLive();
+      write('\x1b[?25h');
+      return;
+    }
+    const shrank = lines.length < renderedRows;
+    const body = lines.map(line => `\x1b[2K${line}`).join('\n');
+    // Skip the write entirely when nothing changed, so an idle block does not
+    // repaint 11 times a second for no visible reason.
+    if (!shrank && body === lastPainted) return;
+    lastPainted = body;
+    // Trailing \x1b[J drops rows left over from a taller previous frame.
+    write(`${cursorToBlockStart()}${body}${shrank ? '\x1b[J' : ''}\x1b[?25l`);
+    renderedRows = lines.length;
   }
 
-  function drawActive() {
-    if (!active || paused || disposed || !isTTY) return;
-    write(`\r\x1b[2K${paint('active', buildActiveText())}\x1b[?25l`);
+  function ensureTimer() {
+    if (timer || !isTTY || disposed) return;
+    const hasMotion = status || [...slots.values()].some(slot => slot.status === 'running');
+    if (!hasMotion) return;
+    timer = setInterval(() => {
+      frameIndex = (frameIndex + 1) % frames.length;
+      drawLive();
+    }, 120);
   }
 
   function stopTimer() {
@@ -148,40 +336,95 @@ export function createTerminalRenderer({
     timer = null;
   }
 
-  function clearActive({ keep = false } = {}) {
-    stopTimer();
-    if (isTTY) write('\r\x1b[2K\x1b[?25h');
-    if (!keep) active = null;
+  function refreshLive() {
+    if (!isTTY) return;
+    drawLive();
+    const hasMotion = status || [...slots.values()].some(slot => slot.status === 'running');
+    if (hasMotion) ensureTimer();
+    else stopTimer();
   }
 
-  function setActive(label, key = '') {
-    if (active && active.key === key && !paused) {
-      active.label = label;
-      drawActive();
+  function setStatus(label, key = '') {
+    const text = sanitizeUntrustedText(label);
+    if (!text) return;
+    if (status && status.key === key) {
+      status.label = text;
+    } else {
+      status = { label: text, key, startedAt: now() };
+    }
+    if (!isTTY) {
+      write(`${text}\n`);
       return;
     }
-    clearActive();
-    active = { label, key, startedAt: now() };
+    refreshLive();
+  }
+
+  function clearStatus() {
+    status = null;
+    if (isTTY) refreshLive();
+  }
+
+  function openSlot(id, tool, label) {
+    if (!id) return;
+    const existing = slots.get(id);
+    if (existing) {
+      existing.label = sanitizeUntrustedText(label) || existing.label;
+      existing.tool = tool || existing.tool;
+    } else {
+      slots.set(id, {
+        id,
+        tool: tool || '',
+        label: sanitizeUntrustedText(label) || toolTag(tool),
+        status: 'running',
+        startedAt: now(),
+        seq: slots.size
+      });
+    }
+    // A tool row supersedes the narrative line; keeping both is redundant.
+    status = null;
     if (!isTTY) {
-      write(`${label}\n`);
+      write(`${sanitizeUntrustedText(label) || toolTag(tool)}\n`);
       return;
     }
-    drawActive();
-    timer = setInterval(() => {
-      frameIndex = (frameIndex + 1) % frames.length;
-      drawActive();
-    }, 90);
+    refreshLive();
+  }
+
+  function closeSlot(id, outcome, text, tool) {
+    const slot = id ? slots.get(id) : null;
+    if (slot) {
+      slot.status = outcome;
+      slot.duration = formatDuration(now() - slot.startedAt);
+      slots.delete(id);
+    }
+    const symbol = outcome === 'done' ? symbols.done : symbols.failed;
+    const tone = outcome === 'done' ? 'success' : 'error';
+    const duration = slot?.duration ? paint('muted', ` · ${slot.duration}`) : '';
+    commitLine(symbol, text, tone, false, duration, tool || slot?.tool);
   }
 
-  function commitLine(symbol, text, tone = 'muted') {
-    clearActive();
-    if (completedCount >= maxCompleted) {
+  /**
+   * Append a permanent log line above the live region. Anything already drawn
+   * in the live block is cleared first, then redrawn beneath the new line.
+   */
+  function commitLine(symbol, text, tone = 'muted', force = false, suffix = '', tool = '') {
+    if (!force && completedCount >= maxCompleted) {
       hiddenCount++;
+      if (isTTY) refreshLive();
       return;
     }
+    clearLive();
     completedCount++;
-    const available = Math.max(12, terminalWidth() - displayWidth(symbol) - 2);
-    write(`${paint(tone, symbol)} ${truncateMiddle(sanitizeUntrustedText(text), available)}\n`);
+    const tag = tool ? `${paint('muted', padEnd(toolTag(tool), 7))} ` : '';
+    const head = `${paint(tone, symbol)} ${tag}`;
+    const available = Math.max(12, terminalWidth() - displayWidth(head) - displayWidth(suffix));
+    write(`${head}${truncateEnd(sanitizeUntrustedText(text), available)}${suffix}\n`);
+    if (isTTY) refreshLive();
+  }
+
+  function writeBlock(lines) {
+    clearLive();
+    for (const line of lines) write(`${line}\n`);
+    if (isTTY) refreshLive();
   }
 
   function finishAnswerLine() {
@@ -191,10 +434,36 @@ export function createTerminalRenderer({
 
   function beginAnswer() {
     if (answerOpen) return;
-    clearActive();
-    write(`\n${paint('brand', 'Dave')}\n`);
+    clearLive();
+    stopTimer();
+    status = null;
+    write(`\n${paint('brand', '●')} `);
     answerOpen = true;
-    answerEndsWithNewline = true;
+    answerEndsWithNewline = false;
+  }
+
+  /** Colourize a unified-diff preview so additions and removals read instantly. */
+  function renderPreview(preview) {
+    const width = terminalWidth();
+    const lines = [];
+    for (const raw of sanitizeUntrustedText(preview).replace(/^\n/, '').split('\n')) {
+      const line = truncateEnd(raw, width - 2);
+      if (/^@@/.test(line)) lines.push(`  ${paint('active', line)}`);
+      else if (/^\+/.test(line)) lines.push(`  ${paint('success', line)}`);
+      else if (/^-/.test(line)) lines.push(`  ${paint('error', line)}`);
+      else if (/^(?:Create|Update|Delete)\s/.test(line)) lines.push(`  ${paint('accent', line)}`);
+      else lines.push(`  ${paint('muted', line)}`);
+    }
+    writeBlock(lines);
+  }
+
+  function setPhase(name, label) {
+    const key = String(name || '').toLowerCase();
+    if (PHASE_ORDER.includes(key)) {
+      if (phase && phase !== key) phaseDone.add(phase);
+      phase = key;
+    }
+    setStatus(label || key.toUpperCase(), `phase-${key}`);
   }
 
   function handle(event) {
@@ -202,79 +471,228 @@ export function createTerminalRenderer({
     const data = event.data || {};
 
     if (event.type === 'turn.started') {
-      setActive(data.label || labels.analyzing, event.type);
+      setStatus(data.label || labels.analyzing, event.type);
+    } else if (event.type === 'phase.changed') {
+      setPhase(data.phase, data.label);
+    } else if (event.type === 'scan.started') {
+      setPhase('scan', cn ? 'SCAN · 正在建立项目索引' : 'SCAN · indexing workspace');
+    } else if (event.type === 'scan.progress') {
+      const files = Number(data.files) || 0;
+      const cache = files ? Math.round((Number(data.cacheHits) || 0) / files * 100) : 0;
+      setStatus(data.planning
+        ? (cn ? `SCAN · 正在制定上下文预算 · ${files} 个文件` : `SCAN · planning context budget · ${files} files`)
+        : (cn ? `SCAN · ${files} 个文件 · 缓存 ${cache}%` : `SCAN · ${files} files · ${cache}% cached`), 'scan');
+    } else if (event.type === 'scan.inspect') {
+      setStatus(cn ? `SCAN · 检查结构 ${data.path}` : `SCAN · inspecting ${data.path}`, 'scan');
+    } else if (event.type === 'scan.index.completed') {
+      const mb = ((Number(data.bytes) || 0) / 1048576).toFixed(1);
+      const files = Number(data.files) || 0;
+      const cache = files ? Math.round((Number(data.cacheHits) || 0) / files * 100) : 0;
+      commitLine(symbols.done, cn
+        ? `Scan · 工作区索引 · ${files} 个文件 · ${mb} MB · 缓存 ${cache}% · 排除 ${data.excluded || 0}`
+        : `Scan · workspace index · ${files} files · ${mb} MB · ${cache}% cached · ${data.excluded || 0} excluded`, 'success');
+    } else if (event.type === 'scan.notebook.checked') {
+      let detail;
+      if (!data.enabled) detail = cn ? '当前模式不使用项目笔记' : 'not used in this mode';
+      else if (!data.found) detail = cn ? '未找到 · 将在 READ 建立' : 'not found · will be created during READ';
+      else detail = cn
+        ? `已找到 · ${data.status || 'ready'} · ${data.files || 0} 个文件`
+        : `found · ${data.status || 'ready'} · ${data.files || 0} files`;
+      commitLine(data.found ? symbols.done : '◇', cn
+        ? `Scan · 项目笔记 · ${detail}`
+        : `Scan · project notebook · ${detail}`, data.found ? 'success' : 'muted');
+    } else if (event.type === 'scan.drift.completed') {
+      let detail;
+      if (!data.enabled) detail = cn ? '已略过' : 'skipped';
+      else if (data.action === 'failed') detail = cn ? '检查失败 · 已标记为陈旧' : 'check failed · marked stale';
+      else if (['built', 'resumed'].includes(data.action)) detail = cn ? '已建立新基线' : 'new baseline created';
+      else if ((Number(data.changes) || 0) === 0) detail = cn ? '无未记录变化' : 'no unrecorded changes';
+      else detail = cn ? `${data.changes} 处变化 · ${data.action}` : `${data.changes} changes · ${data.action}`;
+      commitLine(data.action === 'failed' ? symbols.warning : symbols.done, cn
+        ? `Scan · 变更检查 · ${detail}`
+        : `Scan · drift check · ${detail}`, data.action === 'failed' ? 'warning' : 'success');
+    } else if (event.type === 'scan.completed') {
+      phaseDone.add('scan');
+      commitLine(symbols.done, cn
+        ? 'Scan · 检查完成 · 进入正式读取'
+        : 'Scan · checks complete · entering formal reading', 'success');
+    } else if (event.type === 'scan.degraded') {
+      commitLine(symbols.warning, cn ? `Scan 预算规划降级 · ${data.error}` : `Scan planning degraded · ${data.error}`, 'warning');
+    } else if (event.type === 'scan.note.plan.started') {
+      setStatus(cn
+        ? `SCAN · 正在规划低成本项目读取 · ${data.files || 0} 个文件`
+        : `SCAN · planning token-efficient project reading · ${data.files || 0} files`, 'scan-note-plan');
+    } else if (event.type === 'scan.note.plan.completed') {
+      const groups = data.plan?.groups || [];
+      const count = strategy => groups.filter(group => group.strategy === strategy).reduce((sum, group) => sum + (group.paths?.length || 0), 0);
+      commitLine(symbols.done, cn
+        ? `Scan · 快速读取 · 文件大纲 ${count('outline') + count('read')} · 源码读取 ${count('read')}`
+        : `Scan · fast read · ${count('outline') + count('read')} outlines · ${count('read')} source reads`, 'success');
+    } else if (event.type === 'scan.note.plan.degraded') {
+      commitLine(symbols.warning, cn
+        ? 'Scan · 读取方案已使用保守回退'
+        : 'Scan · conservative read-plan fallback applied', 'warning');
+    } else if (event.type === 'context.planned') {
+      const plan = data.contextPlan || {};
+      const budget = Math.round((Number(plan.contextBudgetTokens || plan.budgetTokens) || 0) / 1000);
+      const turnBudget = Math.round((Number(plan.turnBudgetTokens || plan.budgetTokens) || 0) / 1000);
+      const window = Math.round((Number(plan.contextWindowTokens) || 0) / 1000);
+      const verify = plan.files?.length || plan.notebookReuse?.verifyFiles?.length || plan.recommendedFiles?.length || 0;
+      const source = plan.notebook?.action === 'reuse' || plan.notebookReuse
+        ? (cn ? '笔记优先' : 'notebook first')
+        : (cn ? '索引导向' : 'index guided');
+      commitLine(symbols.done, cn
+        ? `Scan · 上下文方案 · ${source} · ${budget}k/${window}k · 建议核对 ${verify} 个文件`
+        : `Scan · context plan · ${source} · ${budget}k/${window}k per call · ${turnBudget}k turn · verify ${verify} files`, 'success');
+    } else if (event.type === 'context.usage') {
+      const used = formatTokens(data.usedTokens);
+      const budget = formatTokens(data.budgetTokens);
+      gauge = cn ? `上下文 ${used}/${budget}` : `context ${used}/${budget}`;
+      if (isTTY) refreshLive();
+      else setStatus(cn ? `READ · 上下文 ${used}/${budget}` : `READ · Context ${used}/${budget}`, 'context');
+    } else if (event.type === 'model.completed') {
+      const cacheRead = Number(data.cacheReadInputTokens) || 0;
+      const input = Number(data.inputTokens) || 0;
+      if (cacheRead > 0 && input + cacheRead > 0) {
+        const hit = Math.round(cacheRead / (input + cacheRead) * 100);
+        const base = gauge ? gauge.split(' · ')[0] : '';
+        gauge = base ? `${base} · ${labels.cache} ${hit}%` : `${labels.cache} ${hit}%`;
+        if (isTTY) refreshLive();
+      }
+    } else if (event.type === 'note.build.started') {
+      setStatus(cn
+        ? `READ · ${data.continuing ? '继续读取项目' : '首次读取项目'} · ${data.remaining || data.total || 0} 个文件`
+        : `READ · ${data.continuing ? 'resuming project reading' : 'initial project reading'} · ${data.remaining || data.total || 0} files`, 'project-read');
+    } else if (event.type === 'note.build.progress') {
+      const strategy = data.strategy === 'read'
+        ? (cn ? '读取源码' : 'source read')
+        : (cn ? '建立大纲' : 'outline');
+      setStatus(`READ · ${data.completed || 0}/${data.total || 0} · ${strategy}`, 'project-read');
+    } else if (event.type === 'note.synthesis.started') {
+      setStatus(cn
+        ? `READ · 正在整理项目认知 · ${data.files || 0} 个文件`
+        : `READ · organizing project knowledge · ${data.files || 0} files`, 'note-synthesis');
+    } else if (event.type === 'note.synthesis.completed') {
+      setStatus(cn ? 'READ · 项目认知整理完成' : 'READ · project knowledge organized', 'note-synthesis-complete');
+    } else if (event.type === 'note.build.completed') {
+      commitLine(symbols.done, cn
+        ? `Read · 项目认知已缓存 · ${data.files || 0} 个文件`
+        : `Read · project knowledge cached · ${data.files || 0} files`, 'success');
+    } else if (event.type === 'read.file.completed') {
+      commitLine(symbols.done, data.kind === 'read'
+        ? (cn ? `工具 · 已读取 ${data.path} · ${data.lines || 0} 行` : `Tool · read ${data.path} · ${data.lines || 0} lines`)
+        : (cn ? `工具 · 已建立 ${data.path} 的文件大纲` : `Tool · outlined ${data.path}`), 'success');
+    } else if (event.type === 'note.loaded') {
+      setStatus(cn ? 'SCAN · 使用已有项目笔记' : 'SCAN · using existing project notebook', 'note-load');
+    } else if (event.type === 'note.drift') {
+      commitLine(symbols.warning, cn
+        ? `Note · ${data.count || 0} 个未记录变化`
+        : `Note · ${data.count || 0} unrecorded changes`, 'warning');
+    } else if (event.type === 'note.update.started') {
+      setStatus(cn ? `READ · 正在核对 ${data.files || 0} 个变化` : `READ · verifying ${data.files || 0} changes`, 'project-read-update');
+    } else if (event.type === 'note.update.completed') {
+      commitLine(symbols.done, cn
+        ? `Note · 已更新 · ${data.files || 0} 个文件 · ${data.sections || 0} 个章节`
+        : `Note · updated · ${data.files || 0} files · ${data.sections || 0} sections`, 'success');
+    } else if (event.type === 'note.failed') {
+      commitLine(symbols.warning, cn
+        ? `Note · 更新失败，已标记为 ${data.status || 'stale'}`
+        : `Note · update failed; marked ${data.status || 'stale'}`, 'warning', true);
     } else if (event.type === 'context.compacted') {
       const detail = data.omittedMessages
-        ? (lang === 'cn' ? ` · 省略 ${data.omittedMessages} 条旧消息` : ` · ${data.omittedMessages} older messages omitted`)
+        ? (cn ? ` · 省略 ${data.omittedMessages} 条旧消息` : ` · ${data.omittedMessages} older messages omitted`)
         : '';
       commitLine(symbols.done, `${labels.compacted}${detail}`, 'muted');
+    } else if (event.type === 'memory.recalled') {
+      commitLine('◆', cn ? `已回忆 ${Number(data.count) || 0} 条相关工作区记忆` : `Recalled ${Number(data.count) || 0} relevant workspace memories`, 'muted');
+    } else if (event.type === 'memory.saved') {
+      commitLine('◆', cn ? `已保存 ${Number(data.count) || 0} 条工作区记忆` : `Saved ${Number(data.count) || 0} workspace memories`, 'muted');
     } else if (event.type === 'model.started') {
-      if (!answerOpen) setActive(data.label || (data.phase === 'finalizing' ? labels.organizing : labels.analyzing), event.type);
+      if (!answerOpen) setStatus(data.label || (data.phase === 'finalizing' ? labels.organizing : labels.analyzing), event.type);
     } else if (event.type === 'model.retry') {
-      setActive(data.label || labels.retrying, event.type);
+      setStatus(data.label || labels.retrying, event.type);
     } else if (event.type === 'model.delta') {
       const text = sanitizeUntrustedText(data.text || '');
       if (!text) return;
-      clearActive();
       beginAnswer();
-      write(text);
-      answerEndsWithNewline = text.endsWith('\n');
+      const rendered = renderTerminalMarkdown(text, { color: useColor, width: terminalWidth() - 4 });
+      write(rendered);
+      answerEndsWithNewline = rendered.endsWith('\n');
     } else if (event.type === 'tool.requested') {
-      setActive(sanitizeUntrustedText(data.label || data.displaySummary || data.tool || ''), data.toolCallId || event.type);
+      openSlot(data.toolCallId, data.tool, data.label || data.displaySummary || data.tool);
+    } else if (event.type === 'todos.updated') {
+      todos = Array.isArray(data.todos) ? data.todos : [];
+      if (isTTY) refreshLive();
+      else for (const line of todoLines()) write(`${line}\n`);
     } else if (event.type === 'tool.started') {
-      setActive(sanitizeUntrustedText(data.label || data.displaySummary || data.tool || ''), data.toolCallId || event.type);
+      openSlot(data.toolCallId, data.tool, data.label || data.displaySummary || data.tool);
     } else if (event.type === 'tool.progress') {
+      const slot = data.toolCallId ? slots.get(data.toolCallId) : null;
       const progress = Number.isFinite(data.percent) ? ` · ${data.percent}%` : '';
-      setActive(`${sanitizeUntrustedText(data.label || data.displaySummary || data.tool || '')}${progress}`, data.toolCallId || event.type);
+      const label = `${sanitizeUntrustedText(data.label || data.displaySummary || data.tool || '')}${progress}`;
+      if (slot) {
+        slot.label = label;
+        refreshLive();
+      } else {
+        openSlot(data.toolCallId, data.tool, label);
+      }
     } else if (event.type === 'tool.completed') {
-      const prefix = lang === 'cn' ? '工具 · ' : 'Tool · ';
-      commitLine(symbols.done, `${prefix}${data.displaySummary || data.tool || 'Done'}`, 'success');
+      const prefix = data.tool ? '' : (cn ? '工具 · ' : 'Tool · ');
+      closeSlot(data.toolCallId, 'done', `${prefix}${data.displaySummary || data.tool || 'Done'}`, data.tool);
     } else if (event.type === 'tool.failed') {
-      commitLine(symbols.failed, data.displaySummary || data.error || data.tool || labels.failed, 'error');
+      closeSlot(data.toolCallId, 'failed', data.displaySummary || data.error || data.tool || labels.failed, data.tool);
     } else if (event.type === 'permission.requested') {
-      clearActive();
+      clearLive();
+      stopTimer();
       write(`${paint('warning', symbols.warning)} ${sanitizeUntrustedText(data.displaySummary || 'Confirmation required')}\n`);
-      if (data.preview) write(`${sanitizeUntrustedText(data.preview).replace(/^\n/, '')}\n`);
+      if (data.preview) renderPreview(data.preview);
     } else if (event.type === 'permission.resolved') {
       if (!data.allowed) commitLine(symbols.warning, data.displaySummary || labels.cancelled, 'warning');
     } else if (event.type === 'turn.failed') {
+      clearLive();
+      stopTimer();
       finishAnswerLine();
-      commitLine(symbols.failed, data.error || labels.failed, 'error');
+      commitLine(symbols.failed, data.error || labels.failed, 'error', true);
     } else if (event.type === 'turn.cancelled') {
+      clearLive();
+      stopTimer();
       finishAnswerLine();
-      commitLine(symbols.warning, data.reason || labels.cancelled, 'warning');
+      commitLine(symbols.warning, data.reason || labels.cancelled, 'warning', true);
     } else if (event.type === 'turn.completed') {
-      clearActive();
+      if (phase) phaseDone.add(phase);
+      const finalTodos = todoLines();
+      slots.clear();
+      status = null;
+      todos = [];
+      clearLive();
+      stopTimer();
+      if (isTTY) write('\x1b[?25h');
       finishAnswerLine();
-      if (hiddenCount > 0) {
-        write(`${paint('muted', symbols.more)} ${hiddenCount} ${labels.extra}\n`);
-      }
+      // Persist the closing checklist so it survives the cleared live region.
+      for (const line of finalTodos) write(`${line}\n`);
+      if (hiddenCount > 0) write(`${paint('muted', symbols.more)} ${hiddenCount} ${labels.extra}\n`);
       if (answerOpen || completedCount > 0) write('\n');
     }
   }
 
   function pause() {
     paused = true;
-    clearActive({ keep: true });
+    stopTimer();
+    clearLive();
+    if (isTTY) write('\x1b[?25h');
   }
 
   function resume() {
     if (disposed) return;
     paused = false;
-    if (active) {
-      drawActive();
-      if (isTTY && !timer) {
-        timer = setInterval(() => {
-          frameIndex = (frameIndex + 1) % frames.length;
-          drawActive();
-        }, 90);
-      }
-    }
+    refreshLive();
   }
 
   function dispose() {
     if (disposed) return;
-    clearActive();
+    clearLive();
+    stopTimer();
+    if (isTTY) write('\x1b[?25h');
     finishAnswerLine();
     disposed = true;
   }