@iowarp/clio-coder 0.4.1 → 0.4.3

package/src/cli/usage.ts

@@ -8,6 +8,7 @@ import {
 } from "../core/response-model-id.js";
 import { clioDataDir, clioStateDir } from "../core/xdg.js";
 import { loadMemoryRecordsSync, type MemoryRecord } from "../domains/memory/index.js";
+import { summarizeFailedCompactionUsage } from "../domains/observability/compaction-usage.js";
 import { readEvidenceIndex } from "../domains/observability/evidence-index.js";
 import { type OutOfTurnUsageRow, readOutOfTurnUsageRows } from "../domains/observability/out-of-turn-usage.js";
 import { loadSkills } from "../domains/resources/index.js";
@@ -119,18 +120,32 @@ interface CallOrigins {
 	handoffs: number;
 	prewarms: number;
 	backgroundMemory: number;
+	failedCompaction: number;
 }
 
 function emptyCallOrigins(): CallOrigins {
-	return { rows: 0, sideQuestions: 0, handoffs: 0, prewarms: 0, backgroundMemory: 0 };
+	return { rows: 0, sideQuestions: 0, handoffs: 0, prewarms: 0, backgroundMemory: 0, failedCompaction: 0 };
 }
 
 function turnsOf(origins: CallOrigins): number {
-	return origins.rows - origins.sideQuestions - origins.handoffs - origins.prewarms - origins.backgroundMemory;
+	return (
+		origins.rows -
+		origins.sideQuestions -
+		origins.handoffs -
+		origins.prewarms -
+		origins.backgroundMemory -
+		origins.failedCompaction
+	);
 }
 
 function hasLabelledCall(origins: CallOrigins): boolean {
-	return origins.sideQuestions > 0 || origins.handoffs > 0 || origins.prewarms > 0 || origins.backgroundMemory > 0;
+	return (
+		origins.sideQuestions > 0 ||
+		origins.handoffs > 0 ||
+		origins.prewarms > 0 ||
+		origins.backgroundMemory > 0 ||
+		origins.failedCompaction > 0
+	);
 }
 
 function addOutOfTurnRow(origins: CallOrigins, row: OutOfTurnUsageRow): void {
@@ -138,6 +153,7 @@ function addOutOfTurnRow(origins: CallOrigins, row: OutOfTurnUsageRow): void {
 	if (row.label === "side-question") origins.sideQuestions += 1;
 	else if (row.label === "prewarm") origins.prewarms += 1;
 	else if (row.label === "background-memory") origins.backgroundMemory += 1;
+	else if (row.label === "failed-compaction") origins.failedCompaction += 1;
 	else origins.handoffs += 1;
 }
 
@@ -148,16 +164,32 @@ function outOfTurnUsageCall(row: OutOfTurnUsageRow): LedgerUsageCall {
 		attributedModelId: row.attributedModelId,
 		requestedModelId: row.attributedModelId,
 		responseModelIdObservation: { state: "not-observed" },
-		input: row.usage.input,
-		output: row.usage.output,
-		cacheRead: row.usage.cacheRead,
-		cacheWrite: row.usage.cacheWrite,
-		reasoningTokens: row.usage.reasoning,
-		totalTokens: row.usage.totalTokens,
-		costUsd: row.usage.costUsd,
+		input: row.usage.input ?? 0,
+		output: row.usage.output ?? 0,
+		cacheRead: row.usage.cacheRead ?? 0,
+		cacheWrite: row.usage.cacheWrite ?? 0,
+		reasoningTokens: row.usage.reasoning ?? 0,
+		totalTokens: row.usage.totalTokens ?? 0,
+		costUsd: row.usage.costUsd ?? 0,
 	};
 }
 
