@iowarp/clio-coder 0.3.9 → 0.4.0

package/src/interactive/slash-commands.ts

@@ -4,6 +4,7 @@ import type { SafeEventBus } from "../core/event-bus.js";
 import { parseCouncilReport, parseOracleResult } from "../domains/agents/index.js";
 import type { AgentSpec } from "../domains/agents/spec.js";
 import type { ContextInitOptions } from "../domains/context/init-options.js";
+import { AdmissionCanceledError } from "../domains/dispatch/admission-error.js";
 import type { DispatchContract, DispatchRequest } from "../domains/dispatch/contract.js";
 import { type AgentRoleFactsResolver, requestExecutionRole } from "../domains/dispatch/execution-role.js";
 import type { RunReceipt } from "../domains/dispatch/types.js";
@@ -11,6 +12,14 @@ import type { JobThinkingLevel } from "../domains/dispatch/validation.js";
 import type { ReceiptIntegrityOutcome } from "../domains/evidence/trust-status.js";
 import type { InstalledExtension } from "../domains/extensions/index.js";
 import type { InteropAgentId, InteropProposal, InteropReport } from "../domains/interop/index.js";
+import {
+	isPanesPresetId,
+	PANES_PRESET_IDS,
+	PANES_PRESETS,
+	type PanesOperations,
+	type PanesPresetId,
+	type PanesStatus,
+} from "../domains/mux/operations.js";
 import type { ProvidersContract, ResolvedModelRef } from "../domains/providers/index.js";
 import { resolveModelReference } from "../domains/providers/index.js";
 import type {
@@ -27,13 +36,13 @@ import type { NoticeLevel } from "./command-output.js";
 import {
 	buildCouncilDispatchArgs,
 	COUNCIL_MAX_ROUNDS,
+	COUNCIL_SYNTHESIS_LABEL,
 	COUNCIL_SYNTHESIS_MODES,
 	type CouncilCommandOptions,
 	type CouncilRosters,
 	isCouncilSynthesisMode,
 	resolveCouncilRoster,
 } from "./council.js";
-import { COUNCIL_SYNTHESIS_LABEL } from "./council-grid.js";
 import {
 	formatOracleAnswer,
 	ORACLE_AGENT_ID,
@@ -41,8 +50,9 @@ import {
 	type OracleDigestSources,
 	packOracleDigest,
 } from "./oracle.js";
-import { SETTINGS_SECTIONS, type SettingsCenterRowId, type SettingsSectionId } from "./overlays/settings.js";
-import { isLibraryTab, LIBRARY_TABS } from "./overlays/skills-hub.js";
+import { isLibraryTab, LIBRARY_TABS } from "./overlays/library-tabs.js";
+import type { SettingsCenterRowId } from "./overlays/settings.js";
+import { SETTINGS_SECTIONS, type SettingsSectionId } from "./overlays/settings-sections.js";
 import type { CommandArgsSpec, CommandPositionalSpec, ParsedArgs } from "./slash-spec.js";
 import { matchFromSpec, usageLine } from "./slash-spec.js";
 import {
@@ -60,6 +70,25 @@ import type { WorkerEntryState } from "./worker-stream.js";
  * one user-facing slash command: how it parses, which SlashCommand kinds it
  * produces, and how those kinds execute. Adding a new command is one entry
  * rather than extending two parallel switches.
+ *
+ * This module is a CLI seam, which constrains what it may import.
+ * `src/cli/run.ts` reaches `parseSlashCommand` here so a headless
+ * `clio-coder run "/typo"` refuses the token by the same shape test and the same
+ * registry membership the editor uses; a second copy of the parser would drift
+ * from this one on the first command added. That makes the CLI a reacher of
+ * everything this file statically imports, so nothing here may reach the
+ * interactive render graph: no theme, no overlay frame, no overlay module, no
+ * `../engine/tui.js`. Those modules share one bundle chunk with the instant
+ * shell's Stage 0 closure, and a second, disjoint reacher makes esbuild split
+ * it, which is a startup-latency regression rather than a style problem. The
+ * parse-time data tables the registry needs live in leaves for that reason:
+ * `./overlays/settings-sections.js`, `./overlays/library-tabs.js`, and
+ * `COUNCIL_SYNTHESIS_LABEL` in `./council.js`. Import from those, not from the
+ * overlays that re-export them.
+ *
+ * Boundaries rule6 in `tests/boundaries/check-boundaries.ts` refuses a violation
+ * at lint time; `tests/contracts/instant-shell-import-graph.test.ts` is the
+ * measurement it protects.
  */
 
 type ShareCommandVariant =
@@ -116,6 +145,13 @@ type SlashCommandVariant =
 	| { kind: "view"; filter?: string }
 	| { kind: "view-verify"; runId: string }
 	| { kind: "view-usage" }
+	/** `/panes`: mode, health, pane inventory, effective settings. */
+	| { kind: "panes" }
+	| { kind: "panes-show"; target: string }
+	/** A preset the model may also ask for, or operator-only argv. Never both. */
+	| { kind: "panes-open"; preset?: PanesPresetId; argv?: ReadonlyArray<string>; once?: boolean }
+	| { kind: "panes-close"; target: string }
+	| { kind: "panes-usage"; reason?: string }
 	| { kind: "thinking-set"; level: string }
 	| { kind: "output-set"; verbosity: string }
 	| { kind: "model" }
@@ -258,14 +294,20 @@ async function runAttributed(
 			progressBus?.emit(BusChannels.DispatchProgress, { runId: handle.runId, agentId: request.agentId, event });
 		}
 		const receipt = await handle.finalPromise;
-		if (receipt.exitCode !== 0 || receipt.failureMessage) {
+		if (receipt.outcome === "canceled") {
+			notice("warn", `${command} aborted: ${receipt.outcomeDetail ?? "operator abort"}`);
+		} else if (receipt.exitCode !== 0 || receipt.failureMessage) {
 			const failure = receipt.failureMessage ? ` ${receipt.failureMessage}` : "";
 			notice("error", `${command} failed: exit=${receipt.exitCode}${failure}`);
 		}
 		if (share) shareReceipt(request.agentId, receipt, deps);
 	} catch (err) {
 		const msg = err instanceof Error ? err.message : String(err);
-		notice("error", `${command} failed: ${msg}`);
+		if (err instanceof AdmissionCanceledError) {
+			notice("warn", `${command} aborted: ${msg.replace(/^dispatch:\s*/u, "")}`);
+		} else {
+			notice("error", `${command} failed: ${msg}`);
+		}
 	}
 }
 
@@ -629,6 +671,14 @@ export interface SlashCommandContext {
 	seedTaskMemory?: () => TaskMemorySeedCommandResult;
 	/** Open `/view`, the full observability artifact viewer. */
 	openView: (filter?: string) => void;
+	/**
+	 * The pane layer's operator surface. It remains present when mux resolves to
+	 * `none` because the Yazi preset can borrow the terminal for one selection;
+	 * absent only when the host did not compose pane operations at all.
+	 */
+	panes?: PanesOperations;
+	/** Serialize a local async command so the next admitted slash command observes its committed state. */
+	runLocalOperation?: (operation: () => Promise<void>) => void;
 	/**
 	 * Apply a thinking level named on the command line. Returns why it was
 	 * refused so the caller can say so, because the level the operator typed may
@@ -640,8 +690,12 @@ export interface SlashCommandContext {
 	openModel: () => void;
 	/** Live providers contract used by `/model <pattern>` to resolve directly. */
 	providers: ProvidersContract;
-	/** Apply a resolved model reference to settings (and optionally thinking level). */
-	applyModelRef: (ref: ResolvedModelRef) => void;
+	/**
+	 * Apply a resolved model reference, or hand it to the scope dialog. "pending"
+	 * means the operator has yet to choose session or global and nothing has
+	 * changed; the dialog reports the outcome itself.
+	 */
+	applyModelRef: (ref: ResolvedModelRef) => "applied" | "pending";
 	openSettings: (section?: SettingsSectionId, rowId?: SettingsCenterRowId) => void;
 	openResume: () => void;
 	startNewSession: () => void;
@@ -662,10 +716,16 @@ export interface SlashCommandContext {
 	runCompact: (instructions: string | undefined) => void;
 	/**
 	 * Escape hatch for the `view verify` entry: verify a receipt file on disk
-	 * and emit a single status line. Kept on the context so the registry does
+	 * and emit an actionable verification block. Kept on the context so the registry does
 	 * not import the overlay module.
 	 */
-	verifyReceipt: (runId: string) => ReceiptIntegrityOutcome;
+	verifyReceipt: (runId: string) => ReceiptIntegrityOutcome & {
+		receiptPath?: string;
+		sealedDigest?: string | null;
+		trustSummary?: string | null;
+		compromised?: boolean;
+		checks?: ReadonlyArray<{ name: string; ok: boolean; evidence: string }>;
+	};
 	/**
 	 * Handles the "unknown" case: append the text to the chat panel as a user
 	 * turn, submit to the chat loop, and schedule a re-render. Handlers for
@@ -677,6 +737,24 @@ export interface SlashCommandContext {
 	render: () => void;
 }
 
+type SlashReceiptVerification = ReturnType<SlashCommandContext["verifyReceipt"]>;
+
+/** Compact multiline receipt verification for the composer notice surface. */
+export function formatReceiptVerificationBlock(runId: string, result: SlashReceiptVerification): string {
+	const status = result.ok ? (result.compromised ? "compromised" : "ok") : result.retired ? "retired" : "fail";
+	const lines = [
+		`verify ${status} ${runId}`,
+		`receipt  ${result.receiptPath ?? "unavailable"}`,
+		`digest   ${result.sealedDigest ?? "unavailable"}`,
+		`evidence ${result.trustSummary ?? (!result.ok ? result.reason : "trust status unavailable")}`,
+	];
+	if (result.checks && result.checks.length > 0) {
+		lines.push("checks");
+		for (const check of result.checks) lines.push(`  ${check.ok ? "✓" : "✗"} ${check.name}: ${check.evidence}`);
+	}
+	return lines.join("\n");
+}
+
 /** The one operator-authored turn used by slash and overlay handoff paths. */
 export function formatUserTaskHandoff(task: Pick<UserTask, "id" | "title" | "note">): string {
 	const note = task.note ? ` ${task.note}.` : "";
@@ -765,6 +843,35 @@ function usageNotice(entry: BuiltinSlashCommand, subcommand?: string): string {
 	return usageLine(entry, subcommand).trim();
 }
 
+/**
+ * `/panes` output, as plain lines. Pure so the contract test asserts the text
+ * an operator reads rather than the object behind it, and so the registry keeps
+ * its promise not to reach a renderer.
+ */
+export function formatPanesStatus(status: PanesStatus): ReadonlyArray<string> {
+	const server = status.server ? `pane host ${status.server.version}, protocol ${status.server.protocol}` : "no server";
+	const lines = [
+		`panes: mode=${status.mode} ${status.available ? "available" : "unavailable"} (${server})`,
+		`  ${status.reason}`,
+		...(status.socketPath ? [`  socket ${status.socketPath}`] : []),
+		`  settings: enabled=${status.settings.enabled} notifications=${status.settings.notifications} journal=${status.settings.journal}`,
+		`  files: enabled=${status.settings.yazi.enabled} mode=${status.settings.yazi.mode} profile=${status.settings.yazi.profile} followCwd=${status.settings.yazi.followCwd}`,
+		`  file pane: mode=${status.yazi.mode} pane=${status.yazi.paneId ?? "none"} cwd=${status.yazi.paneCwd ?? "unknown"} lastLine=${status.yazi.lastLineAt === null ? "never" : new Date(status.yazi.lastLineAt).toISOString()} dropped=${status.yazi.droppedLines}`,
+	];
+	if (status.panes.length === 0) {
+		lines.push("  no Clio-owned panes");
+	} else {
+		lines.push(`  ${status.panes.length} Clio-owned pane(s):`);
+		for (const pane of status.panes) {
+			const adopted = pane.adopted ? " adopted" : "";
+			const pending = pane.pending ? " opening" : "";
+			lines.push(`    ${pane.paneId} ${pane.purpose} ${pane.label}${adopted}${pending}`);
+		}
+	}
+	lines.push(`  presets: ${PANES_PRESETS.map((preset) => `${preset.id} (${preset.summary})`).join(", ")}`);
+	return lines;
+}
+
 export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 	{
 		name: "quit",
@@ -1505,16 +1612,141 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			}
 			if (command.kind !== "view-verify") return;
 			const result = ctx.verifyReceipt(command.runId);
+			const block = formatReceiptVerificationBlock(command.runId, result);
 			if (result.ok) {
-				ctx.notice("success", `verify ok ${command.runId}`);
+				ctx.notice(result.compromised ? "warn" : "success", block);
 			} else if (result.retired !== undefined) {
 				// A retired seal is the expected state of a run from the previous
 				// release, so it is a warning that names the versions, never the
 				// failure a tampered receipt gets.
-				ctx.notice("warn", `verify retired ${command.runId} ${result.reason}`);
+				ctx.notice("warn", block);
 			} else {
-				ctx.notice("error", `verify fail ${command.runId} ${result.reason}`);
+				ctx.notice("error", block);
+			}
+		},
+	},
+	{
+		name: "panes",
+		description: "Inspect the pane layer, watch a live run in a pane, or open a utility pane",
+		group: "Inspect",
+		kinds: ["panes", "panes-show", "panes-open", "panes-close", "panes-usage"],
+		args: {
+			subcommands: {
+				show: { positionals: [{ name: "run-or-agent", required: true }] },
+				// A rest positional, so an argv pane keeps its own flags: the parser
+				// would otherwise refuse `--follow` as an unknown flag of `/panes`.
+				open: { positionals: [{ name: "preset-or-argv", required: true, rest: true }] },
+				close: { positionals: [{ name: "target", required: false }] },
+			},
+		},
+		subcommandDescriptions: {
+			show: "watch a live run or agent in the watch pane",
+			open: `open a utility pane (${PANES_PRESET_IDS.join(", ")}, or a command)`,
+			close: "close a Clio-owned pane, or all of them",
+		},
+		fromArgs(parsed) {
+			if (parsed.error) return { kind: "panes-usage", reason: parsed.error };
+			if (parsed.subcommand === "show") {
+				return { kind: "panes-show", target: parsed.positionals[0] ?? "" };
+			}
+			if (parsed.subcommand === "open") {
+				const rest = (parsed.rest ?? "").trim();
+				if (rest.length === 0) return { kind: "panes-usage", reason: "Missing required argument: preset-or-argv" };
+				const argv = rest.split(/\s+/).filter((token) => token.length > 0);
+				const first = argv[0] ?? "";
+				// A bare preset name is a preset; anything else is operator argv,
+				// which the tool surface deliberately cannot ask for.
+				if (argv.length === 1 && isPanesPresetId(first)) return { kind: "panes-open", preset: first };
+				if (argv.length === 2 && first === "yazi" && argv[1] === "--once") {
+					return { kind: "panes-open", preset: "yazi", once: true };
+				}
+				return { kind: "panes-open", argv };
+			}
+			if (parsed.subcommand === "close") {
+				return { kind: "panes-close", target: parsed.positionals[0] ?? "all" };
+			}
+			if (parsed.positionals.length > 0) {
+				return { kind: "panes-usage", reason: `Unexpected argument: ${parsed.positionals[0]}` };
+			}
+			return { kind: "panes" };
+		},
+		handle(command, ctx) {
+			const entry = BUILTIN_SLASH_COMMANDS.find((candidate) => candidate.name === "panes");
+			if (command.kind === "panes-usage") {
+				// usageNotice trims the leading newline usageLine carries, so the reason
+				// and the usage line need their own separator or they run together as
+				// `Missing required argument: run-or-agentusage: /panes show ...`.
+				if (entry) ctx.notice("info", command.reason ? `${command.reason}\n${usageNotice(entry)}` : usageNotice(entry));
+				return;
+			}
+			const panes = ctx.panes;
+			if (!panes) {
+				// Inactive by choice, not unavailable: the operations object exists in
+				// every `--with-panes` session, even one where no pane host answered.
+				ctx.notice(
+					"info",
+					"panes are inactive: this session started without them. Restart with `clio-coder --with-panes`, or set panes.enabled=auto",
+				);
+				return;
+			}
+			const runLocal = ctx.runLocalOperation ?? ((operation: () => Promise<void>) => void operation());
+			if (command.kind === "panes") {
+				runLocal(async () => {
+					for (const line of formatPanesStatus(panes.status())) ctx.io.stdout(`${line}\n`);
+					ctx.render();
+				});
+				return;
+			}
+			if (command.kind === "panes-show") {
+				runLocal(async () => {
+					const result = await panes.show(command.target);
+					if (result.status === "watching") {
+						ctx.notice("success", `watching ${result.agentId} (${result.runId})${result.opened ? " in a new pane" : ""}`);
+					} else if (result.status === "not-found") {
+						const known = result.candidates.length > 0 ? `; live runs: ${result.candidates.join(", ")}` : "";
+						ctx.notice("warn", `no live run matches ${result.target}${known}`);
+					} else {
+						ctx.notice("warn", result.reason);
+					}
+				});
+				return;
 			}
+			if (command.kind === "panes-open") {
+				runLocal(async () => {
+					const result = await panes.open({
+						...(command.preset ? { preset: command.preset } : {}),
+						...(command.argv ? { argv: command.argv } : {}),
+						...(command.once ? { once: true } : {}),
+					});
+					if (result.status === "opened") {
+						// The in-terminal chooser has already restored the TUI by the
+						// time this resolves. A pick emitted its composer notice; an empty
+						// chooser was cancellation and deliberately stays silent.
+						if (result.paneId !== null) ctx.notice("success", `opened pane ${result.label} (${result.paneId})`);
+					} else if (result.status === "missing-binary") {
+						// This is a synchronous slash-surface line, not a transient pane-host
+						// notification. It remains visible when no pane was ever created and
+						// reuses the exact doctor/tools diagnostic including the install hint.
+						ctx.io.stdout(`${result.detail}\n`);
+						ctx.render();
+					} else {
+						ctx.notice("warn", result.reason);
+					}
+				});
+				return;
+			}
+			if (command.kind !== "panes-close") return;
+			runLocal(async () => {
+				const result = await panes.close(command.target);
+				if (result.status === "closed") {
+					const what = result.labels.length > 0 ? `: ${result.labels.join(", ")}` : "";
+					ctx.notice(result.closed > 0 ? "success" : "info", `closed ${result.closed} pane(s)${what}`);
+				} else if (result.status === "not-found") {
+					ctx.notice("warn", `no Clio-owned pane matches ${result.target}`);
+				} else {
+					ctx.notice("warn", result.reason);
+				}
+			});
 		},
 	},
 	{
@@ -1604,9 +1836,13 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 					return;
 				}
 				if (result.warning) ctx.notice("warn", result.warning);
-				ctx.applyModelRef(result.ref);
-				const suffix = result.ref.thinkingLevel ? ` thinking=${result.ref.thinkingLevel}` : "";
-				ctx.notice("success", `active: ${result.ref.target}/${result.ref.model}${suffix}`);
+				// "pending" means the scope dialog is up: it says what landed and
+				// where, so announcing a swap here would be announcing a choice the
+				// operator has not made yet.
+				if (ctx.applyModelRef(result.ref) === "applied") {
+					const suffix = result.ref.thinkingLevel ? ` thinking=${result.ref.thinkingLevel}` : "";
+					ctx.notice("success", `active this session: ${result.ref.target}/${result.ref.model}${suffix}`);
+				}
 				ctx.render();
 			})();
 		},

