@agi-fans/dsh-tui 0.18.0 → 0.20.0

package/lib/views/transcript-render.js

@@ -12,38 +12,24 @@ import { renderCopySelector } from "./copy-selector.js";
 import { renderSettings } from "./settings-list.js";
 import { renderTrajectory } from "./trajectory.js";
 import { renderAgentHub } from "./agent-hub.js";
-import { renderPlanReviewPage, renderPromptSelector, renderPromptSelectorPage, } from "./prompt-selector.js";
+import { renderImagePreviewPage, renderPlanReviewPage, renderPromptSelector, renderPromptSelectorPage, renderPromptTreePage, } from "./prompt-selector.js";
 import { resolveStatusBarConfig } from "../chrome/status-config.js";
 import { renderPermissionBadge, renderStatusFooter } from "../chrome/status-line.js";
-import { createTheme, SPINNER, SYMBOL } from "../chrome/theme.js";
+import { createTheme, paintSurface, SPINNER, SYMBOL, BOX } from "../chrome/theme.js";
 import { renderGoalBar } from "../chrome/goal-bar.js";
 import { padToWidth, stripAnsi, truncateToWidth, visibleWidth, wrapText } from "../chrome/width.js";
-import { alignFileDiffs, countDiffStats, paintDiffStats, paintPrefixedDiffLine, wrapPaintedDiffRows, } from "../chrome/diff-render.js";
-import { renderTool } from "../chrome/tool-renderers.js";
+import { alignFileDiffs, wrapPaintedDiffRows, } from "../chrome/diff-render.js";
+import { workspaceBlockLines } from "./workspace-changes.js";
+import { renderTool, toolArgSubject } from "../chrome/tool-renderers.js";
+import { toolArgsObject } from "../chrome/tool-args.js";
 import { renderToolsPanel } from "../chrome/tools-list.js";
 import { renderCommandOutput, renderCommandSeparator } from "../chrome/command-output.js";
 import { renderPathMentionRows } from "../chrome/path-mentions.js";
 import { blockMatchesQuery, transcriptSearchHint } from "./transcript-search.js";
-import { contentToText, prettyArgs, } from "./transcript-types.js";
+import { contentToText, prettyArgs, reasoningKey, } from "./transcript-types.js";
 function isBlockPending(block) {
     return (block.kind === 'assistant' && block.streaming) || (block.kind === 'tool' && block.status === 'running');
 }
