@agi-fans/dsh-tui 0.22.0 → 0.23.1

package/lib/views/transcript-render.js

@@ -1,13 +1,16 @@
+import { renderFileBrowser } from "./file-browser.js";
 /**
  * Transcript rendering: Block -> lines. Every function here is pure; the two
  * WeakMap caches key formatted rows on the immutable block objects the fold
  * half produces, so scrolling never reformats settled content.
  * @module @agi-fans/dsh-tui
  */
+import { uiText } from "../locale/index.js";
+import { rosterItems, workflowStatus } from "./workflow.js";
 import { leadingSlashCommandNameRange, renderAutocomplete, slashInlineHint } from "./autocomplete.js";
 import { HISTORY_SEARCH_MAX_VISIBLE, renderHistorySearch } from "./history-search.js";
 import { DEEP_DRIVING_LABEL, renderEditor, renderFramedBlock, renderWelcome } from "../chrome/box.js";
-import { renderMarkdown } from "../chrome/markdown.js";
+import { renderMarkdown, renderStreamingMarkdown } from "../chrome/markdown.js";
 import { renderSettings } from "./settings-list.js";
 import { renderTrajectory } from "./trajectory.js";
 import { renderImagePreviewPage, renderPlanReviewPage, renderPromptSelector, renderPromptTreePage, } from "./prompt-selector.js";
@@ -16,7 +19,7 @@ import { renderPermissionBadge, renderStatusFooter } from "../chrome/status-line
 import { createTheme, paintSurface, SPINNER, SYMBOL, BOX } from "../chrome/theme.js";
 import { highlightToolText, toolPayloadLanguage } from "../chrome/code-highlight.js";
 import { renderGoalBar } from "../chrome/goal-bar.js";
-import { padToWidth, sliceCells, stripAnsi, truncateToWidth, visibleWidth, wrapTextStable } from "../chrome/width.js";
+import { padToWidth, sliceCells, stripAnsi, truncateToWidth, visibleWidth, wrapCode, wrapTextStable } from "../chrome/width.js";
 import { alignFileDiffs, wrapPaintedDiffRows, } from "../chrome/diff-render.js";
 import { workspaceBlockLines, WORKSPACE_COLLAPSED_LINES } from "./workspace-changes.js";
 import { blockFileAction } from "./file-actions.js";
@@ -28,7 +31,7 @@ import { renderPathMentionRows } from "../chrome/path-mentions.js";
 import { formatElapsed } from "../chrome/relative-time.js";
 import { maskSecrets } from "../chrome/secret-mask.js";
 import { formatOverlayHint } from "./hotkey-format.js";
-import { blockMatchesQuery, matchedRows, searchMatches, transcriptSearchHint, } from "./transcript-search.js";
+import { matchedRows, searchMatches, transcriptSearchHint, } from "./transcript-search.js";
 export { formatElapsed };
 import { contentToText, prettyArgs, reasoningKey, } from "./transcript-types.js";
 function isBlockPending(block) {
@@ -51,15 +54,7 @@ function exclusiveDiffs(presentation) {
         return presentation.call.diffs;
     return undefined;
 }
-/**
- * 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.
- */
+/** Replies and user text have a two-cell margin; process details align after the disclosure glyph. */
 const ASSISTANT_PADDING_X = 2;
 /** Process summaries keep a readable measure even on wide terminals. */
 const PROCESS_WIDTH = 80;
@@ -87,9 +82,33 @@ function shortPath(path, width) {
     }
     return prefix + tail;
 }
