@iowarp/clio-coder 0.3.2 → 0.3.3

package/src/interactive/overlays/ask-user.ts

@@ -13,8 +13,9 @@ import {
 } from "../../engine/tui.js";
 import type { AskUserAnswer, AskUserQuestion, AskUserResult } from "../../tools/ask-user.js";
 import { ASK_USER_OTHER_LABEL, cancelledAskUserResult } from "../../tools/ask-user.js";
-import { buildHint, DEFAULT_SELECT_THEME, showClioOverlayFrame } from "../overlay-frame.js";
+import { buildHint, DEFAULT_SELECT_THEME, type HintEntry, showClioOverlayFrame } from "../overlay-frame.js";
 import { type ClioToken, clioTheme, dotSep, GLYPH, screenTitle } from "../theme/index.js";
+import { nextContentScrollOffset, type ViewScrollAction } from "../view/view-overlay.js";
 
 /**
  * The border and title token while a decision is pending.
@@ -54,7 +55,7 @@ export const ASK_USER_DEFAULT_SURFACE: AskUserSurface = "panel";
 interface AskUserSurfaceGeometry {
 	/** Box width in columns; zero fills the row. The frame clamps to the terminal. */
 	width: number;
-	/** Rows the body may use, before the borders. */
+	/** Rows the body may use, before the borders. Zero means every row the frame has. */
 	maxInnerRows: number;
 	anchor: NonNullable<OverlayOptions["anchor"]>;
 	margin: NonNullable<OverlayOptions["margin"]>;