-/** Collapsed tool-output preview height (OMP `DEFAULT_TERMINAL_PREVIEW_LINES`). */
-export const TOOL_COLLAPSED_LINES = 10;
-export const TOOL_INPUT_COLLAPSED_LINES = 3;
-function slicePreview(lines, limit, expanded, direction) {
-    if (expanded || lines.length <= limit)
-        return { lines: [...lines], hidden: 0 };
-    const hidden = lines.length - limit;
-    return {
-        lines: direction === 'tail' ? lines.slice(hidden) : lines.slice(0, limit),
-        hidden,
-    };
-}
-function toolPreview(lines, width, limit, expanded, direction) {
-    const contentWidth = Math.max(1, width - 4);
-    return slicePreview(lines.flatMap(line => wrapText(line, contentWidth)), limit, expanded, direction);
-}
 function exclusiveDiffs(presentation) {
     if (presentation?.result?.card === 'diff')
         return presentation.result.diffs;
@@ -53,8 +39,42 @@ function exclusiveDiffs(presentation) {
         return presentation.call.diffs;
     return undefined;
 }
-/** OMP AssistantMessage uses one horizontal cell of padding and no vertical padding. */
-const ASSISTANT_PADDING_X = 1;
+/**
+ * The transcript's one content column.
+ *
+ * Every block starts its words in the same column: a reply, a prompt after its
+ * `›`, a run's header after its `▸`, a notice. The marks own the two cells to
+ * the left of it. A reply used to sit one cell in while the marked rows put
+ * their words at three, so a screen had four left edges and read as clutter
+ * however tidy each block was on its own.
+ */
+const ASSISTANT_PADDING_X = 2;
+/** Process summaries keep a readable measure even on wide terminals. */
+const PROCESS_WIDTH = 80;
+function processRoom(width, head) {
+    return Math.max(1, Math.min(PROCESS_WIDTH, width - 2) - visibleWidth(head));
+}
+/** Shorten directories before sacrificing the filename. Both separators occur in replayed sessions. */
+function shortPath(path, width) {
+    if (visibleWidth(path) <= width)
+        return path;
+    const parts = path.split(/[/\\]/u);
+    if (parts.length < 2)
+        return truncateToWidth(path, width);
+    const separator = path.includes('\\') ? '\\' : '/';
+    const file = parts.pop();
+    const tail = '…' + separator + file;
+    if (visibleWidth(tail) >= width)
+        return truncateToWidth(file, width);
+    let prefix = '';
+    for (const part of parts) {
+        const next = prefix + part + separator;
+        if (visibleWidth(next + tail) > width)
+            break;
+        prefix = next;
+    }
+    return prefix + tail;
+}
 function assistantContentLines(lines, width, paddingX) {
     const margin = ' '.repeat(paddingX);
     return lines.map((line) => padToWidth(margin + line + margin, width));
@@ -76,13 +96,28 @@ function assistantMarkdown(source, theme, width, style) {
         return assistantContentLines(rendered, width, paddingX);
     return assistantContentLines(rendered.map(line => lockThinkingLine(line, theme)), width, paddingX);
 }
+/**
+ * What the reader typed.
+ *
+ * No mark in front of it. The prompt is the one block whose author is already
+ * known — the reader typed it, and it is the row that opens a turn — so it
+ * carries its own tint as a slab and reads as a prompt without a glyph
+ * claiming what the tint already says. Its words sit on the same column as
+ * everything else, so nothing on the screen is held off by a gutter.
+ */
 function userBubble(text, theme, width) {
-    const inner = Math.max(1, width - 2);
-    const wrapped = renderPathMentionRows(text, inner, theme);
+    const gutter = '  ';
+    const wrapped = renderPathMentionRows(text, Math.max(1, width - gutter.length), theme);
     const rows = ['', ...wrapped, ''];
-    return rows.map((row) => {
-        const content = row === '' ? padToWidth('', width) : padToWidth(' ' + row, width);
-        return theme.colors ? theme.bg('userMessageBg', content) : content;
+    // The padding rows share the prompt's tint, so the prompt is one slab that
+    // opens the turn. Unpainted, they were two blank rows of their own on top of
+    // the gap between blocks, and the prompt floated in twice the space of
+    // anything else on the screen.
+    return rows.map((row, index) => {
+        if (row === '')
+            return paintSurface(theme, 'userMessageBg', 'userMessageText', padToWidth('', width));
+        const content = padToWidth((index === 1 ? gutter : '') + row, width);
+        return paintSurface(theme, 'userMessageBg', 'userMessageText', content);
     });
 }
 function toolIcon(status, theme, spinnerFrame) {
@@ -95,90 +130,367 @@ function toolIcon(status, theme, spinnerFrame) {
         return theme.fg('success', SYMBOL.success);
     return theme.fg('error', SYMBOL.error);
 }
-/** Render one tool block as an OMP framed output box. */
-function toolBlockLines(block, theme, width, spinnerFrame, expanded) {
-    const icon = toolIcon(block.status, theme, spinnerFrame);
+/**
+ * The gutter mark for a call, or nothing at all.
+ *
+ * A settled successful call used to carry a checkmark, and a run of five calls
+ * put five identical checkmarks in a column — a signal that says only "the row
+ * above exists", which it always did. The gutter is for states a reader has to
+ * act on: in flight, or wrong. A run of successes is legible by its shape, and
+ * the marks that remain mean something.
+ */
+function toolStatusMark(status, theme, spinnerFrame) {
+    if (status === 'ok')
+        return '';
+    return toolIcon(status, theme, spinnerFrame);
+}
+/**
+ * One-line fact for a failed call.
+ *
+ * The row has to answer "what failed" on its own, because that is the whole
+ * reason the reader is looking at this line. A terminal echoing the command it
+ * just ran is not the answer, so it is skipped along with blank lines; whatever
+ * comes back is the first thing the tool itself complained about. Falls back to
+ * the call's own summary when the output says nothing.
+ */
+function toolFailureFact(output, command, fact) {
+    for (const line of output.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '')
+            continue;
+        if (command !== undefined
+            && (trimmed === command || trimmed === `> ${command}` || trimmed === `$ ${command}`))
+            continue;
+        return trimmed;
+    }
+    return fact;
+}
+/**
+ * A folded call shows its description once, or a kind and subject as fallback.
+ * Errors reserve space for their reason; full commands and output stay in the
+ * expanded block. Process rows share an 80-cell measure and right padding.
+ */
+function toolRowLine(block, theme, width, spinnerFrame) {
     const presentation = renderTool({
         name: block.name,
         arguments: prettyArgs(block.args),
         output: block.output,
         status: block.status,
-        expanded,
+        expanded: false,
         ...(block.partial === true ? { partial: true } : {}),
         ...(block.presentation === undefined ? {} : { presentation: block.presentation }),
     });
+    // A PTC sub-call ran inside a program, not because the model asked for it
+    // directly. Indenting says that without a second visual vocabulary, and the
+    // width budget shrinks to match so the row still ends at the same column.
+    const nest = block.parentCallId === undefined ? '' : '  ';
+    // No gutter column. A settled successful call carries no mark at all — a
+    // column of identical bullets says only that the row above exists — and the
+    // two that remain are the states a reader has to act on: motion while the
+    // call is in flight, and the error mark.
+    const mark = block.status === 'ok' ? '' : toolStatusMark(block.status, theme, spinnerFrame) + ' ';
+    const head = nest + mark;
+    const room = processRoom(width, head);
+    const label = processLabel(block.name);
+    const subject = toolRowSubject(block, presentation, label);
+    const args = toolArgsObject(block.args);
+    const call = block.presentation?.call;
+    const description = args?.['description'] ?? (call?.card === 'terminal' ? call.description : undefined);
+    const descriptionLed = (COMMAND_TOOL.test(block.name) || call?.card === 'terminal')
+        && typeof description === 'string' && description.trim() !== '';
+    // The echo a failure skips is the command line, which a description-led row
+    // no longer carries as its subject.
+    const argCommand = args?.['command'];
+    const command = typeof argCommand === 'string'
+        ? argCommand
+        : block.presentation?.call?.card === 'terminal' ? presentation.input[0] ?? subject : subject;
+    const fact = block.status === 'error'
+        ? firstLineOf(block.job !== undefined && block.job.status !== 'completed'
+            ? block.job.detail ?? block.job.status
+            : toolFailureFact(block.output, command, presentation.summary ?? '')).replace(/^error:\s*/iu, '')
+        : exclusiveDiffs(block.presentation) === undefined ? '' : presentation.summary ?? '';
+    // The fact continues the sentence the row already is — `Read file · a.ts ·
+    // no such file` — rather than sitting against the right edge, where it read
+    // as a separate column that belonged to no row in particular. It is reserved
+    // first so a long subject cannot push it off; a failure gets the larger
+    // share, because its fact is the reason the reader stopped.
+    const factShare = block.status === 'error' ? 0.5 : 1 / 3;
+    const factRoom = Math.min(visibleWidth(fact), Math.floor(Math.max(1, room) * factShare));
+    const afterFact = Math.max(1, room - (factRoom === 0 ? 0 : factRoom + ROW_JOIN.length));
+    const labelRoom = descriptionLed ? 0 : Math.min(visibleWidth(label), afterFact);
+    const detailRoom = descriptionLed ? afterFact : afterFact - labelRoom - ROW_JOIN.length;
+    const labelText = descriptionLed ? '' : truncateToWidth(label, Math.max(1, labelRoom));
+    const pathSubject = ['read', 'write', 'edit'].includes(block.name);
+    const detailText = subject === '' || detailRoom < (descriptionLed ? 1 : 8) ? ''
+        : pathSubject ? shortPath(subject, detailRoom) : truncateToWidth(subject, detailRoom);
+    const tailText = fact === '' || factRoom === 0 ? '' : truncateToWidth(fact, factRoom);
+    const text = labelText + (detailText === '' ? '' : (descriptionLed ? '' : ROW_JOIN) + detailText) + (tailText === '' ? '' : ROW_JOIN);
+    // A failure is the one line in a run that has to stay findable while scrolling
+    // past, so its fact carries the error colour rather than the row's dim.
+    const tail = tailText === '' ? '' : block.status === 'error' ? theme.fg('error', tailText) : theme.dim(tailText);
+    return [padToWidth(truncateToWidth(head + theme.fg('muted', text) + tail, Math.max(1, width - 2)), width)];
+}
+/** Separator between a process subject and its outcome. */
+const ROW_JOIN = ' · ';
+/** Tools whose `description` argument says what a command was for. */
+const COMMAND_TOOL = /^(bash|shell|pwsh|exec)$/;
+/**
+ * What a call acted on, as one line.
+ *
+ * A shell call carries a `description` written for exactly this purpose, and it
+ * reads as intent where the command reads as plumbing: `Show recent commits and
+ * status` rather than `cd /long/path && git log --oneline -15 && echo ---`. The
+ * command stays reachable by opening the row. Everything else reads its
+ * argument fields in the shared order, then any string argument at all — a
+ * skill call's only argument is `name` — and finally the card's own title when
+ * it says something the label does not.
+ */
+function toolRowSubject(block, presentation, label) {
+    const args = toolArgsObject(block.args);
+    const call = block.presentation?.call;
+    if (COMMAND_TOOL.test(block.name) || call?.card === 'terminal') {
+        const description = args?.['description'] ?? (call?.card === 'terminal' ? call.description : undefined);
+        if (typeof description === 'string' && description.trim() !== '')
+            return firstLineOf(description);
+    }
+    const fromFields = toolArgSubject(block.args, block.partial === true);
+    if (fromFields !== '')
+        return firstLineOf(fromFields);
+    if (args !== undefined) {
+        for (const value of Object.values(args)) {
+            if (typeof value === 'string' && value.trim() !== '')
+                return firstLineOf(value);
+        }
+    }
+    // A card's first input line is the tool's own idea of what the call was — a
+    // terminal card puts the command there and its title is only the tool name.
+    const fromCard = call === undefined ? '' : firstLineOf(presentation.input[0] ?? '');
+    if (fromCard !== '')
+        return fromCard;
+    const title = presentation.title;
+    if (title === undefined || title === block.name)
+        return '';
+    // `Read src/x.ts` under a `Read file` label would say the verb twice.
+    const verb = label.split(' ')[0] ?? '';
+    return firstLineOf(verb !== '' && title.startsWith(verb + ' ') ? title.slice(verb.length + 1) : title);
+}
+/** Tool content shared by a running turn and a completed turn opened for reading. */
+function toolBlockLines(block, theme, width, mode = 'preview', detailsKey = 'Alt+O') {
+    const full = mode !== 'preview';
+    const presentation = renderTool({
+        name: block.name, arguments: prettyArgs(block.args), output: block.output,
+        status: block.status, expanded: full,
+        ...(block.partial === true ? { partial: true } : {}),
+        ...(block.presentation === undefined ? {} : { presentation: block.presentation }),
+    });
+    const args = toolArgsObject(block.args);
+    const call = block.presentation?.call;
+    const result = block.presentation?.result;
+    const shell = COMMAND_TOOL.test(block.name) || call?.card === 'terminal';
+    const read = block.name === 'read' || result?.card === 'read';
     const diffs = exclusiveDiffs(block.presentation);
-    if (diffs !== undefined) {
-        const rows = alignFileDiffs(diffs);
-        const stats = countDiffStats(rows);
-        const statsLabel = paintDiffStats(stats.added, stats.removed, theme);
-        const header = icon + ' ' + theme.bold(presentation.title ?? block.name)
-            + (statsLabel === '' ? '' : ' ' + statsLabel);
-        const painted = wrapPaintedDiffRows(rows, theme, width);
-        const output = slicePreview(painted, TOOL_COLLAPSED_LINES, expanded, 'head');
-        if (output.hidden > 0) {
-            output.lines.push(theme.fg('dim', `… ${output.hidden} more lines · ⟨Ctrl+O: Expand⟩`));
+    const padding = width > 4 ? 2 : 0;
+    const nest = block.parentCallId === undefined || width < 10 ? 0 : 2;
+    const room = Math.max(1, width - padding * 2 - nest);
+    const subject = toolArgSubject(block.args, block.partial === true)
+        || (result?.card === 'read' ? result.path : '')
+        || (args === undefined ? '' : Object.values(args).find(value => typeof value === 'string')) || '';
+    const command = call?.card === 'terminal' ? call.title
+        : typeof args?.['command'] === 'string' ? args['command'] : subject;
+    const title = shell ? `$ ${command}`
+        : call?.card === 'generic' || call?.card === 'diff' ? call.title
+            : !read && presentation.title !== undefined && presentation.title !== block.name ? presentation.title
+                : `${block.name}${subject === '' ? '' : ` ${subject}`}`;
+    const head = theme.bold(theme.fg(block.status === 'error' ? 'error' : 'toolTitle', title));
+    const rows = wrapText(head, room);
+    let body = [];
+    if (mode === 'details') {
+        let input = block.args;
+        try {
+            input = JSON.stringify(JSON.parse(input), undefined, 2);
+        }
+        catch { /* Partial arguments retain their received text. */ }
+        const output = presentation.output.length > 0 ? presentation.output : block.output.split('\n');
+        const outputRows = diffs === undefined
+            ? output.flatMap(line => wrapText(theme.fg(block.status === 'error' ? 'error' : 'toolOutput', line), room))
+            : wrapPaintedDiffRows(alignFileDiffs(diffs), theme, room);
+        body = [
+            ...wrapText(theme.fg('dim', 'Input'), room),
+            ...input.split('\n').flatMap(line => wrapText(theme.fg('toolOutput', line), room)),
+            '', ...wrapText(theme.fg('dim', 'Output'), room),
+            ...outputRows,
+        ];
+        // Keep the tool's rich presentation, but expose received text it replaced.
+        if (block.output !== '' && (diffs !== undefined || block.output !== output.join('\n'))) {
+            body.push('', ...wrapText(theme.fg('dim', 'Raw result'), room));
+            for (const line of block.output.split('\n')) {
+                body.push(...wrapText(theme.fg(block.status === 'error' ? 'error' : 'toolOutput', line), room));
+            }
         }
-        const state = block.status === 'running' ? 'running' : block.status === 'ok' ? 'ok' : 'error';
-        return renderFramedBlock({ header, state, sections: [{ lines: output.lines }], width }, theme);
     }
-    const summary = presentation.summary === undefined || presentation.summary === ''
-        ? ''
-        : theme.fg('dim', ' ' + presentation.summary);
-    const header = icon + ' ' + theme.bold(presentation.title ?? block.name) + summary;
-    const input = toolPreview(presentation.input, width, TOOL_INPUT_COLLAPSED_LINES, expanded, 'head');
-    const output = toolPreview(presentation.output, width, TOOL_COLLAPSED_LINES, expanded, presentation.outputPreview);
-    const hasOutput = presentation.output.length > 0;
-    const inputLines = input.lines.map(line => (block.presentation?.call?.card === 'diff' ? paintPrefixedDiffLine(line, theme) : theme.fg('toolOutput', line)));
-    if (input.hidden > 0) {
-        const hint = hasOutput && output.hidden > 0 ? '' : ' · ⟨Ctrl+O: Expand⟩';
-        inputLines.push(theme.fg('dim', `… ${input.hidden} more input lines${hint}`));
-    }
-    const outputLines = output.lines.map(line => (block.presentation?.result?.card === 'diff' ? paintPrefixedDiffLine(line, theme) : theme.fg('toolOutput', line)));
-    if (output.hidden > 0) {
-        const position = presentation.outputPreview === 'tail' ? 'earlier' : 'more';
-        const hint = theme.fg('dim', `… ${output.hidden} ${position} lines · ⟨Ctrl+O: Expand⟩`);
-        if (presentation.outputPreview === 'tail')
-            outputLines.unshift(hint);
+    else if (diffs !== undefined) {
+        body = wrapPaintedDiffRows(alignFileDiffs(diffs), theme, room);
+    }
+    else if (full || !read || block.status === 'error') {
+        const output = presentation.output.map(line => theme.fg(block.status === 'error' ? 'error' : 'toolOutput', line));
+        const input = !shell && !read && (call?.card === 'generic' || (call === undefined && presentation.title !== block.name))
+            ? presentation.input.flatMap(line => wrapText(theme.fg('toolOutput', line), room)) : [];
+        body = [...input, ...output.flatMap(line => wrapText(line, room))];
+        // Writes carry their content in arguments before the result arrives.
+        if (body.length === 0 && block.name === 'write' && typeof args?.['content'] === 'string') {
+            body = args['content'].split('\n').flatMap(line => wrapText(theme.fg('toolOutput', line), room));
+        }
+    }
+    while (body.length > 0 && stripAnsi(body[body.length - 1]).trim() === '')
+        body.pop();
+    const limit = full || diffs !== undefined ? body.length : shell ? 5
+        : /^(grep|search)$/.test(block.name) ? 15 : /^(glob|find|ls)$/.test(block.name) ? 20 : 10;
+    const omitted = Math.max(0, body.length - limit);
+    if (omitted > 0) {
+        body = shell ? body.slice(-limit) : body.slice(0, limit);
+        const shortcut = detailsKey === 'Disabled' ? '' : ` · ${detailsKey}: Expand`;
+        const hint = theme.fg('dim', `… ${omitted} ${shell ? 'earlier' : 'more'} lines${shortcut}`);
+        if (shell)
+            body.unshift(...wrapText(hint, room));
         else
-            outputLines.push(hint);
-    }
-    const sections = [
-        ...(inputLines.length === 0 ? [] : [{ lines: inputLines }]),
-        ...(outputLines.length === 0 ? [] : [{
-                ...(inputLines.length === 0 ? {} : { label: theme.fg('toolTitle', 'Output') }),
-                lines: outputLines,
-            }]),
-    ];
-    const state = block.status === 'running' ? 'running' : block.status === 'ok' ? 'ok' : 'error';
-    return renderFramedBlock({ header, state, sections, width }, theme);
+            body.push(...wrapText(hint, room));
+    }
+    if (!full && read && block.status !== 'error' && block.output !== '' && detailsKey !== 'Disabled') {
+        body.push(...wrapText(theme.fg('dim', `${detailsKey}: Expand result`), room));
+    }
+    if (full && block.status === 'error' && call?.card === 'diff')
+        rows.push('', ...wrapPaintedDiffRows(alignFileDiffs(call.diffs), theme, room));
+    if (body.length > 0) {
+        rows.push('');
+        for (const row of body)
+            rows.push(row);
+    }
+    if (block.status === 'error')
+        rows.push(...wrapText(theme.fg('error', 'Tool failed'), room));
+    if (block.job !== undefined)
+        rows.push(...wrapText(theme.fg(block.status === 'error' ? 'error' : 'muted', `Job ${block.job.id} · ${block.job.detail ?? block.job.status}`), room));
+    const bg = block.status === 'running' ? 'toolPendingBg' : block.status === 'error' ? 'toolErrorBg' : 'toolSuccessBg';
+    return ['', ...rows, ''].map(row => paintSurface(theme, bg, 'toolOutput', padToWidth(' '.repeat(padding + nest) + row, width)));
+}
+function firstLineOf(text) {
+    for (const line of text.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed !== '')
+            return trimmed;
+    }
+    return '';
+}
+/** Thinking uses the same quiet Markdown style throughout the turn. */
+function openReasoningLines(block, theme, width, mathMode = 'auto') {
+    return assistantMarkdown(block.reasoning, theme, width, { color: 'thinkingText', italic: true, mathMode });
+}
+/** The block indexes a run shows as rows, in order: its members, then the thought it took from its answer. */
+function groupMembers(group) {
+    const members = [];
+    for (let at = group.start; at < (group.answer ?? group.until); at += 1)
+        members.push(at);
+    if (group.tookThought && group.answer !== undefined)
+        members.push(group.answer);
+    return members;
 }
 /**
- * Render one transcript block to display lines. Pure; shared by the tty view
- * and the non-tty plain printer.
- * @param block - the block to render.
- * @param theme - active theme.
- * @param width - terminal width in columns.
- * @param spinnerFrame - activity spinner phase for running tools.
- * @param toolsExpanded - paint full tool output instead of the collapsed preview.
- * @returns display lines (already width-fitted).
+ * One member of a run, as a row or opened in place.
+ *
+ * `thoughtOnly` is the step that answered: the run took its thought as the
+ * last row and its words are the answer painted below the run, so the run
+ * paints the thought and nothing else.
  */
-export function blockLines(block, theme, width, spinnerFrame = 0, toolsExpanded = false) {
+function groupMemberLines(index, context, thoughtOnly = false) {
+    const { blocks, options, theme, width } = context;
+    const block = blocks[index];
+    // Search must reveal a match even when it falls outside a tool's normal preview.
+    const full = block.kind === 'tool' && (context.matches.has(index) || options.expandedTools?.has(block.callId) === true);
+    const signature = [width, options.colors, context.trueColor, context.themeName, options.mathMode, options.mermaidMode, thoughtOnly, full, options.toolDetailsKey].join('\0');
+    const cached = groupMemberCache.get(block);
+    let lines;
+    if (cached?.signature === signature)
+        lines = cached.lines;
+    else {
+        lines = block.kind === 'tool' ? toolBlockLines(block, theme, width, full ? 'details' : 'preview', options.toolDetailsKey)
+            : block.kind === 'assistant' ? thoughtOnly ? openReasoningLines(block, theme, width, options.mathMode)
+                : blockLines(block, theme, width, { mathMode: options.mathMode ?? 'auto', mermaidMode: options.mermaidMode ?? 'auto' })
+                : block.kind === 'notice' ? blockLines(block, theme, width) : [];
+        groupMemberCache.set(block, { signature, lines });
+    }
+    const search = options.transcriptSearch;
+    return search !== undefined && context.matches.has(index)
+        ? lines.map(line => blockMatchesQuery(stripAnsi(line), search.query) ? theme.inverse(line) : line)
+        : [...lines];
+}
+/** A notice that reports on the run's work, as one of its rows. */
+function processNoticeLine(block, theme, width, indent) {
+    const color = block.level === 'error' ? 'error' : 'muted';
+    const head = indent + (block.level === 'error' ? theme.fg(color, SYMBOL.error) + ' ' : '');
+    const room = processRoom(width, head);
+    return padToWidth(truncateToWidth(head + theme.fg(color, truncateToWidth(block.text.split('\n')[0] ?? '', room)), width), width);
+}
+/**
+ * Rows of a run live across frames, so they are kept per block the same way a
+ * top-level block's rows are: a streamed token re-lays the frame without
+ * re-laying every call the run already made.
+ */
+const groupMemberCache = new WeakMap();
+/** Flat chronological content, shared by live and opened turns. */
+function processGroupBody(group, context) {
+    const lines = [];
+    const offsets = new Map();
+    for (const index of groupMembers(group)) {
+        const rows = groupMemberLines(index, context, index === group.answer && group.tookThought);
+        if (rows.length > 0 && lines.length > 0)
+            lines.push('');
+        offsets.set(index, lines.length);
+        for (const row of rows)
+            lines.push(row);
+    }
+    return { lines, offsets };
+}
+/** A settled turn's length, the way a person would say it. */
+export function formatElapsed(ms) {
+    const seconds = Math.max(0, Math.round(ms / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ${seconds % 60}s`;
+    return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+/** A completed turn's duration and any failures remain visible when folded. */
+function processGroupHeader(group, theme, width, elapsed, expandKey = 'Ctrl+O') {
+    const label = elapsed === undefined ? 'Worked' : `Worked for ${elapsed}`;
+    const failure = group.failures === 0 ? '' : theme.fg('error', ` · ${group.failures} failed`);
+    const labelRoom = Math.max(1, width - 4 - visibleWidth(failure));
+    const summary = `${SYMBOL.folded} ${theme.fg('dim', truncateToWidth(label, labelRoom))}${failure}`;
+    const hint = ` · ${expandKey} to expand`;
+    const suffix = expandKey !== 'Disabled' && visibleWidth(summary) + visibleWidth(hint) <= width - 2
+        ? theme.fg('dim', hint) : '';
+    return [padToWidth(truncateToWidth(summary + suffix, Math.max(1, width - 2)), width)];
+}
+/**
+ * Render a block for the transcript or plain printer. Full output is available
+ * to direct callers; turn inspection uses previews. omitReasoning excludes
+ * thinking already drawn by a run.
+ */
+export function blockLines(block, theme, width, { toolsExpanded = false, omitReasoning = false, toolDetailsKey = 'Alt+O', mathMode = 'auto', mermaidMode = 'auto' } = {}) {
     if (block.kind === 'user')
         return userBubble(block.text, theme, width);
     if (block.kind === 'assistant') {
         const lines = [];
-        if (block.reasoning !== '') {
-            lines.push(...assistantMarkdown(block.reasoning, theme, width, { color: 'thinkingText', italic: true }));
+        if (block.reasoning !== '' && !omitReasoning) {
+            lines.push(...openReasoningLines(block, theme, width, mathMode));
             if (block.text !== '')
                 lines.push('');
         }
-        if (block.text === '' && block.streaming) {
+        if (block.text === '' && block.reasoning === '' && block.streaming) {
             const paddingX = width > ASSISTANT_PADDING_X * 2 ? ASSISTANT_PADDING_X : 0;
             lines.push(...assistantContentLines([theme.fg('dim', '…')], width, paddingX));
         }
         else if (block.text !== '') {
-            lines.push(...assistantMarkdown(block.text, theme, width, hasExplicitTextColor(theme) ? { color: 'text' } : undefined));
+            lines.push(...assistantMarkdown(block.text, theme, width, { ...(hasExplicitTextColor(theme) ? { color: 'text' } : {}), mathMode, mermaidMode }));
         }
         if (block.interrupted === true) {
             const paddingX = width > ASSISTANT_PADDING_X * 2 ? ASSISTANT_PADDING_X : 0;
@@ -186,12 +498,19 @@ export function blockLines(block, theme, width, spinnerFrame = 0, toolsExpanded
         }
         return lines;
     }
-    if (block.kind === 'tool')
-        return toolBlockLines(block, theme, width, spinnerFrame, toolsExpanded);
+    if (block.kind === 'tool') {
+        return toolBlockLines(block, theme, width, toolsExpanded ? 'full' : 'preview', toolDetailsKey);
+    }
     if (block.kind === 'toolCatalog')
         return renderToolsPanel(block.tools, theme, width, toolsExpanded);
+    if (block.kind === 'workspace')
+        return workspaceBlockLines(block, theme, width, toolsExpanded);
     if (block.kind === 'commandOutput')
         return renderCommandOutput(block.command, block.text, theme, width);
+    if (block.boundary === true)
+        return [renderTranscriptBoundary(block.text, theme, width)];
+    if (block.process !== undefined && block.framed !== true)
+        return [processNoticeLine(block, theme, width, '')];
     if (block.framed !== true) {
         const prefix = '  ';
         const continuation = ' '.repeat(visibleWidth(prefix));
@@ -210,16 +529,55 @@ export function blockLines(block, theme, width, spinnerFrame = 0, toolsExpanded
         applyBg: false,
     }, theme);
 }
+/**
+ * Seam labels live in one table with the row that draws them, so a later
+ * language layer moves the strings in one edit rather than chasing them through
+ * the runtime. English until that layer exists.
+ */
+const SEAM_LABELS = {
+    'session-opened': 'session opened · earlier output retained',
+    cleared: 'transcript cleared · earlier output retained',
+};
+/** The row that separates two documents in the terminal's history. */
+export function transcriptSeam(reason) {
+    return { kind: 'notice', level: 'info', text: SEAM_LABELS[reason], boundary: true };
+}
+/**
+ * The seam where the transcript was replaced.
+ *
+ * This row exists because the earlier output is still in the terminal's own
+ * scrollback and stays there. Without it, scrolling up walks into rows that
+ * describe a document the live view no longer holds and nothing says why. The
+ * label names the cause; the rules are chrome, not a message about anything.
+ */
+function renderTranscriptBoundary(label, theme, width) {
+    if (width <= 0)
+        return '';
+    const labelText = theme.fg('dim', label);
+    const rule = theme.fg('border', BOX.horizontal);
+    // A terminal too narrow for a rule on either side still gets the label, since
+    // the label is the part that carries the fact.
+    const room = width - visibleWidth(label) - 2;
+    if (room < 2)
+        return truncateToWidth(labelText, Math.max(1, width));
+    const left = Math.floor(room / 2);
+    return rule.repeat(left) + ' ' + labelText + ' ' + rule.repeat(room - left);
+}
 /** Plain text of one block, used by transcript search and match painting. */
 export function blockSearchText(block) {
     if (block.kind === 'assistant') {
         return block.reasoning === '' ? block.text : `${block.reasoning}\n${block.text}`;
     }
     if (block.kind === 'tool')
-        return `${block.args}\n${block.output}`;
+        return `${block.args}\n${block.output}${block.job === undefined ? '' : `\n${block.job.id} ${block.job.status} ${block.job.detail ?? ''}`}`;
     if (block.kind === 'toolCatalog') {
         return block.tools.map(tool => `${tool.name} ${tool.description}`).join('\n');
     }
+    if (block.kind === 'workspace') {
+        // Only the served file paths are searchable; a turn whose summary the
+        // host no longer holds contributes no path text.
+        return block.summary?.files.map(file => file.display).join('\n') ?? `turn ${block.turn}`;
+    }
     return block.text;
 }
 function fitFrame(lines, width, stablePrefix = 0) {
@@ -243,32 +601,267 @@ function fitFrame(lines, width, stablePrefix = 0) {
 const transcriptBodyCache = new WeakMap();
 /** Settled immutable blocks keep their expensive Markdown/tool layout. */
 const blockLinesCache = new WeakMap();
-function cachedBlockLines(block, options, theme, themeName, trueColor, spinnerFrame, expanded) {
-    const animatedSpinnerFrame = block.kind === 'tool' && block.status === 'running' ? spinnerFrame : -1;
+function cachedBlockLines(block, options, theme, themeName, trueColor, expanded, omitReasoning = false) {
     const cached = blockLinesCache.get(block);
     if (cached !== undefined
         && cached.width === options.width
         && cached.colors === options.colors
         && cached.trueColor === trueColor
         && cached.themeName === themeName
-        && cached.spinnerFrame === animatedSpinnerFrame
-        && cached.expanded === expanded)
+        && cached.expanded === expanded
+        && cached.omitReasoning === omitReasoning
+        && cached.mathMode === options.mathMode
+        && cached.mermaidMode === options.mermaidMode
+        && cached.toolDetailsKey === options.toolDetailsKey
+        && cached.toolDetails === (block.kind === 'tool' && options.expandedTools?.has(block.callId) === true))
         return cached.lines;
-    const lines = blockLines(block, theme, options.width, spinnerFrame, expanded);
+    const toolDetails = block.kind === 'tool' && options.expandedTools?.has(block.callId) === true;
+    const lines = block.kind === 'tool' && toolDetails
+        ? toolBlockLines(block, theme, options.width, 'details', options.toolDetailsKey)
+        : blockLines(block, theme, options.width, { toolsExpanded: expanded, omitReasoning, toolDetailsKey: options.toolDetailsKey ?? 'Alt+O', mathMode: options.mathMode ?? 'auto', mermaidMode: options.mermaidMode ?? 'auto' });
     blockLinesCache.set(block, {
+        mathMode: options.mathMode,
+        mermaidMode: options.mermaidMode,
+        toolDetailsKey: options.toolDetailsKey,
+        toolDetails,
         width: options.width,
         colors: options.colors,
         trueColor,
         themeName,
-        spinnerFrame: animatedSpinnerFrame,
         expanded,
+        omitReasoning,
         lines,
     });
     return lines;
 }
+/**
+ * What a stretch of the transcript was doing, as a short English label.
+ *
+ * Status strings are English until a language layer exists, so every label a
+ * reader can see is resolved from this one table rather than spelled into the
+ * rendering code. A tool with no family is reported by its own name, which is
+ * still more informative than dropping it.
+ */
+const PROCESS_LABELS = [
+    { match: /^read$/, label: 'Read file' },
+    { match: /^(read_image|readImage)$/, label: 'View image' },
+    { match: /^(write|notebook_edit|apply_patch)$/, label: 'Write file' },
+    { match: /^(edit|multi_edit|str_replace_editor)$/, label: 'Edit file' },
+    { match: /^(grep|glob|list_dir|search)$/, label: 'Search code' },
+    { match: /^(bash|shell|pwsh|exec|write_stdin)$/, label: 'Run command' },
+    { match: /^(run_code)$/, label: 'Run code' },
+    { match: /^(web_search)$/, label: 'Search web' },
+    { match: /^(web_fetch)$/, label: 'Fetch page' },
+    {
+        match: /^(subagent|subagent_fork|subagent_isolated|agent|ralph|workflow_run)$/, label: 'Run subagent',
+    },
+    {
+        match: /^(session_search|session_trace|session_event_read|session_event_search|session_event_trace)$/,
+        label: 'Search sessions',
+    },
+    {
+        match: /^(todo_write|update_goal|create_goal|get_goal)$/, label: 'Update plan',
+    },
+    {
+        match: /^(ask_user_question|ask_user|user_question)$/, label: 'Ask question',
+    },
+    { match: /^skill$/, label: 'Load skill' },
+];
+/**
+ * The phrase for one tool, or the tool's own name when it belongs to no
+ * category. An unknown tool still says what it is, which is honest; inventing a
+ * category for it would not be.
+ */
+function processLabel(name) {
+    for (const category of PROCESS_LABELS) {
+        if (category.match.test(name))
+            return category.label;
+    }
+    return name;
+}
+/** A group has to stand for repetition; one row is not repetition. */
+const MIN_GROUP_BLOCKS = 2;
+function blockIdentity(block, index) {
+    if (block.kind === 'tool')
+        return `tool:${block.callId}`;
+    if (block.kind === 'assistant')
+        return `assistant:${reasoningKey(block)}`;
+    // A run is keyed by its first block, and a run may begin with a process
+    // notice. Keying that by kind alone gave every such run in the document the
+    // same key, so opening one opened all of them and the reader's opened-run
+    // state bled across turns. The notice's durable source tells them apart; the
+    // index is the last resort for one that carries none, which still cannot
+    // collide with another notice's keyed run.
+    if (block.kind === 'notice' && block.process?.source !== undefined) {
+        return `notice:${block.process.source}`;
+    }
+    return `${block.kind}@${index}`;
+}
+/**
+ * Does this block belong to a turn's run, or stand on its own?
+ *
+ * Everything a turn does between the prompt and its answer is the run: every
+ * thought, every call, every reply the model wrote on the way, and the notices
+ * that report on that work — a retry, a background job settling. A thought used
+ * to close the run before it, which split a fifty-step turn into fifty runs;
+ * then a reply written mid-turn did the same, and a job notice split it again.
+ * The reference client folds the whole turn behind one line and leaves only the
+ * answer outside, and that is the shape a reader scrolling back wants: one row
+ * per turn, then what it concluded.
+ *
+ * An interrupted step is not work: it carries the notice that it stopped.
+ */
+function isProcessBlock(block) {
+    if (block.kind === 'tool')
+        return true;
+    if (block.kind === 'notice')
+        return block.process !== undefined;
+    return block.kind === 'assistant' && block.interrupted !== true;
+}
+function blockTurn(block) {
+    if (block.kind === 'tool' || block.kind === 'assistant')
+        return block.turn;
+    if (block.kind === 'notice')
+        return block.process?.turn;
+    return undefined;
+}
+function isLiveBlock(block) {
+    return (block.kind === 'tool' && block.status === 'running')
+        || (block.kind === 'assistant' && block.streaming && block.text === '');
+}
+/**
+ * Project the transcript's turns into runs without touching the block list.
+ *
+ * A stretch of process blocks from one turn is one run. If the stretch ends on
+ * a reply, that reply is the turn's answer and stays outside; any reply before
+ * it was written on the way and is part of the run. A prompt, the per-turn
+ * changed-file record, or any notice that speaks to the reader ends the stretch,
+ * and so does a block from another turn — two turns with no prompt between
+ * them, such as a goal continuing itself, still read as two runs.
+ *
+ * The block list is deliberately left alone: a group is a rendering decision, so
+ * search, focus, and the row offsets keep addressing real blocks, and a group
+ * that is still growing cannot invalidate anything a reader already saw.
+ */
+export function processGroups(blocks) {
+    const groups = [];
+    let start = -1;
+    let segmentTurn;
+    const flush = (end) => {
+        if (start < 0)
+            return;
+        // The turn's answer is the stretch's last reply, and process work can
+        // settle after it: a background job finishes, a retry is reported, both
+        // reported as process blocks precisely so they join the run instead of
+        // splitting it. Those trailing blocks are the run's work but not its
+        // conclusion, so the run ends at the answer and they follow it as rows of
+        // their own. Reading only the stretch's last block mistook them for the
+        // answer's absence and folded the answer itself into the run, where a
+        // folded standard transcript hid the whole reply.
+        //
+        // The last reply wins, not the first one met going back: a turn's earlier
+        // replies were written on the way and belong to the run, so scanning back
+        // from the end and taking the first reply would fold the one reply the
+        // model wrote mid-turn and leave the real answer outside it.
+        let answer;
+        for (let at = start; at < end; at += 1) {
+            const block = blocks[at];
+            if (block?.kind === 'assistant' && block.text !== '')
+                answer = at;
+            else if (block !== undefined && !isProcessBlock(block))
+                break;
+        }
+        const memberEnd = answer ?? end;
+        const last = blocks[answer ?? end - 1];
+        const absorbs = answer !== undefined && last?.kind === 'assistant' && last.reasoning !== '' ? answer : undefined;
+        const size = memberEnd - start + (absorbs === undefined ? 0 : 1);
+        const answerIndex = answer;
+        if (size >= MIN_GROUP_BLOCKS || (size > 0 && segmentTurn !== undefined)) {
+            let calls = 0;
+            let failures = 0;
+            let live = false;
+            // The whole stretch counts, not just the part before the answer: a
+            // background job that settles behind the reply is still work this run
+            // did, and a failed call among them is still a failure. Stopping at the
+            // answer left the header saying fewer calls than the reader could see,
+            // and said nothing about a call that failed after it.
+            for (let at = start; at < end; at += 1) {
+                const block = blocks[at];
+                if (isLiveBlock(block))
+                    live = true;
+                if (block.kind === 'notice' && block.level === 'error')
+                    failures += 1;
+                if (block.kind !== 'tool')
+                    continue;
+                calls += 1;
+                if (block.status === 'error')
+                    failures += 1;
+            }
+            const turn = segmentTurn ?? (blocks[end]?.kind === 'workspace' ? blocks[end].turn : undefined);
+            groups.push({
+                start,
+                until: end,
+                ...(answerIndex === undefined ? {} : { answer: answerIndex }),
+                // The run took this step's thought as its last row, so its words are
+                // painted without it. A separate flag rather than a second index: the
+                // block is always the answer.
+                tookThought: absorbs !== undefined,
+                calls,
+                failures,
+                live,
+                ...(turn === undefined ? {} : { turn }),
+                key: blockIdentity(blocks[start], start),
+            });
+        }
+        start = -1;
+        segmentTurn = undefined;
+    };
+    blocks.forEach((block, index) => {
+        if (!isProcessBlock(block)) {
+            flush(index);
+            return;
+        }
+        const turn = blockTurn(block);
+        if (start >= 0 && turn !== undefined && segmentTurn !== undefined && turn !== segmentTurn)
+            flush(index);
+        if (start < 0)
+            start = index;
+        segmentTurn ??= turn;
+    });
+    flush(blocks.length);
+    return groups;
+}
+/**
+ * The runs as the reader sees them now: {@link processGroups}, with the run a
+ * running turn is still adding to marked live.
+ *
+ * That run is live even between two events, when nothing is in flight — the
+ * model is choosing what to do next — and while the answer streams below it,
+ * so it becomes a group once, when the turn ends, rather than folding and
+ * unfolding at every pause. The host aims Ctrl+O with the same projection the
+ * renderer paints, so the two cannot disagree about what is folded.
+ */
+export function turnGroups(state) {
+    const groups = processGroups(state.blocks);
+    if (state.status === 'idle')
+        return groups;
+    const last = state.blocks.length;
+    return groups.map(group => {
+        // `until` is the stretch's true end, including work that settled after the
+        // answer; comparing `end` would call a run with trailing work settled
+        // before the transcript's tail, and it would fold while the turn ran.
+        const trailing = group.until === last
+            || (group.until === last - 1 && state.blocks[group.until]?.kind === 'assistant');
+        const current = (group.turn === state.turn || (state.turn === 0 && trailing))
+            && state.turnSpans?.[state.turn]?.end === undefined;
+        return (current || (group.turn === undefined && trailing)) && !group.live ? { ...group, live: true } : group;
+    });
+}
 function renderTranscriptBody(state, options, theme, spinnerFrame) {
     const toolsExpanded = options.toolsExpanded === true;
     const expandedTools = [...(options.expandedTools ?? [])].sort().join('\0');
+    const expandedReasoning = [...(options.expandedReasoning ?? [])].sort().join('\0');
+    const openedGroups = [...(options.openedGroups ?? [])].sort().join('\0');
     const themeName = options.themeName ?? 'dark';
     const trueColor = options.trueColor === true;
     const animatedSpinnerFrame = state.blocks.some(block => block.kind === 'tool' && block.status === 'running')
@@ -285,36 +878,279 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
         && cached.trueColor === trueColor
         && cached.themeName === themeName
         && cached.spinnerFrame === animatedSpinnerFrame
+        && cached.mathMode === options.mathMode
+        && cached.mermaidMode === options.mermaidMode
         && cached.toolsExpanded === toolsExpanded
         && cached.expandedTools === expandedTools
-        && cached.searchKey === searchKey) {
-        return { lines: cached.lines, blockStarts: cached.blockStarts };
+        && cached.expandedReasoning === expandedReasoning
+        && cached.openedGroups === openedGroups
+        && cached.toolDetailsKey === options.toolDetailsKey
+        && cached.turnSpans === state.turnSpans
+        && cached.turnDetailsKey === options.turnDetailsKey
+        && cached.searchKey === searchKey
+        && cached.status === state.status
+        && cached.focusBlock === options.focusBlock) {
+        return {
+            lines: cached.lines,
+            blockStarts: cached.blockStarts,
+            blockDrawStarts: cached.blockDrawStarts,
+            foldShape: cached.foldShape,
+            foldMarks: cached.foldMarks,
+            liveFrom: cached.liveFrom,
+        };
     }
     const matches = new Set(search?.matches ?? []);
     const lines = [];
     const blockStarts = [];
+    // Where each block is drawn, apart from the offsets above: a search can aim a
+    // block's offset at the thought it also carries, but its drawn span does not
+    // move, and the boundary mapper needs the drawn one.
+    const blockDrawStarts = [];
     let previous;
+    // A group is a rendering decision, so a block keeps its own identity and row
+    // offset whether or not the group around it is open. A collapsed group
+    // therefore owns the rows of its first block and nothing after it, which is
+    // why anything a reader can address — a search match, the focused block — has
+    // to force its own group open.
+    const groups = turnGroups(state);
+    const groupOf = new Int32Array(state.blocks.length).fill(-1);
+    const openGroups = new Set();
+    const absorbed = new Set();
+    // Thoughts a search hit has to show in full, beyond what the reader opened.
+    const openedThoughts = new Set(options.expandedReasoning ?? []);
+    // Where each answer's thought is actually drawn, for its fold mark. The
+    // navigation offset below may point elsewhere; the mark must not follow it.
+    const drawnThoughts = new Map();
+    const lastOfTurn = new Map();
+    groups.forEach((group, index) => {
+        for (let at = group.start; at < group.until; at += 1)
+            groupOf[at] = index;
+        // The turn's answer is painted below the run, not inside it. Leaving it
+        // claimed here would route the reply through the run's body and drop it
+        // from a folded transcript, which is what a reader most needs to see.
+        if (group.answer !== undefined && group.answer !== group.start)
+            groupOf[group.answer] = -1;
+        if (group.tookThought && group.answer !== undefined)
+            absorbed.add(group.answer);
+        if (group.turn !== undefined)
+            lastOfTurn.set(group.turn, index);
+        const reasoningHit = group.tookThought && group.answer !== undefined
+            && search !== undefined && matches.has(group.answer)
+            && blockMatchesQuery(state.blocks[group.answer].reasoning, search.query);
+        // A hit inside the thought the run took needs that thought laid out in
+        // full. Opening only the run shows a one-line preview, so the matched text
+        // stays out of sight while the transcript reports the hit. This is a render
+        // decision, not the reader's own state, so it goes in a local set rather
+        // than into the options the host owns.
+        if (reasoningHit && group.answer !== undefined) {
+            openedThoughts.add(reasoningKey(state.blocks[group.answer]));
+        }
+        const asked = toolsExpanded
+            || options.openedGroups?.has(group.key) === true
+            || state.blocks.slice(group.start, group.until).some(block => block.kind === 'tool' && options.expandedTools?.has(block.callId))
+            || reasoningHit
+            || [...matches].some(index => index >= group.start && index < group.until)
+            || options.focusBlock !== undefined
+                && options.focusBlock >= group.start && options.focusBlock < group.until;
+        if (asked)
+            openGroups.add(index);
+    });
+    // Every surface that is open, keyed and placed, so the host can tell where a
+    // change of shape starts. Global switches reshape from the top.
+    const foldMarks = [];
+    if (toolsExpanded)
+        foldMarks.push({ key: 'all', row: 0 });
+    let liveFrom;
+    const context = {
+        blocks: state.blocks, theme, themeName, trueColor, width: options.width,
+        matches, options: { ...options, expandedReasoning: openedThoughts },
+    };
+    const compactProcessRow = (block) => {
+        if (block?.kind === 'notice')
+            return block.process !== undefined && block.framed !== true;
+        return block?.kind === 'tool' && !toolsExpanded && !options.expandedTools?.has(block.callId);
+    };
+    // Only a turn's last run is summarized by how long the turn took; an earlier
+    // run in the same turn did not take all of it.
+    const elapsedOf = (index) => {
+        const group = groups[index];
+        if (group.live || group.turn === undefined || lastOfTurn.get(group.turn) !== index)
+            return undefined;
+        const span = state.turnSpans?.[group.turn];
+        return span?.end === undefined ? undefined : formatElapsed(span.end - span.start);
+    };
     for (let index = 0; index < state.blocks.length; index += 1) {
         const block = state.blocks[index];
-        if (lines.length > 0) {
+        const groupIndex = groupOf[index] ?? -1;
+        if (groupIndex >= 0) {
+            // A run is painted whole by its first block: the header, then its rows
+            // when open. A collapsed run still shows the rows that failed, because a
+            // header saying only "something failed" would hide the row that says
+            // what — and forcing the whole run open for one failed grep would undo
+            // the fold for the most common failure there is.
+            const group = groups[groupIndex];
+            if (lines.length > 0)
+                lines.push('');
+            const headerRow = lines.length;
+            const opened = openGroups.has(groupIndex);
+            const shape = group.live ? 'live' : opened ? 'open' : 'folded';
+            foldMarks.push({ key: `run:${group.key}:${shape}`, row: headerRow });
+            if (group.live)
+                liveFrom ??= headerRow;
+            // A live run has no header: it becomes a group when its turn ends.
+            if (!group.live && !opened) {
+                lines.push(...processGroupHeader(group, theme, options.width, elapsedOf(groupIndex), options.turnDetailsKey));
+            }
+            const bodyRow = lines.length;
+            let offsets = new Map();
+            if (group.live || opened) {
+                const body = processGroupBody(group, context);
+                for (const line of body.lines)
+                    lines.push(line);
+                offsets = body.offsets;
+            }
+            else {
+                for (let at = group.start; at < (group.answer ?? group.until); at += 1) {
+                    const member = state.blocks[at];
+                    if (!(member.kind === 'tool' && member.status === 'error')
+                        && !(member.kind === 'notice' && member.level === 'error'))
+                        continue;
+                    offsets.set(at, lines.length - bodyRow);
+                    lines.push(...(member.kind === 'tool' ? toolRowLine(member, theme, options.width, spinnerFrame) : groupMemberLines(at, context)));
+                }
+            }
+            // The turn's answer, painted as a row of its own between the run's work
+            // and the work that settled behind it, in the order the events arrived.
+            // Painting it last would read as though the run concluded after the
+            // notice, and — worse — would give the answer and the notice each other's
+            // row, so a reader aiming at one landed on the other.
+            if (group.answer !== undefined) {
+                if (lines.length > 0)
+                    lines.push('');
+                // The run painted this step's thought above; keep its row. The thought's
+                // row is where it is *drawn*, which is not the same as where a search
+                // should put the reader: a query in the reply aims at the reply, a query
+                // in the thought at the thought. The draw position is what a fold mark
+                // has to report, so it is kept apart from the navigation offset below
+                // rather than being overwritten by it.
+                const thoughtHit = group.tookThought
+                    && search !== undefined && matches.has(group.answer)
+                    && !blockMatchesQuery(state.blocks[group.answer].text, search.query);
+                const thoughtRow = offsets.get(group.answer);
+                drawnThoughts.set(group.answer, thoughtRow);
+                // The answer's own drawn start is its words, never the thought above
+                // them — a search aims `offsets` at the thought so the reader lands on
+                // the match, and the boundary mapper must not mistake that for the
+                // answer starting earlier.
+                blockDrawStarts[group.answer] = lines.length;
+                offsets.set(group.answer, lines.length - bodyRow);
+                const answer = state.blocks[group.answer];
+                const rendered = cachedBlockLines(answer, options, theme, themeName, trueColor, toolsExpanded, absorbed.has(group.answer));
+                for (const line of (search !== undefined && matches.has(group.answer)
+                    ? rendered.map(row => blockMatchesQuery(stripAnsi(row), search.query) ? theme.inverse(row) : row)
+                    : rendered))
+                    lines.push(line);
+                if (thoughtHit && thoughtRow !== undefined)
+                    blockStarts[group.answer] = bodyRow + thoughtRow;
+                if (thoughtHit && thoughtRow !== undefined)
+                    offsets.set(group.answer, thoughtRow);
+                // One block, two rows: the run painted its thought above, this painted
+                // its words below. A search hit can be in either, and the offset has to
+                // lead to the one that matched — aiming at the reply left a long
+                // thought's match above the viewport, found and not readable.
+            }
+            // Work that settled after the answer still belongs to the run, so it is
+            // painted as the run's rows directly beneath the reply rather than as
+            // loose paragraphs at the page's left margin.
+            for (let at = group.answer === undefined ? group.until : group.answer + 1; at < group.until; at += 1) {
+                // Appended one at a time: a long run's member can be a very large
+                // array, and spreading it into a call overflows the argument limit.
+                const trailing = state.blocks[at];
+                const failed = (trailing?.kind === 'notice' && trailing.level === 'error')
+                    || (trailing?.kind === 'tool' && trailing.status === 'error');
+                if (group.live || opened || failed) {
+                    if (lines.length > 0 && !(trailing?.kind === 'notice' && state.blocks[at - 1]?.kind === 'notice'))
+                        lines.push('');
+                    offsets.set(at, lines.length - bodyRow);
+                    const rows = !group.live && !opened && trailing?.kind === 'tool'
+                        ? toolRowLine(trailing, theme, options.width, spinnerFrame)
+                        : groupMemberLines(at, context);
+                    for (const line of rows)
+                        lines.push(line);
+                }
+            }
+            // A member the body did not paint answers to the header, which is the row
+            // a reader aiming at it would land on anyway. Offsets are assigned by
+            // block index, never by the order the rows were painted: the two differ
+            // once a run carries an answer with work behind it, and a shifted offset
+            // aims a search hit or a Ctrl+O at the wrong row.
+            for (let at = group.start; at < group.until; at += 1) {
+                const offset = offsets.get(at);
+                const row = offset === undefined ? headerRow : bodyRow + offset;
+                blockStarts[at] = row;
+                const member = state.blocks[at];
+                // Not `offsets`: a search may have aimed that at the thought, and this
+                // array is the blocks' own drawn positions.
+                if (blockDrawStarts[at] === undefined) {
+                    const drawn = offsets.get(at);
+                    blockDrawStarts[at] = drawn === undefined ? headerRow : bodyRow + drawn;
+                }
+                if (member.kind === 'tool' && options.expandedTools?.has(member.callId) === true) {
+                    foldMarks.push({ key: `call:${member.callId}`, row });
+                }
+                // The effective set, not the host's: a search can open a thought the
+                // reader never asked for, and the rows that adds still reshaped. The
+                // key is the same one the host already uses for a thought it opened, so
+                // the two causes share one identity and neither is encoded in it.
+                if (member.kind === 'assistant' && openedThoughts.has(reasoningKey(member))) {
+                    const drawn = drawnThoughts.get(at);
+                    foldMarks.push({ key: `thought:${reasoningKey(member)}`, row: drawn === undefined ? row : bodyRow + drawn });
+                }
+            }
+            // Everything this run owned is painted, so the walk resumes past it.
+            index = group.until - 1;
+            continue;
+        }
+        else if (lines.length > 0) {
             const previousCommand = commandSurfaceName(previous);
             const currentCommand = commandSurfaceName(block);
             if (previousCommand !== undefined && currentCommand !== undefined && previousCommand !== currentCommand) {
                 lines.push('', renderCommandSeparator(theme, options.width), '');
             }
-            else {
+            else if (!compactProcessRow(block) || !compactProcessRow(state.blocks[index - 1])) {
                 lines.push('');
             }
         }
-        blockStarts.push(lines.length);
-        const expanded = toolsExpanded || (block.kind === 'tool' && options.expandedTools?.has(block.callId) === true);
-        const rendered = cachedBlockLines(block, options, theme, themeName, trueColor, spinnerFrame, expanded);
+        blockStarts[index] = lines.length;
+        if (block.kind === 'tool' && options.expandedTools?.has(block.callId) === true) {
+            foldMarks.push({ key: `call:${block.callId}`, row: lines.length });
+        }
+        if (block.kind === 'assistant' && options.expandedReasoning?.has(reasoningKey(block)) === true) {
+            foldMarks.push({ key: `thought:${reasoningKey(block)}`, row: lines.length });
+        }
+        const liveBlock = state.status !== 'idle' && isProcessBlock(block)
+            && (block.kind !== 'assistant' || block.reasoning !== '')
+            && (blockTurn(block) === undefined || blockTurn(block) === state.turn);
+        if (liveBlock)
+            liveFrom ??= lines.length;
+        const expanded = (block.kind === 'workspace' && groups.some((group, at) => group.turn === block.turn && openGroups.has(at))) || matches.has(index) || toolsExpanded
+            || (block.kind === 'tool' && options.expandedTools?.has(block.callId) === true);
+        const rendered = cachedBlockLines(block, options, theme, themeName, trueColor, expanded, absorbed.has(index));
         lines.push(...(search !== undefined && matches.has(index)
             ? rendered.map(line => blockMatchesQuery(stripAnsi(line), search.query) ? theme.inverse(line) : line)
             : rendered));
+        blockDrawStarts[index] = blockStarts[index];
         previous = block;
     }
+    // Streaming text and a call settling change rows in place without changing
+    // this; opening, folding, or a run settling at turn end do.
+    const foldShape = foldMarks.map(mark => mark.key).join('\u0001');
     transcriptBodyCache.set(state.blocks, {
+        mathMode: options.mathMode,
+        mermaidMode: options.mermaidMode,
+        toolDetailsKey: options.toolDetailsKey,
+        turnDetailsKey: options.turnDetailsKey,
+        blockDrawStarts,
         width: options.width,
         colors: options.colors,
         trueColor,
@@ -322,11 +1158,19 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
         spinnerFrame: animatedSpinnerFrame,
         toolsExpanded,
         expandedTools,
+        expandedReasoning,
+        openedGroups,
         searchKey,
+        turnSpans: state.turnSpans,
+        status: state.status,
+        focusBlock: options.focusBlock,
+        foldShape,
+        foldMarks,
+        liveFrom,
         lines,
         blockStarts,
     });
-    return { lines, blockStarts };
+    return { lines, blockStarts, blockDrawStarts, foldShape, foldMarks, liveFrom };
 }
 function commandSurfaceName(block) {
     if (block?.kind === 'toolCatalog')
@@ -337,6 +1181,15 @@ function commandSurfaceName(block) {
 }
 /** Rows moved per Shift+Arrow (OMP ScrollView `fastScrollLines`). */
 export const TRANSCRIPT_FAST_SCROLL = 5;
+const promptSummaryCache = new WeakMap();
+function promptSummary(block) {
+    const cached = promptSummaryCache.get(block);
+    if (cached !== undefined)
+        return cached;
+    const summary = block.text.replace(/\s+/gu, ' ').trim();
+    promptSummaryCache.set(block, summary);
+    return summary;
+}
 function earlierLabel(count) {
     return '… ↑ ' + count + ' earlier line' + (count === 1 ? '' : 's') + ' ⟨Pg↑⟩';
 }
@@ -346,14 +1199,22 @@ function laterLabel(count) {
 /**
  * Window `body` into `budget` rows with ↑/↓ overflow markers.
  * `start` is the first body row to keep; non-finite values pin to the tail.
+ *
+ * `documentRows` says which of `body`'s rows the returned lines are, and where
+ * in the returned lines they start. A window that is nothing but an overflow
+ * marker carries none: `null`, because the frame drew no body rather than
+ * because the caller forgot to say.
  */
 export function windowTranscript(body, budget, start, theme) {
     const len = body.length;
     if (budget <= 0) {
-        return { lines: [], start: 0, maxStart: 0, budget, hiddenAbove: len, hiddenBelow: 0 };
+        return { lines: [], start: 0, maxStart: 0, budget, hiddenAbove: len, hiddenBelow: 0, documentRows: null };
     }
     if (len <= budget) {
-        return { lines: [...body], start: 0, maxStart: 0, budget, hiddenAbove: 0, hiddenBelow: 0 };
+        return {
+            lines: [...body], start: 0, maxStart: 0, budget, hiddenAbove: 0, hiddenBelow: 0,
+            documentRows: { documentStart: 0, documentEnd: len, frameStart: 0 },
+        };
     }
     const maxStart = Math.max(0, len - (budget - 1));
     const s = Number.isFinite(start) ? Math.max(0, Math.min(Math.trunc(start), maxStart)) : maxStart;
@@ -372,6 +1233,7 @@ export function windowTranscript(body, budget, start, theme) {
             budget,
             hiddenAbove: atTail ? len : s,
             hiddenBelow: atTail ? 0 : len - s,
+            documentRows: null,
         };
     }
     if (atTail) {
@@ -379,6 +1241,7 @@ export function windowTranscript(body, budget, start, theme) {
         const hiddenAbove = len - take;
         return {
             lines: [theme.fg('dim', earlierLabel(hiddenAbove)), ...body.slice(hiddenAbove)],
+            documentRows: { documentStart: hiddenAbove, documentEnd: len, frameStart: 1 },
             start: hiddenAbove,
             maxStart,
             budget,
@@ -391,6 +1254,7 @@ export function windowTranscript(body, budget, start, theme) {
         const hiddenBelow = len - take;
         return {
             lines: [...body.slice(0, take), theme.fg('dim', laterLabel(hiddenBelow))],
+            documentRows: { documentStart: 0, documentEnd: take, frameStart: 0 },
             start: 0,
             maxStart,
             budget,
@@ -401,6 +1265,7 @@ export function windowTranscript(body, budget, start, theme) {
     if (budget === 2) {
         return {
             lines: [theme.fg('dim', earlierLabel(s)), body[s] ?? ''],
+            documentRows: { documentStart: s, documentEnd: s + 1, frameStart: 1 },
             start: s,
             maxStart,
             budget,
@@ -416,6 +1281,7 @@ export function windowTranscript(body, budget, start, theme) {
             ...body.slice(s, s + take),
             theme.fg('dim', laterLabel(hiddenBelow)),
         ],
+        documentRows: { documentStart: s, documentEnd: s + take, frameStart: 1 },
         start: s,
         maxStart,
         budget,
@@ -640,6 +1506,17 @@ export function renderTurnError(text, theme, width) {
         + (suffix === '' ? '' : theme.fg('dim', suffix));
     return [padToWidth(line, width)];
 }
+/** Human guidance remains visible until the Harness claims it for a model step. */
+export function renderSteering(inbox, theme, width) {
+    const messages = inbox.filter(message => message.source.kind === 'user');
+    if (messages.length === 0 || width <= 0)
+        return [];
+    const latest = queuedMessageLabel(messages.at(-1));
+    const count = messages.length > 1 ? ` · ${messages.length}` : '';
+    return [truncateToWidth('  ' + theme.fg('border', '│') + ' '
+            + theme.bold(theme.fg('accent', 'Guidance · next step' + count))
+            + theme.fg('dim', ' · ') + theme.fg('text', latest), width)];
+}
 /** Compact, unframed pending-message view placed immediately above the composer. */
 export function renderQueuedSubmissions(submissions, theme, width, inbox = []) {
     const labels = [
@@ -664,9 +1541,9 @@ export function renderQueuedSubmissions(submissions, theme, width, inbox = []) {
         return paintedLeft + '  ' + action;
     };
     if (labels.length === 1) {
-        return [alignAction(rail + queueLabel + theme.fg('dim', ' · ') + theme.fg('text', labels[0] ?? ''), theme.fg('dim', '↑ edit'))];
+        return [alignAction(rail + queueLabel + theme.fg('dim', ' · ') + theme.fg('dim', 'next turn · ') + theme.fg('text', labels[0] ?? ''), theme.fg('dim', '↑ edit'))];
     }
-    const summary = ` · ${labels.length}${hidden === 0 ? '' : ` · ${hidden} earlier`}`;
+    const summary = ` · ${labels.length} · next turn${hidden === 0 ? '' : ` · ${hidden} earlier`}`;
     const visibleLabels = labels.slice(start);
     const lines = [
         alignAction(rail + queueLabel + theme.fg('dim', summary), theme.fg('dim', '↑ edit latest'), false),
@@ -697,6 +1574,8 @@ export function renderView(state, options) {
             lines: fitFrame(hub.lines, width),
             cursor: hub.cursor,
             cursorVisible: hub.cursorVisible,
+            // A full-screen surface drew no transcript body.
+            documentRows: null,
         };
     }
     if (options.trajectory !== undefined) {
@@ -705,6 +1584,8 @@ export function renderView(state, options) {
             lines: fitFrame(trajectory.lines, width),
             cursor: trajectory.cursor,
             cursorVisible: trajectory.cursorVisible,
+            // A full-screen surface drew no transcript body.
+            documentRows: null,
         };
     }
     if (options.settings !== undefined && options.promptSelector === undefined) {
@@ -713,22 +1594,30 @@ export function renderView(state, options) {
             lines: fitFrame(settings.lines, width),
             cursor: settings.cursor,
             cursorVisible: false,
+            // A full-screen surface drew no transcript body.
+            documentRows: null,
         };
     }
-    if (options.promptSelector?.request.presentation === 'fullscreen-list') {
-        const selector = renderPromptSelectorPage(options.promptSelector, theme, width, height, options.input, options.inputCursor, appName);
+    if (options.promptSelector?.request.presentation === 'fullscreen-list' || options.promptSelector?.request.presentation === 'fullscreen-tree') {
+        const selector = (options.promptSelector.request.presentation === 'fullscreen-tree' ? renderPromptTreePage : renderPromptSelectorPage)(options.promptSelector, theme, width, height, options.input, options.inputCursor, appName);
         return {
             lines: fitFrame(selector.lines, width),
+            ...(selector.document === undefined ? {} : { promptDocument: selector.document }),
             cursor: selector.cursor,
             cursorVisible: true,
+            // A full-screen surface drew no transcript body.
+            documentRows: null,
         };
     }
-    if (options.promptSelector?.request.presentation === 'plan-review') {
-        const review = renderPlanReviewPage(options.promptSelector, theme, width, height, options.input, options.inputCursor, appName);
+    if (options.promptSelector?.request.presentation === 'plan-review' || options.promptSelector?.request.presentation === 'document') {
+        const review = options.promptSelector.request.documentImage === undefined ? renderPlanReviewPage(options.promptSelector, theme, width, height, options.input, options.inputCursor, appName) : renderImagePreviewPage(options.promptSelector, theme, width, height, appName, options.imageProtocol, options.imageCellSize);
         return {
+            ...(review.image === undefined ? {} : { image: review.image }),
             lines: fitFrame(review.lines, width),
             cursor: review.cursor,
             cursorVisible: review.cursorVisible === true,
+            // A full-screen surface drew no transcript body.
+            documentRows: null,
             ...(review.document === undefined ? {} : { promptDocument: review.document }),
         };
     }
@@ -764,6 +1653,8 @@ export function renderView(state, options) {
         }, options.transcriptSearch.matches.length)
         : options.inspected === undefined
             ? slashInlineHint(options.input, options.inputCursor, options.commands)
+                ?? (state.status === 'running' && options.steerKey !== undefined
+                    ? `Enter: next turn · ${options.steerKey}: next step` : null)
             : options.inspected.writable
                 ? slashInlineHint(options.input, options.inputCursor, options.commands) ?? 'Enter to steer · Esc to return'
                 : 'Read-only · Esc to return';
@@ -813,7 +1704,10 @@ export function renderView(state, options) {
         : undefined;
     const queuedSubmissions = editor === undefined || options.inspected !== undefined
         ? []
-        : renderQueuedSubmissions(options.queuedSubmissions ?? [], theme, width, state.nextTurnInbox);
+        : [
+            ...renderSteering(state.nextStepInbox, theme, width),
+            ...renderQueuedSubmissions(options.queuedSubmissions ?? [], theme, width, state.nextTurnInbox),
+        ];
     // Above the composer and below the queue: the failure explains why the queue
     // is not moving, and the row survives until the next submission.
     const turnError = editor === undefined || options.inspected !== undefined || state.turnError === undefined
@@ -823,6 +1717,10 @@ export function renderView(state, options) {
     const goal = editor === undefined || options.inspected !== undefined || options.sessionControls?.goal === undefined
         ? []
         : renderGoalBar(options.sessionControls.goal, theme, width);
+    const pendingCount = options.sessionControls?.pendingQuestions ?? 0;
+    const questions = editor === undefined || options.inspected !== undefined || pendingCount === 0
+        ? []
+        : [truncateToWidth(theme.fg('warning', ` ${pendingCount} pending ${pendingCount === 1 ? 'question' : 'questions'} · /questions to answer`), width)];
     const inspect = editor === undefined ? [] : renderInspectBanner(options.inspected, theme, width, spinnerFrame);
     const subagents = editor === undefined
         ? []
@@ -834,29 +1732,46 @@ export function renderView(state, options) {
     const inputLines = promptSelector?.lines ?? settings?.lines ?? copySelector?.lines ?? search?.lines
         ?? (editor === undefined ? [] : editor.lines);
     const spacer = 1;
-    const reserved = inputLines.length + working.length + inspect.length + subagents.length + todos.length + goal.length + queuedSubmissions.length + turnError.length + spacer + autocomplete.length + statusFooter.length;
+    const reserved = inputLines.length + working.length + inspect.length + subagents.length + todos.length + goal.length + questions.length + queuedSubmissions.length + turnError.length + spacer + autocomplete.length + statusFooter.length;
     const budget = Math.max(0, height - reserved);
-    const focusStart = options.focusBlock === undefined
+    const focusIndex = options.focusBlock === undefined
         ? undefined
-        : transcript.blockStarts[Math.max(0, Math.min(options.focusBlock, transcript.blockStarts.length - 1))];
+        // Clamp against the blocks, not the offsets: a collapsed run's members
+        // share its header's row, so the offset list can be shorter than the block
+        // list, and clamping to it would aim the reader at a different block.
+        : Math.max(0, Math.min(options.focusBlock, state.blocks.length - 1));
+    const focusStart = focusIndex === undefined ? undefined : options.focusBlockEdge === 'end'
+        ? Math.max(0, (transcript.blockStarts[focusIndex + 1] ?? transcript.lines.length) - Math.max(1, budget - 2))
+        : transcript.blockStarts[focusIndex];
     const requestedStart = focusStart === undefined
         ? (options.scrollStart ?? Number.POSITIVE_INFINITY)
         : transcriptStart + focusStart;
     const hasOverlay = promptSelector !== undefined || settings !== undefined || copySelector !== undefined || search !== undefined;
     const isFollowing = requestedStart === Number.POSITIVE_INFINITY && !hasOverlay;
-    const livePinned = state.blocks.some(block => block.kind === 'tool' && block.status === 'running');
+    // A run still at work reshapes as it goes — its newest rows scroll, it folds
+    // when the turn ends — so none of it may freeze into history until it
+    // settles, the same way a running call's rows may not.
+    const livePinned = transcript.liveFrom !== undefined
+        || state.blocks.some(block => block.kind === 'tool' && block.status === 'running');
     const windowed = isFollowing
         ? undefined
         : windowTranscript(body, budget, requestedStart, theme);
     const visible = windowed?.lines ?? body;
     const lines = [...visible];
+    const showJump = !hasOverlay && windowed !== undefined && budget >= 3
+        && (windowed.hiddenBelow > 0 || (options.openedGroups?.size ?? 0) > 0 || options.toolsExpanded === true);
+    const jumpText = truncateToWidth(width >= 38 ? ' ↓ Jump to latest message · End ' : ' ↓ Latest · End ', width);
+    const jumpColumn = Math.max(0, Math.floor((width - visibleWidth(jumpText)) / 2));
+    const jumpToLatest = showJump ? { row: lines.length, column: jumpColumn, width: visibleWidth(jumpText) } : undefined;
     if (visible.length > 0)
-        lines.push('');
-    const bottomRows = working.length + goal.length + inspect.length + subagents.length + todos.length + queuedSubmissions.length + turnError.length + inputLines.length + autocomplete.length + statusFooter.length;
+        lines.push(showJump
+            ? ' '.repeat(jumpColumn) + theme.inverse(jumpText) : '');
+    const bottomRows = working.length + goal.length + questions.length + inspect.length + subagents.length + todos.length + queuedSubmissions.length + turnError.length + inputLines.length + autocomplete.length + statusFooter.length;
     const fill = Math.max(0, height - lines.length - bottomRows);
     lines.push(...Array.from({ length: fill }, () => ''));
     lines.push(...working);
     lines.push(...goal);
+    lines.push(...questions);
     lines.push(...inspect);
     lines.push(...subagents);
     lines.push(...todos);
@@ -869,8 +1784,12 @@ export function renderView(state, options) {
     let liveStart;
     if (isFollowing) {
         const firstPending = state.blocks.findIndex(isBlockPending);
-        if (firstPending >= 0) {
-            liveStart = transcriptStart + transcript.blockStarts[firstPending];
+        const pendingRow = firstPending >= 0 ? transcript.blockStarts[firstPending] : undefined;
+        const liveRow = transcript.liveFrom === undefined
+            ? pendingRow
+            : Math.min(pendingRow ?? transcript.liveFrom, transcript.liveFrom);
+        if (liveRow !== undefined) {
+            liveStart = transcriptStart + liveRow;
         }
         else {
             liveStart = lines.length - bottomRows;
@@ -888,8 +1807,40 @@ export function renderView(state, options) {
     // of measuring the complete native-scrollback history on every frame.
     const trimmed = fitFrame(lines, width, isFollowing ? liveStart : 0);
     const caret = promptSelector?.cursor ?? settings?.cursor ?? copySelector?.cursor ?? search?.cursor ?? editor?.cursor ?? { row: 0, column: 0 };
+    // Which document rows this frame's body came from. `body` already includes the
+    // header, so a window's own range is already in document coordinates and must
+    // not have the header added again. No window means the whole body was drawn —
+    // that is a known range, not a frame that failed to report one, and treating
+    // it as "no body" would clear the record on every ordinary follow frame.
+    const windowRange = windowed === undefined
+        ? (body.length === 0 ? null : { documentStart: 0, documentEnd: body.length, frameStart: 0 })
+        : windowed.documentRows;
+    const bodySource = windowRange === undefined
+        ? null
+        : windowRange;
+    const stickyHeaders = [];
+    if (!hasOverlay && budget >= 3) {
+        for (let at = 0; at < state.blocks.length; at += 1) {
+            const block = state.blocks[at];
+            if (block.kind !== 'user')
+                continue;
+            const previous = stickyHeaders.at(-1);
+            if (previous !== undefined)
+                previous.end = transcriptStart + transcript.blockStarts[at];
+            const padding = width > 4 ? 2 : 0;
+            const label = truncateToWidth(promptSummary(block), Math.max(1, width - padding * 2));
+            stickyHeaders.push({
+                start: transcriptStart + (transcript.blockStarts[at + 1] ?? transcript.lines.length),
+                end: body.length,
+                text: paintSurface(theme, 'userMessageBg', 'userMessageText', padToWidth(' '.repeat(padding) + label, width)),
+            });
+        }
+    }
     return {
         lines: trimmed,
+        stickyHeaders,
+        ...(jumpToLatest === undefined ? {} : { jumpToLatest }),
+        documentRows: bodySource,
         cursor: {
             row: editorStart + caret.row,
             column: Math.min(caret.column, width),
@@ -904,12 +1855,19 @@ export function renderView(state, options) {
         // history; the renderer needs to tell them apart because only the first may
         // borrow the alternate buffer.
         ...(liveStart === 0 ? { transientSurface: hasOverlay ? 'overlay' : 'scroll' } : {}),
-        transcript: windowed ?? {
-            start: 0,
-            maxStart: 0,
-            budget,
-            hiddenAbove: 0,
-            hiddenBelow: 0,
+        transcript: {
+            ...(windowed ?? {
+                start: (body.length > budget ? body.length - Math.max(1, budget - 1) : 0),
+                maxStart: (body.length > budget ? body.length - Math.max(1, budget - 1) : 0),
+                budget,
+                hiddenAbove: (body.length > budget ? body.length - Math.max(1, budget - 1) : 0),
+                hiddenBelow: 0,
+            }),
+            blockStarts: transcript.blockStarts,
+            blockDrawStarts: transcript.blockDrawStarts,
+            foldShape: transcript.foldShape,
+            foldMarks: transcript.foldMarks,
+            bodyRow: transcriptStart,
         },
     };
 }