@iowarp/clio-coder 0.3.2 → 0.3.4

package/src/interactive/chat-renderer.ts

@@ -13,6 +13,9 @@
  * `isTransparentAssistantWrapper`.
  */
 
+import { ToolNames } from "../core/tool-names.js";
+import { foldWorkingSet } from "../domains/context/working-set/fold.js";
+import { compactionCut } from "../domains/context/working-set/visible.js";
 import type {
 	BashExecutionEntry,
 	BranchSummaryEntry,
@@ -38,6 +41,8 @@ import {
 } from "../engine/messages.js";
 import { wrapTextWithAnsi } from "../engine/tui.js";
 import type { AgentMessage } from "../engine/types.js";
+import { toolPresentationPolicy } from "../tools/presentation.js";
+import { toolResultPresentationText } from "../tools/result-disposition.js";
 import type { ChatLoopEvent, RetryStatusPayload } from "./chat-loop.js";
 import { isSelfExplainingAbort } from "./chat-loop-messages.js";
 import type { ChatPanel } from "./chat-panel.js";
@@ -53,6 +58,7 @@ import {
 	type StreamPacer,
 	type StreamPacerSlice,
 } from "./stream-pacer.js";
+import { type FoldOverride, policyToolFold, resolveFold, type TranscriptDetailPolicy } from "./transcript-detail.js";
 import { readWorkerReceiptFactsForReplay } from "./worker-receipts.js";
 import { workerEntriesFromRunEntries } from "./worker-replay.js";
 import type { WorkerReceiptReader } from "./worker-stream.js";
@@ -468,18 +474,22 @@ function toolCallMessageFromEntry(entry: MessageEntry): AgentMessage {
 	} as unknown as AgentMessage;
 }
 