@@ -74,12 +75,18 @@ interface AskUserSurfaceGeometry {
 export const ASK_USER_SURFACE_GEOMETRY: Record<AskUserSurface, AskUserSurfaceGeometry> = {
 	compact: { width: 68, maxInnerRows: 10, anchor: "bottom-center", margin: { top: 1, right: 2, bottom: 1, left: 2 } },
 	panel: { width: 88, maxInnerRows: 18, anchor: "center", margin: 1 },
-	interview: { width: 0, maxInnerRows: 42, anchor: "center", margin: 1 },
+	// The interview is a workspace, not a modal. A cap of 42 turned a 66-row
+	// terminal into a centered box with twenty blank rows around it, so the
+	// interview takes every row the frame has and lays its own chrome out inside
+	// them. The one-row margin keeps the border off the top row and the footer.
+	interview: { width: 0, maxInnerRows: 0, anchor: "center", margin: 1 },
 };
 
 const ASK_USER_FRAME_ROWS = 2;
 const ASK_USER_FRAME_AND_MARGIN_ROWS = 4;
 const MIN_VISIBLE_OPTIONS = 3;
+/** Interview rows spent on chrome before an option row: strip, header, blanks, status, one question row. */
+const INTERVIEW_CHROME_ROWS = 7;
 const MAX_VISIBLE_OPTIONS = 12;
 const ELLIPSIS = "…";
 
@@ -227,6 +234,14 @@ class AskUserOverlayView implements Component {
 	private list: SelectList | null = null;
 	private input: Input | null = null;
 	private resolveCurrent: ((result: AskUserResult) => void) | null = null;
+	/** Rows of the interview's scrollable middle already scrolled past. */
+	private contentScrollOffset = 0;
+	/** Whether the last interview render had more content than the region held. */
+	private contentOverflows = false;
+	/** Rows the scroll region drew on the last render, for a page-sized jump. */
+	private contentRegionHeight = 1;
+	/** Rows the scroll region wanted on the last render. */
+	private contentTotalRows = 0;
 
 	constructor(private readonly deps: AskUserOverlayViewDeps) {}
 
@@ -240,6 +255,7 @@ class AskUserOverlayView implements Component {
 		this.states = this.questions.map((question) => createQuestionState(question));
 		this.list = null;
 		this.input = null;
+		this.resetContentScroll();
 		// Before the controls, because how many option rows fit is a property of
 		// the box this round is about to be drawn in.
 		this.setSurface(askUserSurface(this.questions, this.history.length));
@@ -283,6 +299,10 @@ class AskUserOverlayView implements Component {
 		const state = this.currentState();
 		if (!question || !state) return;
 
+		// Scrolling the transcript must not cost the operator their place in the
+		// options, so the region has keys of its own that neither control claims.
+		if (this.handleScrollInput(data, state.mode)) return;
+
 		if (state.mode === "text") {
 			if (this.isTextModePreviousKey(data)) {
 				this.goToRelativeQuestion(-1);
@@ -331,21 +351,106 @@ class AskUserOverlayView implements Component {
 		const question = this.currentQuestion();
 		if (!question) return [clioTheme().fg("muted", "No questions.")];
 
-		const interview = this.surface === "interview";
+		if (this.surface === "interview") return this.renderInterview(question, safeWidth, maxRows);
+
+		this.contentOverflows = false;
 		const controlLines = this.renderControlLines(safeWidth);
-		const ledgerLines = interview ? this.renderAnswerLedger(safeWidth) : [];
 		const statusLines = this.status.length > 0 ? ["", fitLine(clioTheme().fg("dim", this.status), safeWidth)] : [];
-		const stripLines = interview ? [this.renderQuestionStrip(safeWidth), ""] : [];
 		const headerLine = this.renderQuestionHeader(question, safeWidth);
 		const headerLines = headerLine.length > 0 ? [headerLine] : [];
-		const spent =
-			stripLines.length + headerLines.length + statusLines.length + 1 + controlLines.length + ledgerLines.length;
+		const spent = headerLines.length + statusLines.length + 1 + controlLines.length;
 		const questionLines = wrapTextWithAnsi(question.question, safeWidth).slice(0, Math.max(1, maxRows - spent));
 
-		return [...stripLines, ...headerLines, ...questionLines, ...statusLines, "", ...controlLines, ...ledgerLines].slice(
-			0,
-			maxRows,
+		return [...headerLines, ...questionLines, ...statusLines, "", ...controlLines].slice(0, maxRows);
+	}
+
+	/**
+	 * The interview, as a workspace with fixed chrome and a scrolling middle.
+	 *
+	 * The round strip and the question header hold the top; the status line and
+	 * the active control hold the bottom, at their full row cost, so the thing the
+	 * operator has to act on is never the thing that gets clipped. The question
+	 * text and the answer ledger share whatever is left and scroll through it.
+	 * Everything is re-derived per render, so a resize is just the next frame.
+	 */
+	private renderInterview(question: AskUserQuestion, width: number, maxRows: number): string[] {
+		const theme = clioTheme();
+		const controlLines = this.renderControlLines(width);
+		const statusLines = this.status.length > 0 ? ["", fitLine(theme.fg("dim", this.status), width)] : [];
+		const headerLine = this.renderQuestionHeader(question, width);
+		const headerLines = headerLine.length > 0 ? [headerLine] : [];
+		const stripLines = [this.renderQuestionStrip(width), ""];
+		const content = [...wrapTextWithAnsi(question.question, width), ...this.renderAnswerLedger(width)];
+
+		// Chrome sheds from the outside in when the terminal is too short to carry
+		// all of it: the round strip first, then the header, then the status, and
+		// the control only if a terminal is short enough that nothing else is left.
+		let top = [...stripLines, ...headerLines];
+		let bottom = [...statusLines, "", ...controlLines];
+		const region = (): number => maxRows - top.length - bottom.length;
+		if (region() < 1) top = [...headerLines];
+		if (region() < 1) top = [];
+		if (region() < 1) bottom = ["", ...controlLines];
+		if (region() < 1) bottom = [...controlLines];
+		const regionRows = Math.max(1, region());
+
+		const overflows = content.length > regionRows;
+		this.contentOverflows = overflows;
+		this.contentTotalRows = content.length;
+		// One row of the region pays for the indicator when there is more than the
+		// region holds, so the marker never covers a row it is reporting on.
+		const viewRows = overflows ? Math.max(1, regionRows - 1) : regionRows;
+		this.contentRegionHeight = viewRows;
+		this.contentScrollOffset = Math.max(0, Math.min(this.contentScrollOffset, Math.max(0, content.length - viewRows)));
+
+		const visible = content.slice(this.contentScrollOffset, this.contentScrollOffset + viewRows);
+		const middle = [...visible];
+		if (overflows) middle.push(fitLine(theme.fg("dim", this.scrollIndicator(content.length, viewRows)), width));
+		while (middle.length < regionRows) middle.push("");
+
+		return [...top, ...middle, ...bottom].slice(0, maxRows);
+	}
+
+	private scrollIndicator(total: number, viewRows: number): string {
+		const above = this.contentScrollOffset;
+		const below = Math.max(0, total - viewRows - above);
+		const parts: string[] = [];
+		if (above > 0) parts.push(`↑ ${above} more`);
+		if (below > 0) parts.push(`↓ ${below} more`);
+		parts.push(`(${Math.min(total, above + viewRows)}/${total})`);
+		return parts.join("  ");
+	}
+
+	/** True when the key belonged to the scroll region rather than to a control. */
+	private handleScrollInput(data: string, mode: Mode): boolean {
+		if (this.surface !== "interview") return false;
+		const action = this.scrollAction(data, mode);
+		if (!action) return false;
+		const next = nextContentScrollOffset(
+			this.contentScrollOffset,
+			this.contentTotalRows,
+			this.contentRegionHeight,
+			action,
 		);
+		if (next !== this.contentScrollOffset) {
+			this.contentScrollOffset = next;
+			this.deps.requestRender();
+		}
+		return true;
+	}
+
+	private scrollAction(data: string, mode: Mode): ViewScrollAction | null {
+		if (matchesKey(data, "pageUp")) return "page-up";
+		if (matchesKey(data, "pageDown")) return "page-down";
+		// Ctrl+U and Ctrl+D are line-kill and half-page in a text field, so they
+		// stay with the input while one is focused.
+		if (mode === "select" && matchesKey(data, "ctrl+u")) return "half-up";
+		if (mode === "select" && matchesKey(data, "ctrl+d")) return "half-down";
+		return null;
+	}
+
+	private resetContentScroll(): void {
+		this.contentScrollOffset = 0;
 	}
 
 	footerHint(): string {
@@ -357,11 +462,11 @@ class AskUserOverlayView implements Component {
 		if (!question || !state) return buildHint([]);
 		if (state.mode === "text") {
 			return this.questions.length > 1
-				? buildHint([
+				? this.withScrollHint([
 						{ key: "Enter", verb: "submit" },
 						{ key: "Alt+Left/Right", verb: "question" },
 					])
-				: buildHint([{ key: "Enter", verb: "submit" }]);
+				: this.withScrollHint([{ key: "Enter", verb: "submit" }]);
 		}
 		// `accept` rather than `select` or `commit`: the footer of a decision prompt
 		// has one job, which is to name the key that answers it. Esc keeps the
@@ -369,22 +474,32 @@ class AskUserOverlayView implements Component {
 		// interview together.
 		if (question.multi_select === true) {
 			return this.questions.length > 1
-				? buildHint([
+				? this.withScrollHint([
 						{ key: "Left/Right", verb: "question" },
 						{ key: "Space", verb: "toggle" },
 						{ key: "Enter", verb: "accept" },
 					])
-				: buildHint([
+				: this.withScrollHint([
 						{ key: "Space", verb: "toggle" },
 						{ key: "Enter", verb: "accept" },
 					]);
 		}
 		return this.questions.length > 1
-			? buildHint([
+			? this.withScrollHint([
 					{ key: "Left/Right", verb: "question" },
 					{ key: "Enter", verb: "accept" },
 				])
-			: buildHint([{ key: "Enter", verb: "accept" }]);
+			: this.withScrollHint([{ key: "Enter", verb: "accept" }]);
+	}
+
+	/**
+	 * The keys for this question, plus the scroll keys when there is something to
+	 * scroll. A footer that always advertised PgUp would be advertising a key that
+	 * does nothing on most rounds.
+	 */
+	private withScrollHint(entries: ReadonlyArray<HintEntry>): string {
+		if (this.surface !== "interview" || !this.contentOverflows) return buildHint(entries);
+		return buildHint([...entries, { key: "PgUp/PgDn", verb: "scroll" }]);
 	}
 
 	private setSurface(next: AskUserSurface): void {
@@ -443,17 +558,20 @@ class AskUserOverlayView implements Component {
 	private maxInnerRows(): number {
 		const cap = ASK_USER_SURFACE_GEOMETRY[this.surface].maxInnerRows;
 		const rows = this.deps.getTerminalRows();
-		if (!Number.isFinite(rows) || rows <= 0) return cap;
-		return Math.max(1, Math.min(cap, Math.floor(rows) - ASK_USER_FRAME_AND_MARGIN_ROWS));
+		// A zero cap is the interview's "every row the frame has", which is the
+		// same number the frame budgets itself when the mount passes no maxHeight.
+		if (!Number.isFinite(rows) || rows <= 0) return cap > 0 ? cap : 1;
+		const available = Math.max(1, Math.floor(rows) - ASK_USER_FRAME_AND_MARGIN_ROWS);
+		return cap > 0 ? Math.min(cap, available) : available;
 	}
 
 	private maxVisibleOptions(): number {
 		const inner = this.maxInnerRows();
-		// The interview surface spends rows on the round strip and the ledger
-		// before an option ever renders. The other two spend them on a header, a
-		// question, and a separator, so the options get nearly everything.
+		// The interview's option list is budgeted off the live row count rather
+		// than a fixed heuristic: the strip, header, blank, status, blank and one
+		// row of question are what the control shares the workspace with.
 		if (this.surface === "interview") {
-			return Math.max(MIN_VISIBLE_OPTIONS, Math.min(MAX_VISIBLE_OPTIONS, inner - 12));
+			return Math.max(MIN_VISIBLE_OPTIONS, Math.min(MAX_VISIBLE_OPTIONS, inner - INTERVIEW_CHROME_ROWS));
 		}
 		return Math.max(1, Math.min(MAX_VISIBLE_OPTIONS, inner - 4));
 	}
@@ -809,6 +927,7 @@ class AskUserOverlayView implements Component {
 		const next = this.nextUnansweredIndex();
 		if (next !== null) {
 			this.index = next;
+			this.resetContentScroll();
 			const nextState = this.currentState();
 			const nextQuestion = this.currentQuestion();
 			if (nextState && nextQuestion && !nextState.answer.trim()) nextState.mode = initialMode(nextQuestion);
@@ -844,6 +963,7 @@ class AskUserOverlayView implements Component {
 		this.syncActiveControl();
 		this.index = (this.index + delta + this.questions.length) % this.questions.length;
 		this.status = "";
+		this.resetContentScroll();
 		this.rebuildControl();
 		this.deps.requestRender();
 	}
@@ -888,7 +1008,9 @@ export function openAskUserOverlay(tui: TUI, deps: OpenAskUserOverlayDeps): AskU
 		handle = showClioOverlayFrame(tui, view, {
 			anchor: geometry.anchor,
 			width: geometry.width,
-			maxHeight: geometry.maxInnerRows + ASK_USER_FRAME_ROWS,
+			// A zero cap means the frame keeps its own budget, which is every row
+			// the terminal has left after the margins.
+			...(geometry.maxInnerRows > 0 ? { maxHeight: geometry.maxInnerRows + ASK_USER_FRAME_ROWS } : {}),
 			margin: geometry.margin,
 			title: () => (view.isDecisionPending() ? ASK_USER_DECISION_TITLE : ASK_USER_WAITING_TITLE),
 			tone: () => (view.isDecisionPending() ? ASK_USER_DECISION_TONE : undefined),

package/src/interactive/renderers/tool-execution.ts

@@ -15,11 +15,14 @@
 import { sanitizeCallTargetText } from "../../domains/safety/call-target.js";
 import { formatSize } from "../../engine/truncate.js";
 import { visibleWidth, wrapTextWithAnsi } from "../../engine/tui.js";
+import { classifyResourceRead, toolPresentationPolicy } from "../../tools/presentation.js";
 import type { ApprovalRequestView } from "../permission-overlay.js";
 import { clioTheme, formatCompactMs, GLYPH } from "../theme/index.js";
 import { renderDiffLines } from "./diff.js";
 import { tryRenderJson, tryRenderXml } from "./structured.js";
 
+export { classifyResourceRead };
+
 const theme = clioTheme();
 const dim = (text: string): string => theme.fg("dim", text);
 const red = (text: string): string => theme.fg("error", text);
@@ -40,6 +43,8 @@ const FULL_RESULT_PREVIEW_LIMIT = 60_000;
 const FULL_RESULT_ROW_LIMIT = 120;
 const STREAMING_RESULT_ROW_LIMIT = 20;
 const ARGS_BODY_LINE_LIMIT = 24;
+/** Rows of mutation diff a folded edit/write row keeps visible before it defers to the body. */
+const FOLDED_DIFF_ROW_LIMIT = 24;
 const STATUS_OK_GLYPH = GLYPH.ok;
 const STATUS_ERROR_GLYPH = GLYPH.error;
 
@@ -286,24 +291,6 @@ function summarizeArgs(toolName: string, args: unknown): string {
 	return truncate(jsonStringifySafe(safeArgs), ARG_PREVIEW_LIMIT);
 }
 
-/**
- * Compact resource-read classification. Reads of skill/handbook/agent
- * instruction files and docs pages collapse to one labeled line and never
- * auto-expand; their bodies are reference material, not task output.
- */
-export function classifyResourceRead(toolName: string, args: unknown): string | null {
-	if (toolName !== "read") return null;
-	const path = readStringField(args, "path");
-	if (path === null) return null;
-	const normalized = path.replace(/\\/g, "/");
-	const base = normalized.split("/").pop() ?? "";
-	if (base === "SKILL.md") return "skill";
-	if (base === "CLIO-CODER.md") return "handbook";
-	if (base === "AGENTS.md") return "agents";
-	if (/(^|\/)docs\//.test(normalized)) return "docs";
-	return null;
-}
-
 function detailsOf(result: unknown): Record<string, unknown> | null {
 	if (!isPlainObject(result)) return null;
 	return isPlainObject(result.details) ? result.details : null;
@@ -448,15 +435,58 @@ function ledgerTail(finished: ToolExecutionFinished): { facts: string; offload:
 	const parts: string[] = [];
 	const outcome = outcomeSummary(finished);
 	if (outcome !== null) parts.push(outcome);
-	const bytes = isNonExecutedOutcome(finished.outcome) ? null : shownBytesOf(finished);
-	if (bytes !== null && bytes > 0) parts.push(formatSize(bytes));
-	const offloadPath = offloadPathOf(finished);
+	const executed = !isNonExecutedOutcome(finished.outcome);
+	// A folded bash row is the only view of the call the operator gets by
+	// default, so its settlement facts have to be here rather than only in the
+	// expanded body. A failed row already carries `(exit N)` on the status glyph.
+	if (executed && finished.toolName === "bash" && !finished.isError) {
+		parts.push(`exit ${structuredExitCode(finished) ?? "0"}`);
+	}
+	const bytes = executed ? shownBytesOf(finished) : null;
+	if (bytes !== null && bytes > 0) {
+		const total = totalBytesOf(finished);
+		parts.push(
+			total !== null && total > bytes ? `${formatSize(bytes)} shown / ${formatSize(total)} total` : formatSize(bytes),
+		);
+	}
+	if (executed) {
+		if (isTruncatedResult(finished)) parts.push("truncated");
+		const details = detailsOf(finished.result);
+		if (details?.timedOut === true) parts.push("timed out");
+		if (details?.outputCapped === true) parts.push("output capped");
+	}
+	if (finished.excludeFromContext === true) parts.push("excluded from context");
+	const offloadPath = executed ? offloadPathOf(finished) : null;
 	return {
 		facts: parts.length > 0 ? dim(` · ${parts.join(" · ")}`) : "",
 		offload: offloadPath !== null ? dim(` · full: ${offloadPath}`) : "",
 	};
 }
 
+/** Longest diagnostic excerpt a folded failure row may carry. */
+const FAILURE_EXCERPT_LIMIT = 80;
+
+/**
+ * Last non-empty output line of a failed call, bounded so the folded row stays
+ * diagnostically useful without opening the body. Sanitized to one line: the
+ * source is raw tool output. The tool's presentation policy decides whether
+ * its failures carry one; the renderer never names a tool here.
+ */
+function failureExcerpt(finished: ToolExecutionFinished, width: number): string {
+	if (!finished.isError || !toolPresentationPolicy(finished.toolName, finished.args).failureExcerpt) return "";
+	if (isNonExecutedOutcome(finished.outcome)) return "";
+	const text = unwrapResultEnvelope(finished.result);
+	if (typeof text !== "string") return "";
+	let excerpt: string | undefined;
+	for (const raw of text.split("\n")) {
+		const line = sanitizeCallTargetText(raw).trim();
+		if (line.length > 0) excerpt = line;
+	}
+	if (excerpt === undefined) return "";
+	const limit = Math.min(FAILURE_EXCERPT_LIMIT, Math.max(20, width - 20));
+	return dim(` · ${truncate(excerpt, limit)}`);
+}
+
 /**
  * Marker for a call parked at admission awaiting operator approval. Rendered
  * in place of the elapsed counter so a parked call never reads as executing
@@ -531,8 +561,8 @@ function statusGlyph(status: HeaderStatus, meta: StatusMeta = {}): string {
 }
 
 function headerLine(toolName: string, args: unknown, status: HeaderStatus, meta: StatusMeta = {}): string {
-	const summary = summarizeArgs(toolName, args);
-	const head = `${dim(HEADER_PREFIX_PLAIN)}${cyanBold(toolName)}${dim("(")}${cyan(summary)}${dim(")")}`;
+	const body = styleSublineBody(buildSublineBody(toolName, args, status, undefined, meta.outcome));
+	const head = `${dim(HEADER_PREFIX_PLAIN)}${body}`;
 	return `${head}${statusGlyph(status, meta)}`;
 }
 
@@ -546,8 +576,9 @@ function styleSublineBody(body: string): string {
 	return sublineLead(match.groups.lead, match.groups.rest);
 }
 
-function buildUnknownToolBody(toolName: string, args: unknown): string {
-	return `${toolName}(${summarizeArgs(toolName, args)})`;
+function buildGenericToolBody(toolName: string, args: unknown): string {
+	const summary = summarizeArgs(toolName, args);
+	return summary.length > 0 ? `tool action ${summary}` : "tool action";
 }
 
 function buildFieldSublineBody(
@@ -604,6 +635,7 @@ const SUBLINE_BODY_BUILDERS: Readonly<Record<string, (args: unknown) => string |
 	bash: (args) => buildFieldSublineBody(args, "command", "running ", { wrapInBackticks: true }),
 	grep: (args) => buildFieldSublineBody(args, "pattern", "searching for ", { wrapInBackticks: true }),
 	find: (args) => buildFieldSublineBody(args, "pattern", "finding ", { wrapInBackticks: true }),
+	web_fetch: (args) => buildFieldSublineBody(args, "url", "fetching "),
 	git: (args) => buildFieldSublineBody(args, "op", "git "),
 	verify: (args) => buildFieldSublineBody(args, "check", "verifying "),
 	code_nav: (args) => {
@@ -641,7 +673,7 @@ const SUBLINE_BODY_BUILDERS: Readonly<Record<string, (args: unknown) => string |
 /**
  * Per-tool subline templates. Maps a tool name to a function that builds the
  * verb-led subline body without the leading glyph and without the trailing
- * status glyph. Unknown tools fall back to the existing `<name>(<arg>)` form.
+ * status glyph. Unknown tools fall back to a tool-neutral action summary.
  */
 function webFetchMeta(result: unknown): string | null {
 	if (!isPlainObject(result) || !isPlainObject(result.details)) return null;
@@ -658,11 +690,10 @@ function webFetchMeta(result: unknown): string | null {
 
 /**
  * A call the permission gate blocked never executed, so the collapsed row must
- * not claim it did. `ran \`id\` · 667B ✗ blocked` read as a command that ran and
- * produced 667 bytes, while the expanded header for the same node correctly said
- * `bash(id) ✗ blocked`. Blocked rows use that same call-signature form, and the
- * ledger byte count is suppressed because those bytes are the denial text, not
- * output.
+ * not claim it did. Blocked calls keep the ordinary operator-facing action
+ * description but use a neutral noun for commands; the status tail supplies the
+ * blocked outcome. The ledger byte count is suppressed elsewhere because those
+ * bytes are the denial text, not output.
  */
 function isNonExecutedOutcome(outcome: ToolExecutionFinished["outcome"]): boolean {
 	return outcome === "blocked";
@@ -675,21 +706,29 @@ function buildSublineBody(
 	result?: unknown,
 	outcome?: ToolExecutionFinished["outcome"],
 ): string {
-	if (isNonExecutedOutcome(outcome)) return buildUnknownToolBody(toolName, args);
-	if (status === "forming" || status === "ready") return buildUnknownToolBody(toolName, args);
+	if (isNonExecutedOutcome(outcome)) {
+		if (toolName === "bash") {
+			return (
+				buildFieldSublineBody(args, "command", "command ", { wrapInBackticks: true }) ??
+				buildGenericToolBody(toolName, args)
+			);
+		}
+		return SUBLINE_BODY_BUILDERS[toolName]?.(args) ?? buildGenericToolBody(toolName, args);
+	}
 	if (toolName === "web_fetch") {
 		const meta = status === undefined ? null : webFetchMeta(result);
-		return `${buildUnknownToolBody(toolName, args)}${meta ? dim(` · ${meta}`) : ""}`;
+		const body = SUBLINE_BODY_BUILDERS.web_fetch?.(args) ?? buildGenericToolBody(toolName, args);
+		return `${body}${meta ? dim(` · ${meta}`) : ""}`;
 	}
 	if (toolName === "bash") {
-		const lead = status === "running" || status === undefined ? "running " : "ran ";
+		const lead = status === "ok" || status === "error" ? "ran " : "running ";
 		return (
-			buildFieldSublineBody(args, "command", lead, { wrapInBackticks: true }) ?? buildUnknownToolBody(toolName, args)
+			buildFieldSublineBody(args, "command", lead, { wrapInBackticks: true }) ?? buildGenericToolBody(toolName, args)
 		);
 	}
 	const body = SUBLINE_BODY_BUILDERS[toolName]?.(args);
 	if (body !== null && body !== undefined) return body;
-	return buildUnknownToolBody(toolName, args);
+	return buildGenericToolBody(toolName, args);
 }
 
 interface SublineParts {
@@ -1116,10 +1155,40 @@ function sublineStatus(call: ToolExecutionStart | ToolExecutionFinished): Header
  * imports the keybindings manager directly; the caller resolves the key string
  * and passes it in to keep this module pure.
  */
+export interface ToolSublineRenderOptions {
+	/** Live rows color the folded mutation diff; replay and export request plain rows. */
+	diffStyle?: "color" | "plain";
+	/**
+	 * Whether the folded row carries the extras its tool's presentation asks
+	 * for (today the bounded mutation diff). The bare subline level drops them;
+	 * the failure excerpt is not one of them and always rides the row.
+	 */
+	foldedExtras?: "per-tool" | "none";
+}
+
+/**
+ * The bounded diff a folded mutation row keeps under itself, when the tool's
+ * presentation asks for one and the result carries one. A folded `edit` that
+ * hid its change told the operator nothing they could act on.
+ */
+function foldedDiffRows(finished: ToolExecutionFinished, width: number, opts: ToolSublineRenderOptions): string[] {
+	if (opts.foldedExtras === "none") return [];
+	if (finished.isError || isNonExecutedOutcome(finished.outcome)) return [];
+	if (!toolPresentationPolicy(finished.toolName, finished.args).showDiffWhenFolded) return [];
+	const diff = resultDiff(finished.result);
+	if (diff === null) return [];
+	return truncateRowsMiddle(
+		renderMutationDiffBlock(diff, width, opts.diffStyle !== "plain"),
+		FOLDED_DIFF_ROW_LIMIT,
+		false,
+	);
+}
+
 export function renderToolSubline(
 	call: ToolExecutionStart | ToolExecutionFinished,
 	width: number,
 	expandKey?: string,
+	opts: ToolSublineRenderOptions = {},
 ): string[] {
 	const status = sublineStatus(call);
 	const meta: StatusMeta =
@@ -1132,9 +1201,12 @@ export function renderToolSubline(
 				}
 			: { elapsedMs: call.elapsedMs };
 	const parts = sublineParts(call, status, meta);
+	const excerpt = "result" in call ? failureExcerpt(call, width) : "";
 	const showHint = "result" in call && expandKey !== undefined && expandKey.length > 0;
 	const tail = showHint ? `${parts.tail}${dim(` (${expandKey})`)}` : parts.tail;
-	return wrapSublineWithTail(parts.lead, tail, width);
+	const lines = wrapSublineWithTail(`${parts.lead}${excerpt}`, tail, width);
+	if ("result" in call) lines.push(...foldedDiffRows(call, width, opts));
+	return lines;
 }
 
 /**
@@ -1294,6 +1366,13 @@ export interface BashTranscriptExecution {
 	fullOutputPath?: string | undefined;
 	excludeFromContext?: boolean | undefined;
 	error?: string | undefined;
+	/**
+	 * Whether the block draws its one-line row instead of the full body. The
+	 * caller resolves this from the transcript detail policy and the operator's
+	 * override, the same way the panel resolves a model bash call. Omitted means
+	 * folded.
+	 */
+	folded?: boolean | undefined;
 }
 
 /**
@@ -1301,7 +1380,12 @@ export interface BashTranscriptExecution {
  * as model-initiated bash. This is a view projection only; callers keep Clio's
  * existing immutable `bashExecution` ledger entry.
  */
-export function renderBashTranscriptExecution(execution: BashTranscriptExecution, width: number): string[] {
+export function renderBashTranscriptExecution(
+	execution: BashTranscriptExecution,
+	width: number,
+	expandKey?: string,
+	bodyOptions: ToolBodyRenderOptions = {},
+): string[] {
 	const shownBytes = Buffer.byteLength(execution.output, "utf8");
 	const totalBytes = execution.totalBytes ?? shownBytes;
 	const args: Record<string, unknown> = { command: execution.command };
@@ -1319,7 +1403,20 @@ export function renderBashTranscriptExecution(execution: BashTranscriptExecution
 		content: [{ type: "text", text: execution.output }],
 		details,
 	};
+	const folded = execution.folded !== false;
 	if (execution.running) {
+		if (folded) {
+			return renderToolSubline(
+				{
+					toolCallId: "local-bash",
+					toolName: "bash",
+					args,
+					elapsedMs: execution.elapsedMs,
+					phase: "running",
+				},
+				width,
+			);
+		}
 		return renderToolStreamingExecution(
 			{
 				toolCallId: "local-bash",
@@ -1336,22 +1433,20 @@ export function renderBashTranscriptExecution(execution: BashTranscriptExecution
 	const output = message
 		? `${execution.output}${execution.output.length > 0 ? "\n\n" : ""}${message}`
 		: execution.output;
-	return renderToolExecution(
-		{
-			toolCallId: "local-bash",
-			toolName: "bash",
-			args,
-			result: { ...result, content: [{ type: "text", text: output }] },
-			isError: execution.cancelled === true || execution.error !== undefined || (execution.exitCode ?? 0) !== 0,
-			exitCode: execution.exitCode,
-			...(execution.cancelled === true ? { outcome: "aborted" as const } : {}),
-			excludeFromContext: execution.excludeFromContext,
-			resultSummary: {
-				bytes: shownBytes,
-				truncated: execution.truncated === true,
-				...(execution.fullOutputPath !== undefined ? { offloadPath: execution.fullOutputPath } : {}),
-			},
+	const finished: ToolExecutionFinished = {
+		toolCallId: "local-bash",
+		toolName: "bash",
+		args,
+		result: { ...result, content: [{ type: "text", text: output }] },
+		isError: execution.cancelled === true || execution.error !== undefined || (execution.exitCode ?? 0) !== 0,
+		exitCode: execution.exitCode,
+		...(execution.cancelled === true ? { outcome: "aborted" as const } : {}),
+		excludeFromContext: execution.excludeFromContext,
+		resultSummary: {
+			bytes: shownBytes,
+			truncated: execution.truncated === true,
+			...(execution.fullOutputPath !== undefined ? { offloadPath: execution.fullOutputPath } : {}),
 		},
-		width,
-	);
+	};
+	return folded ? renderToolSubline(finished, width, expandKey) : renderToolExecution(finished, width, bodyOptions);
 }

package/src/interactive/status/index.ts

@@ -1,13 +1,24 @@
 export type { StatusController, StatusControllerDeps } from "./controller.js";
 export { createStatusController } from "./controller.js";
+export {
+	compactReasoningTokens,
+	formatReasoningChip,
+	formatReasoningLabel,
+	type ReasoningProvenance,
+	type ReasoningUsageView,
+	reasoningFromSummary,
+	reasoningFromTally,
+	UNMEASURED_REASONING,
+} from "./reasoning.js";
 export { type ReduceContext, reduceStatus, type StatusInputEvent } from "./state-machine.js";
-export { type BuildSummaryInput, buildSummary } from "./summary.js";
+export { type BuildSummaryInput, buildSummary, emptyRunTally, foldMessageIntoRunTally } from "./summary.js";
 export {
 	type AgentStatus,
 	type AgentStatusChangedPayload,
 	type AgentStatusEvent,
 	INITIAL_STATUS,
 	type ReasoningTokenProvenance,
+	type RunTally,
 	type StatusPhase,
 	type TurnStopReason,
 	type TurnSummary,