package/src/interactive/tasks-overlay.ts

@@ -523,6 +523,7 @@ export function openTasksOverlay(
 	const handle = showClioOverlayFrame(tui, body, {
 		anchor: "center",
 		width: TASKS_OVERLAY_WIDTH,
+		markerId: "tasks",
 		title: () => "Tasks",
 		footerHint: () => body.footerHint(),
 	});

package/src/interactive/theme/tokens.ts

@@ -1,17 +1,6 @@
-export type ClioToken =
-	| "accent"
-	| "accentDeep"
-	| "action"
-	| "success"
-	| "warning"
-	| "error"
-	| "info"
-	| "reason"
-	| "dim"
-	| "muted"
-	| "title"
-	| "frame"
-	| "frameStrong";
+import type { ClioToken } from "../../core/theme-token-hex.js";
+
+export type { ClioToken } from "../../core/theme-token-hex.js";
 
 interface TokenColor {
 	rgb: readonly [number, number, number];

package/src/interactive/turn-context.ts

@@ -26,6 +26,7 @@ import { residencyTargetKey } from "../core/residency-target-key.js";
 import type { ToolName } from "../core/tool-names.js";
 import { buildEvictionFields, planEviction } from "../domains/context/working-set/engine.js";
 import { foldWorkingSet } from "../domains/context/working-set/fold.js";
+import { isTurnStart } from "../domains/context/working-set/horizon.js";
 import { resolveWorkingSetPolicy } from "../domains/context/working-set/policies/index.js";
 import { selectVisibleEntries } from "../domains/context/working-set/visible.js";
 import type { ObservabilityContract } from "../domains/observability/contract.js";
@@ -89,7 +90,7 @@ import {
 	toolNamesFromAgentState,
 } from "./chat-loop-messages.js";
 import { buildModelReplayAgentMessagesFromTurns } from "./model-session-replay.js";
-import { renderCompactionSummaryLine } from "./renderers/compaction-summary.js";
+import { renderCompactionSummaryLine, renderEvictionSkipLine } from "./renderers/compaction-summary.js";
 import type { TurnMiddleware } from "./turn-middleware.js";
 import type { AgentRuntime, ChatTurnState } from "./turn-state.js";
 
@@ -218,6 +219,27 @@ export interface TurnContext {
 	dispose(): void;
 }
 
+/**
+ * Why the working-set stage declined, said in the terms the operator can act
+ * on. The two cases are worth separating: a session whose every turn is inside
+ * `protectLastTurns` was never offered a candidate, while a longer one was
+ * offered candidates the policy refused. The first is the shape smoke pass 2
+ * found (G1), and the setting it names is the one that changes it.
+ */
+function evictionSkipMessage(
+	visibleEntries: ReadonlyArray<SessionEntry>,
+	workingSet: Readonly<{ protectLastTurns: number; policy: string }>,
+	policyId: string,
+): string {
+	const turns = visibleEntries.filter(isTurnStart).length;
+	return renderEvictionSkipLine({
+		reason: turns <= workingSet.protectLastTurns ? "all-protected" : "nothing-evictable",
+		turns,
+		protectLastTurns: workingSet.protectLastTurns,
+		policyId,
+	});
+}
+
 export function createTurnContext(deps: TurnContextDeps): TurnContext {
 	const { state, middleware } = deps;
 	const compactionTrigger = new AutoCompactionTrigger<CompactResult | null>();
@@ -661,6 +683,12 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		const autoEnabled = cfg?.auto !== false;
 		if (!force && !autoEnabled) return false;
 		let preSummaryStageActed = false;
+		// G1 from smoke pass 2: a short session generates all its pressure inside
+		// the protection window, the non-destructive layer finds nothing, and the
+		// destructive summary ran with nothing in the transcript saying eviction
+		// was considered and declined. Held here and emitted only if a summary
+		// actually follows.
+		let evictionSkipNotice: string | null = null;
 		const rememberEmptyAutomaticAttempt = (): void => {
 			if (!force && !preSummaryStageActed && activeAutoTurnId) emptyAutoCompactTurnId = activeAutoTurnId;
 		};
@@ -743,12 +771,16 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 					}
 				} else if (settings.context.workingSet.enabled) {
 					let planned: ReturnType<typeof planEviction>;
+					let visibleEntries: ReadonlyArray<SessionEntry> = [];
+					let policyId = settings.context.workingSet.policy;
 					try {
 						const entries = deps.readSessionEntries() ?? [];
 						const view = foldWorkingSet(entries, state.lastTurnId ?? undefined);
 						const policy = resolveWorkingSetPolicy(settings.context.workingSet.policy);
+						policyId = policy.id;
+						visibleEntries = selectVisibleEntries(entries, state.lastTurnId ?? undefined);
 						planned = (deps.planEviction ?? planEviction)(policy, {
-							entries: selectVisibleEntries(entries, state.lastTurnId ?? undefined),
+							entries: visibleEntries,
 							view,
 							cwd: deps.session.current()?.cwd ?? null,
 							settings: settings.context.workingSet,
@@ -830,7 +862,16 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 							emitCompactionActivity("failed", compactionFailureMessage(error));
 							throw error;
 						}
+					} else {
+						evictionSkipNotice = evictionSkipMessage(visibleEntries, settings.context.workingSet, policyId);
 					}
+				} else {
+					evictionSkipNotice = renderEvictionSkipLine({
+						reason: "disabled",
+						turns: 0,
+						protectLastTurns: settings.context.workingSet.protectLastTurns,
+						policyId: settings.context.workingSet.policy,
+					});
 				}
 			}
 		}