+/** Existing numeric accumulators sum known contributions; the report retains missing coverage. */
+function reportedUsageTotals(totals: UsageTotals, rows: ReadonlyArray<OutOfTurnUsageRow>) {
+	const failedCompaction = summarizeFailedCompactionUsage(rows);
+	if (failedCompaction.calls === 0) return totals;
+	const reported: Record<string, unknown> = { ...totals, knownSubtotals: true, failedCompaction };
+	for (const [field, missing] of Object.entries(failedCompaction.unobservedUsageCalls)) {
+		const key = field === "reasoning" ? "reasoningTokens" : field;
+		if (missing > 0 && reported[key] === 0) reported[key] = null;
+	}
+	return reported;
+}
+
+function usageAmount(value: unknown): string {
+	return typeof value === "number" ? String(value) : "unknown";
+}
+
 function addUsageCall(totals: UsageTotals, call: LedgerUsageCall): void {
 	totals.apiCalls += call.apiCalls ?? 1;
 	totals.input += call.input;
@@ -442,6 +474,8 @@ export async function runUsageCommand(argv: ReadonlyArray<string>): Promise<numb
 	// session store is gone can still have recorded out-of-turn spend, and
 	// dropping those rows would report money that was spent as nothing at all.
 	const usageMeasurable = presence.sessionsPresent || outOfTurnRows.length > 0;
+	const reportedTotals = reportedUsageTotals(usageTotals, outOfTurnRows);
+	const failedCompaction = summarizeFailedCompactionUsage(outOfTurnRows);
 	const usageRows = [...usageByModel.values()].sort(
 		(a, b) => b.totals.totalTokens - a.totals.totalTokens || a.providerId.localeCompare(b.providerId),
 	);
@@ -533,7 +567,7 @@ export async function runUsageCommand(argv: ReadonlyArray<string>): Promise<numb
 			emit({
 				kind: "fact",
 				fact: "tokens",
-				...usageTotals,
+				...reportedTotals,
 				...(hasLabelledCall(callOrigins)
 					? {
 							turns: turnsOf(callOrigins),
@@ -541,6 +575,7 @@ export async function runUsageCommand(argv: ReadonlyArray<string>): Promise<numb
 							handoffs: callOrigins.handoffs,
 							prewarms: callOrigins.prewarms,
 							backgroundMemorySteps: callOrigins.backgroundMemory,
+							...(callOrigins.failedCompaction > 0 ? { failedCompactionCalls: callOrigins.failedCompaction } : {}),
 						}
 					: {}),
 			});
@@ -552,7 +587,12 @@ export async function runUsageCommand(argv: ReadonlyArray<string>): Promise<numb
 					attributedModelId: row.attributedModelId,
 					requestedModelIds: [...row.requestedModelIds].sort(),
 					responseModelIdObservationCounts: row.responseModelIdObservationCounts,
-					...row.totals,
+					...reportedUsageTotals(
+						row.totals,
+						outOfTurnRows.filter(
+							(call) => call.target === row.providerId && call.attributedModelId === row.attributedModelId,
+						),
+					),
 				});
 			}
 			for (const session of cacheSessions) {
@@ -615,7 +655,7 @@ export async function runUsageCommand(argv: ReadonlyArray<string>): Promise<numb
 	out(`  audited tool calls in window: ${auditToolCalls.length} (${auditBlocked.length} blocked/denied)`);
 	if (usageMeasurable) {
 		out(
-			`  tokens in window: ${usageTotals.totalTokens} over ${usageTotals.apiCalls} model calls (input ${usageTotals.input}, output ${usageTotals.output}, cache read ${usageTotals.cacheRead}, cache write ${usageTotals.cacheWrite}, reasoning ${usageTotals.reasoningTokens})`,
+			`  tokens in window: ${usageAmount(reportedTotals.totalTokens)} over ${usageTotals.apiCalls} model calls (input ${usageAmount(reportedTotals.input)}, output ${usageAmount(reportedTotals.output)}, cache read ${usageAmount(reportedTotals.cacheRead)}, cache write ${usageAmount(reportedTotals.cacheWrite)}, reasoning ${usageAmount(reportedTotals.reasoningTokens)})`,
 		);
 		if (hasLabelledCall(callOrigins)) {
 			// Only printed when a labelled call is in the window. Over an archive
@@ -629,7 +669,18 @@ export async function runUsageCommand(argv: ReadonlyArray<string>): Promise<numb
 				out(`  background memory steps in window: ${callOrigins.backgroundMemory}`);
 			}
 		}
-		out(`  provider-reported cost in window: $${usageTotals.costUsd.toFixed(4)}`);
+		if (failedCompaction.calls > 0) {
+			out(
+				`  failed-compaction streams: ${failedCompaction.calls} (${failedCompaction.erroredCalls} errored, ${failedCompaction.abortedCalls} aborted, ${failedCompaction.successfulCalls} completed before the attempt failed)`,
+			);
+			out("  usage figures are known subtotals; missing compaction usage is not zero or a complete spending bound");
+			out(
+				`  errored compaction known cost: ${failedCompaction.erroredKnownUsage.costUsd === null ? "unknown" : `$${failedCompaction.erroredKnownUsage.costUsd.toFixed(4)}`}`,
+			);
+		}
+		out(
+			`  ${failedCompaction.calls > 0 ? "known reported/estimated" : "provider-reported"} cost in window: ${typeof reportedTotals.costUsd === "number" ? `$${reportedTotals.costUsd.toFixed(4)}` : "unknown"}`,
+		);
 	}
 	if (usageRows.length > 0) {
 		out("");
@@ -650,19 +701,27 @@ export async function runUsageCommand(argv: ReadonlyArray<string>): Promise<numb
 						"tokens",
 						"cost",
 					],
