@iowarp/clio-coder 0.4.1 → 0.4.2

package/src/domains/mux/detect.ts

@@ -126,19 +126,12 @@ export async function detectMux(options: DetectMuxOptions = {}): Promise<MuxDete
 		return { detection: none("panes are turned off"), client: null };
 	}
 	if (enabled === "embedded") {
-		// Phase 5 owns the session bootstrap. Until then the honest answer is that
-		// Clio cannot provide panes, not that it failed to find them, and the
-		// operator hears it: this degrade is marked a refusal so the boot says so
-		// out loud rather than logging a debug line nobody reads. The reason also
-		// names the rung that does work, because `embedded` costs guest mode too.
-		return {
-			detection: none(
-				"embedded mode is not implemented yet; it ships in phase 5, so this session has no panes at all. Set panes.enabled=auto for guest mode inside a herdr session.",
-				[],
-				true,
-			),
-			client: null,
-		};
+		// Embedded mode (Clio owning the pane host) is not implemented yet. An
+		// operator who picked it wanted panes, so the rung degrades to guest
+		// detection instead of refusing everything; the notice below says which
+		// mode actually runs. When the guest ladder also fails, that failure is
+		// reported on its own terms.
+		log("info", "interface.panes.enabled=embedded is not implemented yet; detecting a guest pane host instead");
 	}
 	if (env.HERDR_ENV !== "1") {
 		return { detection: none("HERDR_ENV is not 1, so Clio is not running inside a pane host"), client: null };

package/src/domains/mux/index.ts

@@ -113,4 +113,4 @@ export {
 	type YaziSessionOptions,
 	type YaziSessionSnapshot,
 } from "./yazi/session.js";
-export { renderYaziTheme } from "./yazi/theme.js";
+export { renderHerdrThemeBlock, renderYaziTheme } from "./yazi/theme.js";

package/src/domains/mux/operations.ts

@@ -14,13 +14,19 @@
  * shell-escape territory (spec 4.8, and the risk register's "tool misuse" row).
  */
 
-/** Utility pane presets, in the order `/panes open` lists them. */
+/**
+ * Utility pane presets, in the order `/panes open` lists them.
+ *
+ * The files preset is a Clio Coder surface named for what it does; yazi is
+ * the engine behind it and shows up only in the install command, because
+ * that is the registry id an operator types.
+ */
 export const PANES_PRESETS = [
 	{
-		id: "yazi",
+		id: "files",
 		/** Probed through the toolchain resolution ladder before the pane is split. */
 		binary: "yazi",
-		summary: "file manager rooted at the workspace",
+		summary: "file view rooted at the workspace; picks land in the composer",
 		/** Printed verbatim when the probe finds nothing. */
 		installHint: "clio-coder tools install yazi",
 	},
@@ -42,10 +48,23 @@ export type PanesPresetId = (typeof PANES_PRESETS)[number]["id"];
 
 export const PANES_PRESET_IDS: ReadonlyArray<PanesPresetId> = PANES_PRESETS.map((preset) => preset.id);
 
-export function isPanesPresetId(value: string): value is PanesPresetId {
+function isPanesPresetId(value: string): value is PanesPresetId {
 	return PANES_PRESETS.some((preset) => preset.id === value);
 }
 
+/**
+ * Retired preset spellings that still parse. The files preset shipped as
+ * `yazi` in 0.4.0 and 0.4.1, so an operator's muscle memory and any script
+ * that says `/panes open yazi` keeps working and lands on the same pane.
+ */
+export const PANES_PRESET_ALIASES: Readonly<Record<string, PanesPresetId>> = { yazi: "files" };
+
+/** The canonical preset id for an operator-typed name, or null when it is not a preset. */
+export function resolvePanesPresetId(value: string): PanesPresetId | null {
+	if (isPanesPresetId(value)) return value;
+	return PANES_PRESET_ALIASES[value] ?? null;
+}
+
 /** One pane Clio owns, flattened for display. */
 export interface PanesInventoryEntry {
 	paneId: string;
@@ -135,7 +154,8 @@ export interface PanesWatchController {
 }
 
 export type PanesOpenResult =
-	| { status: "opened"; label: string; paneId: string | null }
+	/** `existing` is true when the preset already had a live pane and it was focused instead of split again. */
+	| { status: "opened"; label: string; paneId: string | null; existing?: boolean }
 	| { status: "missing-binary"; preset: string; binary: string; installHint: string; detail: string }
 	| { status: "refused"; reason: string }
 	| { status: "unavailable"; reason: string };
@@ -166,9 +186,21 @@ export interface PanesYaziController {
 		| { status: "profile-error"; reason: string }
 		| { status: "unavailable"; reason: string }
 	>;
+	/** Close the files pane if it is open; false when nothing was open. */
+	close(): Promise<boolean>;
+	/** True while a files pane the host still reports is open. */
+	isOpen(): boolean;
 	status(): Readonly<PanesYaziStatus>;
 }
 
+/** What `/files` and the files keybinding settle to. */
+export type PanesFilesResult =
+	| { status: "opened"; paneId: string | null; existing: boolean }
+	| { status: "closed" }
+	| { status: "missing-binary"; binary: string; installHint: string; detail: string }
+	| { status: "refused"; reason: string }
+	| { status: "unavailable"; reason: string };
+
 /**
  * The operations both callers drive. The tool sees a narrower door: its schema
  * has no argv field at all, and `open` refuses one even if a caller fabricates
@@ -185,6 +217,13 @@ export interface PanesOperations {
 	 */
 	zoom(target: string): Promise<PanesZoomResult>;
 	close(target: string): Promise<PanesCloseResult>;
+	/**
+	 * The files pane as one operator verb. `toggle` opens it when closed and
+	 * closes it when open, which is what a keybinding needs; `open` and
+	 * `close` are the explicit halves; `pick` borrows the pane for one
+	 * selection and closes it afterwards.
+	 */
+	files(action: "toggle" | "open" | "close" | "pick"): Promise<PanesFilesResult>;
 	/** Bind the composer-facing Yazi bridge without rebuilding this shared object. */
 	attachYazi(controller: PanesYaziController): () => void;
 	/** Bind the workers-view watch controller; `show` routes runs through it. */

package/src/domains/mux/yazi/assets/yazi.toml

@@ -1,5 +1,5 @@
-# Yazi config for orchestration TUI
-# Git status integration
+# Clio Coder files pane: engine configuration. The pane host lists the pane by
+# the label Clio sets ("files"); this file only shapes what the engine shows.
 
 [mgr]
 show_hidden = true

package/src/domains/mux/yazi/session.ts

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { namingCompatibilityEnvironment } from "../../../core/naming-compat.js";
 import { clioCacheDir } from "../../../core/xdg.js";
@@ -107,6 +107,37 @@ function readOptional(path: string): string {
 	}
 }
 
+/** Transport files older than this are leftovers of a process that never reached its cleanup. */
+export const YAZI_STALE_TRANSPORT_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * Drop transport files no live session can own. A crash, a kill, or a
+ * release before cleanup existed leaves `.stream`, `.chooser`, and `.cwd`
+ * files behind; a day is long past any pane's life, so anything older goes.
+ */
+export function sweepStaleTransportFiles(sessionsDir: string, now: number = Date.now()): number {
+	let removed = 0;
+	let entries: string[];
+	try {
+		entries = readdirSync(sessionsDir);
+	} catch {
+		return 0;
+	}
+	for (const name of entries) {
+		if (!/\.(stream|chooser|cwd)$/u.test(name)) continue;
+		const path = join(sessionsDir, name);
+		try {
+			if (now - statSync(path).mtimeMs > YAZI_STALE_TRANSPORT_MS) {
+				rmSync(path, { force: true });
+				removed += 1;
+			}
+		} catch {
+			// A file that vanished between readdir and stat was someone else's to remove.
+		}
+	}
+	return removed;
+}
+
 /** Open one mux-hosted Yazi process and own its DDS or chooser-file transport. */
 export async function createYaziSession(options: YaziSessionOptions): Promise<YaziSessionOpenResult> {
 	const binaries = (options.resolveBinaries ?? resolveYaziBinaries)();
@@ -125,6 +156,7 @@ export async function createYaziSession(options: YaziSessionOptions): Promise<Ya
 	const sessionId = options.sessionId ?? randomUUID();
 	const sessionsDir = join(cacheDir, "yazi", "sessions");
 	mkdirSync(sessionsDir, { recursive: true });
+	sweepStaleTransportFiles(sessionsDir);
 	const managedProfile =
 		options.profileMode === "managed"
 			? (options.ensureProfile ?? ensureYaziProfile)({
@@ -163,10 +195,19 @@ export async function createYaziSession(options: YaziSessionOptions): Promise<Ya
 		argv = [binaries.yaziPath, options.cwd, "--chooser-file", chooserPath, "--cwd-file", cwdPath];
 	}
 
+	// Transport files are per session and worthless once it ends: a pick has
+	// already been consumed by the bridge, and a chooser file has been read.
+	// Removing them here is what keeps `<cache>/yazi/sessions` from growing by
+	// three files per open for the life of the install.
+	const removeTransportFiles = (): void => {
+		for (const path of [streamPath, chooserPath, cwdPath]) rmSync(path, { force: true });
+	};
+
 	const pane = await options.mux.openUtilityPane({
 		argv,
 		cwd: options.cwd,
-		label: "yazi",
+		label: "files",
+		title: "files",
 		// The files dock: split down from the anchor at the configured share.
 		// Degrades to a plain split inside the contract when the layout tier is
 		// absent.
@@ -174,7 +215,10 @@ export async function createYaziSession(options: YaziSessionOptions): Promise<Ya
 		...(Object.keys(env).length > 0 ? { env } : {}),
 		...(stdoutPath ? { stdoutPath } : {}),
 	});
-	if (!pane) return { status: "unavailable", reason: "pane host refused to open yazi" };
+	if (!pane) {
+		removeTransportFiles();
+		return { status: "unavailable", reason: "the pane host refused to open the files pane" };
+	}
 
 	let paneCwd = options.cwd;
 	let instanceId: string | null = null;
@@ -188,6 +232,7 @@ export async function createYaziSession(options: YaziSessionOptions): Promise<Ya
 		if (chooserTimer) clearInterval(chooserTimer);
 		chooserTimer = null;
 		options.onStopped?.(reason);
+		removeTransportFiles();
 	};
 
 	if (options.mode === "companion") {
@@ -204,7 +249,11 @@ export async function createYaziSession(options: YaziSessionOptions): Promise<Ya
 				options.onEvent(event);
 			},
 		});
-		void stream.done.then((reason) => stop(reason));
+		void stream.done.then((reason) => {
+			// A stream that ended on its own means the pane is gone or the file
+			// was lost; either way the session is over and says so.
+			stop(reason);
+		});
 	} else {
 		const pollChooser = (): void => {
 			if (stopped || alive()) return;

package/src/domains/mux/yazi/theme.ts

@@ -1,30 +1,130 @@
 import { tokenHex } from "../../../core/theme-token-hex.js";
 
-/** Render the deliberately small Clio overlay on Yazi's pinned preset theme. */
+/**
+ * Render the Clio overlay on Yazi's pinned preset theme.
+ *
+ * Every color comes from Clio's own token palette (`core/theme-token-hex.ts`),
+ * read when the managed profile is generated, which happens on the open that
+ * finds no current profile. The profile stamp carries this file's output hash,
+ * so a palette change regenerates the profile on the next open rather than
+ * leaving a pane in last release's colors. Only keys Yazi 26.8 documents are
+ * set; the rest of the preset stays, because a wrong key here is rejected by
+ * the validation open in `profile.ts` and would leave the operator with no
+ * files pane at all.
+ */
 export function renderYaziTheme(): string {
-	return `# Generated by Clio Coder. Changes are replaced when the managed profile regenerates.
+	const accent = tokenHex("accent");
+	const action = tokenHex("action");
+	const success = tokenHex("success");
+	const warning = tokenHex("warning");
+	const error = tokenHex("error");
+	const info = tokenHex("info");
+	const dim = tokenHex("dim");
+	const muted = tokenHex("muted");
+	const frame = tokenHex("frame");
+	const frameStrong = tokenHex("frameStrong");
+	return `# Generated by Clio Coder from its theme tokens. Changes are replaced when the managed profile regenerates.
 
 [mgr]
-cwd = { fg = "${tokenHex("accent")}" }
-find_keyword = { fg = "${tokenHex("warning")}" }
-marker_selected = { fg = "${tokenHex("success")}", bg = "${tokenHex("success")}" }
-marker_copied = { fg = "${tokenHex("accent")}", bg = "${tokenHex("accent")}" }
-marker_cut = { fg = "${tokenHex("error")}", bg = "${tokenHex("error")}" }
-border_style = { fg = "${tokenHex("frame")}" }
+cwd = { fg = "${accent}" }
+hovered = { reversed = true }
+preview_hovered = { underline = true }
+find_keyword = { fg = "${warning}", bold = true }
+find_position = { fg = "${action}", italic = true }
+marker_selected = { fg = "${success}", bg = "${success}" }
+marker_copied = { fg = "${accent}", bg = "${accent}" }
+marker_cut = { fg = "${error}", bg = "${error}" }
+marker_marked = { fg = "${info}", bg = "${info}" }
+count_copied = { fg = "${accent}", bg = "${frame}" }
+count_cut = { fg = "${error}", bg = "${frame}" }
+count_selected = { fg = "${success}", bg = "${frame}" }
+border_style = { fg = "${frame}" }
+syntect_theme = ""
 
 [mode]
-normal_main = { bg = "${tokenHex("accent")}" }
-normal_alt = { fg = "${tokenHex("accent")}" }
-select_main = { bg = "${tokenHex("action")}" }
-select_alt = { fg = "${tokenHex("action")}" }
-unset_main = { bg = "${tokenHex("error")}" }
-unset_alt = { fg = "${tokenHex("error")}" }
+normal_main = { bg = "${accent}", bold = true }
+normal_alt = { fg = "${accent}" }
+select_main = { bg = "${action}", bold = true }
+select_alt = { fg = "${action}" }
+unset_main = { bg = "${error}", bold = true }
+unset_alt = { fg = "${error}" }
 
 [tabs]
-active = { bg = "${tokenHex("accent")}" }
-inactive = { fg = "${tokenHex("accent")}" }
+active = { bg = "${accent}", bold = true }
+inactive = { fg = "${accent}" }
 
 [status]
-perm_sep = { fg = "${tokenHex("dim")}" }
+perm_type = { fg = "${accent}" }
+perm_read = { fg = "${warning}" }
+perm_write = { fg = "${error}" }
+perm_exec = { fg = "${success}" }
+perm_sep = { fg = "${dim}" }
+progress_label = { bold = true }
+progress_normal = { fg = "${accent}" }
+progress_error = { fg = "${error}" }
+
+[which]
+cols = 3
+mask = { bg = "${frame}" }
+cand = { fg = "${accent}" }
+rest = { fg = "${muted}" }
+desc = { fg = "${action}" }
+separator_style = { fg = "${dim}" }
+
+[confirm]
+border = { fg = "${frameStrong}" }
+title = { fg = "${accent}" }
+btn_yes = { reversed = true }
+btn_no = {}
+
+[pick]
+border = { fg = "${frameStrong}" }
+active = { fg = "${action}", bold = true }
+
+[input]
+border = { fg = "${frameStrong}" }
+title = { fg = "${accent}" }
+selected = { reversed = true }
+
+[cmp]
+border = { fg = "${frameStrong}" }
+active = { reversed = true }
+
+[tasks]
+border = { fg = "${frameStrong}" }
+title = { fg = "${accent}" }
+hovered = { fg = "${action}", underline = true }
+
+[help]
+on = { fg = "${accent}" }
+run = { fg = "${action}" }
+footer = { fg = "${muted}" }
+
+[notify]
+title_info = { fg = "${info}" }
+title_warn = { fg = "${warning}" }
+title_error = { fg = "${error}" }
+`;
+}
+
+/**
+ * The same palette as a herdr `[theme.custom]` block.
+ *
+ * herdr themes its chrome (sidebar, tab bar, borders, agent rows) from its own
+ * config.toml and has no per-pane styling on the wire, so Clio cannot color
+ * the panes it opens. What it can do is hand the operator the block that makes
+ * herdr's chrome match Clio, to paste into herdr's config; Clio never writes
+ * another program's configuration itself.
+ */
+export function renderHerdrThemeBlock(): string {
+	return `# Clio Coder theme tokens for herdr. Paste into ~/.config/herdr/config.toml, then run \`herdr server reload-config\`.
+[theme.custom]
+accent = "${tokenHex("accent")}"
+green = "${tokenHex("success")}"
+blue = "${tokenHex("info")}"
+red = "${tokenHex("error")}"
+yellow = "${tokenHex("warning")}"
+selection_bg = "${tokenHex("frame")}"
+active_row_bg = "${tokenHex("frame")}"
 `;
 }

package/src/domains/observability/contract.ts

@@ -18,25 +18,24 @@ export interface TokenThroughputSnapshot {
 }
 
 /**
- * One bounded, product-facing observability event. Notices are a redacted,
- * append-only stream: a runtime eviction, a blocked tool, a hook crash, a
- * pruned context window, and so on. They never carry raw worker output or tool
- * arguments; `message` is a short rendered line and `ref` links back to the
- * subject (a run, a target, an evidence bundle) without embedding its contents.
+ * One bounded, product-facing observability event: an evidence build that
+ * failed for a run, read by the Dispatch Board to explain why a run has no
+ * evidence bundle. This used to also carry runtime/middleware/safety/loop/
+ * tool-budget/context/budget notices classified off the same bus channels the
+ * interactive layer's own notice pipeline (bus-notices.ts and
+ * interactive-event-projection.ts) classifies independently for the toast
+ * surface a session actually shows; those seven kinds had no reader of their
+ * own here and were removed rather than kept as an unread second opinion.
+ * `message` is a short rendered line and `ref` links back to the run.
  */
 export interface ObservabilityNotice {
 	id: string;
 	at: number;
-	kind: "runtime" | "middleware" | "safety" | "loop" | "tool-budget" | "context" | "budget" | "provider" | "evidence";
+	kind: "evidence";
 	level: "info" | "warning" | "error";
 	message: string;
 	ref?: {
 		runId?: string;
-		agentId?: string;
-		targetId?: string;
-		modelId?: string;
-		evidenceId?: string;
-		tool?: string;
 	};
 }
 

package/src/domains/observability/extension.ts

@@ -1,7 +1,8 @@
 /**
  * Observability domain wire-up. Listens to dispatch + safety bus channels and
- * folds payloads into telemetry/cost trackers. Emits nothing; other domains
- * read the snapshot through the contract.
+ * folds payloads into telemetry/cost trackers. Other domains read the snapshot
+ * through the contract; the one thing it emits is
+ * `accountability.evidenceReady`, once per run whose evidence bundle landed.
  */
 
 import { BusChannels, type DispatchCompletedPayload } from "../../core/bus-events.js";
@@ -171,7 +172,14 @@ export function createObservabilityBundle(
 	const trackBuild = (runId: string, succeeded: boolean, attempt: number | undefined): void => {
 		projection.evidenceBuildStarted(runId);
 		const build = buildAndIndexEvidence(runId, succeeded, attempt, {
-			onReady: (id, evidence) => projection.evidenceBuildSucceeded(id, evidence),
+			onReady: (id, evidence) => {
+				projection.evidenceBuildSucceeded(id, evidence);
+				// The same fact, once, for listeners outside this closure (the ACP
+				// server forwards it as the opt-in `accountability.evidenceReady`
+				// kind). The payload spreads the evidence object the projection just
+				// received rather than rebuilding it, so the two cannot drift.
+				context.bus.emit(BusChannels.AccountabilityEvidenceReady, { runId: id, ...evidence });
+			},
 			onFailed: (id, message) => projection.evidenceBuildFailed(id, message),
 		});
 		pendingBuilds.add(build);

package/src/domains/observability/projection.ts

@@ -17,8 +17,10 @@
  */
 
 import { BusChannels } from "../../core/bus-events.js";
+import { resolveDispatchFailureStatus } from "../../core/dispatch-outcome.js";
 import type { SafeEventBus } from "../../core/event-bus.js";
 import type { TargetStatus } from "../providers/contract.js";
+import { resolveCostProvenance } from "../providers/types/cost-provenance.js";
 import type { AccountabilitySummary } from "./accountability.js";
 import type {
 	ObservabilityNotice,
@@ -94,17 +96,6 @@ function resolveHeartbeat(status: unknown): ObservabilityRunSummary["status"] |
 	return null;
 }
 
-/** Map a DispatchFailed outcome/reason to a summary status, mirroring the board. */
-function resolveFailedStatus(reason: unknown): ObservabilityRunSummary["status"] {
-	if (reason === "dead" || reason === "stalled") return "dead";
-	if (reason === "interrupted" || reason === "canceled") return "aborted";
-	return "failed";
-}
-
-function normalizeLevel(value: unknown): ObservabilityNotice["level"] {
-	return value === "error" || value === "warning" || value === "info" ? value : "info";
-}
-
 /** Build a notice ref from candidate parts, dropping anything non-string/empty. */
 function makeRef(parts: Record<string, unknown>): ObservabilityNotice["ref"] | undefined {
 	const ref: Record<string, string> = {};
@@ -216,22 +207,20 @@ export function createObservabilityProjection(bus: SafeEventBus, deps: Projectio
 		if (typeof id.runtimeKind === "string" && id.runtimeKind.length > 0) summary.runtimeKind = id.runtimeKind;
 	}
 
+	// num()'s Number.isFinite check matters here specifically: a NaN or
+	// Infinity costUsd/tokenCount from a payload used to pass the bare
+	// `typeof === "number"` check this function had instead, so the projection
+	// could corrupt a run's running total on a malformed terminal payload while
+	// the dispatch board's parseFiniteNumber (an identical check) rejected it.
 	function applyTerminalTokens(summary: ObservabilityRunSummary, payload: Record<string, unknown>): void {
-		if (typeof payload.tokenCount === "number") summary.tokens.total = payload.tokenCount;
+		summary.tokens.total = num(payload.tokenCount, summary.tokens.total);
 		if (typeof payload.inputTokenCount === "number") {
-			summary.tokens.input = payload.inputTokenCount + num(payload.cacheReadTokenCount, 0);
-		}
-		if (typeof payload.outputTokenCount === "number") summary.tokens.output = payload.outputTokenCount;
-		if (typeof payload.reasoningTokenCount === "number") summary.tokens.reasoning = payload.reasoningTokenCount;
-		if (typeof payload.costUsd === "number") summary.costUsd = payload.costUsd;
-		if (
-			payload.costProvenance === "known" ||
-			payload.costProvenance === "known_free" ||
-			payload.costProvenance === "estimated" ||
-			payload.costProvenance === "unknown"
-		) {
-			summary.costProvenance = payload.costProvenance;
+			summary.tokens.input = num(payload.inputTokenCount, summary.tokens.input) + num(payload.cacheReadTokenCount, 0);
 		}
+		summary.tokens.output = num(payload.outputTokenCount, summary.tokens.output);
+		summary.tokens.reasoning = num(payload.reasoningTokenCount, summary.tokens.reasoning);
+		summary.costUsd = num(payload.costUsd, summary.costUsd);
+		summary.costProvenance = resolveCostProvenance(payload.costProvenance, summary.costProvenance);
 	}
 
 	function pushNotice(
@@ -337,7 +326,7 @@ export function createObservabilityProjection(bus: SafeEventBus, deps: Projectio
 			const now = Date.now();
 			const summary = runs.get(runId) ?? emptyRun(runId, now);
 			applyIdentity(summary, payload);
-			summary.status = resolveFailedStatus(payload.reason);
+			summary.status = resolveDispatchFailureStatus(payload.reason);
 			summary.updatedAtMs = now;
 			summary.finishedAtMs = now;
 			summary.durationMs = num(payload.durationMs, Math.max(0, now - summary.startedAtMs));
@@ -355,71 +344,6 @@ export function createObservabilityProjection(bus: SafeEventBus, deps: Projectio
 			providerHealth.set(payload.id, payload.status as TargetStatus);
 			markChanged();
 		}),
-		bus.on(BusChannels.RuntimeNotice, (raw: unknown) => {
-			const payload = (raw ?? {}) as Record<string, unknown>;
-			pushNotice(
-				"runtime",
-				normalizeLevel(payload.level),
-				str(payload.message, "runtime notice"),
-				makeRef({ targetId: payload.targetId, modelId: payload.model }),
-			);
-		}),
-		bus.on(BusChannels.MiddlewareHookFailed, (raw: unknown) => {
-			const payload = (raw ?? {}) as Record<string, unknown>;
-			const kind = payload.kind;
-			// Mirror the interactive notice policy: every crashed hook surfaces, but
-			// a budget overrun only surfaces once it is steady-state slowness.
-			if (kind === "budget_exceeded" && payload.steadyStateWarn !== true) return;
-			const hook = str(payload.hook, "hook");
-			const message =
-				typeof payload.message === "string" && payload.message.length > 0
-					? payload.message
-					: kind === "budget_exceeded"
-						? `middleware hook ${hook} exceeded ${num(payload.budgetMs, 0)}ms budget`
-						: `middleware hook ${hook} failed`;
-			pushNotice("middleware", kind === "budget_exceeded" ? "warning" : "error", message);
-		}),
-		bus.on(BusChannels.SafetyBlocked, (raw: unknown) => {
-			const payload = (raw ?? {}) as Record<string, unknown>;
-			const tool = str(payload.tool, "tool");
-			const rejection = (payload.rejection ?? {}) as { short?: unknown };
-			const short = str(rejection.short, `${str(payload.actionClass, "action")} blocked`);
-			pushNotice("safety", "warning", `${tool}: ${short}`, makeRef({ tool: payload.tool }));
-		}),
-		bus.on(BusChannels.LoopBlocked, (raw: unknown) => {
-			const payload = (raw ?? {}) as Record<string, unknown>;
-			const tool = str(payload.tool, "tool");
-			pushNotice(
-				"loop",
-				payload.interrupted === true ? "error" : "warning",
-				`loop guard blocked repeated ${tool} (${num(payload.repeatCount, 0)}x)`,
-				makeRef({ tool: payload.tool }),
-			);
-		}),
-		bus.on(BusChannels.ToolBudgetExceeded, (raw: unknown) => {
-			const payload = (raw ?? {}) as Record<string, unknown>;
-			const tool = str(payload.tool, "tool");
-			pushNotice(
-				"tool-budget",
-				payload.interrupted === true ? "error" : "warning",
-				`tool-call budget reached on ${tool} (${num(payload.callsThisTurn, 0)} calls)`,
-				makeRef({ tool: payload.tool }),
-			);
-		}),
-		bus.on(BusChannels.ContextPruned, (raw: unknown) => {
-			const payload = (raw ?? {}) as Record<string, unknown>;
-			const reclaimed = Math.max(0, num(payload.tokensBefore, 0) - num(payload.tokensAfter, 0));
-			pushNotice("context", "info", `context pruned ${reclaimed} tokens (${str(payload.stage, "prune")})`);
-		}),
-		bus.on(BusChannels.BudgetAlert, (raw: unknown) => {
-			const payload = (raw ?? {}) as Record<string, unknown>;
-			const over = payload.level === "over";
-			pushNotice(
-				"budget",
-				over ? "error" : "warning",
-				`session cost $${num(payload.currentUsd, 0).toFixed(2)} ${over ? "over" : "at"} $${num(payload.ceilingUsd, 0).toFixed(2)} ceiling`,
-			);
-		}),
 	];
 
 	return {