-function assistantContentLines(lines, width, paddingX) {
+// Streaming reuses most painted rows even though the enclosing block changes.
+// Bound both row count and retained text, including ANSI and hyperlink bytes.
+const assistantRowCache = new Map();
+let assistantRowChars = 0;
+const ASSISTANT_ROW_CACHE_CHARS = 1024 * 1024;
+function assistantContentLines(lines, width, paddingX, streaming = false) {
     const margin = ' '.repeat(paddingX);
-    return lines.map((line) => padToWidth(margin + line + margin, width));
+    if (!streaming)
+        return lines.map(line => padToWidth(margin + line + margin, width));
+    return lines.map(line => {
+        const key = `${width}:${paddingX}:${line}`;
+        const cached = assistantRowCache.get(key);
+        if (cached !== undefined)
+            return cached.row;
+        const row = padToWidth(margin + line + margin, width);
+        const size = key.length + row.length;
+        if (size <= ASSISTANT_ROW_CACHE_CHARS) {
+            while (assistantRowCache.size >= 4096 || assistantRowChars + size > ASSISTANT_ROW_CACHE_CHARS) {
+                const first = assistantRowCache.keys().next().value;
+                assistantRowChars -= assistantRowCache.get(first).size;
+                assistantRowCache.delete(first);
+            }
+            assistantRowCache.set(key, { row, size });
+            assistantRowChars += size;
+        }
+        return row;
+    });
 }
 function lockThinkingLine(line, theme) {
     if (line === '' || !theme.colors)
@@ -100,13 +119,13 @@ function hasExplicitTextColor(theme) {
     const ansi = theme.getFgAnsi('text');
     return ansi !== '' && ansi !== '\x1b[39m';
 }
-function assistantMarkdown(source, theme, width, style) {
+function assistantMarkdown(source, theme, width, style, streaming = false) {
     const paddingX = width > ASSISTANT_PADDING_X * 2 ? ASSISTANT_PADDING_X : 0;
     const contentWidth = Math.max(1, width - paddingX * 2);
-    const rendered = renderMarkdown(source, theme, contentWidth, style);
+    const rendered = (streaming ? renderStreamingMarkdown : renderMarkdown)(source, theme, contentWidth, style);
     if (style?.color !== 'thinkingText')
-        return assistantContentLines(rendered, width, paddingX);
-    return assistantContentLines(rendered.map(line => lockThinkingLine(line, theme)), width, paddingX);
+        return assistantContentLines(rendered, width, paddingX, streaming);
+    return assistantContentLines(rendered.map(line => lockThinkingLine(line, theme)), width, paddingX, streaming);
 }
 /**
  * What the reader typed.
@@ -185,7 +204,7 @@ function toolFailureFact(output, command, fact) {
  * 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) {
+function toolRowLine(block, theme, width, spinnerFrame, open = false) {
     const presentation = renderTool({
         name: block.name,
         arguments: prettyArgs(block.args),
@@ -204,9 +223,9 @@ function toolRowLine(block, theme, width, spinnerFrame) {
     // 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 head = '  ' + nest + (open ? SYMBOL.unfolded : SYMBOL.folded) + ' ' + mark;
     const room = processRoom(width, head);
-    const label = processLabel(block.name);
+    const label = theme.text(processLabel(block.name));
     const subject = toolRowSubject(block, presentation, label);
     const args = toolArgsObject(block.args);
     const call = block.presentation?.call;
@@ -289,8 +308,35 @@ function toolRowSubject(block, presentation, label) {
     const verb = label.split(' ')[0] ?? '';
     return firstLineOf(verb !== '' && title.startsWith(verb + ' ') ? title.slice(verb.length + 1) : title);
 }
+/** Keep file line numbers outside tokenization and wrapping, including continuation rows. */
+function readContentLines(view, theme, width, error) {
+    const language = toolPayloadLanguage('read', view.path);
+    const source = view.lines.map(line => line.text);
+    const painted = language === undefined
+        ? source.map(line => theme.fg(error ? 'error' : 'toolOutput', line))
+        : highlightedLines(source, language, theme, error ? 'error' : undefined);
+    const digits = view.lines.reduce((max, line) => Math.max(max, String(line.number).length), 1);
+    // Extremely narrow windows retain the file text rather than spending their
+    // final cell on a gutter. Ordinary widths reserve the same column on every row.
+    const gutter = width > digits + 2 ? digits + 2 : 0;
+    return view.lines.flatMap((line, index) => wrapCode(painted[index] ?? '', Math.max(1, width - gutter)).map((row, part) => {
+        const number = part === 0 ? String(line.number).padStart(digits) + '  ' : ' '.repeat(gutter);
+        return (gutter === 0 ? '' : theme.fg('dim', number)) + row;
+    }));
+}
+/** Results are plain output unless a read explicitly identifies source code. */
+function toolOutputLines(block, output, subject, theme, width) {
+    const result = block.presentation?.result;
+    if (result?.card === 'read')
+        return readContentLines(result, theme, width, block.status === 'error');
+    const language = block.name === 'read' && result === undefined ? toolPayloadLanguage('read', subject) : undefined;
+    const painted = language === undefined
+        ? output.map(line => theme.fg(block.status === 'error' ? 'error' : 'toolOutput', line))
+        : highlightedLines(output, language, theme, block.status === 'error' ? 'error' : undefined);
+    return painted.flatMap(line => wrapTextStable(line, width));
+}
 /** Tool content shared by a running turn and a completed turn opened for reading. */
-function toolBlockLines(block, theme, width, mode = 'preview', detailsKey = 'Alt+O', surface = 'toolSuccessBg') {
+function toolBlockLines(block, theme, width, mode = 'preview', detailsKey = 'Alt+O', surface = 'toolSuccessBg', showTitle = true) {
     const full = mode !== 'preview';
     const presentation = renderTool({
         name: block.name, arguments: prettyArgs(block.args), output: block.output,
@@ -304,9 +350,9 @@ function toolBlockLines(block, theme, width, mode = 'preview', detailsKey = 'Alt
     const shell = COMMAND_TOOL.test(block.name) || call?.card === 'terminal';
     const read = block.name === 'read' || result?.card === 'read';
     const diffs = exclusiveDiffs(block.presentation);
-    const padding = width > 4 ? 2 : 0;
+    const padding = width > 8 && !showTitle ? 4 : width > 4 ? 2 : 0;
     const nest = block.parentCallId === undefined || width < 10 ? 0 : 2;
-    const room = Math.max(1, width - padding * 2 - nest);
+    const room = Math.max(1, width - padding - (width > 4 ? 2 : 0) - nest);
     const subject = toolArgSubject(block.args, block.partial === true)
         || (result?.card === 'read' ? result.path : '')
         || (args === undefined ? '' : Object.values(args).find(value => typeof value === 'string')) || '';
@@ -316,15 +362,13 @@ function toolBlockLines(block, theme, width, mode = 'preview', detailsKey = 'Alt
         : call?.card === 'generic' || call?.card === 'diff' ? call.title
             : !read && presentation.title !== undefined && presentation.title !== block.name ? presentation.title
                 : `${block.name}${subject === '' ? '' : ` ${subject}`}`;
-    // The command line is one ink, not a highlighted program.
-    //
-    // A command is the reader's own intent, and it has to be recognisable at a
-    // glance; syntax colouring it competes with the output below, which is the
-    // part that actually has to be read. Pi splits the two the same way: a flat
-    // bold `toolTitle` line for the call, and language highlighting for whatever
-    // the call returned.
+    // Commands and their output use plain ink; only identified file content is tokenized.
     const titleInk = block.status === 'error' ? 'error' : 'toolTitle';
-    const rows = wrapTextStable(theme.bold(theme.fg(titleInk, title)), room);
+    const rows = showTitle || mode !== 'details' && shell && command !== ''
+        ? wrapTextStable(theme.bold(theme.fg(titleInk, title)), room) : [];
+    if (!showTitle && mode !== 'details' && result?.card === 'read' && result.lines.length > 0) {
+        rows.push(...wrapTextStable(theme.dim(`${result.path} · ${result.lines[0].number}–${result.lines.at(-1).number} / ${result.totalLines}`), room));
+    }
     let body = [];
     if (mode === 'details') {
         let input = block.args;
@@ -333,19 +377,15 @@ function toolBlockLines(block, theme, width, mode = 'preview', detailsKey = 'Alt
         }
         catch { /* Partial arguments retain their received text. */ }
         const output = presentation.output.length > 0 ? presentation.output : block.output.split('\n');
-        const detailLanguage = shell ? 'bash' : toolPayloadLanguage(block.name, subject);
         const outputRows = diffs !== undefined
             ? wrapPaintedDiffRows(alignFileDiffs(diffs), theme, room)
-            : (detailLanguage === undefined
-                ? output.map(line => theme.fg(block.status === 'error' ? 'error' : 'toolOutput', line))
-                : highlightedLines(output, detailLanguage, theme, block.status === 'error' ? 'error' : undefined))
-                .flatMap(line => wrapTextStable(line, room));
+            : toolOutputLines(block, output, subject, theme, room);
         body = [
-            ...wrapTextStable(theme.fg('dim', 'Input'), room),
+            ...wrapTextStable(theme.fg('dim', theme.text('Input')), room),
             // The arguments are JSON here (they were re-serialized above), so they are
             // highlighted as JSON whatever the tool itself reads.
             ...highlightedLines(input.split('\n'), 'json', theme, undefined, room),
-            '', ...wrapTextStable(theme.fg('dim', 'Output'), room),
+            '', ...wrapTextStable(theme.fg('dim', theme.text('Output')), room),
             ...outputRows,
         ];
         // Keep the tool's rich presentation, but expose received text it replaced.
@@ -358,20 +398,15 @@ function toolBlockLines(block, theme, width, mode = 'preview', detailsKey = 'Alt
     }
     else if (diffs !== undefined) {
         body = wrapPaintedDiffRows(alignFileDiffs(diffs), theme, room);
+        if (block.status === 'error' && block.output !== '')
+            body.push(...wrapTextStable(theme.fg('error', block.output), room));
     }
     else if (full || !read || block.status === 'error') {
-        // One highlight pass over the whole payload. Painting line by line handed
-        // the tokenizer a fragment with no opening construct, so a second and third
-        // command row came back bare — the "only the first line is highlighted"
-        // report. A file payload uses the subject's own language.
-        const language = shell ? 'bash' : toolPayloadLanguage(block.name, subject);
-        const output = language === undefined
-            ? presentation.output.map(line => theme.fg(block.status === 'error' ? 'error' : 'toolOutput', line))
-            : highlightedLines(presentation.output, language, theme, block.status === 'error' ? 'error' : undefined);
-        const input = !shell && !read && (call?.card === 'generic' || (call === undefined && presentation.title !== block.name))
-            ? highlightedLines(presentation.input, language ?? 'text', theme, undefined, room)
+        const output = toolOutputLines(block, presentation.output, subject, theme, room);
+        const input = presentation.input.length > 0 && !shell && !read && (call?.card === 'generic' || (call === undefined && !/^(grep|glob|find|ls|search|write|edit)$/.test(block.name)))
+            ? presentation.input.flatMap(line => wrapCode(theme.fg('toolOutput', line), room))
             : [];
-        body = [...input, ...output.flatMap(line => wrapTextStable(line, room))];
+        body = [...input, ...output];
         // Writes carry their content in arguments before the result arrives.
         if (body.length === 0 && block.name === 'write' && typeof args?.['content'] === 'string') {
             body = highlightedLines(args['content'].split('\n'), toolPayloadLanguage('write', subject) ?? 'text', theme, undefined, room);
@@ -394,13 +429,17 @@ function toolBlockLines(block, theme, width, mode = 'preview', detailsKey = 'Alt
     if (!full && read && block.status !== 'error' && block.output !== '' && detailsKey !== 'Disabled') {
         body.push(...wrapTextStable(theme.fg('dim', `${detailsKey}: Expand result`), room));
     }
-    if (full && block.status === 'error' && call?.card === 'diff')
+    if (full && diffs === undefined && block.status === 'error' && call?.card === 'diff')
         rows.push('', ...wrapPaintedDiffRows(alignFileDiffs(call.diffs), theme, room));
     if (body.length > 0) {
-        rows.push('');
+        if (rows.length > 0)
+            rows.push('');
         for (const row of body)
             rows.push(row);
     }
+    if (!showTitle && mode !== 'details' && presentation.summary && (result?.card === 'terminal' || result?.card === 'search')) {
+        rows.push(...wrapTextStable(theme.dim(presentation.summary), room));
+    }
     if (block.status === 'error')
         rows.push(...wrapTextStable(theme.fg('error', 'Tool failed'), room));
     if (block.job !== undefined) {
@@ -410,7 +449,7 @@ function toolBlockLines(block, theme, width, mode = 'preview', detailsKey = 'Alt
             rows.push('');
         rows.push(...wrapTextStable(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' : surface;
+    const bg = !showTitle ? 'toolAltBg' : block.status === 'running' ? 'toolPendingBg' : block.status === 'error' ? 'toolErrorBg' : surface;
     return ['', ...rows, ''].map(row => paintSurface(theme, bg, 'toolOutput', padToWidth(' '.repeat(padding + nest) + row, width)));
 }
 function firstLineOf(text) {
@@ -421,21 +460,43 @@ function firstLineOf(text) {
     }
     return '';
 }
-/**
- * One row standing in for a thought the reader has not opened.
- *
- * The first line is kept so a collapsed thought still says what it was about —
- * a labelled placeholder would make every thought look the same.
- */
-function reasoningSummaryRow(reasoning, theme, width) {
+/** Latest stable paragraph heading; streaming fragments never flicker into the preview. */
+function reasoningPreview(block) {
+    const paragraphs = block.reasoning.replace(/\r\n/g, '\n').split(/\n[ \t]*\n/);
+    for (let index = paragraphs.length - 1; index >= 0; index--) {
+        const paragraph = paragraphs[index];
+        if (block.streaming && index === paragraphs.length - 1 && !paragraph.includes('\n'))
+            continue;
+        const first = firstLineOf(paragraph);
+        if (first !== '')
+            return first;
+    }
+    return '';
+}
+function reasoningSummaryRow(block, theme, width) {
     const paddingX = width > ASSISTANT_PADDING_X * 2 ? ASSISTANT_PADDING_X : 0;
-    const label = `Thinking: ${firstLineOf(reasoning)}`;
+    const preview = reasoningPreview(block);
+    const label = `${SYMBOL.folded} ${theme.text('Thinking')}${preview === '' ? '' : ROW_JOIN + preview}`;
     return assistantContentLines([theme.fg('dim', truncateToWidth(label, Math.max(1, width - paddingX * 2)))], width, paddingX)[0]
         ?? '';
 }
+/** A disclosure header stays small; complete tool payloads are laid out only on demand. */
+function toolDisclosureLines(block, theme, width, open, detailsKey = 'Alt+O', spinnerFrame = 0, raw = false) {
+    const rows = toolRowLine(block, theme, width, spinnerFrame, open);
+    if (open)
+        rows.push(...toolBlockLines(block, theme, width, raw ? 'details' : 'full', detailsKey, 'toolAltBg', false));
+    return rows;
+}
+function reasoningDisclosureLines(block, theme, width, open, mathMode = 'auto') {
+    if (!open)
+        return [reasoningSummaryRow(block, theme, width)];
+    const indent = width > 8 ? 2 : 0;
+    return [padToWidth(truncateToWidth(`  ${SYMBOL.unfolded} ${theme.text('Thinking')}`, Math.max(1, width - 2)), width),
+        ...openReasoningLines(block, theme, width - indent, mathMode).map(line => ' '.repeat(indent) + line)];
+}
 /** 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 });
+    return assistantMarkdown(block.reasoning, theme, width, { color: 'thinkingText', italic: true, mathMode }, block.streaming);
 }
 /** The block indexes a run shows as rows, in order: its members, then the thought it took from its answer. */
 function groupMembers(group) {
@@ -453,37 +514,38 @@ function groupMembers(group) {
  * last row and its words are the answer painted below the run, so the run
  * paints the thought and nothing else.
  */
-function groupMemberLines(index, context, thoughtOnly = false, toolOrdinal = 0, 
-/** The reader opened this run, so its thoughts are laid out in full. */
-openRun = 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 surface = toolOrdinal % 2 === 0 ? 'toolSuccessBg' : 'toolAltBg';
-    const thinkingOpen = openRun
-        || (block.kind === 'assistant' && context.openedThoughts.has(reasoningKey(block)));
-    const signature = [width, options.colors, context.depth, context.themeName, terminalKey(options), options.mathMode, options.mermaidMode, thoughtOnly, full, options.toolDetailsKey, surface, thinkingOpen].join('\0');
+    const full = block.kind === 'tool' && (options.toolsExpanded === true || context.matches.has(index) || options.expandedTools?.has(block.callId) === true);
+    const raw = block.kind === 'tool' && (options.toolsExpanded === true || options.rawTools?.has(block.callId) === true || context.matches.has(index));
+    const thinkingOpen = options.hideThinking === false
+        || (block.kind === 'assistant' && (context.openedThoughts.has(reasoningKey(block)) || context.matches.has(index)));
+    const signature = [width, options.colors, context.depth, context.themeName, terminalKey(options), options.mathMode, options.mermaidMode, thoughtOnly, full, raw, options.toolDetailsKey, block.kind === 'tool' && block.status === 'running' ? context.spinnerFrame : 0, thinkingOpen, options.hideThinking !== false].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, surface)
+        lines = block.kind === 'tool' ? toolDisclosureLines(block, theme, width, full, options.toolDetailsKey, context.spinnerFrame, raw)
             : block.kind === 'assistant' ? thoughtOnly
-                ? (options.hideThinking !== true || thinkingOpen
-                    ? openReasoningLines(block, theme, width, options.mathMode)
-                    : [reasoningSummaryRow(block.reasoning, theme, width)])
+                ? reasoningDisclosureLines(block, theme, width, thinkingOpen, options.mathMode)
                 : blockLines(block, theme, width, {
                     mathMode: options.mathMode ?? 'auto',
                     mermaidMode: options.mermaidMode ?? 'auto',
-                    hideThinking: options.hideThinking === true,
+                    hideThinking: options.hideThinking !== false,
                     thinkingOpen,
+                    processDisclosure: true,
                 })
                 : block.kind === 'notice' ? blockLines(block, theme, width) : [];
         groupMemberCache.set(block, { signature, lines });
     }
-    return [...paintSearch(lines, index, context.occurrences, theme)];
+    const painted = [...paintSearch(lines, index, context.occurrences, theme)];
+    if (options.selectedProcess === index && painted.length > 0) {
+        painted[0] = theme.fg('accent', '❯') + sliceCells(painted[0], 1, Math.max(0, width - 1));
+    }
+    return painted;
 }
 /**
  * Paint the query occurrences of one block onto its rows.
@@ -570,11 +632,14 @@ function processGroupBody(group, context) {
     const offsets = new Map();
     const spans = [];
     for (const index of groupMembers(group)) {
-        const isTool = context.blocks[index]?.kind === 'tool';
-        const rows = groupMemberLines(index, context, index === group.answer && group.tookThought, context.toolCards.count, true);
-        if (isTool && rows.length > 0)
-            context.toolCards.count += 1;
-        if (rows.length > 0 && lines.length > 0)
+        const block = context.blocks[index];
+        const rows = groupMemberLines(index, context, index === group.answer && group.tookThought);
+        const previous = context.blocks[index - 1];
+        const opened = (item, at) => item?.kind === 'tool'
+            ? context.options.toolsExpanded === true || context.options.expandedTools?.has(item.callId) === true || context.matches.has(at)
+            : item?.kind === 'assistant' && item.reasoning !== '' && (context.options.hideThinking === false || context.openedThoughts.has(reasoningKey(item)));
+        const reply = block.kind === 'assistant' && block.text !== '' && index !== group.answer;
+        if (rows.length > 0 && lines.length > 0 && (opened(block, index) || opened(previous, index - 1) || reply || previous?.kind === 'assistant' && previous.text !== ''))
             lines.push('');
         offsets.set(index, lines.length);
         if (context.blocks[index]?.kind === 'tool')
@@ -588,8 +653,8 @@ function processGroupBody(group, context) {
 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 labelRoom = Math.max(1, width - 6 - 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) : '';
@@ -600,15 +665,15 @@ function processGroupHeader(group, theme, width, elapsed, expandKey = 'Ctrl+O')
  * 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', hideThinking = false, thinkingOpen = false, expandedOutput = false, outputExpandKey = 'Ctrl+O' } = {}) {
+export function blockLines(block, theme, width, { toolsExpanded = false, omitReasoning = false, toolDetailsKey = 'Alt+O', mathMode = 'auto', mermaidMode = 'auto', hideThinking = false, thinkingOpen = false, processDisclosure = false, rawTool = false, expandedOutput = false, outputExpandKey = 'Ctrl+O' } = {}) {
     if (block.kind === 'user')
         return userBubble(block.text, theme, width);
     if (block.kind === 'assistant') {
         const lines = [];
         if (block.reasoning !== '' && !omitReasoning) {
             const collapsed = hideThinking && !thinkingOpen;
-            lines.push(...(collapsed
-                ? [reasoningSummaryRow(block.reasoning, theme, width)]
+            lines.push(...(processDisclosure ? reasoningDisclosureLines(block, theme, width, !collapsed, mathMode) : collapsed
+                ? [reasoningSummaryRow(block, theme, width)]
                 : openReasoningLines(block, theme, width, mathMode)));
             if (block.text !== '')
                 lines.push('');
@@ -618,7 +683,7 @@ export function blockLines(block, theme, width, { toolsExpanded = false, omitRea
             lines.push(...assistantContentLines([theme.fg('dim', '…')], width, paddingX));
         }
         else if (block.text !== '') {
-            lines.push(...assistantMarkdown(block.text, theme, width, { ...(hasExplicitTextColor(theme) ? { color: 'text' } : {}), mathMode, mermaidMode }));
+            lines.push(...assistantMarkdown(block.text, theme, width, { ...(hasExplicitTextColor(theme) ? { color: 'text' } : {}), mathMode, mermaidMode }, block.streaming));
         }
         if (block.interrupted === true) {
             const paddingX = width > ASSISTANT_PADDING_X * 2 ? ASSISTANT_PADDING_X : 0;
@@ -627,7 +692,8 @@ export function blockLines(block, theme, width, { toolsExpanded = false, omitRea
         return lines;
     }
     if (block.kind === 'tool') {
-        return toolBlockLines(block, theme, width, toolsExpanded ? 'full' : 'preview', toolDetailsKey);
+        return processDisclosure ? toolDisclosureLines(block, theme, width, toolsExpanded, toolDetailsKey, 0, rawTool)
+            : toolBlockLines(block, theme, width, toolsExpanded ? 'full' : 'preview', toolDetailsKey);
     }
     if (block.kind === 'workspace')
         return workspaceBlockLines(block, theme, width, toolsExpanded);
@@ -657,6 +723,12 @@ export function blockLines(block, theme, width, { toolsExpanded = false, omitRea
         return [renderTranscriptBoundary(block.text, theme, width)];
     if (block.process !== undefined && block.framed !== true)
         return [processNoticeLine(block, theme, width, '')];
+    if (block.detail !== undefined) {
+        const head = '  ' + theme.fg('dim', block.text);
+        return expandedOutput
+            ? [truncateToWidth(head, width), '', ...renderMarkdown(block.detail, theme, Math.max(1, width - 4)).map(line => '  ' + line)]
+            : [truncateToWidth(head + theme.fg('dim', ' · ' + outputExpandKey + ': ' + theme.text('Expand')), width)];
+    }
     if (block.framed !== true) {
         const prefix = '  ';
         const continuation = ' '.repeat(visibleWidth(prefix));
@@ -723,15 +795,9 @@ function renderTranscriptBoundary(label, theme, width) {
  */
 const renderedBlockCache = new WeakMap();
 export function renderedBlocks(state, options) {
-    const theme = createTheme(options.colors === true, options.colorDepth ?? 'truecolor', options.themeName ?? 'dark', options.terminal);
-    const key = [
-        options.width,
-        options.toolsExpanded === true,
-        options.hideThinking === true,
-        [...(options.expandedTools ?? [])].sort().join(','),
-        [...(options.expandedReasoning ?? [])].sort().join(','),
-        [...(options.openedGroups ?? [])].sort().join(','),
-    ].join('\u0000');
+    const theme = createTheme(options.colors === true, options.colorDepth ?? 'truecolor', options.themeName ?? 'dark', options.terminal, options.language, options.compactLinks);
+    const key = [options.width, options.colors, options.colorDepth, options.themeName,
+        options.language, options.compactLinks, JSON.stringify(options.terminal), options.mathMode, options.mermaidMode].join('\0');
     const cached = renderedBlockCache.get(state.blocks)?.get(key);
     if (cached !== undefined)
         return cached;
@@ -748,15 +814,10 @@ export function renderedBlocks(state, options) {
 }
 /** Plain rows one block contributes, without the search highlighting applied. */
 function renderedRows(block, theme, options) {
-    if (block.kind === 'assistant') {
-        const thinkingOpen = options.hideThinking !== true || options.expandedReasoning?.has(reasoningKey(block)) === true;
-        return thinkingOpen && block.reasoning !== ''
-            ? openReasoningLines(block, theme, options.width, options.mathMode)
-            : assistantMarkdown(block.text, theme, options.width, {
-                ...(options.mathMode === undefined ? {} : { mathMode: options.mathMode }),
-            });
-    }
-    return blockSearchText(block).split('\n');
+    return blockLines(block, theme, options.width, {
+        processDisclosure: true, toolsExpanded: true, rawTool: true, thinkingOpen: true,
+        expandedOutput: true, mathMode: options.mathMode ?? 'auto', mermaidMode: options.mermaidMode ?? 'auto',
+    });
 }
 /** Plain text of one block, used by transcript search and match painting. */
 export function blockSearchText(block) {
@@ -772,6 +833,8 @@ export function blockSearchText(block) {
     }
     if (block.kind === 'shell')
         return `${block.command}\n${block.output}`;
+    if (block.kind === 'notice' && block.detail !== undefined)
+        return `${block.text}\n${block.detail}`;
     return block.text;
 }
 function fitFrame(lines, width, stablePrefix = 0) {
@@ -796,6 +859,7 @@ const transcriptBodyCache = new WeakMap();
 /** Settled immutable blocks keep their expensive Markdown/tool layout. */
 const blockLinesCache = new WeakMap();
 function cachedBlockLines(block, options, theme, themeName, depth, expanded, omitReasoning = false) {
+    const rawTool = block.kind === 'tool' && (options.toolsExpanded === true || options.rawTools?.has(block.callId) === true || options.transcriptSearch !== undefined && options.transcriptSearch.query.trim() !== '');
     const cached = blockLinesCache.get(block);
     if (cached !== undefined
         && cached.width === options.width
@@ -805,26 +869,29 @@ function cachedBlockLines(block, options, theme, themeName, depth, expanded, omi
         && cached.terminalKey === terminalKey(options)
         && cached.expanded === expanded
         && cached.omitReasoning === omitReasoning
-        && cached.hideThinking === (options.hideThinking === true)
+        && cached.hideThinking === (options.hideThinking !== false)
         && cached.thinkingOpen === (block.kind === 'assistant' && options.expandedReasoning?.has(reasoningKey(block)) === true)
         && cached.mathMode === options.mathMode
         && cached.mermaidMode === options.mermaidMode
         && cached.toolDetailsKey === options.toolDetailsKey
+        && cached.rawTool === rawTool
         && cached.toolDetails === (block.kind === 'tool' && options.expandedTools?.has(block.callId) === true)
         && cached.expandedOutput === (options.expandedOutputs?.has(block) === true))
         return cached.lines;
     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)
+        ? toolDisclosureLines(block, theme, options.width, true, options.toolDetailsKey, 0, rawTool)
         : blockLines(block, theme, options.width, {
             toolsExpanded: expanded,
+            rawTool,
+            processDisclosure: true,
             omitReasoning,
             toolDetailsKey: options.toolDetailsKey ?? 'Alt+O',
             mathMode: options.mathMode ?? 'auto',
             mermaidMode: options.mermaidMode ?? 'auto',
-            hideThinking: options.hideThinking === true,
+            hideThinking: options.hideThinking !== false,
             thinkingOpen: block.kind === 'assistant' && options.expandedReasoning?.has(reasoningKey(block)) === true,
-            expandedOutput: options.expandedOutputs?.has(block) === true,
+            expandedOutput: options.expandedOutputs?.has(block) === true || (block.kind === 'notice' && expanded),
             outputExpandKey: options.turnDetailsKey ?? 'Ctrl+O',
         });
     blockLinesCache.set(block, {
@@ -832,6 +899,7 @@ function cachedBlockLines(block, options, theme, themeName, depth, expanded, omi
         mermaidMode: options.mermaidMode,
         toolDetailsKey: options.toolDetailsKey,
         toolDetails,
+        rawTool,
         expandedOutput: options.expandedOutputs?.has(block) === true,
         width: options.width,
         colors: options.colors,
@@ -840,7 +908,7 @@ function cachedBlockLines(block, options, theme, themeName, depth, expanded, omi
         terminalKey: terminalKey(options),
         expanded,
         omitReasoning,
-        hideThinking: options.hideThinking === true,
+        hideThinking: options.hideThinking !== false,
         thinkingOpen: block.kind === 'assistant' && options.expandedReasoning?.has(reasoningKey(block)) === true,
         lines,
     });
@@ -1072,12 +1140,13 @@ export function turnGroups(state) {
 function renderTranscriptBody(state, options, theme, spinnerFrame) {
     const toolsExpanded = options.toolsExpanded === true;
     const expandedTools = [...(options.expandedTools ?? [])].sort().join('\0');
+    const rawTools = [...(options.rawTools ?? [])].sort().join('\0');
     const expandedReasoning = [...(options.expandedReasoning ?? [])].sort().join('\0');
-    const hideThinking = options.hideThinking === true;
+    const hideThinking = options.hideThinking !== false;
     const openedGroups = [...(options.openedGroups ?? [])].sort().join('\0');
     // A command output the reader opened paints different rows, so the body cache
     // has to see it; without this the frame is reused and the key looks dead.
-    const expandedOutputs = [...(options.expandedOutputs ?? [])].join('\u0000');
+    const expandedOutputs = state.blocks.flatMap((block, index) => options.expandedOutputs?.has(block) ? [index] : []).join(',');
     const themeName = options.themeName ?? 'dark';
     const depth = colorDepthOf(options);
     const animatedSpinnerFrame = state.blocks.some(block => block.kind === 'tool' && block.status === 'running')
@@ -1109,6 +1178,7 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
         && cached.mermaidMode === options.mermaidMode
         && cached.toolsExpanded === toolsExpanded
         && cached.expandedTools === expandedTools
+        && cached.rawTools === rawTools
         && cached.expandedReasoning === expandedReasoning
         && cached.hideThinking === hideThinking
         && cached.openedGroups === openedGroups
@@ -1118,9 +1188,11 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
         && cached.turnDetailsKey === options.turnDetailsKey
         && cached.searchKey === searchKey
         && cached.status === state.status
-        && cached.focusBlock === options.focusBlock) {
+        && cached.focusBlock === options.focusBlock
+        && cached.selectedProcess === options.selectedProcess) {
         return {
             lines: cached.lines,
+            disclosures: cached.disclosures,
             fileRegions: cached.fileRegions,
             blockStarts: cached.blockStarts,
             blockDrawStarts: cached.blockDrawStarts,
@@ -1135,8 +1207,25 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
     const matches = new Set(occurrences.map(match => match.block));
     const lines = [];
     const fileRegions = [];
-    const filesAt = (index, start, length, expanded = false) => {
+    const disclosures = [];
+    const disclosureByBlock = new Map();
+    const disclosureAt = (index, row) => {
         const block = state.blocks[index];
+        if (block.kind !== 'tool' && !(block.kind === 'assistant' && block.reasoning.trim() !== ''))
+            return;
+        const column = block.kind === 'tool' && block.parentCallId !== undefined ? 4 : 2;
+        if (options.width < column + 4)
+            return;
+        const target = { block: index, row, column: 0, width: column + 2,
+            key: block.kind === 'tool' ? `call:${block.callId}` : `thought:${reasoningKey(block)}` };
+        disclosures.push(target);
+        disclosureByBlock.set(index, target);
+    };
+    const regionsAt = (index, start, length, expanded = false) => {
+        const block = state.blocks[index];
+        const target = disclosureByBlock.get(index);
+        if (block.kind === 'tool' && target !== undefined && length > 1)
+            target.detailEnd = start + length;
         if (length === 0 || blockFileAction(block) === undefined)
             return;
         if (block.kind === 'workspace') {
@@ -1165,6 +1254,11 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
     const absorbed = new Set();
     // Thoughts a search hit has to show in full, beyond what the reader opened.
     const openedThoughts = new Set(options.expandedReasoning ?? []);
+    for (const index of matches) {
+        const block = state.blocks[index];
+        if (block?.kind === 'assistant' && block.reasoning !== '')
+            openedThoughts.add(reasoningKey(block));
+    }
     // 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();
@@ -1181,21 +1275,9 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
             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;
@@ -1216,7 +1298,7 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
         blocks: state.blocks, theme, themeName, depth, width: options.width,
         matches, occurrences, options: { ...options, expandedReasoning: openedThoughts },
         openedThoughts,
-        toolCards: { count: 0 },
+        spinnerFrame,
     };
     const compactProcessRow = (block) => {
         if (block?.kind === 'notice')
@@ -1263,6 +1345,8 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
                 liveFrom ??= headerRow;
             // A live run has no header: it becomes a group when its turn ends.
             if (!group.live && !shown) {
+                if (options.width >= 6)
+                    disclosures.push({ row: headerRow, column: 0, width: 4, block: group.start, key: `run:${group.key}`, group: group.key });
                 lines.push(...processGroupHeader(group, theme, options.width, elapsedOf(groupIndex), options.turnDetailsKey));
             }
             const bodyRow = lines.length;
@@ -1272,18 +1356,26 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
                 for (const line of body.lines)
                     lines.push(line);
                 offsets = body.offsets;
+                for (const [index, offset] of offsets)
+                    disclosureAt(index, bodyRow + offset);
                 for (const span of body.spans)
-                    filesAt(span.index, bodyRow + span.start, span.end - span.start);
+                    regionsAt(span.index, bodyRow + span.start, span.end - span.start);
             }
             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')
+                    const reply = member.kind === 'assistant' && member.text !== '';
+                    if (!reply && !(member.kind === 'tool' && member.status === 'error')
                         && !(member.kind === 'notice' && member.level === 'error'))
                         continue;
+                    if (reply && lines.length > 0)
+                        lines.push('');
                     offsets.set(at, lines.length - bodyRow);
-                    const rows = member.kind === 'tool' ? toolRowLine(member, theme, options.width, spinnerFrame) : groupMemberLines(at, context);
-                    filesAt(at, lines.length, rows.length);
+                    const rows = member.kind === 'tool' ? toolRowLine(member, theme, options.width, spinnerFrame)
+                        : reply ? cachedBlockLines(member, options, theme, themeName, depth, toolsExpanded, true) : groupMemberLines(at, context);
+                    if (member.kind === 'tool')
+                        disclosureAt(at, lines.length);
+                    regionsAt(at, lines.length, rows.length);
                     lines.push(...rows);
                 }
             }
@@ -1302,8 +1394,7 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
                 // 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);
+                    && search !== undefined && matches.has(group.answer);
                 const thoughtRow = offsets.get(group.answer);
                 drawnThoughts.set(group.answer, thoughtRow);
                 // The answer's own drawn start is its words, never the thought above
@@ -1314,11 +1405,14 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
                 offsets.set(group.answer, lines.length - bodyRow);
                 const answer = state.blocks[group.answer];
                 const rendered = cachedBlockLines(answer, options, theme, themeName, depth, toolsExpanded, absorbed.has(group.answer));
-                for (const line of paintSearch(rendered, group.answer, occurrences, theme))
+                const thoughtLines = thoughtHit
+                    ? groupMemberLines(group.answer, context, true).length + 1 : 0;
+                const answerHits = thoughtLines === 0 ? occurrences : occurrences.map(hit => hit.block === group.answer ? { ...hit, row: hit.row - thoughtLines } : hit);
+                for (const line of paintSearch(rendered, group.answer, answerHits, theme))
                     lines.push(line);
                 if (thoughtHit && thoughtRow !== undefined)
                     blockStarts[group.answer] = bodyRow + thoughtRow;
-                if (thoughtHit && thoughtRow !== undefined)
+                if ((thoughtHit || options.selectedProcess === group.answer) && 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
@@ -1340,8 +1434,9 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
                     offsets.set(at, lines.length - bodyRow);
                     const rows = !group.live && !opened && trailing?.kind === 'tool'
                         ? toolRowLine(trailing, theme, options.width, spinnerFrame)
-                        : groupMemberLines(at, context, false, 0, group.live || opened);
-                    filesAt(at, lines.length, rows.length);
+                        : groupMemberLines(at, context);
+                    disclosureAt(at, lines.length);
+                    regionsAt(at, lines.length, rows.length);
                     for (const line of rows)
                         lines.push(line);
                 }
@@ -1363,7 +1458,7 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
                     blockDrawStarts[at] = drawn === undefined ? headerRow : bodyRow + drawn;
                 }
                 if (member.kind === 'tool' && options.expandedTools?.has(member.callId) === true) {
-                    foldMarks.push({ key: `call:${member.callId}`, row });
+                    foldMarks.push({ key: `call:${member.callId}${options.rawTools?.has(member.callId) ? ':raw' : ''}`, 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
@@ -1389,10 +1484,11 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
             }
         }
         blockStarts[index] = lines.length;
+        disclosureAt(index, lines.length);
         if (block.kind === 'tool' && options.expandedTools?.has(block.callId) === true) {
-            foldMarks.push({ key: `call:${block.callId}`, row: lines.length });
+            foldMarks.push({ key: `call:${block.callId}${options.rawTools?.has(block.callId) ? ':raw' : ''}`, row: lines.length });
         }
-        if (block.kind === 'assistant' && options.expandedReasoning?.has(reasoningKey(block)) === true) {
+        if (block.kind === 'assistant' && openedThoughts.has(reasoningKey(block))) {
             foldMarks.push({ key: `thought:${reasoningKey(block)}`, row: lines.length });
         }
         const liveBlock = state.status !== 'idle' && isProcessBlock(block)
@@ -1402,17 +1498,34 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
             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, depth, expanded, absorbed.has(index));
-        filesAt(index, lines.length, rendered.length, expanded);
+        const rendered = cachedBlockLines(block, context.options, theme, themeName, depth, expanded, absorbed.has(index));
+        if (block.kind === 'commandOutput' && block.text.trimEnd().includes('\n')) {
+            const foldable = /^ [▸▾] /u.test(stripAnsi(rendered[0] ?? ''));
+            disclosures.push({ block: index, row: lines.length, column: 0, width: foldable ? Math.max(0, options.width - 8) : 0,
+                key: `output:${index}`, detailEnd: lines.length + rendered.length,
+                ...(options.width >= 30 ? { actionColumn: options.width - 7 } : {}),
+            });
+        }
+        regionsAt(index, lines.length, rendered.length, expanded);
         lines.push(...paintSearch(rendered, index, occurrences, theme));
         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 selectedTool = disclosures.find(target => target.block === options.selectedProcess && target.group === undefined
+        && state.blocks[target.block]?.kind === 'tool');
+    if (selectedTool !== undefined && options.width >= 20) {
+        selectedTool.actionColumn = options.width - 7;
+        const title = lines[selectedTool.row];
+        const content = sliceCells(title, 0, visibleWidth(stripAnsi(title).trimEnd()));
+        lines[selectedTool.row] = padToWidth(truncateToWidth(content, selectedTool.actionColumn - 1), selectedTool.actionColumn)
+            + theme.fg('accent', '[···]') + '  ';
+    }
     const foldShape = foldMarks.map(mark => mark.key).join('\u0001');
     transcriptBodyCache.set(state.blocks, {
         fileRegions,
+        disclosures,
         mathMode: options.mathMode,
         mermaidMode: options.mermaidMode,
         toolDetailsKey: options.toolDetailsKey,
@@ -1426,6 +1539,7 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
         spinnerFrame: animatedSpinnerFrame,
         toolsExpanded,
         expandedTools,
+        rawTools,
         expandedReasoning,
         hideThinking,
         openedGroups,
@@ -1434,13 +1548,14 @@ function renderTranscriptBody(state, options, theme, spinnerFrame) {
         turnSpans: state.turnSpans,
         status: state.status,
         focusBlock: options.focusBlock,
+        selectedProcess: options.selectedProcess,
         foldShape,
         foldMarks,
         liveFrom,
         lines,
         blockStarts,
     });
-    return { lines, blockStarts, blockDrawStarts, fileRegions, foldShape, foldMarks, liveFrom, occurrences };
+    return { lines, blockStarts, blockDrawStarts, fileRegions, disclosures, foldShape, foldMarks, liveFrom, occurrences };
 }
 function commandSurfaceName(block) {
     if (block?.kind === 'commandOutput')
@@ -1642,7 +1757,7 @@ export function renderAside(panel, theme, width, available = ASIDE_MAX_ROWS) {
     const detail = panel.detail === undefined || panel.detail === ''
         ? []
         : ['', theme.fg('dim', panel.detail)];
-    const hint = ' ' + theme.fg('dim', formatOverlayHint([{ keys: '↑↓', action: 'scroll' }, { keys: '/copy', action: 'copy' }, { keys: 'Esc', action: 'close' }]));
+    const hint = ' ' + theme.fg('dim', formatOverlayHint([{ keys: '↑↓', action: 'scroll' }, { keys: '/copy', action: 'copy' }, { keys: 'Esc', action: 'close' }], 'lowercase', theme.language));
     // Two rules, the question, its blank line, and the hint are always drawn. What
     // is left is the answer's window, so the pane never grows past its cap.
     const cap = Math.max(6, Math.min(ASIDE_MAX_ROWS, available));
@@ -1701,12 +1816,14 @@ function subagentPhaseGlyph(phase, theme, spinnerFrame) {
             return theme.fg('accent', SYMBOL.running);
         return theme.fg('accent', SPINNER[spinnerFrame % SPINNER.length] ?? SYMBOL.running);
     }
+    if (phase === 'stopped')
+        return theme.fg('warning', '■');
     if (phase === 'error')
         return theme.fg('error', SYMBOL.error);
     return theme.fg('success', SYMBOL.success);
 }
 const SUBAGENT_PHASE_LABELS = {
-    starting: 'Starting', running: 'Running', waiting: 'Waiting', completed: 'Done', error: 'Failed',
+    starting: 'Starting', running: 'Running', waiting: 'Ready', completed: 'Done', stopped: 'Stopped', error: 'Failed',
 };
 /** How long a child has been (or was) running, as one label. */
 export function formatAgentElapsed(agent, now = Date.now()) {
@@ -1720,46 +1837,63 @@ export function formatAgentElapsed(agent, now = Date.now()) {
         return `${(ms / 1_000).toFixed(ms < 10_000 ? 1 : 0)}s`;
     return `${Math.floor(ms / 60_000)}m${String(Math.floor((ms % 60_000) / 1_000)).padStart(2, '0')}s`;
 }
-function subagentRowText(agent) {
+function subagentRowText(agent, theme) {
     const indent = agent.depth > 1 ? '  '.repeat(agent.depth - 1) : '';
-    return `${indent}${agent.label} · ${SUBAGENT_PHASE_LABELS[agent.phase]}`;
+    return `${indent}${agent.label} · ${theme.text(agent.needsApproval ? 'Needs approval' : SUBAGENT_PHASE_LABELS[agent.phase])}`;
+}
+/** Choose one viewport for workflows and agents so neither can crowd out the composer. */
+export function rosterPreviewStart(roster) {
+    const items = rosterItems(roster);
+    const activeWorkflow = items.findIndex(item => item.kind === 'workflow' && item.run.status === 'open');
+    if (activeWorkflow >= 0)
+        return Math.max(0, Math.min(activeWorkflow, items.length - SUBAGENT_PREVIEW));
+    return Math.max(0, Math.min((roster?.workflows?.length ?? 0) + subagentPreviewStart(roster?.agents ?? []), items.length - SUBAGENT_PREVIEW));
 }
 /** Compact, unframed descendant-subagent tree placed above Todos. */
 export function renderSubagents(roster, theme, width, spinnerFrame = 0, inspectedId, selected) {
     const agents = roster?.agents ?? [];
-    if (agents.length === 0 || width <= 0)
+    const items = rosterItems(roster);
+    if (items.length === 0 || width <= 0)
         return [];
     const running = agents.filter(agent => agent.phase === 'running' || agent.phase === 'starting').length;
     const failed = agents.filter(agent => agent.phase === 'error').length;
     const waiting = agents.filter(agent => agent.phase === 'waiting').length;
     const done = agents.filter(agent => agent.phase === 'completed').length;
+    const stopped = agents.filter(agent => agent.phase === 'stopped').length;
+    const attention = agents.filter(agent => agent.needsApproval).length;
     const counts = [
-        running === 0 ? undefined : `${running} running`,
-        waiting === 0 ? undefined : `${waiting} waiting`,
-        done === 0 ? undefined : `${done} done`,
-        failed === 0 ? undefined : `${failed} failed`,
+        attention === 0 ? undefined : theme.text('{count} need approval', { count: attention }),
+        stopped === 0 ? undefined : theme.text('{count} stopped', { count: stopped }),
+        running === 0 ? undefined : theme.text('{count} running', { count: running }),
+        waiting === 0 ? undefined : theme.text('{count} ready', { count: waiting }),
+        done === 0 ? undefined : theme.text('{count} done', { count: done }),
+        failed === 0 ? undefined : theme.text('{count} failed', { count: failed }),
     ].filter((part) => part !== undefined);
     const pointing = selected !== undefined;
-    const headerBody = theme.bold(theme.fg('accent', 'Agents'))
+    const headerBody = theme.bold(theme.fg('accent', theme.text('Agents')))
         + (counts.length === 0 ? '' : theme.fg('dim', ` · ${counts.join(' · ')}`))
         // Short enough to survive a narrow bar: the counts already use the width.
-        + theme.fg('dim', pointing ? ' · ↑↓ · Enter open · Esc' : ' · ↓ select');
+        + theme.fg('dim', pointing ? ' · ' + theme.text('↑↓ · Enter open · Esc') : ' · ' + theme.text('↓ select'));
     const header = '  ' + (pointing ? theme.inverse(headerBody) : headerBody);
-    // A workflow run belongs to the same roster: it is the one place a reader learns
-    // that a workflow is still going, so it stays as the bar's first row rather than
-    // living in the screen this bar replaced.
-    const workflows = (roster?.workflows ?? []).map(run => '  ' + theme.fg(run.status === 'completed' ? 'success' : run.status === 'open' ? 'accent' : 'warning', `Workflow · ${run.name} · ${run.status}${run.phase === undefined ? '' : ` · ${run.phase}`}`));
-    const start = subagentPreviewStart(agents);
-    const end = Math.min(agents.length, start + SUBAGENT_PREVIEW);
+    const start = selected === undefined ? rosterPreviewStart(roster) : Math.max(0, Math.min(selected, items.length - SUBAGENT_PREVIEW));
+    const end = Math.min(items.length, start + SUBAGENT_PREVIEW);
     const rows = [
         ...(start === 0 ? [] : [`… ${start} earlier`]),
-        ...agents.slice(start, end),
-        ...(end === agents.length ? [] : [`… ${agents.length - end} more`]),
+        ...items.slice(start, end),
+        ...(end === items.length ? [] : [`… ${items.length - end} more`]),
     ];
-    const lines = [header, ...workflows, ...rows.map((row, index) => {
+    const lines = [header, ...rows.map((item, index) => {
             const branch = '  ' + theme.fg('dim', index === rows.length - 1 ? '└─' : '├─') + ' ';
-            if (typeof row === 'string')
-                return branch + theme.fg('dim', row);
+            if (typeof item === 'string')
+                return branch + theme.fg('dim', item);
+            const pointed = selected !== undefined && items[selected]?.key === item.key;
+            if (item.kind === 'workflow') {
+                const run = item.run;
+                const body = (pointed ? SYMBOL.cursor + ' ' : '') + theme.text('Workflow') + ` · ${run.name} · ` + theme.text(workflowStatus(run.status))
+                    + (run.phase === undefined ? '' : ` · ${run.phase}`);
+                return branch + theme.fg(run.status === 'completed' ? 'success' : run.status === 'open' ? 'accent' : 'warning', pointed ? theme.bold(body) : body);
+            }
+            const row = item.agent;
             const current = inspectedId === row.id;
             const paint = row.phase === 'completed'
                 ? (text) => theme.fg('dim', theme.strikethrough(text))
@@ -1768,9 +1902,8 @@ export function renderSubagents(roster, theme, width, spinnerFrame = 0, inspecte
                     : row.phase === 'waiting'
                         ? (text) => theme.fg('dim', text)
                         : (text) => text;
-            const pointed = index === selected;
             const marker = current || pointed ? theme.fg('accent', SYMBOL.cursor) + ' ' : '';
-            const body = marker + subagentPhaseGlyph(row.phase, theme, spinnerFrame) + ' ' + paint(subagentRowText(row));
+            const body = marker + subagentPhaseGlyph(row.phase, theme, spinnerFrame) + ' ' + paint(subagentRowText(row, theme));
             return branch + (current || pointed ? theme.bold(body) : body);
         })];
     return lines.map(line => truncateToWidth(line, width));
@@ -1779,9 +1912,12 @@ export function renderSubagents(roster, theme, width, spinnerFrame = 0, inspecte
 export function renderInspectBanner(inspected, theme, width, spinnerFrame = 0) {
     if (inspected === undefined || width <= 0)
         return [];
-    const guidance = inspected.writable ? 'Enter to steer · Esc to return' : 'read-only · Esc to return';
+    const guidance = inspected.phase === 'running' || inspected.phase === 'starting'
+        ? theme.text('Ctrl+C stops this agent · Esc to return')
+        : inspected.writable ? theme.text('Esc to return') : theme.text('Read-only · Esc to return');
     const line = '  ' + theme.fg('accent', '←') + ' ' + subagentPhaseGlyph(inspected.phase, theme, spinnerFrame)
         + ' ' + theme.bold(inspected.label)
+        + theme.fg('dim', ' · ' + theme.text(inspected.needsApproval ? 'Needs approval' : SUBAGENT_PHASE_LABELS[inspected.phase]))
         + theme.fg('dim', ` · ${guidance}`);
     return [truncateToWidth(line, width)];
 }
@@ -1813,11 +1949,11 @@ function queuedMessageLabel(message) {
  * failed while the user was reading elsewhere leaves an apparently idle screen.
  * The row is bounded to a single line so it cannot squeeze the transcript.
  */
-export function renderTurnError(text, theme, width) {
+export function renderTurnError(text, theme, width, canContinue = false) {
     if (text === '' || width <= 0)
         return [];
     const prefix = SYMBOL.error + ' ';
-    const hint = ' · Alt+R retry';
+    const hint = canContinue ? ' · ' + theme.text('Alt+R continue') : '';
     // Drop the retry hint before the message itself when the terminal is narrow.
     const suffix = width - 2 - visibleWidth(prefix) - visibleWidth(hint) >= 8 ? hint : '';
     const budget = Math.max(1, width - 2 - visibleWidth(prefix) - visibleWidth(suffix));
@@ -1832,23 +1968,26 @@ 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 latest = queuedMessageLabel(messages[0]);
     const count = messages.length > 1 ? ` · ${messages.length}` : '';
     return [truncateToWidth('  ' + theme.fg('border', '│') + ' '
-            + theme.bold(theme.fg('accent', 'Guidance · next step' + count))
+            + theme.bold(theme.fg('accent', theme.text('Steer · 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 = []) {
+export function renderQueuedSubmissions(submissions, theme, width, inbox = [], editable = true) {
     const labels = [
         ...inbox.filter(message => message.source.kind === 'user').map(queuedMessageLabel),
-        ...submissions.map(queuedSubmissionLabel),
+        ...submissions.map(submission => theme.text(submission.recovered ? 'Recovered' : 'Sending') + ' · ' + queuedSubmissionLabel(submission)),
     ];
     if (labels.length === 0 || width <= 0)
         return [];
     const start = Math.max(0, labels.length - QUEUED_SUBMISSION_PREVIEW);
     const hidden = start;
-    const queueLabel = theme.bold(theme.fg('accent', 'Queued'));
+    const accepted = inbox.some(message => message.source.kind === 'user');
+    const recovered = submissions.some(submission => submission.recovered);
+    const queueLabel = theme.bold(theme.fg('accent', theme.text(accepted ? 'Queue' : recovered ? 'Recovered' : 'Sending')));
+    const timing = theme.text(recovered ? 'review before sending' : accepted ? 'next turn' : 'not yet accepted');
     const rail = '  ' + theme.fg('border', '│') + ' ';
     const alignAction = (left, action, preserveAction = true) => {
         const leftWidth = visibleWidth(left);
@@ -1861,15 +2000,12 @@ export function renderQueuedSubmissions(submissions, theme, width, inbox = []) {
         const paintedLeft = truncateToWidth(left, width - actionWidth - 2);
         return paintedLeft + '  ' + action;
     };
-    const editSingleHint = width >= 72 ? '↑/Alt+Up edit · Alt+Q queue' : '↑ edit';
-    const editMultiHint = width >= 72 ? '↑/Alt+Up edit latest · Alt+Q queue' : '↑ edit latest';
+    const editSingleHint = !editable ? '' : width >= 72 ? theme.text('↑/Alt+Up recall · Alt+Q manage') : theme.text('Alt+Q manage');
+    const editMultiHint = !editable ? '' : width >= 72 ? theme.text('↑ recall latest · Alt+Q manage') : theme.text('Alt+Q manage');
     if (labels.length === 1) {
-        return [alignAction(
-            // Pi's vocabulary: what Enter typed was a follow-up, and the row says so
-            // in the same word the composer hint uses.
-            rail + queueLabel + theme.fg('dim', ' · ') + theme.fg('dim', 'follow-up · ') + theme.fg('text', labels[0] ?? ''), theme.fg('dim', editSingleHint))];
+        return [alignAction(rail + queueLabel + theme.fg('dim', ' · ') + theme.fg('dim', timing + ' · ') + theme.fg('text', accepted ? labels[0] ?? '' : queuedSubmissionLabel(submissions[0])), theme.fg('dim', editSingleHint))];
     }
-    const summary = ` · ${labels.length} · follow-up${hidden === 0 ? '' : ` · ${hidden} earlier`}`;
+    const summary = ` · ${labels.length} · ${timing}${hidden === 0 ? '' : ' · ' + theme.text('{count} earlier', { count: hidden })}`;
     const visibleLabels = labels.slice(start);
     const lines = [
         alignAction(rail + queueLabel + theme.fg('dim', summary), theme.fg('dim', editMultiHint), false),
@@ -1886,7 +2022,7 @@ export function renderQueuedSubmissions(submissions, theme, width, inbox = []) {
  * @returns the frame to hand to a renderer.
  */
 export function renderView(state, options) {
-    const theme = createTheme(options.colors === true, options.colorDepth ?? 'truecolor', options.themeName ?? 'dark', options.terminal);
+    const theme = createTheme(options.colors === true, options.colorDepth ?? 'truecolor', options.themeName ?? 'dark', options.terminal, options.language, options.compactLinks);
     const width = options.width;
     const height = options.height;
     const appName = options.appName ?? 'omdsh';
@@ -1894,6 +2030,10 @@ export function renderView(state, options) {
     const pwd = options.pwd ?? '';
     const motion = options.motion ?? 'full';
     const spinnerFrame = motion === 'off' ? -1 : options.spinnerFrame ?? 0;
+    if (options.fileBrowser !== undefined) {
+        const browser = renderFileBrowser(options.fileBrowser, theme, width, height);
+        return { ...browser, lines: fitFrame(browser.lines, width), documentRows: null };
+    }
     if (options.trajectory !== undefined) {
         const trajectory = renderTrajectory(options.trajectory, theme, width, height);
         return {
@@ -1914,7 +2054,7 @@ export function renderView(state, options) {
             documentRows: null,
         };
     }
-    if (options.promptSelector?.request.presentation === 'plan-review' || options.promptSelector?.request.presentation === 'document') {
+    if (options.promptSelector?.renderDocument === undefined && (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 }),
@@ -1924,6 +2064,7 @@ export function renderView(state, options) {
             // A full-screen surface drew no transcript body.
             documentRows: null,
             ...(review.document === undefined ? {} : { promptDocument: review.document }),
+            ...(review.actions === undefined ? {} : { promptActions: review.actions }),
         };
     }
     const welcome = renderWelcome({
@@ -1946,19 +2087,17 @@ export function renderView(state, options) {
     const activityLabelText = state.status === 'running'
         ? options.workingLabel ?? DEEP_DRIVING_LABEL
         : state.status === 'compacting'
-            ? options.workingLabel ?? 'Compacting'
+            ? options.workingLabel ?? theme.text('Compacting')
             : undefined;
     const working = [];
     const statusBar = resolveStatusBarConfig(options.statusBar, options.statusPreset);
     const placeholder = options.inspected === undefined && state.status === 'idle'
         && options.input === '' && (options.inputImages ?? 0) === 0
         ? options.modelReady === false
-            ? 'Run /login to connect a model'
-            // `/ commands` and `@ files` are already on the header's hint line, and this
-            // one is the copy that costs every frame: the header's scrolls into history
-            // once the conversation starts, this one does not. A bare prompt is enough
-            // to say the composer is ready for words.
-            : 'Ask anything'
+            ? theme.text('Run /login to connect a model')
+            : (options.sessionControls?.plan?.pending ? !options.sessionControls.plan.active : options.sessionControls?.plan?.active)
+                ? theme.text('Describe your task to generate a plan')
+                : theme.text('Ask anything')
         : null;
     const inlineHint = options.transcriptSearch !== undefined
         ? transcriptSearchHint({
@@ -1969,11 +2108,17 @@ export function renderView(state, options) {
         : options.inspected === undefined
             ? slashInlineHint(options.input, options.inputCursor, options.commands)
                 ?? placeholder
-                ?? (state.status === 'running' && options.steerKey !== undefined
-                    ? `Enter: follow-up · ${options.steerKey}: next step` : null)
+                ?? (state.status === 'running' && !options.input.startsWith('!') && options.steerKey !== undefined
+                    ? (options.input === '' ? '' : '  ') + (options.busyEnter === 'steer'
+                        ? theme.text('Enter: Steer · {key}: Queue', { key: options.queueKey ?? 'Alt+Enter' })
+                        : theme.text('Enter: Queue · {key}: Steer', { key: options.steerKey })) : null)
             : options.inspected.writable
-                ? slashInlineHint(options.input, options.inputCursor, options.commands) ?? 'Enter to steer · Esc to return'
-                : 'Read-only · Esc to return';
+                ? slashInlineHint(options.input, options.inputCursor, options.commands) ?? (state.status === 'running'
+                    ? options.busyEnter === 'steer'
+                        ? theme.text('Enter: Steer · {key}: Queue', { key: options.queueKey ?? 'Alt+Enter' })
+                        : theme.text('Enter: Queue · {key}: Steer', { key: options.steerKey ?? 'Alt+S' })
+                    : theme.text('Enter to send'))
+                : theme.text('Read-only · Esc to return');
     const statusFooter = renderStatusFooter({
         model: options.model,
         ...(options.reasoningEffort === undefined ? {} : { reasoningEffort: options.reasoningEffort }),
@@ -1987,6 +2132,15 @@ export function renderView(state, options) {
         width,
     }, theme);
     const permissionBadge = renderPermissionBadge(options.sessionControls?.permission, theme);
+    const selectionLabels = options.selectionActions === undefined ? [] : [
+        { action: 'copy', label: '[' + uiText(options.language ?? 'en', 'Copy') + ']' },
+        ...(options.selectionActions === 'copy' ? [] : [{ action: 'quote', label: '[' + uiText(options.language ?? 'en', 'Quote') + ']' }]),
+    ];
+    // Drop whole buttons on narrow terminals; never expose a clipped click target.
+    while (selectionLabels.length > 0 && visibleWidth(selectionLabels.map(item => item.label).join(' ')) + 4 > width)
+        selectionLabels.pop();
+    const selectionNote = selectionLabels.map(item => item.label).join(' ');
+    const selectionHint = selectionNote + ' · ' + uiText(options.language ?? 'en', 'Esc cancel');
     const editorOpts = {
         width,
         input: options.input,
@@ -1997,7 +2151,7 @@ export function renderView(state, options) {
         // says so the moment the character is typed — before the reader commits to
         // running anything. Green is the one ink that means "this runs on your
         // machine", which is also what a successful tool card uses.
-        border: options.input.trimStart().startsWith('!')
+        border: options.inspected === undefined && options.input.trimStart().startsWith('!')
             ? 'shellMode'
             : options.inspected !== undefined && options.inspected.writable !== true
                 || state.status === 'idle'
@@ -2008,7 +2162,8 @@ export function renderView(state, options) {
             ? { paintInput: (text, start) => paintComposerInputSlice(options.input, text, start, theme) }
             : {}),
         ...(inlineHint !== null ? { inlineHint } : {}),
-        ...(options.transientStatus === undefined ? {} : { note: options.transientStatus }),
+        ...(options.transientStatus !== undefined ? { note: options.transientStatus } : selectionNote === '' ? {}
+            : { note: visibleWidth(selectionHint) + 4 <= width ? selectionHint : selectionNote }),
         ...(activityLabelText === undefined ? {} : {
             activity: {
                 frame: motion === 'off' ? SYMBOL.running : SPINNER[Math.max(0, spinnerFrame) % SPINNER.length] ?? SYMBOL.running,
@@ -2029,9 +2184,17 @@ export function renderView(state, options) {
     const treeRows = options.promptSelector === undefined || options.promptSelector.request.presentation !== 'tree'
         ? undefined
         : renderPromptTreePage(options.promptSelector, theme, width, Math.max(10, Math.min(height - 8, Math.floor(height * 0.6))), options.input, options.inputCursor, appName);
-    const promptSelector = treeRows ?? (options.promptSelector === undefined
+    let promptVisibleRows = Math.max(3, Math.min(10, height - working.length - 14));
+    const documentPanel = options.promptSelector?.renderDocument === undefined ? undefined : renderPlanReviewPage(options.promptSelector, theme, width, Math.max(10, Math.min(height - working.length - 4, options.promptSelector.renderDocument(theme, Math.max(1, width - 6)).length + 8)), options.input, options.inputCursor, appName);
+    let promptSelector = documentPanel ?? treeRows ?? (options.promptSelector === undefined
         ? undefined
-        : renderPromptSelector(options.promptSelector, theme, width, options.input, options.inputCursor, Math.max(3, Math.min(10, height - working.length - 14))));
+        : renderPromptSelector(options.promptSelector, theme, width, options.input, options.inputCursor, promptVisibleRows));
+    // Details and live notices consume rows too. Window choices before they push
+    // the navigation hints and fixed footer outside a short terminal.
+    while (documentPanel === undefined && treeRows === undefined && options.promptSelector?.request.allowCustom === false
+        && promptSelector !== undefined && promptSelector.lines.length > height - working.length - 3 && promptVisibleRows > 3) {
+        promptSelector = renderPromptSelector(options.promptSelector, theme, width, options.input, options.inputCursor, --promptVisibleRows);
+    }
     const settings = promptSelector !== undefined || options.settings === undefined
         ? undefined
         : renderSettings(options.settings, theme, width);
@@ -2041,17 +2204,17 @@ export function renderView(state, options) {
     const editor = promptSelector === undefined && settings === undefined && search === undefined
         ? renderEditor(editorOpts, theme)
         : undefined;
-    const queuedSubmissions = editor === undefined || options.inspected !== undefined
+    const queuedSubmissions = editor === undefined
         ? []
         : [
             ...renderSteering(state.nextStepInbox, theme, width),
-            ...renderQueuedSubmissions(options.queuedSubmissions ?? [], theme, width, state.nextTurnInbox),
+            ...renderQueuedSubmissions(options.inspected === undefined || options.queuedSubmissionScope === options.inspected.id ? options.queuedSubmissions ?? [] : [], theme, width, state.nextTurnInbox, options.inspected === undefined || options.inspected.writable === true),
         ];
     // 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
         ? []
-        : renderTurnError(state.turnError, theme, width);
+        : renderTurnError(state.turnError, theme, width, options.canContinue === true);
     const todos = editor === undefined || options.inspected !== undefined ? [] : renderTodos(state.todos, theme, width);
     const aside = editor === undefined || options.inspected !== undefined || options.aside === undefined
         ? []
@@ -2082,9 +2245,12 @@ export function renderView(state, options) {
         // 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 focusRow = focusIndex === undefined ? undefined : transcript.blockStarts[focusIndex];
+    const detailEnd = focusIndex === undefined ? undefined : transcript.disclosures.find(target => target.block === focusIndex)?.detailEnd;
+    const focusOffset = Math.max(0, Math.min(options.focusBlockOffset ?? 0, (detailEnd ?? 0) - (focusRow ?? 0) - 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];
+        : focusRow === undefined ? undefined : focusRow + focusOffset;
     const requestedStart = focusStart === undefined
         ? (options.scrollStart ?? Number.POSITIVE_INFINITY)
         : transcriptStart + focusStart;
@@ -2102,12 +2268,12 @@ export function renderView(state, options) {
     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 jumpText = truncateToWidth('↓ 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(showJump
-            ? ' '.repeat(jumpColumn) + theme.inverse(jumpText) : '');
+            ? ' '.repeat(jumpColumn) + theme.fg('muted', jumpText) : '');
     const bottomRows = aside.length + 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);
     /**
@@ -2203,21 +2369,51 @@ export function renderView(state, options) {
             });
         }
     }
+    // Tool context takes precedence in the existing single pinned row. Only
+    // painted detail spans participate; folded calls and following replies do not.
+    if (!hasOverlay && budget >= 3)
+        for (const target of transcript.disclosures) {
+            if (target.detailEnd === undefined)
+                continue;
+            const block = state.blocks[target.block];
+            if (block?.kind !== 'tool')
+                continue;
+            const title = transcript.lines[target.row];
+            const titleStart = block.parentCallId === undefined ? 4 : 6;
+            const label = sliceCells(title, titleStart, (target.actionColumn ?? width) - titleStart).trimEnd();
+            stickyHeaders.push({
+                start: transcriptStart + topPad + target.row + 1,
+                end: transcriptStart + topPad + target.detailEnd,
+                text: paintSurface(theme, 'toolAltBg', 'toolOutput', padToWidth(truncateToWidth('  ' + label, width), width)),
+            });
+        }
+    const selectionActions = [];
+    if (!hasOverlay && editor !== undefined && options.transientStatus === undefined) {
+        const row = editorStart + inputLines.length - 1 + topPad;
+        const painted = stripAnsi(trimmed[row] ?? '');
+        for (const item of selectionLabels) {
+            const at = painted.indexOf(item.label);
+            if (at >= 0)
+                selectionActions.push({ row, column: visibleWidth(painted.slice(0, at)), width: visibleWidth(item.label), action: item.action });
+        }
+    }
     return {
         lines: trimmed,
+        selectionActions,
         stickyHeaders,
         ...(jumpToLatest === undefined ? {} : { jumpToLatest: { ...jumpToLatest, row: jumpToLatest.row + topPad } }),
         // The tree's preview is a scrollable document too: without its coordinates
         // the advertised Ctrl+↑↓ had nothing to move, because the card path never
         // reported them.
         ...(promptSelector?.document === undefined ? {} : { promptDocument: promptSelector.document }),
+        ...(promptSelector?.choices === undefined ? {} : { promptChoices: promptSelector.choices.map(choice => ({ ...choice, row: choice.row + editorStart + topPad })) }),
+        ...(promptSelector?.actions === undefined ? {} : { promptActions: promptSelector.actions.map(action => ({ ...action, row: action.row + editorStart + topPad })) }),
         documentRows: bodySource,
         cursor: {
             row: editorStart + caret.row + topPad,
             column: Math.min(caret.column, width),
         },
-        cursorVisible: state.status === 'compacting'
-            || (options.inspected !== undefined && options.inspected.writable !== true)
+        cursorVisible: (options.selectedProcess !== undefined && !hasOverlay) || (options.inspected !== undefined && options.inspected.writable !== true)
             ? false
             : promptSelector?.cursorVisible ?? (settings === undefined),
         liveStart,
@@ -2235,6 +2431,8 @@ export function renderView(state, options) {
                 hiddenBelow: 0,
             }),
             blockStarts: transcript.blockStarts,
+            disclosures: transcript.disclosures.map(target => ({ ...target, row: transcriptStart + topPad + target.row,
+                ...(target.detailEnd === undefined ? {} : { detailEnd: transcriptStart + topPad + target.detailEnd }) })),
             fileRegions: transcript.fileRegions.map(region => ({ ...region, start: transcriptStart + topPad + region.start, end: transcriptStart + topPad + region.end })),
             blockDrawStarts: transcript.blockDrawStarts,
             foldShape: transcript.foldShape,