@iowarp/clio-coder 0.4.0 → 0.4.2

package/src/interactive/overlays/side-question.ts

@@ -37,7 +37,7 @@ export interface OpenSideQuestionOverlayOptions {
 const SIDE_QUESTION_OVERLAY_MIN_WIDTH = 44;
 const SIDE_QUESTION_OVERLAY_MAX_WIDTH = 100;
 
-export function sideQuestionOverlayWidth(columns: number): number {
+function sideQuestionOverlayWidth(columns: number): number {
 	return Math.max(SIDE_QUESTION_OVERLAY_MIN_WIDTH, Math.min(SIDE_QUESTION_OVERLAY_MAX_WIDTH, columns - 4));
 }
 
@@ -46,7 +46,7 @@ export function sideQuestionOverlayWidth(columns: number): number {
  * the question in dim above a rule, then the answer, then one status line that
  * says whether the round is still running, cancelled, or failed.
  */
-export function formatSideQuestionBody(
+function formatSideQuestionBody(
 	question: string,
 	phase: SideQuestionOverlayPhase,
 	width: number,

package/src/interactive/overlays/skills-hub.ts

@@ -113,7 +113,7 @@ interface LibraryTabContext {
  * approval preview instead, so this returns null for one and the caller routes
  * it there.
  */
-export function libraryUseInvocation(entry: Pick<LibraryEntry, "kind" | "name">): string | null {
+function libraryUseInvocation(entry: Pick<LibraryEntry, "kind" | "name">): string | null {
 	if (entry.kind === "fleet") return null;
 	if (entry.kind === "agent") return `/run ${entry.name} `;
 	if (entry.kind === "prompt") return `/${entry.name} `;
@@ -148,7 +148,7 @@ function skillBody(content: string): string {
 }
 
 /** @internal exported for contract tests */
-export function buildInstalledItems(list: ResourceList<Skill>): ListOverlayItem[] {
+function buildInstalledItems(list: ResourceList<Skill>): ListOverlayItem[] {
 	return list.items.map((skill) => {
 		const theme = clioTheme();
 		const flagged = list.diagnostics.some((diag) => diagnosticTouchesSkill(diag.path, skill));
@@ -182,7 +182,7 @@ export function buildInstalledItems(list: ResourceList<Skill>): ListOverlayItem[
 }
 
 /** @internal exported for contract tests */
-export function buildMarketplaceItems(
+function buildMarketplaceItems(
 	skills: ReadonlyArray<MarketplaceSkill>,
 	installed: ReadonlySet<string>,
 ): ListOverlayItem[] {
@@ -215,7 +215,7 @@ export function buildMarketplaceItems(
 }
 
 /** @internal exported for contract tests */
-export function buildDiagnosticItems(
+function buildDiagnosticItems(
 	list: ResourceList<Skill>,
 	marketplaceDiagnostics: ReadonlyArray<string> = [],
 ): ListOverlayItem[] {
@@ -252,7 +252,7 @@ export function buildDiagnosticItems(
 }
 
 /** @internal exported for contract tests */
-export function libraryRowId(entry: Pick<LibraryEntry, "kind" | "name">): string {
+function libraryRowId(entry: Pick<LibraryEntry, "kind" | "name">): string {
 	return `${LIBRARY_ROW_PREFIX}${libraryEntryRef(entry)}`;
 }
 
@@ -267,7 +267,7 @@ export function libraryRowId(entry: Pick<LibraryEntry, "kind" | "name">): string
  *
  * @internal exported for contract tests
  */
-export function buildLibraryItems(kind: LibraryEntryKind, context: LibraryTabContext): ListOverlayItem[] {
+function buildLibraryItems(kind: LibraryEntryKind, context: LibraryTabContext): ListOverlayItem[] {
 	const theme = clioTheme();
 	return context.discovery.entries
 		.filter((entry) => entry.kind === kind)
@@ -318,7 +318,7 @@ export function buildLibraryItems(kind: LibraryEntryKind, context: LibraryTabCon
  *
  * @internal exported for contract tests
  */
-export function buildLibraryDiagnosticItems(discovery: LibraryDiscoveryResult): ListOverlayItem[] {
+function buildLibraryDiagnosticItems(discovery: LibraryDiscoveryResult): ListOverlayItem[] {
 	const theme = clioTheme();
 	return discovery.diagnostics
 		.filter((message) => message !== MARKETPLACE_UNCONFIGURED)
@@ -360,7 +360,7 @@ export interface LibraryInstallRunner {
  *
  * @internal exported for contract tests
  */
-export async function runLibraryInstall(
+async function runLibraryInstall(
 	entry: LibraryEntry,
 	runner: LibraryInstallRunner,
 	options: { withRequirements: boolean },

package/src/interactive/overlays/tree-selector.ts

@@ -100,7 +100,7 @@ function fallbackPreview(node: TreeSnapshotNode): string {
  * of turns and the discarded branch had no route back. Returns null for a
  * session that was not forked.
  */
-export function forkParentLine(snapshot: TreeSnapshot, theme: ClioTheme): string | null {
+function forkParentLine(snapshot: TreeSnapshot, theme: ClioTheme): string | null {
 	const parentSessionId = snapshot.meta.parentSessionId;
 	if (typeof parentSessionId !== "string" || parentSessionId.length === 0) return null;
 	const parentTurnId = snapshot.meta.parentTurnId;
@@ -155,7 +155,7 @@ function flattenTreeSnapshot(snapshot: TreeSnapshot): TreeRow[] {
 const ROW_PREVIEW_BUDGET = 55;
 
 /** @internal */
-export function formatTreeRow(row: TreeRow, opts: { showTimestamps: boolean; width: number }): string {
+function formatTreeRow(row: TreeRow, opts: { showTimestamps: boolean; width: number }): string {
 	const theme = clioTheme();
 	const indent = "  ".repeat(row.depth);
 	// The active tip is where the next message lands; it gets its own glyph so

package/src/interactive/panes-runtime.ts

@@ -27,6 +27,7 @@ import type { MuxContract, MuxPaneRecord } from "../domains/mux/index.js";
 import {
 	PANES_PRESETS,
 	type PanesCloseResult,
+	type PanesFilesResult,
 	type PanesInventoryEntry,
 	type PanesOpenResult,
 	type PanesOperations,
@@ -35,6 +36,8 @@ import {
 	type PanesWatchController,
 	type PanesYaziController,
 	type PanesYaziStatus,
+	type PanesZoomResult,
+	resolvePanesPresetId,
 } from "../domains/mux/operations.js";
 import { resolveBinary } from "../tools/executables.js";
 import { type PaneWatchSource, paneWatchDecision } from "./pane-policy.js";
@@ -53,7 +56,28 @@ export interface PanesRuntimeDeps {
 	newestJournalRunId?: () => string | null;
 }
 
-const UNAVAILABLE = "the pane layer is not available in this session";
+/**
+ * Why there is no pane layer, in the operator's terms. Detection already
+ * knows (no `HERDR_ENV`, no socket, a refused rung); repeating that reason
+ * beside the refusal is what turns "unavailable" into a next step, and the
+ * `--with-panes` hint covers the session that never asked for panes.
+ */
+function unavailableReason(mux: MuxContract): string {
+	const reason = mux.detection().reason;
+	return `the pane layer is not available in this session: ${reason}. Start Clio inside a herdr session with \`clio-coder --with-panes\` to get panes`;
+}
+
+/** Fuzzy operator addressing shared by `close` and `zoom`: id, label, purpose; newest first. */
+function matchOwnedPane(owned: ReadonlyArray<MuxPaneRecord>, target: string): MuxPaneRecord | null {
+	const needle = target.trim().toLowerCase();
+	const newestFirst = [...owned].reverse();
+	return (
+		newestFirst.find((record) => record.ref.paneId.toLowerCase() === needle) ??
+		newestFirst.find((record) => record.label.toLowerCase().includes(needle)) ??
+		newestFirst.find((record) => record.purpose === needle) ??
+		null
+	);
+}
 
 function inventory(records: ReadonlyArray<MuxPaneRecord>): ReadonlyArray<PanesInventoryEntry> {
 	return records.map((record) => ({
@@ -65,6 +89,27 @@ function inventory(records: ReadonlyArray<MuxPaneRecord>): ReadonlyArray<PanesIn
 	}));
 }
 
+/**
+ * The sentence `/quit` prints about the panes it did not close, or null when
+ * there are none.
+ *
+ * Policy (#272): docks close with the session and utility panes stay. A dock
+ * is a Clio surface (the files pane, the workers watch pane), so it goes the
+ * way a native application's windows go. A pane opened with `/panes open
+ * shell|logs|<argv>` is a terminal the operator may be typing in, and killing
+ * it on quit is the one thing a pane host must never do behind the operator's
+ * back. The next session does not adopt it either, so without this line the
+ * pane simply sat there with nothing naming it. Computed before the mux
+ * domain stops, because shutdown forgets its registry.
+ */
+export function describePanesLeftBehind(mux: Pick<MuxContract, "list" | "docks">): string | null {
+	const dockIds = new Set(mux.docks().map((dock) => dock.paneId));
+	const left = mux.list().filter((record) => !dockIds.has(record.ref.paneId));
+	if (left.length === 0) return null;
+	const named = left.map((record) => `${record.label} (${record.ref.paneId})`).join(", ");
+	return `Clio left ${left.length} ${left.length === 1 ? "pane" : "panes"} open in herdr: ${named}. Utility panes stay when a session ends; the docks closed with it. Next time run \`/panes close all\` before \`/quit\` to take them with you, or close ${left.length === 1 ? "it" : "them"} now with \`herdr pane close <paneId>\`.`;
+}
+
 export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 	const probe = deps.resolveBinaryPath ?? resolveBinary;
 	const journalRoot = deps.journalRoot ?? runEventJournalRoot;
@@ -130,7 +175,7 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 	};
 
 	const show = async (target: string, source: PaneWatchSource): Promise<PanesShowResult> => {
-		if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+		if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
 		const match = matchRun(target);
 		if (match === null) {
 			// The candidate list is what turns a miss into a next step: it names
@@ -151,10 +196,62 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 		return { status: "watching", runId: match.runId, agentId: match.agentId, opened: watched.opened };
 	};
 
+	/**
+	 * The files pane's open half, shared by `/files`, `/panes open files`, the
+	 * keybinding, and the model tool. The settings gate and the missing-engine
+	 * message live here so every door says the same thing.
+	 */
+	const openFiles = async (once: boolean): Promise<Exclude<PanesFilesResult, { status: "closed" }>> => {
+		const preset = PANES_PRESETS[0];
+		if (!deps.getSettings().interface.panes.files.enabled) {
+			return { status: "refused", reason: "the files pane is disabled by interface.panes.files.enabled" };
+		}
+		if (!yaziController) {
+			return { status: "unavailable", reason: "the files pane return path is not ready" };
+		}
+		const pendingId = beginPendingOpen(preset.id);
+		try {
+			const result = await yaziController.open(once ? { once: true } : undefined);
+			if (result.status === "opened") {
+				return { status: "opened", paneId: result.paneId, existing: result.existing };
+			}
+			if (result.status === "missing-binary") {
+				return {
+					status: "missing-binary",
+					binary: result.binary,
+					installHint: preset.installHint,
+					// The engine's own resolution sentence, prefixed with the surface it
+					// serves: an operator who typed `/files` should not have to know the
+					// name of the program to read the answer.
+					detail: `the files pane engine is not available: ${result.detail}`,
+				};
+			}
+			return {
+				status: result.status === "profile-error" ? "refused" : "unavailable",
+				reason: result.reason,
+			};
+		} finally {
+			pendingOpens.delete(pendingId);
+		}
+	};
+
 	return {
+		async files(action): Promise<PanesFilesResult> {
+			if (action === "close") {
+				await yaziController?.close();
+				return { status: "closed" };
+			}
+			if (action === "toggle" && yaziController?.isOpen()) {
+				await yaziController.close();
+				return { status: "closed" };
+			}
+			return openFiles(action === "pick");
+		},
+
 		status(): PanesStatus {
 			const detection = deps.mux.detection();
-			const panes = deps.getSettings().panes;
+			const settings = deps.getSettings();
+			const panes = settings.interface.panes;
 			return {
 				mode: deps.mux.mode,
 				available: deps.mux.available(),
@@ -164,10 +261,16 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 				settings: {
 					enabled: panes.enabled,
 					notifications: panes.notifications,
-					journal: panes.journal,
-					yazi: { ...panes.yazi },
+					layout: panes.layout,
+					journal: settings.fleet.history.journal,
+					yazi: { ...panes.files },
 				},
 				yazi: yaziController?.status() ?? closedYaziStatus(),
+				docks: deps.mux.docks().map((dock) => ({
+					slot: dock.slot,
+					paneId: dock.paneId,
+					targetShare: dock.targetShare,
+				})),
 				panes: [...inventory(deps.mux.list()), ...pendingOpens.values()],
 			};
 		},
@@ -181,41 +284,31 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 		async open(request: { preset?: string; argv?: ReadonlyArray<string>; once?: boolean }): Promise<PanesOpenResult> {
 			const cwd = deps.getCwd();
 			if (request.preset !== undefined) {
-				const preset = PANES_PRESETS.find((entry) => entry.id === request.preset);
+				const presetId = resolvePanesPresetId(request.preset);
+				const preset = presetId === null ? undefined : PANES_PRESETS.find((entry) => entry.id === presetId);
 				if (!preset) {
 					return { status: "refused", reason: `unknown preset: ${request.preset}` };
 				}
-				if (preset.id === "yazi") {
-					if (!deps.getSettings().panes.yazi.enabled) {
-						return { status: "refused", reason: "the files pane is disabled by panes.yazi.enabled" };
-					}
-					if (!yaziController) {
-						return { status: "unavailable", reason: "the files-pane return path is not ready" };
+				if (preset.id === "files") {
+					const result = await openFiles(request.once === true);
+					if (result.status === "opened") {
+						return { status: "opened", label: preset.id, paneId: result.paneId, existing: result.existing };
 					}
-					const pendingId = beginPendingOpen(preset.id);
-					try {
-						const result = await yaziController.open(request.once ? { once: true } : undefined);
-						if (result.status === "opened") {
-							return { status: "opened", label: preset.id, paneId: result.paneId };
-						}
-						if (result.status === "missing-binary") {
-							return {
-								status: "missing-binary",
-								preset: preset.id,
-								binary: result.binary,
-								installHint: preset.installHint,
-								detail: result.detail,
-							};
-						}
-						return {
-							status: result.status === "profile-error" ? "refused" : "unavailable",
-							reason: result.reason,
-						};
-					} finally {
-						pendingOpens.delete(pendingId);
+					if (result.status === "missing-binary") {
+						return { ...result, preset: preset.id };
 					}
+					return result;
+				}
+				if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
+				// One pane per preset. A second `/panes open shell` is a request to
+				// see the shell that is already there, not to split the screen again;
+				// the pane host is asked for focus so the operator lands in it.
+				const live = deps.mux.list().find((record) => record.purpose === "utility" && record.label === preset.id);
+				if (live) {
+					await deps.mux.unzoomSelf();
+					await deps.mux.focusPane(live.ref.paneId);
+					return { status: "opened", label: preset.id, paneId: live.ref.paneId, existing: true };
 				}
-				if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
 				const binaryPath = probe(preset.binary);
 				if (binaryPath === null) {
 					return {
@@ -228,7 +321,10 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 				}
 				const argv = presetArgv(preset.id, binaryPath);
 				if (argv === null) {
-					return { status: "refused", reason: `preset ${preset.id} has nothing to show yet` };
+					return {
+						status: "refused",
+						reason: `no dispatched run has written a journal under ${journalRoot()} yet; the logs pane follows the newest run once one starts`,
+					};
 				}
 				const pendingId = beginPendingOpen(preset.id);
 				try {
@@ -239,7 +335,7 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 					pendingOpens.delete(pendingId);
 				}
 			}
-			if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+			if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
 			const argv = request.argv ?? [];
 			if (argv.length === 0) return { status: "refused", reason: "nothing to run" };
 			const label = argv[0] ?? "pane";
@@ -253,8 +349,19 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 			}
 		},
 
+		async zoom(target: string): Promise<PanesZoomResult> {
+			if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
+			const match = matchOwnedPane(deps.mux.list(), target.trim().length === 0 ? "watch" : target);
+			if (!match) return { status: "not-found", target: target.trim().length === 0 ? "watch" : target };
+			const changed = await deps.mux.zoomPane(match.ref.paneId, "toggle");
+			if (!changed) {
+				return { status: "unavailable", reason: "the pane host does not support zoom (protocol below pane.zoom)" };
+			}
+			return { status: "zoomed", paneId: match.ref.paneId, label: match.label };
+		},
+
 		async close(target: string): Promise<PanesCloseResult> {
-			if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+			if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
 			const owned = deps.mux.list();
 			if (target === "all") {
 				const labels: string[] = [];
@@ -264,12 +371,7 @@ export function createPanesRuntime(deps: PanesRuntimeDeps): PanesOperations {
 				}
 				return { status: "closed", closed: labels.length, labels };
 			}
-			const needle = target.trim().toLowerCase();
-			const newestFirst = [...owned].reverse();
-			const match =
-				newestFirst.find((record) => record.ref.paneId.toLowerCase() === needle) ??
-				newestFirst.find((record) => record.label.toLowerCase().includes(needle)) ??
-				newestFirst.find((record) => record.purpose === needle);
+			const match = matchOwnedPane(owned, target);
 			if (!match) return { status: "not-found", target };
 			const closed = await deps.mux.closePane(match.ref.paneId);
 			return closed ? { status: "closed", closed: 1, labels: [match.label] } : { status: "not-found", target };

package/src/interactive/permission-overlay.ts

@@ -203,7 +203,7 @@ function wrapArtifactLine(value: string, max: number): string[] {
 	return lines;
 }
 
-export function permissionDecisionPresentation(view: ApprovalRequestView): DecisionPresentation {
+function permissionDecisionPresentation(view: ApprovalRequestView): DecisionPresentation {
 	return classifyDecisionPresentation(
 		decisionFactsForPermission({
 			tool: view.tool,
@@ -307,7 +307,7 @@ function permissionInspectionLines(
  * 80-column one saw the command being authorized end mid-argument, both with
  * nothing marking the cut.
  */
-export function permissionOverlayLines(view: ApprovalRequestView, width: number): string[] {
+function permissionOverlayLines(view: ApprovalRequestView, width: number): string[] {
 	const content = Math.max(8, Math.floor(width));
 	const presentation = permissionDecisionPresentation(view);
 	// The parked call is awaiting a decision, not blocked: the raw rejection

package/src/interactive/prompt-cache-identity.ts

@@ -0,0 +1,88 @@
+import type { SessionPromptInputs } from "../domains/prompts/compiler.js";
+import { canonicalJson, sha256 } from "../domains/prompts/hash.js";
+import type { ContextWindowSource } from "../domains/providers/index.js";
+import type { AutonomyLevel } from "../domains/safety/autonomy.js";
+
+/** The exact schema bytes pi attaches to a provider request for one tool. */
+export interface AttachedToolSchema {
+	name: string;
+	description: string;
+	parameters: unknown;
+}
+
+/**
+ * Project the live agent tools onto the schema fields sent to the provider.
+ * Array order is preserved because providers serialize the attached tools in
+ * that order, so reordering them changes prompt-prefix bytes too.
+ */
+export function attachedToolSchemasFromState(tools: ReadonlyArray<unknown>): AttachedToolSchema[] {
+	const schemas: AttachedToolSchema[] = [];
+	for (const tool of tools) {
+		if (!tool || typeof tool !== "object" || Array.isArray(tool)) continue;
+		const record = tool as Record<string, unknown>;
+		schemas.push({
+			name: typeof record.name === "string" ? record.name : "",
+			description: typeof record.description === "string" ? record.description : "",
+			parameters: record.parameters ?? null,
+		});
+	}
+	return schemas;
+}
+
+/**
+ * Serialize the exact ordered schema sequence attached to a provider request.
+ *
+ * `canonicalJson` is deliberately not used here: provider JSON preserves tool
+ * array order and nested object insertion order, so canonicalizing parameters
+ * can alias two byte-distinct request prefixes. Standard `JSON.stringify`
+ * matches the request serialization boundary and throws for unsupported
+ * values such as circular references and bigint.
+ */
+export function attachedToolSchemaBytes(schemas: ReadonlyArray<AttachedToolSchema>): string {
+	try {
+		const bytes = JSON.stringify(schemas);
+		if (bytes === undefined) throw new Error("JSON.stringify returned undefined");
+		return bytes;
+	} catch (err) {
+		const reason = err instanceof Error ? err.message : String(err);
+		throw new Error(`attached tool schemas are not JSON-serializable: ${reason}`, { cause: err });
+	}
+}
+
+export interface MainPromptCacheIdentityInput {
+	targetId: string;
+	runtimeId: string;
+	wireModelId: string;
+	autonomy: AutonomyLevel;
+	sessionId: string;
+	cwd: string;
+	workingContextPaths: ReadonlyArray<string>;
+	contextWindowSource: ContextWindowSource | null;
+	promptInputEpoch: string;
+	sessionInputs: SessionPromptInputs;
+	attachedToolSchemas: ReadonlyArray<AttachedToolSchema>;
+}
+
+/**
+ * Canonical identity for the interactive session-prompt compile cache.
+ * Config hot reload explicitly invalidates compiler-owned fragments and
+ * rosters; this identity covers every live/caller input resolved per turn.
+ */
+export function mainPromptCacheIdentity(input: MainPromptCacheIdentityInput): string {
+	return sha256(
+		canonicalJson({
+			version: 2,
+			targetId: input.targetId,
+			runtimeId: input.runtimeId,
+			wireModelId: input.wireModelId,
+			autonomy: input.autonomy,
+			sessionId: input.sessionId,
+			cwd: input.cwd,
+			workingContextPaths: [...input.workingContextPaths].sort((a, b) => a.localeCompare(b)),
+			contextWindowSource: input.contextWindowSource,
+			promptInputEpoch: input.promptInputEpoch,
+			sessionInputs: input.sessionInputs,
+			attachedToolSchemaBytes: attachedToolSchemaBytes(input.attachedToolSchemas),
+		}),
+	);
+}

package/src/interactive/renderers/retry-status.ts

@@ -1,13 +1,21 @@
 import type { RetryStatusPayload } from "../chat-loop.js";
 import { styleTaggedNotice } from "./notice.js";
 
-function shorten(value: string, limit: number): string {
-	if (value.length <= limit) return value;
-	return `${value.slice(0, Math.max(0, limit - 3))}...`;
+const RETRY_ERROR_MAX_CHARS = 2_000;
+const RETRY_ERROR_TRUNCATION_MARKER = "… [retry error truncated]";
+
+function boundedRetryError(value: string): string {
+	const characters = Array.from(value);
+	if (characters.length <= RETRY_ERROR_MAX_CHARS) return value;
+	return `${characters.slice(0, RETRY_ERROR_MAX_CHARS).join("").trimEnd()}${RETRY_ERROR_TRUNCATION_MARKER}`;
 }
 
 function rawRetryStatus(status: RetryStatusPayload): string {
-	const suffix = status.errorMessage ? `: ${shorten(status.errorMessage, 120)}` : "";
+	// Both live and replay renderers wrap this notice to their terminal width, so
+	// ordinary errors keep their complete remedy. Raw provider failures can also
+	// be an HTML proxy page, though; keep a generous ceiling so one retry does not
+	// turn that page into hundreds of transcript rows.
+	const suffix = status.errorMessage ? `: ${boundedRetryError(status.errorMessage)}` : "";
 	if (status.phase === "waiting") {
 		return `[retry] attempt ${status.attempt}/${status.maxAttempts} in ${status.seconds ?? 0}s${suffix}`;
 	}

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

@@ -426,7 +426,7 @@ function ledgerTail(finished: ToolExecutionFinished): { facts: string; offload:
 		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");
+	if (finished.excludeFromContext === true) parts.push("not sent to model");
 	if (finished.evictedReason !== undefined) parts.push("evicted", finished.evictedReason);
 	const offloadPath = executed ? offloadPathOf(finished) : null;
 	return {
@@ -994,7 +994,7 @@ function toolUsageFact(result: unknown): string | null {
 function outputFacts(finished: ToolExecutionFinished): string[] {
 	const parts: string[] = [];
 	if (isNonExecutedOutcome(finished.outcome)) {
-		if (finished.excludeFromContext === true) parts.push("excluded from context");
+		if (finished.excludeFromContext === true) parts.push("not sent to model");
 		return parts;
 	}
 	const exitCode = structuredExitCode(finished) ?? (finished.toolName === "bash" && !finished.isError ? "0" : null);
@@ -1024,7 +1024,7 @@ function outputFacts(finished: ToolExecutionFinished): string[] {
 		if (added.length > 0) parts.push(`added ${added.join(", ")}`);
 	}
 	if (isPlainObject(finished.result) && finished.result.terminate === true) parts.push("terminal result");
-	if (finished.excludeFromContext === true) parts.push("excluded from context");
+	if (finished.excludeFromContext === true) parts.push("not sent to model");
 	if (finished.evictedReason !== undefined) parts.push("evicted", finished.evictedReason);
 	return parts;
 }
@@ -1379,7 +1379,7 @@ export function renderBashTranscriptExecution(
 	const shownBytes = Buffer.byteLength(execution.output, "utf8");
 	const totalBytes = execution.totalBytes ?? shownBytes;
 	const args: Record<string, unknown> = { command: execution.command };
-	if (execution.excludeFromContext === true) args.context = "excluded from model context";
+	if (execution.excludeFromContext === true) args.context = "not sent to model";
 	const details = {
 		resultSize: {
 			bytes: totalBytes,

package/src/interactive/session-transcript.ts

@@ -7,7 +7,7 @@ import { buildModelReplayAgentMessagesFromTurns } from "./model-session-replay.j
 
 type SessionOwner = Pick<SessionContract, "create" | "current">;
 type SessionChat = Pick<ChatLoop, "resetForSession">;
-type RoutingSettings = Pick<ClioSettings, "orchestrator">;
+type RoutingSettings = Pick<ClioSettings, "chat">;
 
 export interface SessionTranscriptDeps {
 	session?: SessionOwner;
@@ -74,8 +74,8 @@ export function createSessionTranscript(deps: SessionTranscriptDeps): SessionTra
 		const input: { cwd: string; target?: string; model?: string } = {
 			cwd: deps.getCwd?.() ?? process.cwd(),
 		};
-		if (settings?.orchestrator.target) input.target = settings.orchestrator.target;
-		if (settings?.orchestrator.model) input.model = settings.orchestrator.model;
+		if (settings?.chat.target) input.target = settings.chat.target;
+		if (settings?.chat.model) input.model = settings.chat.model;
 		deps.session.create(input);
 	};