-					...usageRows.map((row) => [
-						row.providerId,
-						row.attributedModelId,
-						[...row.requestedModelIds].sort().join(","),
-						responseModelIdObservationCountsLabel(row.responseModelIdObservationCounts),
-						String(row.totals.apiCalls),
-						String(row.totals.input),
-						String(row.totals.output),
-						String(row.totals.cacheRead),
-						String(row.totals.reasoningTokens),
-						String(row.totals.totalTokens),
-						`$${row.totals.costUsd.toFixed(4)}`,
-					]),
+					...usageRows.map((row) => {
+						const reported = reportedUsageTotals(
+							row.totals,
+							outOfTurnRows.filter(
+								(call) => call.target === row.providerId && call.attributedModelId === row.attributedModelId,
+							),
+						);
+						return [
+							row.providerId,
+							row.attributedModelId,
+							[...row.requestedModelIds].sort().join(","),
+							responseModelIdObservationCountsLabel(row.responseModelIdObservationCounts),
+							String(row.totals.apiCalls),
+							usageAmount(reported.input),
+							usageAmount(reported.output),
+							usageAmount(reported.cacheRead),
+							usageAmount(reported.reasoningTokens),
+							usageAmount(reported.totalTokens),
+							typeof reported.costUsd === "number" ? `$${reported.costUsd.toFixed(4)}` : "unknown",
+						];
+					}),
 				]),
 			),
 		);

package/src/cli/validate-model.ts

