@semalt-ai/code 1.19.0 → 1.20.1

package/lib/ui/format.js

@@ -16,8 +16,17 @@
 //   duration  formatDuration(ms), pending lines trail with "…"
 //   meta      type-specific tail — exit codes, byte counts, match counts, …
 
-const { RST, DIM } = require('./ansi');
-const { UI_THEME, UI_ICONS, TOOL_CATEGORIES } = require('./theme');
+const { RST, DIM, SPINNER_DEFS } = require('./ansi');
+const { UI_ICONS, categoryForTag, resolveLineColors, colorEnabled } = require('./theme');
+const { truncateVisible, stripAnsi } = require('./utils');
+
+// Per-frame cadence for the animated running glyph. Matches the single
+// animation driver's base interval (lib/ui/anim.js BASE_INTERVAL_MS) so that,
+// as the driver repaints a running op every ~100 ms with a fresh elapsed time,
+// the derived spinner frame advances by one. Deriving the frame from the
+// elapsed duration (rather than a shared counter) keeps formatToolLine a pure
+// input→string function — no animation state to thread.
+const RUNNING_GLYPH_INTERVAL_MS = 100;
 
 // Adaptive precision. ms < 1s shows "Nms", under a minute shows "N.Ns"
 // (sub-10s) or "Ns", under an hour shows "MmSs", above uses "HhMm". Never
@@ -90,8 +99,8 @@ function _normalizeTag(tag) {
 // operation columns; category names of 5 chars ("shell") fit exactly.
 const CATEGORY_WIDTH = 5;
 
-function _categoryLabel(tag) {
-  const cat = TOOL_CATEGORIES[_normalizeTag(tag)] || 'tool';
+function _categoryLabel(category) {
+  const cat = category || 'tool';
   return cat.length >= CATEGORY_WIDTH ? cat.slice(0, CATEGORY_WIDTH) : cat.padEnd(CATEGORY_WIDTH);
 }
 
@@ -220,10 +229,55 @@ function _metaParts(tag, meta, error) {
       if (meta && typeof meta.bytes === 'number' && meta.bytes >= 0) out.push(formatBytes(meta.bytes));
       if (meta && meta.kind) out.push(meta.kind);
       break;
+    case 'ask_user':
+      // The user's chosen answer, surfaced in scrollback (it was previously only
+      // sent to the model). Truncated so a long option keeps the result line on
+      // one physical row.
+      if (meta && meta.answer != null && String(meta.answer) !== '') {
+        out.push(`→ ${_truncate(String(meta.answer), 40)}`);
+      }
+      break;
   }
   return out;
 }
 
+// Word-wrap `text` to `cols` columns and clamp to `maxLines`, appending a
+// "… N more lines" tail when truncated. Mirrors the permission picker's
+// MAX_DESC_LINES handling (permissions.js) so a long ask_user question can't
+// overflow the modal band. Pure: returns an array of plain (unstyled) lines;
+// the caller applies any colour. An empty/whitespace `text` returns [] so the
+// caller can skip rendering a header entirely.
+function wrapPromptLines(text, opts) {
+  const o = opts || {};
+  const cols = (Number.isInteger(o.cols) && o.cols > 0) ? o.cols : 80;
+  const maxLines = (Number.isInteger(o.maxLines) && o.maxLines > 0) ? o.maxLines : 12;
+  const src = String(text == null ? '' : text);
+  if (!src.trim()) return [];
+  const wrapped = [];
+  for (const para of src.split('\n')) {
+    if (para.trim() === '') { wrapped.push(''); continue; }
+    let line = '';
+    for (const word of para.split(/\s+/).filter(Boolean)) {
+      if (line && (line.length + 1 + word.length) > cols) {
+        wrapped.push(line);
+        line = '';
+      }
+      if (!line && word.length > cols) {
+        // Hard-break a single token longer than the column budget.
+        let w = word;
+        while (w.length > cols) { wrapped.push(w.slice(0, cols)); w = w.slice(cols); }
+        line = w;
+      } else {
+        line = line ? `${line} ${word}` : word;
+      }
+    }
+    if (line) wrapped.push(line);
+  }
+  if (wrapped.length <= maxLines) return wrapped;
+  const hidden = wrapped.length - maxLines;
+  return wrapped.slice(0, maxLines).concat([`… ${hidden} more ${hidden === 1 ? 'line' : 'lines'}`]);
+}
+
 // Build the full styled 4-segment tool line. `status` is one of
 // 'pending' | 'success' | 'failure'. For 'failure', caller may pass an
 // Error-shaped `error` and/or partial `meta` — we format both when
@@ -238,44 +292,55 @@ function formatToolLine(args) {
     meta,
     error,
     noDuration,
+    category,
   } = args || {};
 
+  // Colour is keyed by the descriptor's {category, status} via the single
+  // resolver in theme.js — not re-derived here. Callers going through the
+  // descriptor (render-operation.js) pass `category`; direct callers let us
+  // resolve it from the tag. The glyph CHARACTER stays here (status → '●/✓/✗');
+  // only its colour comes from the resolver.
+  const cat = category || categoryForTag(tag);
+  const colors = resolveLineColors(cat, error ? 'error' : status);
+  const enabled = colorEnabled();
+  const R = enabled ? RST : '';
+
   let glyph;
-  let glyphColor;
   if (status === 'pending') {
-    glyph = UI_ICONS.pending;
-    glyphColor = UI_THEME.muted;
-  } else if (status === 'failure' || error) {
-    glyph = UI_ICONS.error;
-    glyphColor = UI_THEME.error;
-  } else {
-    glyph = UI_ICONS.success;
-    glyphColor = UI_THEME.success;
-  }
-
-  const cat = _categoryLabel(tag);
-  const catColor = (UI_THEME.categories && UI_THEME.categories[_normalizeTag(tag) && (TOOL_CATEGORIES[_normalizeTag(tag)] || 'tool')]) || UI_THEME.accent;
+    if (noDuration) {
+      // Blocking tools (ask_user) render once and freeze — a ticking spinner
+      // would falsely imply work is happening. Keep the static pending dot.
+      glyph = UI_ICONS.pending;
+    } else {
+      // Running op: animate the spinner frames (the `tool` SPINNER_DEF) in the
+      // category-tinted pending colour (colors.glyph). The frame is derived
+      // from the elapsed duration so it advances each time the driver repaints
+      // the row with a fresh elapsedMs — keeping the formatter pure.
+      const frames = SPINNER_DEFS.tool.frames;
+      const idx = Math.floor(Math.max(0, durationMs || 0) / RUNNING_GLYPH_INTERVAL_MS) % frames.length;
+      glyph = frames[idx];
+    }
+  } else if (status === 'failure' || error) glyph = UI_ICONS.error;
+  else glyph = UI_ICONS.success;
 
