@bahulam/code 2.6.14 → 2.6.16

package/src/terminal/repl-model-form.mjs

@@ -0,0 +1,132 @@
+/**
+ * Interactive per-role model form for /model (PRD-076 W7).
+ *
+ * ↑↓ picks a role row, ←→ cycles through [backend default] + the curated
+ * platform catalog for that role, Enter applies to session overrides,
+ * c resets every row to default, Esc cancels. Same raw-stdin overlay
+ * pattern as the resume picker (repl-resume.mjs): pause readline, raw
+ * mode on, redraw in place with cursor-up + erase-down, restore on exit.
+ */
+
+import { c } from './ansi.mjs';
+import { fitAnsiLine, writeOverlayFrame, eraseOverlayFrame } from './repl-format.mjs';
+
+const DEFAULT_SENTINEL = '__default__';
+
+function creditBadge(row) {
+  const usd = Number(row?.input_cost_usd_per_m);
+  if (!Number.isFinite(usd) || usd <= 0) return '';
+  const credits = usd * 200; // credits = provider cost × 2 × 100/USD
+  return `~${credits < 10 ? credits.toFixed(1) : String(Math.round(credits))} cr/M`;
+}
+
+/**
+ * @param {object} opts
+ * @param {object|null} opts.rl        readline instance to pause/resume
+ * @param {Array}  opts.roles          [{ role, label, current, defaultLabel }]
+ * @param {Array}  opts.catalog        raw /api/models rows (may be empty)
+ * @param {Array}  [opts.fallbackIds]  model ids to cycle when no curated catalog
+ * @param {string} [opts.unavailableNote] why the catalog is missing (shown in header)
+ * @returns {Promise<{overrides: Record<string,string>}|null>} null = cancelled
+ */
+export async function pickModelOverridesForm({ rl, roles, catalog, fallbackIds, unavailableNote }) {
+  if (!process.stdin.isTTY) return null;
+  if (rl) rl.pause();
+
+  const curated = (catalog || []).filter(m => m?.harness_validated && m?.id);
+  const usingFallback = curated.length === 0;
+  const optionIds = usingFallback
+    ? [...new Set((fallbackIds || []).filter(Boolean))]
+    : curated.map(m => m.id);
+  const baseOptions = [DEFAULT_SENTINEL, ...optionIds];
+  const byId = new Map(curated.map(m => [m.id, m]));
+
+  // Per-row option list; a current override that isn't in the curated list
+  // is appended so it stays visible and selectable.
+  const rows = roles.map(r => {
+    let opts = baseOptions;
+    let idx = 0;
+    if (r.current) {
+      const found = baseOptions.indexOf(r.current);
+      if (found >= 0) {
+        idx = found;
+      } else {
+        opts = [...baseOptions, r.current];
+        idx = opts.length - 1;
+      }
+    }
+    return { ...r, opts, idx };
+  });
+
+  return await new Promise((resolve) => {
+    const wasRaw = process.stdin.isRaw;
+    let cursor = 0;
+    let renderedLines = 0;
+
+    const valueLabel = (row) => {
+      const value = row.opts[row.idx];
+      if (value === DEFAULT_SENTINEL) {
+        return c.dim(row.defaultLabel ? `default · ${row.defaultLabel}` : 'backend default');
+      }
+      const meta = byId.get(value);
+      const badge = meta ? creditBadge(meta) : '';
+      // Only flag uncurated picks when a curated catalog actually loaded —
+      // in fallback mode every option is a known backend model, not a stray.
+      const flag = meta || usingFallback ? '' : c.yellow(' (uncurated)');
+      return `${c.brand(value)}${badge ? ` ${c.dim(badge)}` : ''}${flag}`;
+    };
+
+    const render = () => {
+      const cols = Math.max(60, process.stderr.columns || 120);
+      const lines = [];
+      lines.push(`  ${c.bold('Models')} ${c.dim('· session overrides · curated platform catalog')}`);
+      if (usingFallback) {
+        const why = unavailableNote ? ` — ${unavailableNote}` : '';
+        lines.push(`  ${c.yellow('!')} ${c.dim(`catalog unavailable${why}; showing this session's backend models`)}`);
+      }
+      lines.push('');
+      rows.forEach((row, i) => {
+        const marker = i === cursor ? c.brand('▸') : ' ';
+        const rawLabel = String(row.label || row.role).padEnd(14, ' ');
+        const label = i === cursor ? c.brand(rawLabel) : rawLabel;
+        lines.push(fitAnsiLine(`  ${marker} ${label} ${c.dim('‹')} ${valueLabel(row)} ${c.dim('›')}`, cols - 1));
+      });
+      lines.push('');
+      lines.push(fitAnsiLine(`  ${c.dim('↑↓ role · ←→ model · Enter apply · c defaults · Esc cancel')}`, cols - 1));
+      writeOverlayFrame(renderedLines, lines);
+      renderedLines = lines.length;
+    };
+
+    const cleanup = (value) => {
+      process.stdin.removeListener('data', onData);
+      process.stdin.setRawMode(wasRaw || false);
+      eraseOverlayFrame(renderedLines);
+      if (rl) rl.resume();
+      resolve(value);
+    };
+
+    const onData = (data) => {
+      const key = data.toString('utf8');
+      if (key === '\x1b' || key === '\x03' || key === 'q') { cleanup(null); return; }
+      if (key === '\r' || key === '\n') {
+        const overrides = {};
+        for (const row of rows) {
+          const value = row.opts[row.idx];
+          if (value && value !== DEFAULT_SENTINEL) overrides[row.role] = value;
+        }
+        cleanup({ overrides });
+        return;
+      }
+      if (key === 'c' || key === 'C') { rows.forEach(r => { r.idx = 0; }); render(); return; }
+      if (key === '\x1b[A') { cursor = Math.max(0, cursor - 1); render(); return; }
+      if (key === '\x1b[B') { cursor = Math.min(rows.length - 1, cursor + 1); render(); return; }
+      if (key === '\x1b[D') { const r = rows[cursor]; r.idx = (r.idx - 1 + r.opts.length) % r.opts.length; render(); return; }
+      if (key === '\x1b[C') { const r = rows[cursor]; r.idx = (r.idx + 1) % r.opts.length; render(); return; }
+    };
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on('data', onData);
+    render();
+  });
+}

package/src/terminal/repl-render.mjs

@@ -27,6 +27,51 @@ import {
   isInputDockMounted,
   moveToContent,
 } from '../ui/input-dock.mjs';
+import * as queue from '../ui/render-queue.mjs';
+
+// Single seam for the transient spinner/status line. Rich mode (render
+// queue active) → coalesced last-wins status that can never interleave
+// with content. Legacy dock path and bare-TTY inPlace stay as fallbacks
+// until their write-sites migrate onto the queue too.
+// Max inner-tool lines shown under the spinner during a sub-agent run.
+const SUB_AGENT_WINDOW_ROWS = 7;
+
+function presentStatus(rendered) {
+  if (queue.isActive()) {
+    const win = runtime.subAgentWindow;
+    if (win?.active && win.lines.length) {
+      queue.statusBlock([
+        rendered,
+        ...win.lines.slice(-SUB_AGENT_WINDOW_ROWS).map(l => `    ${c.dim(l)}`),
+      ]);
+      return;
+    }
+    queue.status(rendered);
+    return;
+  }
+  if (isInputDockMounted()) { drawPinnedStatus(rendered); return; }
+  inPlace(rendered);
+}
+
+/** Push a line into the live sub-agent tool window (dedup consecutive). */
+export function pushSubAgentWindowLine(line) {
+  const win = runtime.subAgentWindow;
+  if (!win?.active) return;
+  const text = String(line || '').trim();
+  if (!text || win.lines[win.lines.length - 1] === text) return;
+  win.lines.push(text);
+  if (win.lines.length > 24) win.lines.splice(0, win.lines.length - 24);
+}
+
+export function setSubAgentWindowActive(active) {
+  runtime.subAgentWindow = { active: Boolean(active), lines: [] };
+}
+
+function erasePresentedStatus() {
+  if (queue.isActive()) { queue.clearStatus(); return; }
+  if (isInputDockMounted()) { clearPinnedStatus(); moveToContent(); return; }
+  inPlace('');
+}
 import {
   formatCardHead,
   formatCompactFileDiff,
@@ -157,11 +202,11 @@ export function renderExploreRun() {
   // picks up exploreSummary() text instead of any stale label.
   runtime.exploreRun.lineActive = true;
 
-  if (isInputDockMounted()) {
-    // Docked terminals reserve a bottom input area. Keeping explore progress
-    // as an animated bottom overlay creates visible gaps between the sub-agent
-    // transcript and the current tool. Emit bounded snapshots into the
-    // transcript instead; every hidden call remains available through /expand.
+  if (!queue.isActive() && isInputDockMounted()) {
+    // Legacy docked path (queue not engaged): an animated bottom overlay
+    // created visible gaps, so emit bounded snapshots into the transcript
+    // instead. With the render queue active this branch is skipped — the
+    // coalesced status line can animate safely in dock mode.
     if (runtime.spinInterval) {
       clearInterval(runtime.spinInterval);
       runtime.spinInterval = null;
@@ -183,8 +228,7 @@ export function renderExploreRun() {
       const frame = SPIN_FRAMES[runtime.spinFrame % SPIN_FRAMES.length];
       runtime.spinFrame++;
       const rendered = `  ${c.brand(frame)} ${c.dim(label)}`;
-      if (isInputDockMounted()) moveToContent();
-      inPlace(rendered);
+      presentStatus(rendered);
     }, 80);
   }
   runtime.lastRenderedBlock = 'tool';
@@ -200,9 +244,10 @@ export function flushExploreRun() {
     if (wasActive) {
       if (runtime.spinInterval) { clearInterval(runtime.spinInterval); runtime.spinInterval = null; }
       runtime.spinText = '';
-      if (!isInputDockMounted()) inPlace('');
+      if (queue.isActive()) queue.clearStatus();
+      else if (!isInputDockMounted()) inPlace('');
     }
-    if (!isInputDockMounted() || summary !== runtime.exploreRun.lastPrintedSummary) {
+    if (queue.isActive() || !isInputDockMounted() || summary !== runtime.exploreRun.lastPrintedSummary) {
       writeExploreSnapshot(summary);
     }
   }
@@ -238,6 +283,17 @@ export function renderToolCall(data) {
     return;
   }
 
+  // Sub-agent live window (queue mode): inner tool calls stream into the
+  // fixed-height status block instead of appending transcript lines. The
+  // card is still recorded so /expand, /last, and `d` show full detail.
+  if (queue.isActive() && runtime.subAgentWindow?.active && inSubAgentBlock()) {
+    recordCard({ id: callId, tool, args, startedAt: Date.now() });
+    session.toolCounts[tool] = (session.toolCounts[tool] || 0) + 1;
+    const label = readToolLabel(tool, { args });
+    pushSubAgentWindowLine(label ? `→ ${tool} · ${label}` : `→ ${tool}`);
+    return; // the spinner tick paints the window block
+  }
+
   flushExploreRun();
   renderBlockBoundary('tool', { compactSame: tool !== 'shell' });
 
@@ -251,8 +307,12 @@ export function renderToolCall(data) {
   session.toolCounts[tool] = (session.toolCounts[tool] || 0) + 1;
   runtime.pendingHead = { callId, head, indent };
   runtime.lastRenderedBlock = 'tool';
-  // Spinner shows what's running until the result arrives.
-  startSpinner(`${tool}…`);
+  // Spinner shows what's running until the result arrives. Per-call phase
+  // gives each tool its own elapsed clock — long shell runs count up live.
+  const spinLabel = tool === 'shell' && args.command
+    ? `shell: ${String(args.command).split('\n')[0].slice(0, 48)}`
+    : `${tool}…`;
+  startSpinner(spinLabel, { phase: `tool:${callId}` });
 }
 
 /**
@@ -279,6 +339,7 @@ export function renderToolResult(data, eventType = 'tool_result') {
   const tool = data.tool || data._tool || '';
   const durationMs = data?.duration_ms ?? (data?.duration_s != null ? data.duration_s * 1000 : null);
   recordReadActivity(tool, data.args || {});
+  recordWriteActivity(tool, data.args || {}, data);
 
   // Update the card buffer so /last and `d` can find it.
   if (callId) recordCard({ id: callId, tool, args: data.args, result: data, durationMs });
@@ -315,6 +376,12 @@ export function renderToolResult(data, eventType = 'tool_result') {
     return;
   }
 
+  // Sub-agent live window: the call line is already streaming in the
+  // status block; the result stays card-only (close card summarizes).
+  if (queue.isActive() && runtime.subAgentWindow?.active && inSubAgentBlock()) {
+    return;
+  }
+
   // ── Single-line combined emit ──
   // If the head for this call is still buffered (no interleaving content
   // landed), and the combined line fits the terminal width, emit ONE line
@@ -324,7 +391,11 @@ export function renderToolResult(data, eventType = 'tool_result') {
     const combined = `${runtime.pendingHead.head}  ${outcome}`;
     if (stripAnsi(combined).length <= cols) {
       process.stderr.write(`${combined}\n`);
-      if (diffPreview) process.stderr.write(`${diffPreview}\n`);
+      if (diffPreview) {
+        process.stderr.write(`${diffPreview}\n`);
+        rememberFileDiffPreview(data);
+      }
+      renderPlanBody(tool, data);
       runtime.lastRenderedBlock = 'tool';
       runtime.pendingHead = null;
       return;
@@ -332,7 +403,11 @@ export function renderToolResult(data, eventType = 'tool_result') {
     if (isInlineOutcomeTool(tool)) {
       const compactHead = compactHeadForOutcome(runtime.pendingHead.head, outcome, cols);
       process.stderr.write(`${compactHead}  ${outcome}\n`);
-      if (diffPreview) process.stderr.write(`${diffPreview}\n`);
+      if (diffPreview) {
+        process.stderr.write(`${diffPreview}\n`);
+        rememberFileDiffPreview(data);
+      }
+      renderPlanBody(tool, data);
       runtime.lastRenderedBlock = 'tool';
       runtime.pendingHead = null;
       return;
@@ -347,7 +422,11 @@ export function renderToolResult(data, eventType = 'tool_result') {
 
   // Two-line shape: gutter under the (already-printed or just-flushed) head.
   process.stderr.write(`${gutter}${outcome}\n`);
-  if (diffPreview) process.stderr.write(`${diffPreview}\n`);
+  if (diffPreview) {
+    process.stderr.write(`${diffPreview}\n`);
+    rememberFileDiffPreview(data);
+  }
+  renderPlanBody(tool, data);
   runtime.lastRenderedBlock = 'tool';
 
   // Lint warnings stay visible alongside writes.
@@ -356,6 +435,81 @@ export function renderToolResult(data, eventType = 'tool_result') {
   }
 }
 
+// The plan sub-agent's output is the one peer result the USER needs to
+// see, not just the model — it's the execution contract for the turn.
+// Render the body as a bordered block (capped; full text stays on the
+// card via /last). All other peer verbs keep the one-line summary.
+const PLAN_BODY_MAX_LINES = 30;
+
+function renderPlanBody(tool, data) {
+  if (String(tool || '').toLowerCase() !== 'plan') return;
+  const text = String(data?.output ?? data?.result ?? '').trim();
+  if (!text) return;
+  const indent = subAgentIndent();
+  const lines = transcriptRenderableLines(renderMarkdown(text));
+  if (!lines.length) return;
+  const shown = lines.slice(0, PLAN_BODY_MAX_LINES);
+  process.stderr.write(`${indent}${paint.text.dim('┌ plan')}\n`);
+  for (const line of shown) {
+    process.stderr.write(`${indent}${paint.text.dim('│')} ${line}\n`);
+  }
+  process.stderr.write(lines.length > shown.length
+    ? `${indent}${paint.text.dim(`└ … ${lines.length - shown.length} more lines · /last to expand`)}\n`
+    : `${indent}${paint.text.dim('└')}\n`);
+}
+
+function fileDiffKey(data = {}) {
+  return fileDiffKeys(data)[0] || '';
+}
+
+function fileDiffKeys(data = {}) {
+  const keys = [];
+  const callId = data.call_id || data._callId || data.request_id || data.id;
+  if (callId) keys.push(`call:${callId}`);
+  const diff = Array.isArray(data.file_diffs) ? data.file_diffs[0]
+    : data.file_diff ? data.file_diff
+    : data.type === 'file_diff' ? data
+    : null;
+  const file = diff?.relative_path || diff?.path || data.relative_path || data.path || '';
+  if (file) {
+    const added = diff?.lines_added ?? data.lines_added ?? '';
+    const removed = diff?.lines_removed ?? data.lines_removed ?? '';
+    keys.push(`file:${file}:${added}:${removed}`);
+  }
+  return keys;
+}
+
+function rememberFileDiffPreview(data = {}) {
+  for (const key of fileDiffKeys(data)) {
+    runtime.renderedFileDiffPreviews.add(key);
+  }
+}
+
+export function renderFileDiffEvent(data = {}) {
+  const keys = fileDiffKeys(data);
+  if (keys.some(key => runtime.renderedFileDiffPreviews.has(key))) return false;
+
+  const indent = subAgentIndent();
+  const gutter = `${indent}${paint.text.dim('⎿')}  `;
+  const diffPreview = formatCompactFileDiff({
+    file_diff: data,
+    lines_added: data.lines_added,
+    lines_removed: data.lines_removed,
+  }, {
+    indent: gutter,
+    columns: process.stderr.columns || 120,
+    showFileHeader: true,
+  });
+  if (!diffPreview) return false;
+
+  renderBlockBoundary('tool', { compactSame: true });
+  process.stderr.write(`${diffPreview}\n`);
+  for (const key of keys) runtime.renderedFileDiffPreviews.add(key);
+  rememberChangedFile(data.relative_path || data.path);
+  runtime.lastRenderedBlock = 'tool';
+  return true;
+}
+
 function shellResultTool(tool) {
   return [
     'shell', 'run_tests', 'validate_build', 'lint_check',
@@ -415,6 +569,11 @@ export function rememberReadFile(filePath) {
   if (file && !session.filesRead.includes(file)) session.filesRead.push(file);
 }
 
+export function rememberChangedFile(filePath) {
+  const file = shortPath(String(filePath || '').trim());
+  if (file && !session.filesChanged.includes(file)) session.filesChanged.push(file);
+}
+
 export function recordReadActivity(tool, args = {}) {
   const normalized = String(tool || '').toLowerCase();
   if (normalized === 'read_file' || normalized === 'read') {
@@ -429,6 +588,26 @@ export function recordReadActivity(tool, args = {}) {
   }
 }
 
+export function recordWriteActivity(tool, args = {}, result = {}) {
+  const normalized = String(tool || '').toLowerCase();
+  if (!['write_file', 'edit_file', 'delete_file', 'write_project'].includes(normalized)) return;
+
+  if (normalized === 'write_project') {
+    const files = Array.isArray(args.files) ? args.files : [];
+    for (const file of files) {
+      rememberChangedFile(file?.file_path || file?.path);
+    }
+  }
+
+  rememberChangedFile(args.file_path || args.path || result.file_path || result.path);
+  const diffs = Array.isArray(result.file_diffs)
+    ? result.file_diffs
+    : result.file_diff ? [result.file_diff] : [];
+  for (const diff of diffs) {
+    rememberChangedFile(diff.relative_path || diff.path);
+  }
+}
+
 export function thinkingKind(text) {
   return /\b(read|reading|inspect|scan|search|open|trace|look(?:ing)?\s+at)\b/i.test(text)
     ? 'Reading'
@@ -454,10 +633,37 @@ export const SPIN_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '
 // (declaration moved to repl-state.mjs runtime.*)
 // (declaration moved to repl-state.mjs runtime.*)
 
-export function startSpinner(text) {
+// Compose the status label with live phase telemetry: elapsed seconds
+// (shown once a phase runs ≥3s — quick tools stay clean) and the
+// per-phase tool-call counter (sub-agent progress). The 80ms tick calls
+// this every frame, so elapsed counts up without any extra timer.
+function composeStatusLabel(label) {
+  const parts = [label];
+  if (runtime.spinStartedAt) {
+    const elapsedS = Math.floor((Date.now() - runtime.spinStartedAt) / 1000);
+    if (runtime.spinToolCalls > 0) {
+      parts.push(`${runtime.spinToolCalls} call${runtime.spinToolCalls === 1 ? '' : 's'}`);
+    }
+    if (elapsedS >= 3) parts.push(`${elapsedS}s`);
+  }
+  return parts.join(' · ');
+}
+
+/**
+ * Start (or re-label) the spinner. `phase` scopes the elapsed clock:
+ * a phase change resets it, same-phase updates keep it counting. Callers
+ * that don't pass a phase get a generic per-call reset (old behavior).
+ */
+export function startSpinner(text, { phase = null } = {}) {
+  const nextPhase = phase || `generic:${text}`;
+  if (runtime.spinPhase !== nextPhase) {
+    runtime.spinPhase = nextPhase;
+    runtime.spinStartedAt = Date.now();
+    runtime.spinToolCalls = 0;
+  }
   runtime.spinText = text;
   runtime.spinFrame = 0;
-  if (runtime.exploreRun && runtime.exploreRun.lineActive && isInputDockMounted()) return;
+  if (!queue.isActive() && runtime.exploreRun && runtime.exploreRun.lineActive && isInputDockMounted()) return;
   if (runtime.spinInterval) return; // already running
   runtime.spinInterval = setInterval(() => {
     // While an explore run is active, its live counts own the spinner
@@ -468,20 +674,29 @@ export function startSpinner(text) {
     if (!label) return;
     const frame = SPIN_FRAMES[runtime.spinFrame % SPIN_FRAMES.length];
     runtime.spinFrame++;
-    const rendered = `  ${c.brand(frame)} ${c.dim(label)}`;
-    if (isExploreActive && isInputDockMounted()) {
-      return;
-    }
-    if (isInputDockMounted()) {
-      drawPinnedStatus(rendered);
+    const rendered = `  ${c.brand(frame)} ${c.dim(composeStatusLabel(label))}`;
+    if (!queue.isActive() && isExploreActive && isInputDockMounted()) {
       return;
     }
-    inPlace(rendered);
+    presentStatus(rendered);
   }, 80);
 }
 
 export function updateSpinner(text) {
   runtime.spinText = text;
+  // Self-healing: a content flush stops the spinner (clears the
+  // interval), but long-running work — sub-agent runs especially —
+  // keeps sending updates afterwards. Without reviving the interval
+  // those updates write into a dead timer and the user sees a frozen
+  // "▸ running" with no progress at all. Same phase → clock continues.
+  if (!runtime.spinInterval && text) {
+    startSpinner(text, { phase: runtime.spinPhase || undefined });
+  }
+}
+
+/** Bump the per-phase progress counter (sub-agent tool calls). */
+export function bumpSpinnerProgress() {
+  runtime.spinToolCalls++;
 }
 
 export function stopSpinner() {
@@ -491,12 +706,10 @@ export function stopSpinner() {
   if (runtime.exploreRun && runtime.exploreRun.lineActive) return;
   if (runtime.spinInterval) { clearInterval(runtime.spinInterval); runtime.spinInterval = null; }
   runtime.spinText = '';
-  if (isInputDockMounted()) {
-    clearPinnedStatus();
-    moveToContent();
-    return;
-  }
-  inPlace('');
+  runtime.spinPhase = null;
+  runtime.spinStartedAt = 0;
+  runtime.spinToolCalls = 0;
+  erasePresentedStatus();
 }
 
 // ── Content Streaming Display ──
@@ -511,6 +724,7 @@ export function startContentStream() {
   runtime.streamBuffer = '';
   runtime.streamedPartialText = '';
   runtime.renderedToolResults.clear();
+  runtime.renderedFileDiffPreviews.clear();
   runtime.exploreRun = { counts: {}, recent: [], lineActive: false, lastPrintedSummary: '', lastPrintedTotal: 0, lastPrintedAt: 0 };
   runtime.renderedContentThisTurn = false;
   runtime.contentHeaderPrinted = false;
@@ -535,27 +749,36 @@ export function flushContent() {
   if (runtime.streamTimer) { clearTimeout(runtime.streamTimer); runtime.streamTimer = null; }
   if (!runtime.streamBuffer) return;
 
+  const rendered = renderMarkdown(runtime.streamBuffer);
+  const lines = transcriptRenderableLines(rendered);
+  runtime.streamBuffer = '';
+  if (!lines.length) return;
+
   if (isInputDockMounted()) moveToContent();
   stopSpinner();
   // Any buffered tool head needs to land BEFORE this content so the order
   // is preserved on screen.
   flushPendingHead();
   flushCompactReadRun();
-  renderBlockBoundary('content');
+  renderBlockBoundary('content', { compactSame: true });
   if (!runtime.contentHeaderPrinted) {
     process.stdout.write(`${transcriptHeader('bahulam', { tone: 'assistant' })}\n`);
     runtime.contentHeaderPrinted = true;
   }
-  const rendered = renderMarkdown(runtime.streamBuffer);
-  for (const line of rendered.split('\n')) {
+  for (const line of lines) {
     process.stdout.write(`${transcriptLine(line, { tone: 'assistant' })}\n`);
   }
-  runtime.streamBuffer = '';
   runtime.renderedContentThisTurn = true;
   runtime.lastRenderedBlock = 'content';
   if (typeof runtime.afterContentFlush === 'function') runtime.afterContentFlush();
 }
 
+export function transcriptRenderableLines(rendered) {
+  const lines = String(rendered ?? '').replace(/\r\n?/g, '\n').split('\n');
+  while (lines.length && lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}
+
 export function renderStagnation(data = {}) {
   const rawMessage = data?.message || '';
   const reason = data?.reason || rawMessage.replace(/^Stagnation:\s*/i, '').trim();