dave-code 1.0.4 → 1.2.0

package/bin/terminalRenderer.js

@@ -0,0 +1,701 @@
+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'
+};
+
+const PHASE_ORDER = ['scan', 'read', 'act', 'verify'];
+const PHASE_TITLES = {
+  cn: { scan: '扫描', read: '读取', act: '执行', verify: '验证' },
+  en: { scan: 'SCAN', read: 'READ', act: 'ACT', verify: 'VERIFY' }
+};
+
+/**
+ * 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 '';
+
+  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('')}`;
+  }
+
+  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;
+    }
+  }
+
+  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) {
+  if (!Number.isFinite(ms) || ms < 0) return '';
+  if (ms < 1000) return `${Math.round(ms)}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',
+  color = true,
+  maxCompleted = 8,
+  now = Date.now
+} = {}) {
+  const isTTY = !!stdout.isTTY;
+  const useColor = Boolean(color && isTTY && !process.env.NO_COLOR);
+  const useUnicode = Boolean(isTTY && process.env.TERM !== 'dumb');
+  const frames = useUnicode
+    ? ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+    : ['-', '\\', '|', '/'];
+  const symbols = useUnicode
+    ? { 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: '正在整理结果',
+        retrying: '流式响应不可用，正在切换兼容模式',
+        compacted: '已压缩上下文',
+        cancelled: '操作已取消',
+        failed: '执行失败',
+        extra: '另有步骤已完成',
+        parallel: '并行执行',
+        tools: '个工具',
+        todos: '任务清单',
+        cache: '缓存'
+      }
+    : {
+        analyzing: 'Thinking',
+        organizing: 'Organizing results',
+        retrying: 'Streaming unavailable, switching to compatibility mode',
+        compacted: 'Context compacted',
+        cancelled: 'Operation cancelled',
+        failed: 'Turn failed',
+        extra: 'additional steps completed',
+        parallel: 'Running',
+        tools: 'tools in parallel',
+        todos: 'Task checklist',
+        cache: 'cache'
+      };
+
+  let frameIndex = 0;
+  let timer = null;
+  let paused = false;
+  let disposed = false;
+  let answerOpen = false;
+  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));
+
+  function terminalWidth() {
+    return Math.max(24, stdout.columns || 80);
+  }
+
+  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 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 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() {
+    if (timer) clearInterval(timer);
+    timer = null;
+  }
+
+  function refreshLive() {
+    if (!isTTY) return;
+    drawLive();
+    const hasMotion = status || [...slots.values()].some(slot => slot.status === 'running');
+    if (hasMotion) ensureTimer();
+    else stopTimer();
+  }
+
+  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;
+    }
+    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(`${sanitizeUntrustedText(label) || toolTag(tool)}\n`);
+      return;
+    }
+    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);
+  }
+
+  /**
+   * 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 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() {
+    if (answerOpen && !answerEndsWithNewline) write('\n');
+    answerEndsWithNewline = true;
+  }
+
+  function beginAnswer() {
+    if (answerOpen) return;
+    clearLive();
+    stopTimer();
+    status = null;
+    write(`\n${paint('brand', '●')} `);
+    answerOpen = 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) {
+    if (!event || disposed) return;
+    const data = event.data || {};
+
+    if (event.type === 'turn.started') {
+      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
+        ? (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) setStatus(data.label || (data.phase === 'finalizing' ? labels.organizing : labels.analyzing), event.type);
+    } else if (event.type === 'model.retry') {
+      setStatus(data.label || labels.retrying, event.type);
+    } else if (event.type === 'model.delta') {
+      const text = sanitizeUntrustedText(data.text || '');
+      if (!text) return;
+      beginAnswer();
+      const rendered = renderTerminalMarkdown(text, { color: useColor, width: terminalWidth() - 4 });
+      write(rendered);
+      answerEndsWithNewline = rendered.endsWith('\n');
+    } else if (event.type === 'tool.requested') {
+      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') {
+      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}%` : '';
+      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 = data.tool ? '' : (cn ? '工具 · ' : 'Tool · ');
+      closeSlot(data.toolCallId, 'done', `${prefix}${data.displaySummary || data.tool || 'Done'}`, data.tool);
+    } else if (event.type === 'tool.failed') {
+      closeSlot(data.toolCallId, 'failed', data.displaySummary || data.error || data.tool || labels.failed, data.tool);
+    } else if (event.type === 'permission.requested') {
+      clearLive();
+      stopTimer();
+      write(`${paint('warning', symbols.warning)} ${sanitizeUntrustedText(data.displaySummary || 'Confirmation required')}\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', true);
+    } else if (event.type === 'turn.cancelled') {
+      clearLive();
+      stopTimer();
+      finishAnswerLine();
+      commitLine(symbols.warning, data.reason || labels.cancelled, 'warning', true);
+    } else if (event.type === 'turn.completed') {
+      if (phase) phaseDone.add(phase);
+      const finalTodos = todoLines();
+      slots.clear();
+      status = null;
+      todos = [];
+      clearLive();
+      stopTimer();
+      if (isTTY) write('\x1b[?25h');
+      finishAnswerLine();
+      // 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;
+    stopTimer();
+    clearLive();
+    if (isTTY) write('\x1b[?25h');
+  }
+
+  function resume() {
+    if (disposed) return;
+    paused = false;
+    refreshLive();
+  }
+
+  function dispose() {
+    if (disposed) return;
+    clearLive();
+    stopTimer();
+    if (isTTY) write('\x1b[?25h');
+    finishAnswerLine();
+    disposed = true;
+  }
+
+  return { handle, pause, resume, dispose };
+}