+  const label = _categoryLabel(cat);
   const op = _operation(tag, arg, attrs);
   const metaParts = _metaParts(tag, meta, error);
 
-  // Segment-by-segment styling. Each fragment carries its own ANSI codes
-  // so the " · " separator — neutral DIM — can sit between them without
-  // leaking the surrounding color into the separator itself.
-  const sep = ` ${DIM}·${RST} `;
-
-  const durColor = status === 'failure' ? UI_THEME.error : UI_THEME.muted;
-  const metaColor = status === 'failure' ? UI_THEME.error : UI_THEME.subtle;
+  // Segment-by-segment styling. Each fragment carries its own ANSI codes so the
+  // " · " separator — neutral DIM — can sit between them without leaking the
+  // surrounding colour. Under NO_COLOR/non-TTY the separator and resets go plain.
+  const sep = enabled ? ` ${DIM}·${R} ` : ' · ';
 
   const segments = [];
-  segments.push(`  ${glyphColor}${glyph}${RST} ${catColor}${cat}${RST}`);
-  segments.push(`${UI_THEME.default}${op}${RST}`);
+  segments.push(`  ${colors.glyph}${glyph}${R} ${colors.label}${label}${R}`);
+  segments.push(`${colors.op}${op}${R}`);
   if (!noDuration) {
     const durStr = formatDuration(durationMs || 0) + (status === 'pending' ? '…' : '');
-    segments.push(`${durColor}${durStr}${RST}`);
+    segments.push(`${colors.dur}${durStr}${R}`);
   }
   for (const m of metaParts) {
-    if (m) segments.push(`${metaColor}${m}${RST}`);
+    if (m) segments.push(`${colors.meta}${m}${R}`);
   }
   return segments.join(sep);
 }