-function toolResultContent(result: unknown): unknown[] {
+function toolResultContent(result: unknown, unbounded = false): unknown[] {
 	const obj = payloadObject(result);
 	if (Array.isArray(obj?.content)) {
-		return cloneContentBlocks(obj.content, MAX_REPLAY_TEXT_CHARS) ?? [];
+		return cloneContentBlocks(obj.content, unbounded ? undefined : MAX_REPLAY_TEXT_CHARS) ?? [];
 	}
-	if (isTextResult(result)) return [{ type: "text", text: truncateReplayText(result.text) }];
-	if (typeof result === "string") return [{ type: "text", text: truncateReplayText(result) }];
-	return [{ type: "text", text: stringifyPreview(result, 10_000) }];
+	if (isTextResult(result)) return [{ type: "text", text: unbounded ? result.text : truncateReplayText(result.text) }];
+	if (typeof result === "string") return [{ type: "text", text: unbounded ? result : truncateReplayText(result) }];
+	return [{ type: "text", text: stringifyPreview(result, unbounded ? Number.POSITIVE_INFINITY : 10_000) }];
 }
 
-function displayReplayToolResult(result: unknown): unknown {
-	const content = toolResultContent(result);
+function displayReplayToolResult(result: unknown, unbounded = false): unknown {
+	const presentationText = toolResultPresentationText(result);
+	const content =
+		presentationText === null
+			? toolResultContent(result, unbounded)
+			: [{ type: "text", text: unbounded ? presentationText : truncateReplayText(presentationText) }];
 	// Preserve the details record (observation envelope, exec records) so the
 	// replayed ledger line carries the same outcome facts as the live one.
 	const details = payloadObject(result)?.details;
@@ -704,19 +714,28 @@ function appendReplayLine(chatPanel: ChatPanel, text: string): void {
 	chatPanel.appendReplayBlock((width) => renderReplayLine(truncateReplayText(text), width));
 }
 
-function renderBashExecutionEntry(entry: BashExecutionEntry, width: number): string[] {
+function renderBashExecutionEntry(
+	entry: BashExecutionEntry,
+	width: number,
+	folded: boolean,
+	unbounded: boolean,
+): string[] {
+	const normalizedOutput = entry.output.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\s+$/g, "");
 	return renderBashTranscriptExecution(
 		{
 			command: entry.command,
-			output: truncateReplayText(entry.output.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\s+$/g, "")),
+			output: unbounded ? normalizedOutput : truncateReplayText(normalizedOutput),
 			running: false,
 			exitCode: entry.exitCode,
 			cancelled: entry.cancelled,
 			truncated: entry.truncated,
 			fullOutputPath: entry.fullOutputPath,
 			excludeFromContext: entry.excludeFromContext,
+			folded,
 		},
 		width,
+		undefined,
+		{ unbounded, diffStyle: "plain" },
 	);
 }
 
@@ -823,13 +842,6 @@ function truncateAtTurn(entries: ReadonlyArray<SessionEntry>, uptoTurnId?: strin
 	return entries.slice(0, index + 1);
 }
 
-function latestCompactionIndex(entries: ReadonlyArray<SessionEntry>): number {
-	for (let i = entries.length - 1; i >= 0; i--) {
-		if (entries[i]?.kind === "compactionSummary") return i;
-	}
-	return -1;
-}
-
 function toolCallIdsInEntry(entry: SessionEntry): string[] {
 	if (entry.kind !== "message") return [];
 	if (entry.role === "tool_call") return [extractToolCall(entry).id];
@@ -907,19 +919,13 @@ export function selectReplayEntries(
 ): SessionEntry[] {
 	const active = filterEntriesToActivePath(turns, options.activeLeafTurnId ?? options.uptoTurnId);
 	const entries = truncateAtTurn(active, options.uptoTurnId);
-	const compactionIndex = latestCompactionIndex(entries);
-	if (compactionIndex < 0) return dropLegacyToolResultAssistantDuplicates(entries);
-
-	const compaction = entries[compactionIndex] as CompactionSummaryEntry;
-	const selected: SessionEntry[] = [compaction];
-	const firstKeptIndex = compaction.firstKeptTurnId
-		? entries.findIndex((entry) => entry.turnId === compaction.firstKeptTurnId)
-		: -1;
-	if (firstKeptIndex >= 0 && firstKeptIndex < compactionIndex) {
-		selected.push(...entries.slice(firstKeptIndex, compactionIndex));
-	}
-	selected.push(...entries.slice(compactionIndex + 1));
-	return dropLegacyToolResultAssistantDuplicates(repairToolResultOrphans(entries, selected, compactionIndex));
+	// The cut itself is the working-set layer's definition of "what the model
+	// can see", shared with the eviction policy input so the two cannot drift.
+	const cut = compactionCut(entries);
+	if (cut.compactionIndex < 0) return dropLegacyToolResultAssistantDuplicates(entries);
+	const compaction = entries[cut.compactionIndex] as CompactionSummaryEntry;
+	const selected: SessionEntry[] = [compaction, ...cut.visible];
+	return dropLegacyToolResultAssistantDuplicates(repairToolResultOrphans(entries, selected, cut.compactionIndex));
 }
 
 function dropLegacyToolResultAssistantDuplicates(entries: ReadonlyArray<SessionEntry>): SessionEntry[] {
@@ -1031,6 +1037,11 @@ export function buildReplayAgentMessagesFromTurns(
 			// It reaches the model only when an operator shares it, and a share
 			// is already a user message by the time it lands in the ledger.
 			case "workerRun":
+			// Working-set entries are folded into a view by the context domain
+			// and applied as a projection before this builder runs; the
+			// entries themselves never become messages.
+			case "contextEviction":
+			case "contextRecall":
 				break;
 		}
 	}
@@ -1066,7 +1077,13 @@ export function rehydrateChatPanelFromTurns(
 	options: RehydrateChatPanelOptions = {},
 ): void {
 	const pendingToolIds: string[] = [];
+	let runAssistantMessages: AgentMessage[] = [];
 	const selected = selectReplayEntries(turns, options);
+	// The transcript shows the ledger, never the projection: an evicted result
+	// still renders its full body here, tagged with the reason it left the
+	// model's working set. Folded once over the same active path the replay
+	// uses, so a /tree switch cannot tag a row from an abandoned branch.
+	const workingSet = foldWorkingSet(turns, options.activeLeafTurnId ?? options.uptoTurnId);
 	// One block per assignment, drawn where its first attempt started. Later
 	// attempts of the same assignment fold into that block as `↻` rail lines, so
 	// a failover replays as the one run it was rather than as two.
@@ -1079,6 +1096,7 @@ export function rehydrateChatPanelFromTurns(
 		switch (entry.kind) {
 			case "message": {
 				if (entry.role === "user") {
+					runAssistantMessages = [];
 					const text = truncateReplayText(replayedUserText(entry));
 					if (text.length > 0) chatPanel.appendUser(text);
 					break;
@@ -1094,7 +1112,8 @@ export function rehydrateChatPanelFromTurns(
 							(message as { stopReason?: string; errorMessage?: string }).errorMessage = failure.errorMessage;
 						}
 						chatPanel.applyEvent({ type: "message_end", message });
-						chatPanel.applyEvent({ type: "agent_end", messages: [message] });
+						runAssistantMessages.push(message);
+						chatPanel.applyEvent({ type: "agent_end", messages: runAssistantMessages });
 					}
 					break;
 				}
@@ -1112,6 +1131,7 @@ export function rehydrateChatPanelFromTurns(
 				}
 				if (entry.role === "tool_result") {
 					const result = extractToolResult(entry);
+					const evictedReason = workingSet.evicted.get(entry.turnId)?.reason;
 					const fallbackId = result.id ?? pendingToolIds.pop() ?? null;
 					if (fallbackId) {
 						const pendingIndex = pendingToolIds.indexOf(fallbackId);
@@ -1120,12 +1140,13 @@ export function rehydrateChatPanelFromTurns(
 							type: "tool_execution_end",
 							toolCallId: fallbackId,
 							toolName: result.name,
-							result: displayReplayToolResult(result.result),
+							result: displayReplayToolResult(result.result, options.unboundedToolBodies === true),
 							isError: result.isError,
 							...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
 							...(result.resultSummary !== undefined ? { resultSummary: result.resultSummary } : {}),
 							...(result.outcome !== undefined ? { outcome: result.outcome } : {}),
 							...(result.blockReason !== undefined ? { blockReason: result.blockReason } : {}),
+							...(evictedReason !== undefined ? { evictedReason } : {}),
 						} as ChatLoopEvent);
 					} else {
 						chatPanel.appendReplayBlock((width) =>
@@ -1133,12 +1154,13 @@ export function rehydrateChatPanelFromTurns(
 								{
 									toolCallId: result.id ?? "",
 									toolName: result.name,
-									result: displayReplayToolResult(result.result),
+									result: displayReplayToolResult(result.result, options.unboundedToolBodies === true),
 									isError: result.isError,
 									...(result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
 									...(result.resultSummary !== undefined ? { resultSummary: result.resultSummary } : {}),
 									...(result.outcome === "blocked" ? { outcome: "blocked" as const } : {}),
 									...(result.blockReason !== undefined ? { blockReason: result.blockReason } : {}),
+									...(evictedReason !== undefined ? { evictedReason } : {}),
 								},
 								width,
 								{ unbounded: options.unboundedToolBodies === true },
@@ -1159,9 +1181,25 @@ export function rehydrateChatPanelFromTurns(
 				}
 				break;
 			}
-			case "bashExecution":
-				chatPanel.appendReplayBlock((width) => renderBashExecutionEntry(entry, width));
+			case "bashExecution": {
+				let fold: FoldOverride;
+				const presentation = toolPresentationPolicy(ToolNames.Bash, undefined);
+				const policyFold = (detail: TranscriptDetailPolicy) => policyToolFold(detail, presentation);
+				const unbounded = options.unboundedToolBodies === true;
+				chatPanel.appendReplayBlock(
+					(width, detail) =>
+						renderBashExecutionEntry(entry, width, resolveFold(fold, policyFold(detail)) === "folded", unbounded),
+					undefined,
+					{
+						policyFold,
+						fold: () => fold,
+						setFold: (next: FoldOverride) => {
+							fold = next;
+						},
+					},
+				);
 				break;
+			}
 			case "custom":
 				if (rendersCustomEntry(entry)) chatPanel.appendReplayBlock((width) => renderCustomEntry(entry, width));
 				break;
@@ -1208,6 +1246,8 @@ export function rehydrateChatPanelFromTurns(
 			case "label":
 			case "taskLedger":
 			case "decisionLedger":
+			case "contextEviction":
+			case "contextRecall":
 				break;
 		}
 	}
@@ -1220,9 +1260,9 @@ export function rehydrateChatPanelFromTurns(
 			isError: true,
 		});
 	}
-	// Replay favors a compact historical ledger even though fresh non-resource
-	// calls auto-expand for live arguments and output. Collapse reconstructed
-	// tools explicitly; /export re-expands them afterward via
-	// toggleAllToolsExpanded, while /resume and /fork retain the compact form.
-	chatPanel.collapseAllTools();
+	// A rehydrated transcript starts from the transcript detail policy alone:
+	// whatever the operator had opened or folded before the switch belonged to
+	// the transcript they left. /export reaches the same policy with a verbose
+	// panel, so nothing here is terminal-only.
+	chatPanel.clearFoldOverrides();
 }

package/src/interactive/context-meter.ts

@@ -156,6 +156,16 @@ export function renderContextMeterGrid(
 	return lines;
 }
 
+/**
+ * Evicted tokens live outside the window: the working-set projection removed
+ * them from what the model sees, so they are not a meter category and must
+ * not claim cells or a legend row. One line after the legend names them.
+ */
+export function renderEvictedTokensLine(evictedTokens: number, theme: ClioTheme = clioTheme()): string {
+	const tokens = Math.round(Math.max(0, evictedTokens)).toLocaleString("en-US");
+	return `${theme.fg("dim", GLYPH.contextReserve)} ${theme.fg("muted", "evicted (outside window)")} ${theme.fg("dim", `${tokens} tokens`)}`;
+}
+
 /** A small colored swatch for a category, for inline legends. */
 export function contextCategorySwatch(category: ContextLedgerCategory, theme: ClioTheme = clioTheme()): string {
 	return theme.fg(CONTEXT_CATEGORY_TOKEN[category], contextCategoryGlyph(category));

package/src/interactive/context-overlay.ts

@@ -2,9 +2,10 @@ import { homedir } from "node:os";
 import { relative } from "node:path";
 import { BusChannels } from "../core/bus-events.js";
 import type { SafeEventBus } from "../core/event-bus.js";
+import type { WorkingSetView } from "../domains/context/working-set/contract.js";
 import type { ContextLedger, ContextLedgerGroup } from "../domains/session/context-ledger.js";
 import { type OverlayHandle, Text, type TUI, visibleWidth } from "../engine/tui.js";
-import { contextCategorySwatch, renderContextMeterGrid } from "./context-meter.js";
+import { contextCategorySwatch, renderContextMeterGrid, renderEvictedTokensLine } from "./context-meter.js";
 import { buildHint, showClioOverlayFrame } from "./overlay-frame.js";
 import { abbreviateModelId, type ClioToken, clioTheme, formatContextPercent } from "./theme/index.js";
 
@@ -81,7 +82,62 @@ function legendRow(group: ContextLedgerGroup, contentWidth: number): string {
 	return `${swatch} ${theme.fg(labelToken, labelText)} ${theme.fg("muted", right)}`;
 }
 
-export function renderContextLedgerLines(ledger: ContextLedger, contentWidth: number): string[] {
+function evictedTokens(view: WorkingSetView): number {
+	let total = 0;
+	for (const state of view.evicted.values()) total += state.tokensFreed;
+	return total;
+}
+
+function formatChurn(view: WorkingSetView): string {
+	if (view.itemsEvicted === 0) return "n/a";
+	return (view.recalls / view.itemsEvicted).toFixed(2);
+}
+
+/**
+ * Prose for one cache-disturbance reason. The wire values are stamped by
+ * `noteColdReason` in turn-context.ts and persisted on the assistant entry's
+ * `promptCache.expectedColdReasons`; the overlay reads them back, so an unknown
+ * reason renders as itself rather than disappearing.
+ */
+function coldReasonLabel(reason: string): string {
+	switch (reason) {
+		case "working_set_evict":
+			return "working-set eviction";
+		case "compaction":
+			return "compaction";
+		case "dispatch":
+			return "dispatch traffic";
+		default:
+			return reason;
+	}
+}
+
+/**
+ * The working-set section: what the projection has taken out of the window
+ * and how often the model has asked for it back. Churn is recalls over items
+ * evicted; a high number means the policy evicts what is still needed.
+ */
+function renderWorkingSetLines(view: WorkingSetView): string[] {
+	const theme = clioTheme();
+	const items = view.evicted.size;
+	const summary = [
+		`${items} evicted item${items === 1 ? "" : "s"}`,
+		`${formatTokens(evictedTokens(view))} tokens`,
+		`${view.evictionEvents} event${view.evictionEvents === 1 ? "" : "s"}`,
+		`${view.recalls} recall${view.recalls === 1 ? "" : "s"}`,
+		`churn ${formatChurn(view)}`,
+	].join(" · ");
+	return [
+		`${theme.fg("muted", "working set")} ${theme.fg("dim", "·")} ${theme.fg("accent", `policy ${view.lastPolicyId ?? "none"}`)}`,
+		theme.fg("dim", summary),
+	];
+}
+
+export function renderContextLedgerLines(
+	ledger: ContextLedger,
+	contentWidth: number,
+	workingSet?: WorkingSetView | null,
+): string[] {
 	const theme = clioTheme();
 	const lines: string[] = [];
 
@@ -110,8 +166,13 @@ export function renderContextLedgerLines(ledger: ContextLedger, contentWidth: nu
 	lines.push("");
 
 	for (const group of ledger.meter) lines.push(legendRow(group, contentWidth));
+	if (workingSet && workingSet.evicted.size > 0) lines.push(renderEvictedTokensLine(evictedTokens(workingSet), theme));
 
 	lines.push("");
+	if (workingSet) {
+		for (const line of renderWorkingSetLines(workingSet)) lines.push(line);
+		lines.push("");
+	}
 	if (ledger.projectPreload && ledger.groups.some((group) => group.category === "project")) {
 		lines.push(theme.fg("dim", `project preload: ${ledger.projectPreload}`));
 	}
@@ -141,11 +202,21 @@ export function renderContextLedgerLines(ledger: ContextLedger, contentWidth: nu
 		const uncached =
 			cache.uncachedInputTokens !== null ? `uncached input ${formatTokens(cache.uncachedInputTokens)}` : null;
 		const line = ["prompt cache:", shell, "·", backend, "·", read, ...(uncached ? ["·", uncached] : [])].join(" ");
+		// Reasons Clio recorded before the run: working-set eviction, summary
+		// compaction, and dispatch traffic all move the byte prefix a local
+		// single-slot backend caches, so a cold turn after one of them is the
+		// expected outcome rather than a provider surprise.
+		const coldReasons = cache.backendVerdict === "cold" ? (cache.expectedColdReasons ?? []) : [];
 		// A reused shell with a cold backend means Clio kept the bytes stable
 		// but the provider re-prefilled anyway; surface that disagreement
-		// instead of hiding it.
-		const misleading = cache.shellReused && cache.backendVerdict === "cold";
+		// instead of hiding it. An expected reason explains the same numbers, so
+		// it is reported on its own line and not as a warning.
+		const misleading = cache.shellReused && cache.backendVerdict === "cold" && coldReasons.length === 0;
 		lines.push(theme.fg(misleading ? "warning" : "dim", line));
+		if (coldReasons.length > 0) {
+			const reasons = coldReasons.map(coldReasonLabel).join(", ");
+			lines.push(theme.fg("dim", `last cold turn: ${reasons} (expected)`));
+		}
 	}
 
 	if (ledger.lastCompaction) {
@@ -170,6 +241,8 @@ export interface OpenContextOverlayOptions {
 		onEvent(handler: (event: { type: string }) => void): () => void;
 		isStreaming(): boolean;
 	};
+	/** Working-set fold at the live leaf; null or absent hides the section. */
+	getWorkingSet?: () => WorkingSetView | null;
 }
 
 /**
@@ -183,7 +256,9 @@ export function openContextOverlay(
 	getLedger: () => ContextLedger,
 	options?: OpenContextOverlayOptions,
 ): OverlayHandle {
-	const text = new Text(renderContextLedgerLines(getLedger(), DEFAULT_CONTENT_WIDTH).join("\n"), 0, 0);
+	const render = (): string =>
+		renderContextLedgerLines(getLedger(), DEFAULT_CONTENT_WIDTH, options?.getWorkingSet?.() ?? null).join("\n");
+	const text = new Text(render(), 0, 0);
 	const handle = showClioOverlayFrame(tui, text, {
 		anchor: "center",
 		width: CONTEXT_OVERLAY_WIDTH,
@@ -192,7 +267,7 @@ export function openContextOverlay(
 	});
 
 	const refresh = (): void => {
-		text.setText(renderContextLedgerLines(getLedger(), DEFAULT_CONTENT_WIDTH).join("\n"));
+		text.setText(render());
 		text.invalidate();
 		tui.requestRender();
 	};

package/src/interactive/context-recall-command.ts

@@ -0,0 +1,110 @@
+/**
+ * `/context recall <ref>`: the operator's half of working-set recall.
+ *
+ * The model recalls through `context(scope="recall", ref=...)`, which puts the
+ * body back in front of the model at the tail of the working set. This command
+ * answers a different question, asked by a person: what was in the result the
+ * marker replaced. So the body goes to the transcript and nowhere else. It is
+ * never submitted as a turn, never replayed, and never counted against the
+ * context window, which is why an operator can read a 40k-line build log back
+ * without paying for it.
+ *
+ * Everything else is identical to the tool path, deliberately: the same
+ * `resolveRecall` over the same fold at the same live leaf, the same
+ * `contextRecall` ledger entry (with `trigger: "operator"`), and the same
+ * `BusChannels.ContextRecalled` publication. A recall is a churn signal
+ * whoever asked for it, and a policy that keeps evicting something a human
+ * keeps reading back is a policy worth changing.
+ */
+
+import type { ContextRecalledPayload } from "../core/bus-events.js";
+import type { EvictedState } from "../domains/context/working-set/contract.js";
+import { foldWorkingSet } from "../domains/context/working-set/fold.js";
+import {
+	buildRecallFields,
+	recallErrorMessage,
+	recallParentTurnId,
+	resolveRecall,
+} from "../domains/context/working-set/recall.js";
+import type { SessionEntryInput } from "../domains/session/contract.js";
+import type { SessionEntry } from "../domains/session/entries.js";
+
+/** Ledger access the command needs, mirroring the context tool's `ContextSessionDeps`. */
+export interface OperatorRecallDeps {
+	hasSession(): boolean;
+	readEntries(): ReadonlyArray<SessionEntry>;
+	/** The live append point (`/tree` pin or tree leaf); undefined lets the fold infer it. */
+	activeLeafTurnId(): string | undefined;
+	appendEntry(entry: SessionEntryInput): SessionEntry;
+	/** Publisher for `BusChannels.ContextRecalled`; the runtime supplies the bus. */
+	onRecalled?: (payload: ContextRecalledPayload) => void;
+	now?: () => number;
+}
+
+export type OperatorRecallOutcome =
+	| {
+			ok: true;
+			/** One-line summary for the notice bar. */
+			headline: string;
+			/** The original body, byte-exact, for the transcript. */
+			body: string;
+	  }
+	| { ok: false; message: string };
+
+function formatTokens(tokens: number): string {
+	return tokens.toLocaleString("en-US");
+}
+
+/**
+ * Ref, why it left, what it costs to read, and where the full artifact lives
+ * when the original result was offloaded. Nothing else: the body is on the next
+ * line and the operator is already looking at it.
+ */
+function headlineFor(ref: string, tokens: number, state: EvictedState | undefined, offloadPath?: string): string {
+	const parts = [ref];
+	if (state !== undefined) {
+		parts.push(state.by === undefined ? `evicted: ${state.reason}` : `evicted: ${state.reason} by ${state.by}`);
+	}
+	parts.push(`${formatTokens(tokens)} tokens`);
+	if (offloadPath !== undefined) parts.push(`offload: ${offloadPath}`);
+	return `[/context recall] ${parts.join(" · ")}`;
+}
+
+export function runOperatorRecall(ref: string, deps: OperatorRecallDeps): OperatorRecallOutcome {
+	if (!deps.hasSession()) {
+		return { ok: false, message: "[/context recall] no active session; start one with /new or /resume first" };
+	}
+	const trimmed = ref.trim();
+	if (trimmed.length === 0) {
+		return { ok: false, message: "[/context recall] needs a ref: the turnId named in an [evicted ...] marker" };
+	}
+	const entries = deps.readEntries();
+	const leaf = deps.activeLeafTurnId();
+	const view = foldWorkingSet(entries, leaf);
+	const resolved = resolveRecall(entries, view, trimmed, leaf);
+	// A ref that resolves to nothing is usually a typo or a stale marker; the
+	// shared message ends with the refs the operator could have typed instead.
+	if (!resolved.ok)
+		return { ok: false, message: `[/context recall] ${recallErrorMessage(resolved.error, entries, view)}` };
+	const { result } = resolved;
+	const fields = buildRecallFields(result, { trigger: "operator" });
+	try {
+		deps.appendEntry({ ...fields, parentTurnId: recallParentTurnId(entries, leaf) });
+	} catch (err) {
+		return {
+			ok: false,
+			message: `[/context recall] recall of ${result.ref.entry} could not be recorded: ${err instanceof Error ? err.message : String(err)}`,
+		};
+	}
+	deps.onRecalled?.({
+		ref: result.ref.entry,
+		trigger: "operator",
+		tokensReadmitted: result.tokens,
+		at: deps.now?.() ?? Date.now(),
+	});
+	return {
+		ok: true,
+		headline: headlineFor(result.ref.entry, result.tokens, view.evicted.get(result.ref.entry), result.offloadPath),
+		body: result.body,
+	};
+}

package/src/interactive/editor-submit.ts

@@ -1,7 +1,9 @@
 import { combineBashOutput, runBashCommand } from "../core/bash-exec.js";
 import type { PendingSkillRequest } from "../core/skill-activation.js";
+import { ToolNames } from "../core/tool-names.js";
 import type { DispatchContract } from "../domains/dispatch/contract.js";
 import type { SessionContract, SessionEntry } from "../domains/session/index.js";
+import { toolPresentationPolicy } from "../tools/presentation.js";
 import type { ChatLoop } from "./chat-loop.js";
 import type { ChatPanel } from "./chat-panel.js";
 import { bashExecutionEntryInput, parseEditorBashCommand } from "./editor-bash.js";
@@ -14,6 +16,13 @@ import {
 import { type ExternalEditResult, editTextExternally, resolveExternalEditor } from "./external-editor.js";
 import { type BashTranscriptExecution, renderBashTranscriptExecution } from "./renderers/tool-execution.js";
 import { parseSlashCommand, type RunIo, type SlashCommand, type SlashCommandDispatchResult } from "./slash-commands.js";
+import {
+	type FoldOverride,
+	policyRunningToolFold,
+	policyToolFold,
+	resolveFold,
+	type TranscriptDetailPolicy,
+} from "./transcript-detail.js";
 
 const EDITOR_BASH_TIMEOUT_MS = 300_000;
 
@@ -154,16 +163,32 @@ export function createEditorSubmitController(deps: EditorSubmitDeps): EditorSubm
 			totalBytes: 0,
 			excludeFromContext: parsed.excludeFromContext,
 		};
+		// The operator's bash row follows the same rule as a model bash call: the
+		// transcript detail policy (through bash's presentation once settled)
+		// unless the operator overrode this one block with the expand key.
+		let fold: FoldOverride;
+		const bashPresentation = toolPresentationPolicy(ToolNames.Bash, undefined);
+		const policyFold = (detail: TranscriptDetailPolicy) =>
+			execution.running ? policyRunningToolFold(detail) : policyToolFold(detail, bashPresentation);
 		deps.chatPanel.appendReplayBlock(
-			(width) =>
+			(width, detail) =>
 				renderBashTranscriptExecution(
 					{
 						...execution,
+						folded: resolveFold(fold, policyFold(detail)) === "folded",
 						...(execution.running ? { elapsedMs: Math.max(0, performance.now() - startedAt) } : {}),
 					},
 					width,
 				),
 			() => execution.running,
+			{
+				policyFold,
+				fold: () => fold,
+				setFold: (next: FoldOverride) => {
+					fold = next;
+					deps.ui.requestRender();
+				},
+			},
 		);
 		deps.ui.requestRender();
 

package/src/interactive/footer/widgets.ts

@@ -19,7 +19,13 @@ import {
 	dispatchStatusPresentation,
 } from "../dispatch-board.js";
 import { buildSegmentedContextBar, CONTEXT_BAR_LABEL_WIDTH, formatFooterTokens } from "../footer-panel.js";
-import { type AgentStatus, spinnerFrame, type TurnSummary } from "../status/index.js";
+import {
+	type AgentStatus,
+	formatReasoningChip,
+	reasoningFromSummary,
+	spinnerFrame,
+	type TurnSummary,
+} from "../status/index.js";
 import {
 	type ClioTheme,
 	type ClioToken,
@@ -706,11 +712,8 @@ export function formatLastTurn(theme: ClioTheme, summary: TurnSummary): string {
 	];
 	// Zero suppresses the chip, the same rule the chat panel's turn line follows:
 	// a turn that spent no reasoning tokens states nothing by printing `r0`.
-	if (typeof summary.reasoningTokens === "number" && summary.reasoningTokens > 0) {
-		const marker =
-			summary.reasoningTokenProvenance === "estimated" || summary.reasoningTokenProvenance === "mixed" ? "≈" : "";
-		parts.push(theme.fg("reason", `r${marker}${summary.reasoningTokens}`));
-	}
+	const chip = formatReasoningChip(reasoningFromSummary(summary), String);
+	if (chip !== null) parts.push(theme.fg("reason", chip));
 	if (summary.cacheReadTokens > 0 || summary.cacheWriteTokens > 0) {
 		parts.push(theme.fg("dim", `cache ${summary.cacheReadTokens}/${summary.cacheWriteTokens}`));
 	}
@@ -802,6 +805,17 @@ function liveTokenValue(
 	return joined.length > 0 ? joined : null;
 }
 
+/**
+ * The last turn's reasoning chip, or null when the turn spent none. Every
+ * surface that shows reasoning reads the same projection, so the transcript,
+ * this footer, and the receipt cannot disagree about the count or whether it
+ * is provider-attested.
+ */
+function reasoningChip(theme: ClioTheme, lastTurn: TurnSummary): string | null {
+	const chip = formatReasoningChip(reasoningFromSummary(lastTurn), formatFooterTokens);
+	return chip === null ? null : theme.fg("reason", chip);
+}
+
 function lastTurnOutcome(theme: ClioTheme, lastTurn: TurnSummary): string {
 	const stop = stopReasonStyle(lastTurn.stopReason);
 	return theme.fg(stop.token, `${stop.glyph} ${formatCompactMs(lastTurn.elapsedMs)}`);
@@ -813,12 +827,7 @@ function lastTurnDetails(theme: ClioTheme, lastTurn: TurnSummary): string {
 			"muted",
 			`${GLYPH.up}${formatFooterTokens(lastTurn.inputTokens)} ${GLYPH.down}${formatFooterTokens(lastTurn.outputTokens)}`,
 		),
-		lastTurn.reasoningTokens !== undefined && lastTurn.reasoningTokens > 0
-			? theme.fg(
-					"reason",
-					`r${lastTurn.reasoningTokenProvenance === "estimated" || lastTurn.reasoningTokenProvenance === "mixed" ? "≈" : ""}${formatFooterTokens(lastTurn.reasoningTokens)}`,
-				)
-			: null,
+		reasoningChip(theme, lastTurn),
 		lastTurn.cacheReadTokens > 0 || lastTurn.cacheWriteTokens > 0
 			? theme.fg(
 					"dim",
@@ -1202,14 +1211,7 @@ export function buildMetricStrip(
 				`${GLYPH.up}${formatFooterTokens(lastTurn.inputTokens)} ${GLYPH.down}${formatFooterTokens(lastTurn.outputTokens)}`,
 			),
 		);
-		candidates.push(
-			lastTurn.reasoningTokens !== undefined && lastTurn.reasoningTokens > 0
-				? theme.fg(
-						"reason",
-						`r${lastTurn.reasoningTokenProvenance === "estimated" || lastTurn.reasoningTokenProvenance === "mixed" ? "≈" : ""}${formatFooterTokens(lastTurn.reasoningTokens)}`,
-					)
-				: null,
-		);
+		candidates.push(reasoningChip(theme, lastTurn));
 		// Held back so the session totals below outrank them. The chip list is cut
 		// to `maxChipsCount` before it is measured, and with cache and tools ahead
 		// of the totals an 80-column terminal spent the whole budget on per-turn