@@ -847,6 +888,10 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			summaryLifecycleStarted = true;
 		};
 		if (force) startSummaryLifecycle();
+		// Said before the summary call, not after it: the operator is about to wait
+		// on a destructive stage, and the reason the cheap one was skipped is only
+		// useful ahead of it.
+		if (evictionSkipNotice) deps.emitNotice(evictionSkipNotice);
 		let result: CompactResult | null = null;
 		const beforeSnapshotId = currentContextSnapshot?.snapshotId ?? null;
 		try {

package/src/interactive/view/artifacts.ts

@@ -5,12 +5,14 @@ import type { DispatchContract } from "../../domains/dispatch/contract.js";
 import { isReceiptIntegrity, verifyReceiptIntegrity } from "../../domains/dispatch/receipt-integrity.js";
 import type { RunEnvelope, RunReceipt } from "../../domains/dispatch/types.js";
 import { evidenceDirectory, inspectEvidence, listEvidenceOverviews } from "../../domains/evidence/store.js";
-import { formatTrustSummaryLine } from "../../domains/evidence/trust-projection.js";
+import { formatTrustSummaryLine, trustStateWord } from "../../domains/evidence/trust-projection.js";
 import {
 	inspectRunReceiptTrustStatus,
 	type ReceiptIntegrityOutcome,
 	retiredReceiptIntegrity,
 	retiredReceiptIntegrityReason,
+	TRUST_STATUS_AXES,
+	type TrustStatusAxis,
 } from "../../domains/evidence/trust-status.js";
 import type { EvidenceFinding, EvidenceOverview, EvidenceSource } from "../../domains/evidence/types.js";
 import { type AccountabilitySummary, readAccountabilitySummary } from "../../domains/observability/index.js";
@@ -113,6 +115,20 @@ const JSON_PRETTY_MAX_BYTES = 10 * 1024 * 1024;
 
 export type ReceiptVerifyResult = ReceiptIntegrityOutcome;
 
+export interface ReceiptVerificationCheck {
+	name: string;
+	ok: boolean;
+	evidence: string;
+}
+
+export type ReceiptVerificationReport = ReceiptIntegrityOutcome & {
+	receiptPath: string;
+	sealedDigest: string | null;
+	trustSummary: string | null;
+	compromised: boolean;
+	checks: ReceiptVerificationCheck[];
+};
+
 /**
  * What a verify action reports. `retired` marks a seal this build does not
  * verify because its integrity version was retired: not a pass, and not the
@@ -435,6 +451,98 @@ export function verifyReceiptFile(stateDir: string, runId: string): ReceiptVerif
 	return verifyReceiptIntegrity(r as unknown as RunReceipt, ledger.envelope);
 }
 
+const RECEIPT_FILE_FAILURE = /^(?:receipt file not found|read error:)/u;
+const RECEIPT_CONTRACT_FAILURE =
+	/^(?:invalid json:|receipt is not an object|missing field:|runId invalid:|runId mismatch:|agentId invalid:|task invalid:|targetId invalid:|wireModelId invalid:|runtimeId invalid:|runtimeKind invalid:|exitCode out of range:|tokenCount out of range:|inputTokenCount out of range:|outputTokenCount out of range:|cacheReadTokenCount out of range:|cacheWriteTokenCount out of range:|costUsd out of range:|reasoningTokenCount out of range:|startedAt not ISO-8601:|endedAt not ISO-8601:|clioVersion empty|piMonoVersion invalid:|platform invalid:|nodeVersion invalid:|toolCalls out of range:|toolStats\[|compiledPromptHash invalid:|staticCompositionHash invalid:|sessionId invalid:|integrity invalid|execution role invalid|routing intent invalid|route decision invalid)/u;
+const LEDGER_FAILURE = /^(?:run ledger not found|run not found in ledger|ledger mismatch:)/u;
+
+function receiptIntegrityDigest(value: unknown): string | null {
+	if (!isRecord(value) || value.algorithm !== "sha256" || !isNonEmptyString(value.digest)) return null;
+	return `sha256:${value.digest}`;
+}
+
+function trustCheckEvidence(status: ReturnType<typeof inspectRunReceiptTrustStatus>["status"], axis: string): string {
+	const entry = status[axis as keyof typeof status];
+	if (typeof entry !== "object" || entry === null || !("state" in entry)) return "canonical trust projection";
+	if (entry.state === "absent") return `reason=${entry.reason}`;
+	const refs = entry.artifacts.map((artifact) => `${artifact.kind}:${artifact.id}`);
+	return refs.length > 0 ? refs.join(", ") : `${entry.authority.kind}:${entry.authority.id}`;
+}
+
+function compromisedTrustAxes(status: ReturnType<typeof inspectRunReceiptTrustStatus>["status"]): TrustStatusAxis[] {
+	return TRUST_STATUS_AXES.filter((axis) => {
+		const state = status[axis].state;
+		if (axis === "artifactIntegrity") return state === "failed";
+		if (axis === "validationGrounding") return state === "failed" || state === "ungrounded";
+		if (axis === "independentReview") return state === "failed" || state === "not_independent";
+		if (axis === "contextProvenance") return state === "invalid";
+		if (axis === "autonomyEnforcement") return state === "bypassed";
+		return false;
+	});
+}
+
+/** Actionable `/view verify` report without changing the low-level verifier contract. */
+export function verifyReceiptFileReport(stateDir: string, runId: string): ReceiptVerificationReport {
+	const receiptPath = receiptFilePath(stateDir, runId);
+	const result = verifyReceiptFile(stateDir, runId);
+	let receipt: RunReceipt | null = null;
+	try {
+		receipt = JSON.parse(readFileSync(receiptPath, "utf8")) as RunReceipt;
+	} catch {
+		// The verifier's named file or JSON check below retains the actionable error.
+	}
+	const sealedDigest = receiptIntegrityDigest(receipt?.integrity);
+	const ledger = readRunEnvelope(stateDir, runId);
+	const inspection = receipt === null ? null : inspectRunReceiptTrustStatus(receipt, ledger.ok ? ledger.envelope : null);
+	const trustSummary = inspection === null ? null : formatTrustSummaryLine(inspection.status);
+	const compromiseAxes = inspection === null ? [] : compromisedTrustAxes(inspection.status);
+	const checks: ReceiptVerificationCheck[] = [];
+
+	if (!result.ok && RECEIPT_FILE_FAILURE.test(result.reason)) {
+		checks.push({ name: "receipt file", ok: false, evidence: `${receiptPath}: ${result.reason}` });
+	} else {
+		checks.push({ name: "receipt file", ok: true, evidence: receiptPath });
+		if (!result.ok && (RECEIPT_CONTRACT_FAILURE.test(result.reason) || result.retired !== undefined)) {
+			checks.push({ name: "receipt contract", ok: false, evidence: result.reason });
+		} else {
+			checks.push({
+				name: "receipt contract",
+				ok: true,
+				evidence: `current integrity v${receipt?.integrity.version ?? "unknown"}`,
+			});
+			if (!result.ok && LEDGER_FAILURE.test(result.reason)) {
+				checks.push({ name: "run ledger", ok: false, evidence: result.reason });
+			} else {
+				checks.push({ name: "run ledger", ok: true, evidence: `run ${runId} fields match` });
+				checks.push({
+					name: "sealed digest",
+					ok: result.ok,
+					evidence: result.ok ? `${sealedDigest ?? "digest unavailable"} matches receipt and ledger` : result.reason,
+				});
+			}
+		}
+	}
+
+	if (inspection !== null) {
+		for (const axis of compromiseAxes) {
+			checks.push({
+				name: `trust ${axis}`,
+				ok: false,
+				evidence: `${trustStateWord(axis, inspection.status[axis].state)}; ${trustCheckEvidence(inspection.status, axis)}`,
+			});
+		}
+	}
+
+	return {
+		...result,
+		receiptPath,
+		sealedDigest,
+		trustSummary,
+		compromised: compromiseAxes.length > 0,
+		checks,
+	};
+}
+
 function pushCapped(lines: string[], line: string, maxLines: number): boolean {
 	if (lines.length >= maxLines) return false;
 	lines.push(line);

package/src/interactive/view/view-overlay.ts

@@ -764,6 +764,7 @@ export function openViewOverlay(
 		width: VIEW_OVERLAY_WIDTH,
 		maxHeight: VIEW_OVERLAY_MAX_HEIGHT,
 		margin: VIEW_OVERLAY_MARGIN,
+		markerId: "view",
 		title: "View",
 		footerHint: (innerWidth) => view.getHint(innerWidth),
 	});