@iowarp/clio-coder 0.3.7 → 0.3.9

package/src/interactive/dispatch-board.ts

@@ -24,6 +24,12 @@ import {
 	type RunStatus,
 	runKindSupportsLiveSteering,
 } from "../domains/dispatch/types.js";
+import { describeWriteBoundaryAttributionDowngrade } from "../domains/dispatch/write-boundary.js";
+import {
+	summarizeTrustStatus,
+	type TrustSummaryProjection,
+	type TrustVerdict,
+} from "../domains/evidence/trust-projection.js";
 import {
 	COST_NOT_MEASURED,
 	costAggregateForAmount,
@@ -31,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";
@@ -83,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;
@@ -92,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. */
@@ -113,6 +127,13 @@ export interface DispatchBoardRow {
 	council?: { group: string; label: string; color?: string; round: number };
 	/** Orchestrator-executed declared verification status. */
 	hostVerification?: "verified" | "rejected" | "skipped";
+	/**
+	 * The canonical trust projection of the sealed receipt, read back from
+	 * disk and authenticated against the ledger row. Absent while the run is
+	 * live or when the receipt could not be read back, so the card never
+	 * implies a verdict the terminal bus event cannot carry.
+	 */
+	trust?: TrustSummaryProjection;
 	/** Dead-node failover hops recorded on this run's chain. */
 	rerouteCount?: number;
 	/** Assignment retry attempts observed on the assignment event stream. */
@@ -144,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
@@ -586,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);
@@ -641,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}`)]
@@ -651,7 +695,6 @@ export function renderDispatchCard(
 		`${theme.fg("dim", "ttft")} ${theme.fg("muted", ttft)}`,
 		`${theme.fg("dim", "cost")} ${theme.fg("muted", cost)}`,
 	];
-	const hostVerification = theme.fg("info", `host_verification=${row.hostVerification ?? "not_requested"}`);
 	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
@@ -670,7 +713,7 @@ export function renderDispatchCard(
 			? [truncateToWidth(`${cardKvKey(theme, "task")}${theme.fg("muted", row.taskSummary)}`, contentWidth, "…", false)]
 			: []),
 		cardUnitsLine(theme, "status", statusUnits, contentWidth),
-		cardUnitsLine(theme, "evidence", [hostVerification], contentWidth),
+		...trustCardLines(theme, row, contentWidth),
 		...(row.budget !== undefined
 			? [
 					truncateToWidth(
@@ -731,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.
@@ -949,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) =>
@@ -957,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[] = [];
@@ -1135,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 };
@@ -1160,6 +1233,33 @@ function parseOptionalDetail(value: unknown): string | null {
 	return detail.length > 0 ? detail : null;
 }
 
+/** Only an authenticated independent pass earns the success token; sealed alone is never green. */
+function trustVerdictToken(verdict: TrustVerdict): ClioToken {
+	switch (verdict) {
+		case "reviewed":
+			return "success";
+		case "grounded":
+			return "info";
+		case "unverified":
+			return "muted";
+		case "compromised":
+			return "error";
+		default:
+			return "dim";
+	}
+}
+
+function trustVerdictGlyph(verdict: TrustVerdict): string {
+	switch (verdict) {
+		case "reviewed":
+			return GLYPH.ok;
+		case "compromised":
+			return GLYPH.error;
+		default:
+			return "◇";
+	}
+}
+
 function terminalDetail(row: DispatchBoardRow): string | null {
 	if (row.status !== "failed" && row.status !== "dead" && row.status !== "aborted") return null;
 	return parseOptionalDetail(row.outcomeDetail);
@@ -1304,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,
@@ -1319,6 +1420,7 @@ function toRow(entry: DispatchBoardEntry, now: number): DispatchBoardRow {
 		...(entry.gate !== undefined ? { gate: { ...entry.gate } } : {}),
 		...(entry.council !== undefined ? { council: { ...entry.council } } : {}),
 		...(entry.hostVerification !== undefined ? { hostVerification: entry.hostVerification } : {}),
+		...(entry.trust !== undefined ? { trust: entry.trust } : {}),
 		...(entry.rerouteCount !== undefined ? { rerouteCount: entry.rerouteCount } : {}),
 		...(entry.failoverHops !== undefined ? { failoverHops: entry.failoverHops } : {}),
 		...(entry.contextWindow !== undefined ? { contextWindow: entry.contextWindow } : {}),
@@ -1331,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 } } : {}),
 	};
 }
 
@@ -1394,8 +1497,10 @@ export function createDispatchBoardStore(
 	 * before it publishes one, so this is the first moment the file exists.
 	 */
 	const settleFromReceipt = (entry: DispatchBoardEntry): void => {
-		const text = readReceipt?.(entry.runId)?.text;
+		const facts = readReceipt?.(entry.runId);
+		const text = facts?.text;
 		entry.progress.settle(typeof text === "string" && text.trim().length > 0 ? text : undefined);
+		if (facts?.trust !== undefined) entry.trust = summarizeTrustStatus(facts.trust);
 	};
 
 	// Payloads arrive typed off the bus, but the board keeps its runtime
@@ -1411,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;
@@ -1427,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,
@@ -1455,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));
@@ -1604,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-event-projection.ts

@@ -3,6 +3,7 @@ import {
 	type ConfigReloadFailedPayload,
 	type ContextPrunedPayload,
 	type ContextWarningPayload,
+	type DispatchScopeNoticePayload,
 	type LoopBlockedPayload,
 	type RuntimeNoticePayload,
 	type ToolBudgetExceededPayload,
@@ -271,6 +272,19 @@ export function createInteractiveEventProjection(deps: InteractiveEventProjectio
 	);
 
 	remainingUnsubscribers.push(
+		deps.bus.on(BusChannels.DispatchScopeNotice, (payload) => {
+			const event = payload as DispatchScopeNoticePayload | null | undefined;
+			if (
+				!event ||
+				typeof event !== "object" ||
+				!["typed_scope_replaced_inferred_paths", "legacy_scope_inferred", "legacy_scope_empty"].includes(event.code) ||
+				typeof event.message !== "string"
+			) {
+				return;
+			}
+			deps.appendTranscriptNotice("warn", event.message);
+			deps.requestRender();
+		}),
 		deps.bus.on(BusChannels.LoopBlocked, (payload) => {
 			const event = payload as LoopBlockedPayload | null | undefined;
 			if (!event || typeof event !== "object" || typeof event.tool !== "string" || typeof event.repeatCount !== "number") {

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;