@iowarp/clio-coder 0.3.8 → 0.3.9

package/src/interactive/dispatch-board.ts

@@ -24,6 +24,7 @@ import {
 	type RunStatus,
 	runKindSupportsLiveSteering,
 } from "../domains/dispatch/types.js";
+import { describeWriteBoundaryAttributionDowngrade } from "../domains/dispatch/write-boundary.js";
 import {
 	summarizeTrustStatus,
 	type TrustSummaryProjection,
@@ -36,7 +37,7 @@ import {
 	type ObservabilityNotice,
 	type ObservabilitySnapshot,
 } from "../domains/observability/index.js";
-import type { CostProvenance } from "../domains/providers/index.js";
+import { type CostProvenance, foregroundStreamUsage } from "../domains/providers/index.js";
 import { sanitizeCallTargetText } from "../domains/safety/call-target.js";
 import { type Component, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "../engine/tui.js";
 import { formatWorkerContextMeter } from "./context-meter.js";
@@ -88,6 +89,12 @@ export interface DispatchSteerAcknowledgement {
 	chars: number;
 }
 
+export interface DispatchWriteRecordDowngrade {
+	reason: "opaque_tool_succeeded";
+	tool: string;
+	toolCallId: string;
+}
+
 export interface DispatchBoardRow {
 	runId: string;
 	agentId: string;
@@ -97,6 +104,8 @@ export interface DispatchBoardRow {
 	runtimeId: string;
 	targetId: string;
 	wireModelId: string;
+	/** Canonical inference scheduler and its independent request-slot bound. */
+	endpoint?: { key: string; label: string; limit: number };
 	/** Sanitized, one-line summary of the task assigned to this run. */
 	taskSummary?: string;
 	/** Immutable budget admission provenance for this run. */
@@ -156,6 +165,8 @@ export interface DispatchBoardRow {
 	retry?: DispatchRetryPresentation;
 	/** Most recent worker delivery acknowledgement for an operator steer. */
 	steerAcknowledgement?: DispatchSteerAcknowledgement;
+	/** First successful opaque call that opened this run's write record. */
+	writeRecordDowngrade?: DispatchWriteRecordDowngrade;
 	/**
 	 * Where this run sits in a fleet plan: the wave the step was scheduled in
 	 * and the step id it executes. Present only for runs a fleet plan
@@ -598,11 +609,29 @@ function progressAnswerLines(
 	return body.map((row, index) => `${index === 0 ? cardKvKey(theme, "answer") : " ".repeat(gutter)}${row}`);
 }
 
+/** Keep the canonical tier and every summary clause visible by wrapping the value under its card key. */
+function trustCardLines(theme: ClioTheme, row: DispatchBoardRow, contentWidth: number): string[] {
+	const gutter = CARD_KV_KEY_WIDTH + 1;
+	const valueWidth = Math.max(1, contentWidth - gutter);
+	const trust =
+		row.trust === undefined
+			? theme.fg("dim", isTerminalStatus(row.status) ? "receipt not read back" : "not sealed yet")
+			: theme.fg(
+					trustVerdictToken(row.trust.verdict),
+					`${trustVerdictGlyph(row.trust.verdict)} ${row.trust.verdict}; ${row.trust.text}`,
+				);
+	const host =
+		row.hostVerification === undefined ? "" : ` · ${theme.fg("muted", `host checks ${row.hostVerification}`)}`;
+	return wrapTextWithAnsi(`${trust}${host}`, valueWidth).map(
+		(line, index) => `${index === 0 ? cardKvKey(theme, "trust") : " ".repeat(gutter)}${line}`,
+	);
+}
+
 export function renderDispatchCard(
 	row: DispatchBoardRow,
 	width: number,
 	evidence?: RunEvidencePresentation,
-	options: { selected?: boolean; expanded?: boolean } = {},
+	options: { selected?: boolean; expanded?: boolean; endpointActive?: number } = {},
 ): string[] {
 	const theme = clioTheme();
 	const contentWidth = Math.max(0, width - 4);
@@ -653,6 +682,9 @@ export function renderDispatchCard(
 	const statusUnits = [
 		statusStr,
 		theme.fg("muted", `node ${row.node ?? "local"}`),
+		...(row.endpoint !== undefined
+			? [theme.fg("info", `slots ${options.endpointActive ?? 0}/${row.endpoint.limit} ${row.endpoint.label}`)]
+			: []),
 		...(row.gate !== undefined ? [theme.fg("info", `gate ${row.gate.role} c${row.gate.cycle}`)] : []),
 		...(row.rerouteCount !== undefined && row.rerouteCount > 0
 			? [theme.fg("warning", `rerouted x${row.rerouteCount}`)]
@@ -663,15 +695,6 @@ export function renderDispatchCard(
 		`${theme.fg("dim", "ttft")} ${theme.fg("muted", ttft)}`,
 		`${theme.fg("dim", "cost")} ${theme.fg("muted", cost)}`,
 	];
-	// The trust line is the canonical projection, styled by its verdict tier;
-	// a host check is folded into that projection as validation grounding, so
-	// it is named as a secondary fact and never as independent verification.
-	const trustUnits = [
-		row.trust === undefined
-			? theme.fg("dim", isTerminalStatus(row.status) ? "trust: receipt not read back" : "trust: not sealed yet")
-			: theme.fg(trustVerdictToken(row.trust.verdict), `${trustVerdictGlyph(row.trust.verdict)} ${row.trust.text}`),
-		...(row.hostVerification !== undefined ? [theme.fg("muted", `host checks ${row.hostVerification}`)] : []),
-	];
 	const contextUnit = formatWorkerContextMeter(row.lastContextTokens ?? 0, row.contextWindow, theme);
 	// The phase column: a fleet step says which wave it belongs to and which
 	// step it is; every other run leaves the cell empty rather than inventing a
@@ -690,7 +713,7 @@ export function renderDispatchCard(
 			? [truncateToWidth(`${cardKvKey(theme, "task")}${theme.fg("muted", row.taskSummary)}`, contentWidth, "…", false)]
 			: []),
 		cardUnitsLine(theme, "status", statusUnits, contentWidth),
-		cardUnitsLine(theme, "trust", trustUnits, contentWidth),
+		...trustCardLines(theme, row, contentWidth),
 		...(row.budget !== undefined
 			? [
 					truncateToWidth(
@@ -751,6 +774,16 @@ export function renderDispatchCard(
 			),
 		);
 	}
+	if (row.writeRecordDowngrade) {
+		const warning = describeWriteBoundaryAttributionDowngrade({
+			...row.writeRecordDowngrade,
+			runId: row.runId,
+			stepId: row.phase?.stepId ?? null,
+		});
+		bodyLines.push(
+			...wrapTextWithAnsi(`${cardKvKey(theme, "record")}${theme.fg("warning", `open: ${warning}`)}`, contentWidth),
+		);
+	}
 	// The proof row is present only when the observability projection knows an
 	// evidence state for this run; an unknown/none state adds no line, so cards
 	// without evidence keep their existing three-line body.
@@ -969,6 +1002,16 @@ export function formatDispatchBoardLines(
 		});
 	}
 
+	const endpointActive: Record<string, number> = { ...foregroundStreamUsage() };
+	for (const row of rows) {
+		if (
+			row.endpoint !== undefined &&
+			(row.status === "running" || row.status === "stale" || row.status === "enqueued" || row.status === "cancelling")
+		) {
+			endpointActive[row.endpoint.key] = (endpointActive[row.endpoint.key] ?? 0) + 1;
+		}
+	}
+
 	// A council is one question asked of several members, so its rows render as
 	// one card holding the whole group rather than as unrelated neighbours.
 	const cards = dispatchBoardItems(rows, selectedRunId).map((item) =>
@@ -977,6 +1020,7 @@ export function formatDispatchBoardLines(
 			: renderDispatchCard(item.row, width, deriveRunEvidenceState(observability, item.row.runId), {
 					selected: item.row.runId === selectedRunId,
 					expanded: detailExpanded && item.row.runId === selectedRunId,
+					...(item.row.endpoint !== undefined ? { endpointActive: endpointActive[item.row.endpoint.key] ?? 0 } : {}),
 				}),
 	);
 	const body: string[] = [];
@@ -1155,6 +1199,15 @@ function parseGateBadge(value: unknown): { role: string; cycle: number } | undef
 	return { role: record.role, cycle };
 }
 
+function parseEndpointCapacity(value: unknown): DispatchBoardRow["endpoint"] | undefined {
+	if (typeof value !== "object" || value === null) return undefined;
+	const record = value as { key?: unknown; label?: unknown; limit?: unknown };
+	const key = parseNonEmptyString(record.key);
+	const label = parseNonEmptyString(record.label);
+	const limit = parsePositiveInt(record.limit);
+	return key === undefined || label === undefined || limit === undefined ? undefined : { key, label, limit };
+}
+
 function parseCouncilBadge(value: unknown): DispatchBoardRow["council"] | undefined {
 	if (typeof value !== "object" || value === null) return undefined;
 	const record = value as { group?: unknown; label?: unknown; color?: unknown; round?: unknown };
@@ -1351,6 +1404,7 @@ function toRow(entry: DispatchBoardEntry, now: number): DispatchBoardRow {
 		runtimeId: entry.runtimeId,
 		targetId: entry.targetId,
 		wireModelId: entry.wireModelId,
+		...(entry.endpoint !== undefined ? { endpoint: { ...entry.endpoint } } : {}),
 		...(entry.taskSummary !== undefined ? { taskSummary: entry.taskSummary } : {}),
 		...(entry.budget !== undefined ? { budget: entry.budget } : {}),
 		status: retry ? "retrying" : entry.status,
@@ -1379,6 +1433,7 @@ function toRow(entry: DispatchBoardEntry, now: number): DispatchBoardRow {
 		recentTools: progress.recentActions.map((action) => action.tool),
 		...(retry ? { retry: { ...retry } } : {}),
 		...(entry.steerAcknowledgement ? { steerAcknowledgement: { ...entry.steerAcknowledgement } } : {}),
+		...(entry.writeRecordDowngrade ? { writeRecordDowngrade: { ...entry.writeRecordDowngrade } } : {}),
 	};
 }
 
@@ -1461,6 +1516,7 @@ export function createDispatchBoardStore(
 		const agentAudience = parseAgentAudience(raw.agentAudience, previous?.agentAudience);
 		const requestOrigin = parseRequestOrigin(raw.requestOrigin, previous?.requestOrigin);
 		const node = parseNonEmptyString(raw.node) ?? previous?.node;
+		const endpoint = parseEndpointCapacity(raw.endpoint) ?? previous?.endpoint;
 		const gate = parseGateBadge(raw.gate) ?? previous?.gate;
 		const council = parseCouncilBadge(raw.council) ?? previous?.council;
 		const rerouteCount = parsePositiveInt(raw.rerouteCount) ?? previous?.rerouteCount;
@@ -1477,6 +1533,7 @@ export function createDispatchBoardStore(
 			runtimeId: parseText(raw.runtimeId, previous?.runtimeId ?? "-"),
 			targetId: parseText(raw.targetId, previous?.targetId ?? "-"),
 			wireModelId: parseText(raw.wireModelId, previous?.wireModelId ?? "-"),
+			...(endpoint !== undefined ? { endpoint } : {}),
 			...(taskSummary !== undefined ? { taskSummary } : {}),
 			...(budget !== undefined ? { budget } : {}),
 			status,
@@ -1505,6 +1562,7 @@ export function createDispatchBoardStore(
 			progress: previous?.progress ?? createWorkerProgressFold(),
 			...(previous?.retry ? { retry: { ...previous.retry } } : {}),
 			...(previous?.steerAcknowledgement ? { steerAcknowledgement: { ...previous.steerAcknowledgement } } : {}),
+			...(previous?.writeRecordDowngrade ? { writeRecordDowngrade: { ...previous.writeRecordDowngrade } } : {}),
 		};
 		entries.set(runId, entry);
 		pruneEntries(entries, (evicted) => fleetPhases.delete(evicted));
@@ -1654,6 +1712,20 @@ export function createDispatchBoardStore(
 					entry.ttftMs = Math.round(performance.now() - entry.startedAtClockMs);
 				}
 			}
+			if (type === "clio_write_record_downgraded") {
+				const rawPayload = (workerEvent as { payload?: unknown }).payload;
+				const payload =
+					typeof rawPayload === "object" && rawPayload !== null ? (rawPayload as Record<string, unknown>) : null;
+				const tool = payload === null ? undefined : parseNonEmptyString(payload.tool);
+				const toolCallId = payload === null ? undefined : parseNonEmptyString(payload.toolCallId);
+				if (payload?.reason === "opaque_tool_succeeded" && tool !== undefined && toolCallId !== undefined) {
+					entry.writeRecordDowngrade = {
+						reason: "opaque_tool_succeeded",
+						tool: sanitizeCallTargetText(tool),
+						toolCallId: sanitizeCallTargetText(toolCallId),
+					};
+				}
+			}
 			// The one fold that reads worker prose and tool activity. Everything the
 			// board says about what a worker is saying or touching comes from here,
 			// so the board and the transcript block cannot tell two stories.

package/src/interactive/fleet-run-preview.ts

@@ -26,7 +26,11 @@ import {
 	validateFleetGraph,
 } from "../domains/agents/index.js";
 import type { AgentSpec } from "../domains/agents/spec.js";
-import type { ExecutionPlan, ExecutionPlanStep } from "../domains/dispatch/execution-plan.js";
+import {
+	bindExecutionPlanEndpoints,
+	type ExecutionPlan,
+	type ExecutionPlanStep,
+} from "../domains/dispatch/execution-plan.js";
 import {
 	type AgentRoleFactsResolver,
 	requestExecutionRole,
@@ -40,6 +44,7 @@ export interface FleetRunPreviewRoute {
 	targetId: string;
 	wireModelId: string;
 	nodeId: string;
+	endpoint?: { key: string; label: string; limit: number; foregroundHeld?: number };
 }
 
 export interface FleetRunPreviewStep {
@@ -207,6 +212,40 @@ export function compileFleetRunPreview(input: FleetRunPreviewInput): FleetRunPre
 		diagnostics.push(describeError(error));
 		return fail();
 	}
+	const routes = new Map<string, FleetRunPreviewRoute>();
+	if (input.resolveRoute !== undefined) {
+		for (const step of plan.steps) {
+			if (step.kind === "code") continue;
+			try {
+				const route = input.resolveRoute({
+					stepId: step.id,
+					agentId: step.agentId,
+					task: step.task,
+					scope: step.scope,
+					...(step.target !== undefined ? { target: step.target } : {}),
+					...(step.profile !== undefined ? { profile: step.profile } : {}),
+				});
+				if (route !== null) routes.set(step.id, route);
+			} catch (error) {
+				diagnostics.push(`step '${step.id}' route preflight failed: ${describeError(error)}`);
+			}
+		}
+		plan = bindExecutionPlanEndpoints(
+			plan,
+			Object.fromEntries(
+				[...routes].map(([stepId, route]) => [
+					stepId,
+					route.endpoint === undefined
+						? undefined
+						: {
+								key: route.endpoint.key,
+								limit: route.endpoint.limit,
+								...(route.endpoint.foregroundHeld !== undefined ? { foregroundHeld: route.endpoint.foregroundHeld } : {}),
+							},
+				]),
+			),
+		);
+	}
 
 	// A declared boundary is verified against the checkout, so the checkout has
 	// to be one this can read. Refused here, before any dispatch, rather than
@@ -261,20 +300,7 @@ export function compileFleetRunPreview(input: FleetRunPreviewInput): FleetRunPre
 					},
 				];
 			}
-			let route: FleetRunPreviewRoute | null = null;
-			try {
-				route =
-					input.resolveRoute?.({
-						stepId: step.id,
-						agentId: step.agentId,
-						task: step.task,
-						scope: step.scope,
-						...(step.target !== undefined ? { target: step.target } : {}),
-						...(step.profile !== undefined ? { profile: step.profile } : {}),
-					}) ?? null;
-			} catch (error) {
-				diagnostics.push(`step '${step.id}' route preflight failed: ${describeError(error)}`);
-			}
+			const route = routes.get(step.id) ?? null;
 			return [
 				{
 					...base,

package/src/interactive/handoff-round.ts

@@ -34,6 +34,22 @@ export const HANDOFF_SYSTEM_PROMPT = [
 /** A handoff record is a list of short entries, so the budget is modest. */
 export const HANDOFF_MAX_TOKENS = 4096;
 
+/** The name the wire dialect gives the schema, where it takes one. */
+export const HANDOFF_SCHEMA_NAME = "handoff_record";
+
+/** Characters of the refused answer quoted back to the model in the repair round. */
+export const HANDOFF_REPAIR_QUOTE_CHARS = 600;
+
+/**
+ * What the first round returned and why the parser refused it. The repair round
+ * shows the model both, because "return one JSON object" repeated verbatim is
+ * the instruction it already failed (issue #223).
+ */
+export interface HandoffRepairInput {
+	complaint: string;
+	previous: string;
+}
+
 export interface HandoffRoundInput {
 	model: EngineModel;
 	/** Read-only. The round copies before appending its own message. */
@@ -42,15 +58,38 @@ export interface HandoffRoundInput {
 	apiKey?: string;
 	signal?: AbortSignal;
 	maxTokens?: number;
+	/** Resolved runtime id, which decides whether the schema can be bound on the wire. */
+	runtimeId?: string;
+	/** Set on the second and last round, after the parser refused the first. */
+	repair?: HandoffRepairInput;
+}
+
+function repairText(goal: string, repair: HandoffRepairInput): string {
+	const quoted = repair.previous.slice(0, HANDOFF_REPAIR_QUOTE_CHARS);
+	return [
+		`The next session's goal is: ${goal}`,
+		"",
+		"Your previous answer could not be read as a handoff record.",
+		`The parser said: ${repair.complaint}`,
+		"This is what you returned, verbatim:",
+		"---",
+		quoted.length > 0 ? quoted : "(nothing)",
+		"---",
+		"Answer again with one JSON object matching the schema and nothing else.",
+		"No prose before it, no prose after it, no code fence.",
+	].join("\n");
 }
 
 /** Run the round. Provider failures reject; the caller renders the reason. */
 export async function runHandoffRound(input: HandoffRoundInput): Promise<SideQuestionResult> {
-	const { goal, ...rest } = input;
+	const { goal, repair, ...rest } = input;
 	return runOutOfTurnRound({
 		...rest,
 		maxTokens: input.maxTokens ?? HANDOFF_MAX_TOKENS,
 		systemPrompt: HANDOFF_SYSTEM_PROMPT,
-		userText: `The next session's goal is: ${goal}\n\nExtract the handoff record for that goal now.`,
+		responseSchema: { name: HANDOFF_SCHEMA_NAME, schema: HANDOFF_RESPONSE_SCHEMA },
+		userText: repair
+			? repairText(goal, repair)
+			: `The next session's goal is: ${goal}\n\nExtract the handoff record for that goal now.`,
 	});
 }

package/src/interactive/interactive-application.ts

@@ -3,6 +3,7 @@ import type { ClioSettings } from "../core/config.js";
 import type { SafeEventBus } from "../core/event-bus.js";
 import { expandInlineFileReferencesAsync } from "../core/file-references.js";
 import type { PendingSkillRequest } from "../core/skill-activation.js";
+import { clioStateDir } from "../core/xdg.js";
 import type { AgentsContract } from "../domains/agents/contract.js";
 import type { ClioKeybinding } from "../domains/config/keybindings.js";
 import type { ContextState } from "../domains/context/index.js";
@@ -41,6 +42,7 @@ import { createInteractiveSubscriptions } from "./interactive-subscriptions.js";
 import { createInteractiveTickers } from "./interactive-tickers.js";
 import { createOverlayLifecycle, type OverlayLifecycleController, type OverlayState } from "./overlay-lifecycle.js";
 import { interopOverlaySurface } from "./overlays/interop.js";
+import { writeInputWedgeDump } from "./render-trace.js";
 import { settleChatBeforeSessionSwitch } from "./session-switch-settlement.js";
 import { createSessionTranscript } from "./session-transcript.js";
 import type {
@@ -429,6 +431,21 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		});
 	const { terminal, tui } = shell;
 	const renderTrace = getActiveRenderTrace();
+	// SIGTERM is the kill an operator reaches for when a pane stops answering, so
+	// it is where the always-on input-wedge ring has to land (#224). It writes
+	// synchronously from its own listener rather than from a termination hook: a
+	// session wedged badly enough to be killed may never reach the coordinator's
+	// asynchronous drain, and this dump has to survive that.
+	const dumpInputWedgeOnTerminate = renderTrace
+		? (): void => {
+				try {
+					writeInputWedgeDump(clioStateDir(), renderTrace.snapshotInputWedge());
+				} catch {
+					// Best effort. The process is ending either way.
+				}
+			}
+		: null;
+	if (dumpInputWedgeOnTerminate) process.on("SIGTERM", dumpInputWedgeOnTerminate);
 	const visibleEventIngress = new WeakMap<
 		object,
 		{ sequence: number; traceSequence: number; generation: number; ingressAt: number }
@@ -498,6 +515,11 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		getLeaderArmed: () => leaderArmed,
 		getShutdownArmed: () => shutdownArmed,
 		isAwaitingApproval: () => overlayLifecycle?.getState() === "permission-confirm",
+		getPermissionInspection: () => {
+			if (overlayLifecycle === undefined || overlayLifecycle === null) return "none";
+			if (!overlayLifecycle.canInspectMutation()) return "none";
+			return overlayLifecycle.isInspectingMutation() ? "open" : "closed";
+		},
 		resolveVisibleEventSequence: (event) => visibleEventIngress.get(event)?.traceSequence ?? null,
 		resolveStreamIngress: (event) => visibleEventIngress.get(event) ?? null,
 		commitFrame: (reason) => shell.commitCurrentFrame(reason === "teardown" ? 300 : 30_000),
@@ -618,7 +640,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		chat: deps.chat,
 		chatPanel: {
 			appendReplayBlock: (...args) => chatRenderer.mutate(() => chatPanel.appendReplayBlock(...args), "slash-output"),
-			appendUser: (text) => chatRenderer.mutate(() => chatPanel.appendUser(text), "user-submit"),
+			appendUser: (text, status) => chatRenderer.mutate(() => chatPanel.appendUser(text, status), "user-submit"),
 			clearFoldOverrides: () => chatRenderer.mutate(() => chatPanel.clearFoldOverrides(), "output-detail"),
 		},
 		beforeSemanticSubmit: () => chatRenderer.flush(),
@@ -949,6 +971,7 @@ export async function createInteractiveApplication(deps: InteractiveDeps): Promi
 		cancelParkedCalls: (reason) => deps.toolRegistry?.cancelParkedCalls(reason),
 		onShutdown: async () => {
 			try {
+				if (dumpInputWedgeOnTerminate) process.off("SIGTERM", dumpInputWedgeOnTerminate);
 				await deps.onShutdown();
 			} finally {
 				if (lease) await lease.close();

package/src/interactive/interactive-input-runtime.ts

@@ -60,6 +60,10 @@ export interface InteractiveInputRuntimeDeps {
 		closeOverlay(): void;
 		confirmPermission(): void;
 		stopTurnFromPermission(): void;
+		canInspectMutation(): boolean;
+		isInspectingMutation(): boolean;
+		toggleMutationInspection(): void;
+		scrollMutationInspection(delta: number): void;
 		cancelAskUser(): void;
 		toggleFooterDashboardState(): void;
 		toggleDispatchBoardOverlay(): void;
@@ -213,6 +217,10 @@ export function createInteractiveInputRuntime(deps: InteractiveInputRuntimeDeps)
 					confirmPermission: () => deps.overlay.confirmPermission(),
 					stopTurnFromPermission: () => deps.overlay.stopTurnFromPermission(),
 					composerHasDraft: () => deps.editor.getText().length > 0,
+					canInspectMutation: () => deps.overlay.canInspectMutation(),
+					isInspectingMutation: () => deps.overlay.isInspectingMutation(),
+					toggleMutationInspection: () => deps.overlay.toggleMutationInspection(),
+					scrollMutationInspection: (delta) => deps.overlay.scrollMutationInspection(delta),
 					editDraft: (data) => {
 						deps.editor.handleInput?.(data);
 						deps.requestRender();

package/src/interactive/interactive-presentation.ts

@@ -99,6 +99,8 @@ export interface InteractivePresentationDeps {
 	getShutdownArmed?: () => boolean;
 	/** Whether a permission prompt owns the keyboard, for the composer's CONFIRM rail. */
 	isAwaitingApproval?: () => boolean;
+	/** Whether that prompt has a mutation to inspect, and whether it is open (issue #254). */
+	getPermissionInspection?: () => import("./permission-hint.js").PermissionInspectionHint;
 	getCwd?: () => string;
 	resolveVisibleEventSequence?: (event: ChatLoopEvent) => number | null;
 	resolveStreamIngress?: (
@@ -418,6 +420,8 @@ export function createInteractivePresentation(deps: InteractivePresentationDeps)
 		},
 		isStreaming: () => deps.chat.isStreaming(),
 		...(deps.isAwaitingApproval ? { isAwaitingApproval: deps.isAwaitingApproval } : {}),
+		...(deps.getPermissionInspection ? { getPermissionInspection: deps.getPermissionInspection } : {}),
+		getTurnPreparation: () => deps.chat.turnPreparation().phase,
 		willEnterSteer: (text) => willEnterSteerActiveWork(deps, text),
 		getSubmitKeyLabel: () => formatKeyLabel(keybindings.getKeys("tui.input.submit")[0], "Enter"),
 		getNewlineKeyLabel: () => formatKeyLabel(keybindings.getKeys("tui.input.newLine")[0], "Shift+Enter"),

package/src/interactive/interactive-shell.ts

@@ -158,9 +158,11 @@ export function createInteractiveShell<TTerminal extends Terminal, TTui extends
 }
 
 /**
- * Trace for the current process, created once when CLIO_CODER_RENDER_TRACE names a
- * file. The panel wires its render metrics into the same instance, so the
- * frame rows carry both the build cost and the write cost.
+ * Trace for the current process, created once per interactive shell. It writes
+ * a JSONL file when CLIO_CODER_RENDER_TRACE names one and otherwise keeps only
+ * its bounded input-wedge ring in memory. The panel wires its render metrics
+ * into the same instance, so the frame rows carry both the build cost and the
+ * write cost.
  */
 let activeRenderTrace: RenderTrace | null = null;
 
@@ -203,20 +205,21 @@ export function createProcessInteractiveShell(
 	let restoreRoot: (() => void) | null = null;
 	let backpressure: StdoutBackpressureGate | null = null;
 	let observedBackpressure = false;
-	if (tracePath) {
-		let candidate: RenderTrace | null = null;
-		try {
-			candidate = createRenderTrace(tracePath);
-			restoreStdout = traceProcessStdout(candidate);
-			activeRenderTrace = candidate;
-		} catch {
-			// A diagnostics path must never prevent the interactive application from starting.
-			restoreStdout?.();
-			restoreStdout = null;
-			void candidate?.close().catch(() => {});
-			activeRenderTrace = null;
-		}
-	} else activeRenderTrace = null;
+	let candidate: RenderTrace | null = null;
+	try {
+		// A null path is the ring-only mode: no file, but the input-wedge ring still
+		// fills, because the operator who hits a wedge did not arm a trace before it
+		// happened (#224).
+		candidate = createRenderTrace(tracePath);
+		restoreStdout = traceProcessStdout(candidate);
+		activeRenderTrace = candidate;
+	} catch {
+		// A diagnostics path must never prevent the interactive application from starting.
+		restoreStdout?.();
+		restoreStdout = null;
+		void candidate?.close().catch(() => {});
+		activeRenderTrace = null;
+	}
 	const trace = activeRenderTrace;
 	if (trace && options.onFirstFrameCommit) trace.onFirstFrameCommit(options.onFirstFrameCommit);
 	let firstFrameDelivered = false;

package/src/interactive/interactive-slash-runtime.ts

@@ -62,6 +62,7 @@ export interface InteractiveSlashSubmitExpansion {
 
 type SlashChat = Pick<ChatLoop, "getSessionId" | "isStreaming" | "submit">;
 type SlashChatPanel = Pick<ChatPanel, "appendReplayBlock" | "appendUser" | "clearFoldOverrides">;
+type UserTurnStatus = import("./chat-panel.js").UserTurnStatus;
 type SlashResources = Pick<ResourcesContract, "prompts" | "expandPromptTemplate" | "reload">;
 type SlashExtensions = Pick<ExtensionsContract, "list">;
 type SlashAgents = Pick<AgentsContract, "getSpec" | "listSpecs">;
@@ -245,9 +246,13 @@ export function createInteractiveSlashRuntime(deps: InteractiveSlashRuntimeDeps)
 			const willQueue = deps.chat.isStreaming();
 			deps.recordSubmittedTurn();
 			deps.refreshFooter();
-			if (!willQueue) deps.chatPanel.appendUser(sub.text);
+			// The row is painted now, so the operator sees their prompt land, but
+			// it is marked pending until the durable append at admission: nothing
+			// is in the ledger yet, and a refused preflight must not leave a row
+			// that reads like a committed turn (issue #251).
+			let rowStatus: UserTurnStatus = "pending";
+			if (!willQueue) deps.chatPanel.appendUser(sub.text, () => rowStatus);
 			deps.requestRender();
-			deps.beforeSemanticSubmit?.();
 			let acknowledgeAdmission = (): void => {};
 			const admitted = new Promise<void>((resolve) => {
 				acknowledgeAdmission = resolve;
@@ -257,7 +262,19 @@ export function createInteractiveSlashRuntime(deps: InteractiveSlashRuntimeDeps)
 				...(sub.workingContextPaths.length > 0 ? { workingContextPaths: sub.workingContextPaths } : {}),
 				...(sub.pendingSkillRequests.length > 0 ? { pendingSkillRequests: sub.pendingSkillRequests } : {}),
 				...(awaitAdmission && willQueue ? { steering: "end-of-turn" as const } : {}),
-				...(awaitAdmission ? { onAdmitted: acknowledgeAdmission } : {}),
+				...(!willQueue
+					? {
+							onPreparationVisible: async () => {
+								deps.beforeSemanticSubmit?.();
+								await deps.settleVisibleFrame?.("submit-preparing");
+							},
+						}
+					: {}),
+				onAdmitted: () => {
+					rowStatus = "committed";
+					deps.requestRender();
+					if (awaitAdmission) acknowledgeAdmission();
+				},
 			});
 			const settlement = turn
 				.then(() => deps.settleVisibleFrame?.("submit-return"))
@@ -265,7 +282,13 @@ export function createInteractiveSlashRuntime(deps: InteractiveSlashRuntimeDeps)
 					const msg = err instanceof Error ? err.message : String(err);
 					deps.io.stderr(`[interactive] chat failed: ${msg}\n`);
 				})
-				.finally(deps.requestRender);
+				.finally(() => {
+					// Settlement without admission is a refusal: the probe failed, the
+					// overflow preflight blocked the request, or the submit became a
+					// steer. Say so on the row rather than leaving a phantom turn.
+					if (rowStatus === "pending") rowStatus = willQueue ? "committed" : "refused";
+					deps.requestRender();
+				});
 			return awaitAdmission ? Promise.race([admitted, settlement]) : settlement;
 		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);

package/src/interactive/memory-overlay.ts

@@ -1,5 +1,6 @@
 import {
 	describeTaskMemoryActivity,
+	formatTaskMemorySpend,
 	type MemoryProposalResult,
 	type MemoryRecord,
 	type TaskMemoryActivityEvent,
@@ -38,6 +39,12 @@ export function formatMemoryStatusLine(status: TaskMemoryOperatorStatus, content
 		theme.fg("muted", `last ${status.lastDecision ?? "none"}`),
 	];
 	if (status.stepInFlight) units.push(theme.fg("reason", "step running"));
+	// Lifetime cost of the background plane, beside the state of the current
+	// session. The tier spent 137,205 tokens over 14 days on the operator's own
+	// machine before any surface said so (#229), and a hit rate is the one figure
+	// that says whether that spend is buying anything.
+	const spend = status.spend === null || status.spend === undefined ? "" : formatTaskMemorySpend(status.spend);
+	if (spend.length > 0) units.push(theme.fg("dim", spend));
 	return fitUnits(theme, "", units, width);
 }
 
@@ -172,6 +179,7 @@ function memorySignature(status: TaskMemoryOperatorStatus, records: ReadonlyArra
 		String(status.size),
 		status.lastDecision ?? "none",
 		status.stepInFlight ? "running" : "idle",
+		`${status.spend?.llmSteps ?? 0}:${status.spend?.injections ?? 0}:${status.spend?.totalTokens ?? 0}`,
 	];
 	for (const record of records) parts.push(`r:${record.id}:${record.approved}:${record.rejectedAt ?? ""}`);
 	for (const entry of bankEntries(status.bank)) {