@@ -332,6 +397,79 @@ function summarizeToolResult(content) {
   return trimmed;
 }
 
+// ── Collapsible output preview (Output Refactor — Phase 5) ───────────────────
+//
+// Shell / MCP / subagent output is shown in MODERATION in the chrome: a short
+// preview of the leading lines + an exact `… N more lines` hint.
+// These two helpers are PURE (no IO, no config) so the policy is unit-testable
+// and single-sourced: both the descriptor renderer (render-operation.js) and the
+// live commit path (chat-history.js) drive their preview from here.
+
+// Default preview budget when a caller passes none. Mirrors
+// constants.DEFAULT_SHELL_PREVIEW_LINES; duplicated as a bare fallback so this
+// module stays config-free (the real value flows in from config via the caller).
+const DEFAULT_PREVIEW_LINES = 5;
+
+const _FENCE_OPEN = '<<<UNTRUSTED_EXTERNAL_CONTENT';
+const _FENCE_CLOSE = '<<<END_UNTRUSTED_EXTERNAL_CONTENT>>>';
+
+// Recover the human-facing OUTPUT body from a model-facing tool-result string,
+// stripping the framing the model needs but the user has already seen on the
+// result line above:
+//   - shell:           `Command \`<cmd>\`:\nExit code: <N>\n<body>` → <body>
+//   - MCP / subagent:   `<prefix>:\n<<<UNTRUSTED…>>>\n<content>\n<<<END…>>>` → <content>
+// Pure. Returns '' when there's nothing worth previewing. NOTE: this NEVER feeds
+// the model — it is chrome only; the model receives the full framed result via
+// boundToolOutput, untouched.
+function extractDisplayBody(result) {
+  if (typeof result !== 'string' || !result) return '';
+  let body = result;
+  const shellMatch = result.match(/^Command `[\s\S]*?`:\nExit code: -?\d+\n([\s\S]*)$/);
+  if (shellMatch) body = shellMatch[1];
+  // Strip an untrusted fence (MCP/subagent/web): drop everything up to and
+  // including the fence-open line, and the closing marker. The model-facing
+  // prefix line (before the fence) is dropped with it.
+  const open = body.indexOf(_FENCE_OPEN);
+  if (open !== -1) {
+    const afterOpenNl = body.indexOf('\n', open);
+    const close = body.lastIndexOf(_FENCE_CLOSE);
+    if (afterOpenNl !== -1 && close > afterOpenNl) {
+      body = body.slice(afterOpenNl + 1, close);
+    }
+  }
+  return body.replace(/[ \t\r\n]+$/, '');
+}
+
+// Slice `body` into a single-row-fitted preview. Returns:
+//   { lines, hiddenCount, total, truncatable }
+// where `lines` is what to show (the first `previewLines` when collapsed, ALL
+// when `expanded`), each truncated to one physical row (cols−1), `total` is the
+// line count, `hiddenCount` is EXACTLY total − previewLines when collapsed (0
+// otherwise), and `truncatable` says whether an affordance applies at all.
+// Pure. Trailing blank lines are dropped so they never inflate the count.
+function formatOutputPreview(body, opts) {
+  const o = opts || {};
+  const previewLines = (Number.isInteger(o.previewLines) && o.previewLines > 0) ? o.previewLines : DEFAULT_PREVIEW_LINES;
+  const expanded = !!o.expanded;
+  const cols = (Number.isInteger(o.cols) && o.cols > 0) ? o.cols : 80;
+  const max = Math.max(0, cols - 1);
+  const raw = String(body == null ? '' : body).replace(/[\r\n]+$/, '');
+  const allLines = raw === '' ? [] : raw.split('\n');
+  // A child process's own SGR escapes can ride in `body`. Under NO_COLOR (or
+  // non-TTY) strip them BEFORE truncateVisible so it receives escape-free input
+  // and, by its content-driven gate, appends no reset — leaving the body line
+  // byte-clean. With color on we preserve the captured color (mirrors the
+  // md-stream.js inline() precedent: colorEnabled() ? styled : stripAnsi).
+  const keepColor = colorEnabled();
+  const fitted = allLines.map((l) => truncateVisible(keepColor ? l : stripAnsi(l), max));
+  const total = fitted.length;
+  const truncatable = total > previewLines;
+  if (expanded || !truncatable) {
+    return { lines: fitted, hiddenCount: 0, total, truncatable };
+  }
+  return { lines: fitted.slice(0, previewLines), hiddenCount: total - previewLines, total, truncatable };
+}
+
 module.exports = {
   formatDuration,
   formatBytes,
@@ -339,4 +477,11 @@ module.exports = {
   formatToolLine,
   summarizeToolResult,
   normalizeCmdForDisplay,
+  // The word-boundary-aware single-line truncator (used by the file-activity
+  // summary to fit the basename list to the remaining columns). Exported under a
+  // public name; the internal `_truncate` is otherwise module-private.
+  truncateLine: _truncate,
+  extractDisplayBody,
+  formatOutputPreview,
+  wrapPromptLines,
 };

package/lib/ui/input-field.js

@@ -27,7 +27,7 @@ function parseKeySequence(buf) {
     0x09:'tab', 0x01:'ctrl+a', 0x02:'ctrl+b', 0x05:'ctrl+e',
     0x06:'ctrl+f', 0x07:'ctrl+g', 0x0b:'ctrl+k', 0x0e:'ctrl+n',
     0x10:'ctrl+p', 0x12:'ctrl+r', 0x14:'ctrl+t', 0x15:'ctrl+u',
-    0x17:'ctrl+w', 0x0c:'ctrl+l', 0x03:'ctrl+c', 0x04:'ctrl+d', 0x0f:'ctrl+o',
+    0x17:'ctrl+w', 0x0c:'ctrl+l', 0x03:'ctrl+c', 0x04:'ctrl+d',
   };
   if (SINGLE[b0]) return { key: SINGLE[b0], len: 1 };
 
@@ -201,6 +201,10 @@ class InputField extends EventEmitter {
     this._render();
   }
   getValue() { return this._chars.join(''); }
+  // True once the field has settled into its idle state (the one-shot _goIdle
+  // fired) and not since reactivated. Lets startup re-sync the status-bar clock
+  // to the field's real idle state after an await may have fired _goIdle early.
+  isIdle() { return this._idle; }
   onSubmit(cb) { this.on('submit', cb); }
 
   captureSelect(menu) {
@@ -800,7 +804,6 @@ class InputField extends EventEmitter {
       case 'ctrl+t':       this._transposeChars(); this._render(); break;
       case 'ctrl+l':       this._chatHistory.clearMessages(); break;
       case 'ctrl+r':       this._enterSearchMode(); break;
-      case 'ctrl+o':       if (this._navCapture) this._navCapture('expand'); else this.emit('expand'); break;
       case 'ctrl+g':       this.emit('interrupt'); break;
       case 'ctrl+c':       this._onCtrlC(); break;
       case 'ctrl+d':       this._onCtrlD(); break;
@@ -905,8 +908,6 @@ class InputField extends EventEmitter {
         this.emit('abort');
       } else if (buf[0] === 0x04) {
         // Ctrl+D while agent active: ignored (bash readline semantics).
-      } else if (buf[0] === 0x0f) {
-        this.emit('expand');
       } else if (buf[0] === 0x1b && buf.length === 1) {
         // Bare ESC while agent is running: buffer and confirm after 20ms so that
         // escape sequences (arrow keys, etc.) arriving as separate bytes are ignored.

package/lib/ui/md-stream.js

@@ -0,0 +1,234 @@
+'use strict';
+
+// Stateful, line-at-a-time Markdown → ANSI styler for the interactive TUI's
+// agent narration. It COMPOSES the existing hand-rolled helpers rather than
+// reinventing them (zero-dep invariant #13):
+//   - diff.js  `_mdInline`        — inline bold/italic/code span styler
+//   - diff.js  `_truncateByWidth` — plain-text width truncation (code bodies)
+//   - stream.js `colorizeCode`    — per-line code syntax highlight
+//   - theme.js `colorEnabled`     — the single NO_COLOR + non-TTY gate
+//   - theme/ansi palette          — FG_CODE_BG/BORDER/LANG, RST, EL, BOLD, DIM
+//
+// It is fed COMPLETE lines (the caller splits the token stream on '\n'); inline
+// spans are therefore always line-complete and never strand an open SGR across
+// calls. The only cross-line state is the fenced-code-block buffer: while a
+// ``` block is open, body lines are buffered and the whole width-aware code box
+// is emitted at the closing fence. `flush()` closes a still-open fence cleanly.
+//
+// Both the live streaming path AND the --resume / history replay path drive the
+// SAME implementation (see `renderBlock`), so a replayed turn is byte-identical
+// to the live one.
+
+const { colorEnabled, FG_CODE_BG, FG_CODE_BORDER, FG_CODE_LANG, THEME } = require('./theme');
+const { RST, EL, BOLD, DIM } = require('./ansi');
+const { _mdInline, _truncateByWidth } = require('./diff');
+const { colorizeCode } = require('./stream');
+const { getCols, repeatToWidth, termWidth, stripAnsi } = require('./utils');
+
+// Gate a raw SGR code through the single NO_COLOR/non-TTY switch.
+function c(code) { return colorEnabled() ? code : ''; }
+
+// Inline span styler, color-gated. Reuses diff.js `_mdInline`; under NO_COLOR we
+// strip the SGR it injects, which also drops the `**`/`*`/`` ` `` markers, so the
+// plain output reads as clean prose with no escape codes.
+function inline(text) {
+  const styled = _mdInline(text);
+  return colorEnabled() ? styled : stripAnsi(styled);
+}
+
+class StreamMarkdown {
+  constructor(opts) {
+    const o = opts || {};
+    // Leading indent every emitted line carries (matches the 2-space narration
+    // gutter the AI bubble used before styling).
+    this.indent = o.indent != null ? String(o.indent) : '  ';
+    this.reset();
+  }
+
+  // Drop all per-turn state. Called between turns so a fresh turn never inherits
+  // an open fence or buffered body from the previous one.
+  reset() {
+    this.inCodeBlock = false;
+    this.codeLang = '';
+    this._codeBuf = [];
+  }
+
+  // Style a COMPLETE line. Returns the styled string to commit (no trailing
+  // newline — the caller appends one), or null when there is nothing to emit yet
+  // (a buffered code-block body line, or the opening ``` fence). A code block's
+  // box is returned in full when its closing ``` arrives.
+  feedLine(line) {
+    if (this.inCodeBlock) {
+      if (line.trim() === '```') {
+        const box = this._renderCodeBox();
+        this.inCodeBlock = false;
+        this.codeLang = '';
+        this._codeBuf = [];
+        return box;
+      }
+      this._codeBuf.push(line);
+      return null;
+    }
+    if (line.length >= 3 && line[0] === '`' && line[1] === '`' && line[2] === '`') {
+      this.inCodeBlock = true;
+      this.codeLang = line.slice(3).trim();
+      this._codeBuf = [];
+      return null;
+    }
+    return this._renderProse(line);
+  }
+
+  // Close any open state and return the styled remainder. If a fenced block is
+  // still buffering (no closing ```), emit the buffered body as a finished box so
+  // scrollback never strands an unclosed fence or a leaked SGR. Returns null when
+  // there is nothing pending.
+  flush() {
+    if (this.inCodeBlock) {
+      const box = this._renderCodeBox();
+      this.inCodeBlock = false;
+      this.codeLang = '';
+      this._codeBuf = [];
+      return box;
+    }
+    return null;
+  }
+
+  // Style one prose/heading/list/blockquote/rule line. Mirrors diff.js
+  // `renderMarkdown`'s block grammar, but every SGR routes through `c()` and the
+  // configured indent prefixes each line. Always ends with a reset so no ANSI
+  // bleeds into the next immutable scrollback line.
+  _renderProse(line) {
+    const ind = this.indent;
+    const barW = Math.max(1, getCols() - ind.length);
+    const trimmed = line.trim();
+
+    if (trimmed === '') return ind;
+
+    // Horizontal rule.
+    if (trimmed === '---' || trimmed === '===') {
+      return ind + c(THEME.dim) + '─'.repeat(barW) + c(RST);
+    }
+
+    // ATX heading (levels 1–3), optionally underlined like renderMarkdown.
+    let level = 0;
+    while (level < line.length && line[level] === '#') level++;
+    if (level >= 1 && level <= 3 && level < line.length && line[level] === ' ') {
+      const htext = line.slice(level + 1);
+      if (level === 1) {
+        return ind + c(THEME.agent) + c(BOLD) + htext + c(RST)
+             + '\n' + ind + c(THEME.dim) + '═'.repeat(barW) + c(RST);
+      }
+      if (level === 2) {
+        return ind + c(BOLD) + htext + c(RST)
+             + '\n' + ind + c(THEME.dim) + '─'.repeat(barW) + c(RST);
+      }
+      return ind + c(BOLD) + htext + c(RST);
+    }
+
+    // Blockquote.
+    if (line[0] === '>') {
+      const inner = line.length > 1 && line[1] === ' ' ? line.slice(2) : line.slice(1);
+      return ind + c(THEME.tool) + '│' + c(RST) + ' ' + inline(inner) + c(RST);
+    }
+
+    // Unordered list item (with simple nesting by leading-space depth).
+    let lead = 0;
+    while (lead < line.length && line[lead] === ' ') lead++;
+    const rest = line.slice(lead);
+    if (rest.length > 2 && (rest[0] === '-' || rest[0] === '*') && rest[1] === ' ') {
+      const nest = '  '.repeat(Math.floor(lead / 2));
+      return ind + nest + c(THEME.agent) + '❯' + c(RST) + ' ' + inline(rest.slice(2)) + c(RST);
+    }
+
+    // Ordered list item.
+    let ni = 0;
+    while (ni < line.length && line[ni] >= '0' && line[ni] <= '9') ni++;
+    if (ni > 0 && ni < line.length - 1 && line[ni] === '.' && line[ni + 1] === ' ') {
+      return ind + c(THEME.dim) + line.slice(0, ni) + '.' + c(RST) + ' ' + inline(line.slice(ni + 2)) + c(RST);
+    }
+
+    // Plain prose.
+    return ind + inline(line) + c(RST);
+  }
+
+  // Render the buffered code-block body as a width-aware box: a top border with
+  // the language label, syntax-highlighted body lines whose background fills to
+  // the physical right edge via EL (the diff.js technique), and a bottom border.
+  // The body is capped at the existing `max_output_lines` config (no new limit).
+  _renderCodeBox() {
+    const ind = this.indent;
+    const cols = getCols();
+    const { loadConfig } = require('../config');
+    const maxLines = (loadConfig().max_output_lines) || 50;
+
+    let body = this._codeBuf;
+    let overflow = 0;
+    if (body.length > maxLines) {
+      overflow = body.length - maxLines;
+      body = body.slice(0, maxLines);
+    }
+
+    const lines = [];
+
+    // Top border with language label, reaching the current width.
+    const label = this.codeLang ? ` ${this.codeLang} ` : '';
+    const prefix = '╭─── ';
+    const used = ind.length + termWidth(prefix) + termWidth(label);
+    const topFill = repeatToWidth('─', cols, used);
+    lines.push(
+      ind + c(FG_CODE_BORDER) + prefix + c(RST)
+          + c(FG_CODE_LANG) + label + c(RST)
+          + c(FG_CODE_BORDER) + topFill + c(RST)
+    );
+
+    // Body. Truncate the PLAIN text to the code width first (diff.js order), THEN
+    // colorize, so the syntax spans never get cut mid-escape; EL then fills the
+    // background to the edge.
+    const CODE_W = Math.max(1, cols - (ind.length + 2)); // │ + space
+    for (const raw of body) {
+      const disp = (raw || '').replace(/\t/g, '  ');
+      const code = _truncateByWidth(disp, CODE_W);
+      const colored = colorEnabled() ? colorizeCode(code) : code;
+      lines.push(
+        ind + c(FG_CODE_BORDER) + '│' + c(RST) + ' '
+            + c(FG_CODE_BG) + colored + c(EL) + c(RST)
+      );
+    }
+
+    if (overflow > 0) {
+      lines.push(ind + c(DIM) + `[... ${overflow} more lines]` + c(RST));
+    }
+
+    // Bottom border.
+    const botFill = repeatToWidth('─', cols, ind.length + 1);
+    lines.push(ind + c(FG_CODE_BORDER) + '╰' + botFill + c(RST));
+
+    return lines.join('\n');
+  }
+}
+
+// Render a complete stored content block through a fresh StreamMarkdown, line by
+// line, EXACTLY as the live path does: feed every line but the last via
+// feedLine; feed the trailing line only when non-empty (the live partial path
+// skips an empty partial); then flush. Returns the joined styled body with NO
+// trailing newline. This is the single seam that keeps --resume / history replay
+// byte-identical to live narration.
+function renderBlock(content, opts) {
+  const md = new StreamMarkdown(opts);
+  const lines = String(content == null ? '' : content).split('\n');
+  const partial = lines.pop();
+  const out = [];
+  for (const line of lines) {
+    const s = md.feedLine(line);
+    if (s !== null) out.push(s);
+  }
+  if (partial !== '') {
+    const s = md.feedLine(partial);
+    if (s !== null) out.push(s);
+  }
+  const tail = md.flush();
+  if (tail !== null) out.push(tail);
+  return out.join('\n');
+}
+
+module.exports = { StreamMarkdown, renderBlock };

package/lib/ui/render-operation.js

@@ -0,0 +1,113 @@
+'use strict';
+
+// Pure renderer for a ToolOperation descriptor (Output Refactor — Phase 1).
+//
+// `renderOperation(descriptor, { mode, phase, maxLines })` → the string for that
+// phase/mode. This is the SINGLE place a tool-call's chrome line is assembled
+// for the interactive path; chat-turn.js builds a descriptor and calls here
+// instead of assembling formatToolLine arguments inline.
+//
+// Phase 1 is a re-routing, not a re-styling: the renderer internally reuses the
+// existing `formatToolLine` (glyph/category/operation/meta assembly) and
+// `buildExecutionDiff` (diff body), so its output is byte-for-byte identical to
+// today's. Do NOT change glyphs, spacing, colours, or wording here — equivalence
+// with the old formatters is the phase's pass/fail.
+//
+// modes:  'ansi'  (interactive) — assembles the chrome line via formatToolLine.
+//         'json'  (Phase 6d-i) — the pure embeddable per-operation object built
+//                 from the shared `operationCore` (descriptor-native names, no
+//                 ANSI/IO/framing); a superset-or-equal of serializeOperation's
+//                 persistable core, minus the `v` persistence tag.
+//         'event' (Phase 6d-i) — the json object plus the `phase` it rendered
+//                 for, for a single per-lifecycle emission. Headless (6d-ii)
+//                 owns any NDJSON envelope / `type` tag around it.
+// phases: 'pending' — the live activity line (with growing timer)
+//         'result'  — the committed final line
+//         'detail'  — the collapsible body (Phase 5): a file-edit diff (expanded
+//                     to maxLines) or a shell/MCP/subagent output preview
+//                     (previewLines + `… N more lines`). Errors carry no detail
+//                     (expanded elsewhere).
+
+const { formatToolLine, formatOutputPreview } = require('./format');
+const { buildExecutionDiff } = require('./diff');
+const { operationCore } = require('./tool-operation');
+
+// Map the descriptor's status vocabulary back to formatToolLine's.
+function _formatStatus(descriptor, phase) {
+  if (phase === 'pending') return 'pending';
+  return descriptor.status === 'error' ? 'failure' : 'success';
+}
+
+// Reconstruct the formatToolLine argument bag from the descriptor. Phase 1
+// guarantees identical output by feeding the same fields the old call sites did.
+function _toolLineArgs(descriptor, phase) {
+  return {
+    status: _formatStatus(descriptor, phase),
+    // Colour is resolved from the descriptor's category (Phase 2.5): the
+    // renderer hands formatToolLine the already-resolved category so colour is
+    // the renderer's job, keyed by the descriptor, not re-derived from the tag.
+    category: descriptor.category,
+    tag: descriptor.tag,
+    arg: descriptor.target,
+    attrs: descriptor.attrs,
+    durationMs: descriptor.durationMs == null ? 0 : descriptor.durationMs,
+    meta: phase === 'pending' ? null : descriptor.meta,
+    error: phase === 'pending' ? null : descriptor.error,
+    noDuration: descriptor.noDuration,
+  };
+}
+
+function _renderAnsi(descriptor, opts) {
+  const phase = opts.phase || 'result';
+  if (phase === 'detail') {
+    // The detail body, COLLAPSED per the Phase 5 policy (keyed by detail-kind):
+    //   - diff   → the file-edit diff, EXPANDED to maxLines (unchanged).
+    //   - output → a shell_preview_lines preview + `… N more lines`. (Errors
+    //              carry no detail — the error body renders expanded on the
+    //              chat-history path.)
+    const detail = descriptor.detail;
+    if (!detail) return '';
+    if (detail.kind === 'diff') {
+      const diffStr = buildExecutionDiff({ diff: detail.payload, maxLines: opts.maxLines });
+      return diffStr || '';
+    }
+    if (detail.kind === 'output') {
+      const { lines, hiddenCount } = formatOutputPreview(detail.payload.body, {
+        previewLines: opts.previewLines,
+        cols: opts.cols,
+      });
+      const out = lines.slice();
+      if (hiddenCount > 0) {
+        out.push(`… ${hiddenCount} more ${hiddenCount === 1 ? 'line' : 'lines'}`);
+      }
+      return out.join('\n');
+    }
+    return '';
+  }
+  return formatToolLine(_toolLineArgs(descriptor, phase));
+}
+
+function renderOperation(descriptor, opts) {
+  if (!descriptor) return '';
+  const o = opts || {};
+  const mode = o.mode || 'ansi';
+  if (mode === 'ansi') return _renderAnsi(descriptor, o);
+  // json/event are PURE structured-data modes (Phase 6d-i): no ANSI, no IO, no
+  // framing. Both derive ONLY from the shared `operationCore` mapping — the same
+  // one `serializeOperation` uses — so there is exactly one descriptor→data
+  // serializer in the codebase.
+  //   - json : the embeddable per-operation object (descriptor-native field
+  //            names; the persistable core WITHOUT the `v` persistence tag).
+  //   - event: the same data shaped for a single per-lifecycle emission — the
+  //            json object plus the `phase` it was rendered for. The consumer
+  //            (headless, Phase 6d-ii) owns any envelope/`type` framing.
+  if (mode === 'json') return operationCore(descriptor);
+  if (mode === 'event') {
+    const core = operationCore(descriptor);
+    return core && { ...core, phase: o.phase || 'result' };
+  }
+  // unknown mode — degrade to empty string (never throw).
+  return '';
+}
+
+module.exports = { renderOperation };

package/lib/ui/select.js

@@ -11,7 +11,7 @@ const writer = require('./writer');
 // Two input paths:
 //   * TUI:     opts.captureNavigation(handler) → release fn. Mirrors the
 //              permission picker. The host (input-field) routes prev/next/
-//              select/cancel/expand actions to handler; release detaches.
+//              select/cancel actions to handler; release detaches.
 //   * Non-TUI: direct raw stdin. Used by cmdModels and the permission-
 //              prompt fallback in non-chat command flows.
 //
@@ -59,8 +59,6 @@ async function interactiveSelect(items, renderItem, options) {
           writer.clearModal();
           if (typeof releaseNav === 'function') releaseNav();
           resolve(action === 'select' ? idx : null);
-        } else if (action === 'expand') {
-          if (typeof opts.onExpand === 'function') opts.onExpand();
         }
       });
     });
@@ -93,7 +91,6 @@ async function interactiveSelect(items, renderItem, options) {
     const onData = (chunk) => {
       if (done) return;
       const data = chunk.toString('utf8');
-      if (data[0] === '\x0f') { if (typeof opts.onExpand === 'function') opts.onExpand(); return; }
       if (data === '\x03' || data === '\x1b' || data === 'q') { finish(null); return; }
       if (data === '\r' || data === '\n') { finish(idx); return; }
       if (data === '\x1b[A' || data === 'k') {