@semalt-ai/code 1.8.5 → 1.20.0

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);
 }
 
@@ -153,7 +162,28 @@ function _operation(tag, arg, attrs) {
     case 'recall_memory':    return _truncate(`recall ${a.key || arg || ''}`, max);
     case 'list_memories':    return 'list memories';
     case 'system_info':      return 'system info';
-    default:                 return _truncate(arg ? `${tag} ${arg}` : tag, max);
+    default:
+      if (_normalizeTag(tag).startsWith('git_')) return _truncate(_gitOperation(_normalizeTag(tag), a), max);
+      // arg may be a structured options object for newer tools — avoid rendering
+      // "[object Object]" by only appending string/number args.
+      return _truncate((arg && typeof arg !== 'object') ? `${tag} ${arg}` : tag, max);
+  }
+}
+
+// Human-readable one-liner for the native git tools (Task 5.1). `a` is the
+// options object (attrs) carried by the call.
+function _gitOperation(tag, a) {
+  const paths = Array.isArray(a.paths) ? a.paths.join(' ') : (a.paths || '');
+  switch (tag) {
+    case 'git_status':   return 'git status';
+    case 'git_diff':     return `git diff${a.staged ? ' --staged' : ''}${a.path ? ' ' + a.path : ''}`;
+    case 'git_log':      return `git log${a.count ? ' -n ' + a.count : ''}${a.path ? ' ' + a.path : ''}`;
+    case 'git_add':      return `git add ${a.all ? '-A' : paths}`.trim();
+    case 'git_commit':   return `git commit${a.all ? ' -a' : ''} -m "${normalizeCmdForDisplay(a.message || '')}"`;
+    case 'git_branch':   return a.name ? `git branch ${a.delete ? '-d ' : ''}${a.name}` : 'git branch';
+    case 'git_checkout': return `git checkout ${a.create ? '-b ' : ''}${a.name || ''}`.trim();
+    case 'git_worktree': return `git worktree ${a.op || 'list'}${a.path ? ' ' + a.path : ''}`;
+    default:             return tag;
   }
 }
 
@@ -199,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
@@ -217,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);
 }
@@ -311,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,
@@ -318,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

@@ -7,10 +7,13 @@ const { RST, DIM, FG_CYAN, FG_GREEN, FG_YELLOW } = require('./ansi');
 const { stripAnsi, termWidth } = require('./utils');
 const writer = require('./writer');
 
-const SLASH_CMDS = [
-  '/help','/file','/new','/model','/models','/shell','/compact',
-  '/clear','/approve','/debug','/config','/history','/login','/whoami','/logout','/chats',
-];
+// Tab-completion command list is generated from the slash-command registry —
+// the single source of truth — so it can never drift from the dispatcher.
+// Resolved LIVE (not snapshotted at load) so commands registered after this
+// module loads — notably the Markdown custom commands discovered at chat
+// startup (Task 3.1) — appear in completion. The exported `SLASH_CMDS` is kept
+// for back-compat (since 1.3) but backed by the same live getter.
+const { completionNames } = require('../commands/registry');
 
 // ─── Key sequence parser ──────────────────────────────────────────────────────
 
@@ -24,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 };
 
@@ -198,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) {
@@ -571,7 +578,7 @@ class InputField extends EventEmitter {
       sources.push({ type: 'history', text });
     for (const item of this._searchExtraItems)
       sources.push(item);
-    for (const cmd of SLASH_CMDS)
+    for (const cmd of completionNames())
       sources.push({ type: 'command', text: cmd });
     return sources;
   }
@@ -635,7 +642,7 @@ class InputField extends EventEmitter {
     }
 
     if (!val.startsWith('/')) return;
-    const matches = SLASH_CMDS.filter(c => c.startsWith(val));
+    const matches = completionNames().filter(c => c.startsWith(val));
     if (!matches.length) return;
     if (matches.length === 1) {
       this._setValue(matches[0] + ' ');
@@ -797,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;
@@ -902,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.
@@ -1266,4 +1270,10 @@ class InputField extends EventEmitter {
   }
 }
 
-module.exports = { InputField, parseKeySequence, SLASH_CMDS };
+module.exports = { InputField, parseKeySequence };
+// SLASH_CMDS kept for back-compat (since 1.3), but now a live getter so callers
+// reading it after custom-command registration see the current set.
+Object.defineProperty(module.exports, 'SLASH_CMDS', {
+  enumerable: true,
+  get() { return completionNames(); },
+});

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