@@ -15,9 +15,8 @@ export interface ValidateModelInput {
 	modelId: string;
 	knownModels: ReadonlyArray<string>;
 	/**
-	 * The live list, when one was fetched. It is consulted only when the static
-	 * catalog is empty, so the catalog stays the authority for cloud runtimes
-	 * and the probe becomes the authority where there is nothing else.
+	 * The live list, when one was fetched. Callers provide it only when that
+	 * runtime declares live discovery authoritative for the concrete target.
 	 */
 	live?: LiveModelInventory | undefined;
 	force: boolean;
@@ -50,6 +49,7 @@ function formatUnadvertisedModelReason(modelId: string, live: LiveModelInventory
 
 export function validateModelChoice(input: ValidateModelInput): ValidateModelResult {
 	const { runtimeId, modelId, knownModels, live, force } = input;
+	if (live !== undefined) return validateAgainstLive(modelId, live, force);
 	if (knownModels.length === 0) return validateAgainstLive(modelId, live, force);
 	if (knownModels.includes(modelId)) return { ok: true };
 	if (force) {

package/src/cli/wiki-generate.ts

@@ -236,7 +236,7 @@ async function runWikiDispatch(input: {
 	} catch (err) {
 		return { ok: false, detail: err instanceof Error ? err.message : String(err) };
 	}
-	const deadline = armInternalDispatchDeadline(input.dispatch, handle.runId, input.label, process.env, input.deadlineMs);
+	const deadline = armInternalDispatchDeadline(input.dispatch, handle.runId, input.label, input.deadlineMs);
 	let lastHeartbeatAt = startedAtClock;
 	try {
 		const summary = await drainDispatchEvents(handle.events, (tools) => {

package/src/core/artifact-paths.ts

@@ -15,7 +15,7 @@
  * be checking a path the tool never writes. One artifact per kind is therefore
  * the contract; keep several by passing explicit paths.
  *
- * See docs/artifact-placement.md for the full taxonomy.
+ * See docs/architecture/artifact-placement.md for the full taxonomy.
  */
 
 /** Project-local directory holding everything Clio generates for one repo. */

package/src/core/bash-exec.ts

@@ -18,7 +18,7 @@ export { clampTimerDelayMs as clampTimeoutMs } from "./timers.js";
 // (failing assertion, compiler error, exit summary) must survive.
 export const BASH_HARD_CAP_BYTES = 16 * 1024 * 1024;
 
-const CLIO_CONTROL_ENV_KEYS = ["CLIO_CODER_INTERACTIVE", "CLIO_CODER_RESUME_SESSION_ID"] as const;
+const CLIO_CONTROL_ENV_KEYS = ["CLIO_CODER_INTERACTIVE"] as const;
 
 export interface BashCommandResult {
 	error: NodeJS.ErrnoException | null;
@@ -52,6 +52,129 @@ export interface RunBashCommandOptions {
 
 const BASH_UPDATE_THROTTLE_MS = 100;
 
+export interface BashProgressScheduler {
+	now(): number;
+	setTimeout(callback: () => void, delayMs: number): unknown;
+	clearTimeout(timer: unknown): void;
+}
+
+export interface BashOutputProgressController {
+	/** Emit the initial empty cumulative snapshot, when a callback is configured. */
+	start(): void;
+	/** Accept one stream chunk. Returns true only when this chunk reaches the hard cap. */
+	append(target: "stdout" | "stderr", chunk: Buffer): boolean;
+	/** Seal output, cancel progress work, emit the final snapshot, and return the result fields. */
+	settle(): Pick<BashCommandResult, "stdout" | "stderr" | "outputBytes" | "outputCapped">;
+}
+
+const SYSTEM_PROGRESS_SCHEDULER: BashProgressScheduler = {
+	now: Date.now,
+	setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+	clearTimeout: (timer) => clearTimeout(timer as ReturnType<typeof setTimeout>),
+};
+
+/**
+ * Cumulative stdout/stderr fold shared by the child stream handlers and a
+ * deterministic contract-test seam. Settlement is a phase, not just a final
+ * boolean: once it starts, re-entrant or queued stream work is rejected while
+ * the one final advisory snapshot is still allowed to publish.
+ */
+export function createBashOutputProgressController(
+	onUpdate?: (progress: BashCommandProgress) => void,
+	scheduler: BashProgressScheduler = SYSTEM_PROGRESS_SCHEDULER,
+): BashOutputProgressController {
+	let phase: "active" | "settling" | "settled" = "active";
+	let stdout = "";
+	let stderr = "";
+	const stdoutDecoder = new StringDecoder("utf8");
+	const stderrDecoder = new StringDecoder("utf8");
+	let decodersFinished = false;
+	let outputBytes = 0;
+	let outputCapped = false;
+	let updateTimer: unknown = null;
+	let updateDirty = false;
+	let lastUpdateAt = 0;
+
+	const snapshot = (): BashCommandProgress => ({ stdout, stderr, outputBytes });
+
+	const finishDecoders = (): void => {
+		if (decodersFinished) return;
+		decodersFinished = true;
+		// A hard byte cap may bisect a multibyte code point. Discard the
+		// decoder's incomplete suffix instead of manufacturing U+FFFD.
+		if (outputCapped) return;
+		stdout += stdoutDecoder.end();
+		stderr += stderrDecoder.end();
+	};
+
+	const emitUpdate = (final = false): void => {
+		if (onUpdate === undefined || !updateDirty) return;
+		if (phase !== "active" && !(final && phase === "settling")) return;
+		updateDirty = false;
+		lastUpdateAt = scheduler.now();
+		try {
+			onUpdate(snapshot());
+		} catch {
+			// Rendering progress is advisory and must never change command execution.
+		}
+	};
+
+	const clearUpdateTimer = (): void => {
+		if (updateTimer === null) return;
+		scheduler.clearTimeout(updateTimer);
+		updateTimer = null;
+	};
+
+	const scheduleUpdate = (): void => {
+		if (onUpdate === undefined || phase !== "active") return;
+		updateDirty = true;
+		const delay = BASH_UPDATE_THROTTLE_MS - (scheduler.now() - lastUpdateAt);
+		if (delay <= 0) {
+			clearUpdateTimer();
+			emitUpdate();
+			return;
+		}
+		updateTimer ??= scheduler.setTimeout(() => {
+			updateTimer = null;
+			// A timer already queued by the event loop may still invoke its callback
+			// after clearTimeout. The phase check makes that callback inert.
+			emitUpdate();
+		}, delay);
+	};
+
+	return {
+		start(): void {
+			if (phase !== "active" || onUpdate === undefined) return;
+			updateDirty = true;
+			emitUpdate();
+		},
+		append(target, chunk): boolean {
+			if (phase !== "active" || outputCapped) return false;
+			const remaining = BASH_HARD_CAP_BYTES - outputBytes;
+			const accepted = chunk.byteLength <= remaining ? chunk : chunk.subarray(0, Math.max(0, remaining));
+			outputBytes += accepted.byteLength;
+			if (accepted.byteLength > 0) {
+				const decoded = target === "stdout" ? stdoutDecoder.write(accepted) : stderrDecoder.write(accepted);
+				if (target === "stdout") stdout += decoded;
+				else stderr += decoded;
+			}
+			if (accepted.byteLength < chunk.byteLength) outputCapped = true;
+			scheduleUpdate();
+			return outputCapped;
+		},
+		settle() {
+			if (phase === "settled") return { ...snapshot(), outputCapped };
+			if (phase === "settling") return { ...snapshot(), outputCapped };
+			phase = "settling";
+			clearUpdateTimer();
+			finishDecoders();
+			emitUpdate(true);
+			phase = "settled";
+			return { ...snapshot(), outputCapped };
+		},
+	};
+}
+
 function buildToolEnv(): NodeJS.ProcessEnv {
 	const env = { ...process.env };
 	env.AI_AGENT = AI_AGENT_NAME;
@@ -152,16 +275,7 @@ export async function runBashCommand(command: string, options: RunBashCommandOpt
 		let timeoutId: ReturnType<typeof setTimeout> | null = null;
 		let killGraceTimer: ReturnType<typeof setTimeout> | null = null;
 		let killSent = false;
-		let stdout = "";
-		let stderr = "";
-		const stdoutDecoder = new StringDecoder("utf8");
-		const stderrDecoder = new StringDecoder("utf8");
-		let decodersFinished = false;
-		let outputBytes = 0;
-		let outputCapped = false;
-		let updateTimer: ReturnType<typeof setTimeout> | null = null;
-		let updateDirty = false;
-		let lastUpdateAt = 0;
+		const output = createBashOutputProgressController(options.onUpdate);
 
 		const child = spawn("/bin/bash", [plan.mode, command], {
 			...(options.cwd === undefined ? {} : { cwd: options.cwd }),
@@ -170,53 +284,7 @@ export async function runBashCommand(command: string, options: RunBashCommandOpt
 			stdio: ["ignore", "pipe", "pipe"],
 		});
 
-		const finishDecoders = (): void => {
-			if (decodersFinished) return;
-			decodersFinished = true;
-			// A hard byte cap may bisect a multibyte code point. Discard the
-			// decoder's incomplete suffix instead of manufacturing U+FFFD.
-			if (outputCapped) return;
-			stdout += stdoutDecoder.end();
-			stderr += stderrDecoder.end();
-		};
-
-		const emitUpdate = (): void => {
-			if (options.onUpdate === undefined || !updateDirty) return;
-			updateDirty = false;
-			lastUpdateAt = Date.now();
-			try {
-				options.onUpdate({ stdout, stderr, outputBytes: Math.min(outputBytes, BASH_HARD_CAP_BYTES) });
-			} catch {
-				// Rendering progress is advisory and must never change command execution.
-			}
-		};
-		const clearUpdateTimer = (): void => {
-			if (updateTimer === null) return;
-			clearTimeout(updateTimer);
-			updateTimer = null;
-		};
-		const scheduleUpdate = (): void => {
-			if (options.onUpdate === undefined) return;
-			updateDirty = true;
-			const delay = BASH_UPDATE_THROTTLE_MS - (Date.now() - lastUpdateAt);
-			if (delay <= 0) {
-				clearUpdateTimer();
-				emitUpdate();
-				return;
-			}
-			updateTimer ??= setTimeout(() => {
-				updateTimer = null;
-				emitUpdate();
-			}, delay);
-		};
-		const finishUpdates = (): void => {
-			clearUpdateTimer();
-			emitUpdate();
-		};
-		if (options.onUpdate !== undefined) {
-			updateDirty = true;
-			emitUpdate();
-		}
+		output.start();
 
 		const clearKillGraceTimer = (): void => {
 			if (!killGraceTimer) return;
@@ -265,22 +333,7 @@ export async function runBashCommand(command: string, options: RunBashCommandOpt
 		}
 
 		const appendChunk = (target: "stdout" | "stderr", chunk: Buffer): void => {
-			if (outputCapped) return;
-			const remaining = BASH_HARD_CAP_BYTES - outputBytes;
-			const accepted = chunk.byteLength <= remaining ? chunk : chunk.subarray(0, Math.max(0, remaining));
-			outputBytes += accepted.byteLength;
-			if (accepted.byteLength > 0) {
-				const decoded = target === "stdout" ? stdoutDecoder.write(accepted) : stderrDecoder.write(accepted);
-				if (target === "stdout") stdout += decoded;
-				else stderr += decoded;
-			}
-			if (accepted.byteLength < chunk.byteLength) {
-				outputCapped = true;
-				scheduleUpdate();
-				killChild();
-				return;
-			}
-			scheduleUpdate();
+			if (output.append(target, chunk)) killChild();
 		};
 
 		child.stdout?.on("data", (chunk: Buffer) => appendChunk("stdout", chunk));
@@ -290,19 +343,15 @@ export async function runBashCommand(command: string, options: RunBashCommandOpt
 			settled = true;
 			if (timeoutId) clearTimeout(timeoutId);
 			clearKillGraceTimer();
-			finishDecoders();
-			finishUpdates();
+			const finalOutput = output.settle();
 			options.signal?.removeEventListener("abort", onAbort);
 			resolve({
 				error: error as NodeJS.ErrnoException,
-				stdout,
-				stderr,
+				...finalOutput,
 				exitCode: null,
 				signal: null,
 				aborted,
 				timedOut,
-				outputCapped,
-				outputBytes,
 			});
 		});
 		child.on("close", (code, signalName) => {
@@ -310,8 +359,7 @@ export async function runBashCommand(command: string, options: RunBashCommandOpt
 			settled = true;
 			if (timeoutId) clearTimeout(timeoutId);
 			clearKillGraceTimer();
-			finishDecoders();
-			finishUpdates();
+			const finalOutput = output.settle();
 			options.signal?.removeEventListener("abort", onAbort);
 			const error =
 				code === 0 && signalName === null
@@ -324,14 +372,11 @@ export async function runBashCommand(command: string, options: RunBashCommandOpt
 						} as NodeJS.ErrnoException);
 			resolve({
 				error,
-				stdout,
-				stderr,
+				...finalOutput,
 				exitCode: code,
 				signal: signalName,
 				aborted,
 				timedOut,
-				outputCapped,
-				outputBytes,
 			});
 		});
 	});

package/src/core/bus-events.ts

@@ -24,6 +24,7 @@ import type {
 	ToolActivitySummary,
 } from "../domains/dispatch/types.js";
 import type { MiddlewareHook } from "../domains/middleware/types.js";
+import type { ObservabilityRunEvidence } from "../domains/observability/contract.js";
 import type { TargetStatus } from "../domains/providers/contract.js";
 import type { CostProvenance } from "../domains/providers/index.js";
 import type { ClioSettings } from "./config.js";
@@ -58,9 +59,11 @@ export const BusChannels = {
 	DispatchProgress: "dispatch.progress",
 	DispatchCompleted: "dispatch.completed",
 	DispatchFailed: "dispatch.failed",
+	AccountabilityEvidenceReady: "accountability.evidenceReady",
 	CompactionBegin: "compaction.begin",
 	CompactionEnd: "compaction.end",
 	MiddlewareHookFailed: "middleware.hookFailed",
+	ExtensionsReloaded: "extensions.reloaded",
 	ContextActivity: "context.activity",
 	ContextWarning: "context.warning",
 	ContextPruned: "context.pruned",
@@ -628,8 +631,8 @@ export interface DispatchTerminalStats {
 	exitCode: number;
 	/** Honest activity record aggregated from the run's tool telemetry; null when the receipt predates it. */
 	toolActivity: ToolActivitySummary | null;
-	/** Host-run declared verification status when the request included checks. */
-	hostVerification?: "verified" | "rejected" | "skipped";
+	/** Host-run declared verification status when the request included checks; `not_implicated` is a batch member the failure was charged away from. */
+	hostVerification?: "verified" | "rejected" | "skipped" | "not_implicated";
 }
 
 /** Published on {@link BusChannels.DispatchCompleted} when a run finalizes as succeeded. */
@@ -667,6 +670,24 @@ export interface DispatchFailedPayload extends DispatchRunIdentity, Partial<Disp
 	skillActivations?: ReadonlyArray<SkillActivation>;
 }
 
+// ---------------------------------------------------------------------------
+// Accountability
+// ---------------------------------------------------------------------------
+
+/**
+ * Published on {@link BusChannels.AccountabilityEvidenceReady} by the
+ * observability extension once a finalized run's evidence bundle and its
+ * sidecar index row have landed. The evidence fields are exactly
+ * {@link ObservabilityRunEvidence}, the shape the projection already attaches
+ * to the run summary, so the bus and the snapshot cannot describe the same
+ * moment two ways. A failed build publishes nothing here: the projection's
+ * notice is the failure surface, and a client that never receives this event
+ * has learned only that no bundle is ready, which is the truth.
+ */
+export interface AccountabilityEvidenceReadyPayload extends ObservabilityRunEvidence {
+	runId: string;
+}
+
 // ---------------------------------------------------------------------------
 // Compaction
 // ---------------------------------------------------------------------------
@@ -677,6 +698,26 @@ export interface CompactionPayload {
 	at: number;
 }
 
+// ---------------------------------------------------------------------------
+// Extensions
+// ---------------------------------------------------------------------------
+
+/**
+ * Published on {@link BusChannels.ExtensionsReloaded} by the composition
+ * root after a new extension generation and its user-hook registrations
+ * have both been committed. Consumers that cache extension-sourced data
+ * (prompt fragments, agent recipes, the session prompt) refresh on
+ * `changed`; an unchanged generation carries the previous digest and needs
+ * no work. Never published between the two commits.
+ */
+export interface ExtensionsReloadedPayload {
+	generation: number;
+	previousGeneration: number;
+	changed: boolean;
+	/** Content identity of the committed snapshot. */
+	digest: string;
+}
+
 // ---------------------------------------------------------------------------
 // Middleware
 // ---------------------------------------------------------------------------
@@ -685,15 +726,17 @@ export interface CompactionPayload {
  * Published on {@link BusChannels.MiddlewareHookFailed} when a middleware hook
  * registration misbehaves: `hook_failed` for a thrown evaluate (its effects
  * are discarded and the turn proceeds), `budget_exceeded` for a soft
- * wall-time overrun (effects still apply). Diagnostics only; nothing
- * subscribing here may decide anything.
+ * wall-time overrun (effects still apply), `registration_conflict` when an
+ * owned registration set (user hooks) offered an id a builtin or host
+ * registration holds, or a host registration evicted an owned one.
+ * Diagnostics only; nothing subscribing here may decide anything.
  */
 export interface MiddlewareHookFailedPayload {
-	kind: "hook_failed" | "budget_exceeded";
+	kind: "hook_failed" | "budget_exceeded" | "registration_conflict";
 	registrationId: string;
 	hook: MiddlewareHook;
 	at: number;
-	/** Error text; hook_failed only. */
+	/** Error text for hook_failed; one formatted line for registration_conflict. */
 	message?: string | undefined;
 	/** Measured and allowed wall time in ms; budget_exceeded only. */
 	elapsedMs?: number | undefined;
@@ -798,9 +841,11 @@ export type BusPayloadMap = {
 	[BusChannels.DispatchProgress]: DispatchProgressPayload;
 	[BusChannels.DispatchCompleted]: DispatchCompletedPayload;
 	[BusChannels.DispatchFailed]: DispatchFailedPayload;
+	[BusChannels.AccountabilityEvidenceReady]: AccountabilityEvidenceReadyPayload;
 	[BusChannels.CompactionBegin]: CompactionPayload;
 	[BusChannels.CompactionEnd]: CompactionPayload;
 	[BusChannels.MiddlewareHookFailed]: MiddlewareHookFailedPayload;
+	[BusChannels.ExtensionsReloaded]: ExtensionsReloadedPayload;
 	[BusChannels.ContextActivity]: ContextActivityPayload;
 	[BusChannels.ContextWarning]: ContextWarningPayload;
 	[BusChannels.ContextPruned]: ContextPrunedPayload;