@iowarp/clio-coder 0.4.1 → 0.4.3

package/src/entry/task-memory-lifecycle.ts

@@ -0,0 +1,35 @@
+import { BusChannels } from "../core/bus-events.js";
+import type { SafeEventBus } from "../core/event-bus.js";
+import type { TaskMemoryStepUsage } from "../domains/memory/task-memory-policy.js";
+import type { MemoryInterventionRegistration } from "../domains/middleware/memory-intervention.js";
+import {
+	type RecordBackgroundMemoryStepInput,
+	recordBackgroundMemoryStep,
+} from "../domains/observability/background-memory-usage.js";
+
+/** Explicit navigation owns memory lifetime; ordinary leaf advances and tree reads do not. */
+export function bindTaskMemoryLifecycle(
+	bus: SafeEventBus,
+	memory: Pick<MemoryInterventionRegistration, "reset" | "dispose">,
+): () => void {
+	const unsubscribe = [
+		bus.on(BusChannels.SessionParked, () => memory.reset()),
+		bus.on(BusChannels.SessionResumed, () => memory.reset()),
+		bus.on(BusChannels.SessionTurnSwitched, () => memory.reset()),
+		bus.on(BusChannels.SessionEnd, () => memory.dispose()),
+	];
+	return () => {
+		memory.dispose();
+		for (const off of unsubscribe) off();
+	};
+}
+
+/** The durable row keeps launch identity even when the live cost tracker has moved on. */
+export function captureTaskMemoryUsage(
+	input: Omit<RecordBackgroundMemoryStepInput, "usage">,
+): (usage: TaskMemoryStepUsage, isCurrent: boolean) => void {
+	const { observability, ...origin } = input;
+	return (usage, isCurrent) => {
+		recordBackgroundMemoryStep({ ...origin, usage, observability: isCurrent ? observability : undefined });
+	};
+}

package/src/interactive/application-controller.ts

@@ -18,11 +18,12 @@ const CLOSED_ACTION_ORDER = [
 	"clio-coder.thinking.expandAll",
 ] as const satisfies ReadonlyArray<ClioKeybinding>;
 
-const GLOBAL_ACTION_ORDER = [
+export const GLOBAL_ACTION_ORDER = [
 	"clio-coder.status.toggle",
 	"clio-coder.thinking.cycle",
 	"clio-coder.session.tree",
 	"clio-coder.dispatchBoard.toggle",
+	"clio-coder.files.toggle",
 	"clio-coder.tasks.open",
 	"clio-coder.decisions.open",
 	"clio-coder.dispatch.background",

package/src/interactive/bus-notices.ts

@@ -72,7 +72,7 @@ function isSafetyBlockedPayload(value: unknown): value is SafetyBlockedPayload {
 function isMiddlewareHookFailedPayload(value: unknown): value is MiddlewareHookFailedPayload {
 	if (!value || typeof value !== "object") return false;
 	const p = value as Record<string, unknown>;
-	if (p.kind !== "hook_failed" && p.kind !== "budget_exceeded") return false;
+	if (p.kind !== "hook_failed" && p.kind !== "budget_exceeded" && p.kind !== "registration_conflict") return false;
 	if (typeof p.registrationId !== "string" || p.registrationId.length === 0) return false;
 	if (typeof p.hook !== "string" || p.hook.length === 0) return false;
 	if (p.message !== undefined && typeof p.message !== "string") return false;
@@ -142,6 +142,13 @@ function middlewareHookFailedNotice(
 	options: MiddlewareHookFailedNoticeOptions = {},
 ): BusNotice | null {
 	if (!isMiddlewareHookFailedPayload(payload)) return null;
+	if (payload.kind === "registration_conflict") {
+		const detail =
+			payload.message !== undefined && payload.message.length > 0
+				? payload.message
+				: `registration '${payload.registrationId}' conflicts with an existing id`;
+		return { level: "warn", text: `[middleware] ${detail}` };
+	}
 	if (payload.kind === "hook_failed") {
 		const detail = payload.message !== undefined && payload.message.length > 0 ? `: ${payload.message}` : "";
 		return {

package/src/interactive/chat-loop-messages.ts

@@ -21,12 +21,13 @@ import {
 } from "../core/response-model-id.js";
 import type { PendingSkillRequest, PendingSkillToolPolicy, SkillDeclaredToolPolicy } from "../core/skill-activation.js";
 import { ToolNames } from "../core/tool-names.js";
-import { canonicalJson, sha256 } from "../domains/prompts/hash.js";
+import { sha256 } from "../domains/prompts/hash.js";
 import { toContextOverflowError } from "../domains/providers/errors.js";
 import type { ResolvedRuntimeTarget } from "../domains/providers/index.js";
 import { ceilChars, extractReasoningTokens } from "../domains/session/context-accounting.js";
 import type { AgentMessage } from "../engine/types.js";
 import type { AskUserToolPolicy } from "../tools/registry.js";
+import { attachedToolSchemaBytes, attachedToolSchemasFromState } from "./prompt-cache-identity.js";
 
 /** Minimal structural view of the engine agent used by state-inspection helpers. */
 export interface AgentStateView {
@@ -291,18 +292,7 @@ export function pendingSkillRequestPreamble(requests: ReadonlyArray<PendingSkill
  * tool-surface change.
  */
 export function toolSignatureFromState(tools: ReadonlyArray<unknown>): string {
-	const schemas: Array<{ name: string; description: string; parameters: unknown }> = [];
-	for (const tool of tools) {
-		if (!tool || typeof tool !== "object" || Array.isArray(tool)) continue;
-		const record = tool as Record<string, unknown>;
-		schemas.push({
-			name: typeof record.name === "string" ? record.name : "",
-			description: typeof record.description === "string" ? record.description : "",
-			parameters: record.parameters ?? null,
-		});
-	}
-	schemas.sort((a, b) => a.name.localeCompare(b.name));
-	return sha256(canonicalJson(schemas));
+	return sha256(attachedToolSchemaBytes(attachedToolSchemasFromState(tools)));
 }
 
 /**
@@ -481,11 +471,11 @@ export function backendCacheVerdict(
 	return classifyCacheUsage(input, cacheRead);
 }
 
-/** Per-API-call latency captured from the agent event stream (T3.2). */
+/** Native stream-invocation latency, measured on one monotonic clock. */
 export interface AssistantCallTiming {
-	/** message_start → first assistant delta; null when no delta arrived. */
+	/** Invocation to first assistant output; null when no output arrived. */
 	ttftMs: number | null;
-	/** message_start → message_end for the same assistant API call. */
+	/** Invocation to message_end for the same assistant API call. */
 	apiMs: number;
 }
 
@@ -500,7 +490,16 @@ export function assistantSessionPayload(
 	if (Array.isArray(raw.content)) payload.content = raw.content;
 	if (thinking.length > 0) payload.thinking = thinking;
 	payload.responseModelIdObservation = responseModelIdObservationFromRecord(raw, "not-observed");
-	for (const key of ["usage", "api", "provider", "model", "responseModel", "responseId", "diagnostics"]) {
+	for (const key of [
+		"usage",
+		"api",
+		"provider",
+		"model",
+		"responseModel",
+		"responseId",
+		"gatewayRouting",
+		"diagnostics",
+	]) {
 		if (raw[key] !== undefined) payload[key] = raw[key];
 	}
 	if (failure && !isSelfExplainingAbort({ stopReason: raw.stopReason, errorMessage: raw.errorMessage, text })) {

package/src/interactive/chat-loop.ts

@@ -16,7 +16,14 @@
 import { BusChannels, type RunAbortSource } from "../core/bus-events.js";
 import type { ClioSettings } from "../core/config.js";
 import type { SafeEventBus } from "../core/event-bus.js";
-import type { PendingSkillRequest } from "../core/skill-activation.js";
+import {
+	armedSkillSurface,
+	type PendingSkillRequest,
+	type PendingSkillToolPolicy,
+	skillSurfaceLabels,
+	skillSurfaceNames,
+	withModelSkillActivation,
+} from "../core/skill-activation.js";
 import { clioStateDir } from "../core/xdg.js";
 import {
 	createMiddlewareToolChoiceControl,
@@ -36,6 +43,7 @@ import {
 	runtimeTargetSnapshot,
 	targetRequiresAuth,
 } from "../domains/providers/index.js";
+import { type AutonomyLevel, modelMayActivateSkills } from "../domains/safety/autonomy.js";
 import type { ProtectedArtifactState } from "../domains/safety/protected-artifacts.js";
 import type { CompactResult } from "../domains/session/compaction/compact.js";
 import type { ContextSnapshot, ContextUsageSnapshot } from "../domains/session/context-accounting.js";
@@ -285,6 +293,12 @@ export interface ChatLoop {
 	 * queues the text for the next slot instead.
 	 */
 	interruptRefusal(): string | null;
+	/**
+	 * `/skill off`: drop the tool surface an activated skill armed, so the next
+	 * turn runs with the full surface again. Returns the skill names that were
+	 * armed, or an empty list when nothing was.
+	 */
+	clearSkillSurface(): ReadonlyArray<string>;
 	clearQueuedFollowUps(): string[];
 	queuedMessages(): QueuedMessagesSnapshot;
 	cancel(options?: ChatCancelOptions): void;
@@ -368,6 +382,12 @@ export interface ChatLoop {
 
 export interface CreateChatLoopDeps {
 	getSettings: () => Readonly<ClioSettings>;
+	/**
+	 * The same effective autonomy level registry admission resolves, so the
+	 * skill-activation gate and the tool gate can never disagree. Absent falls
+	 * back to the settings value.
+	 */
+	getAutonomy?: () => AutonomyLevel;
 	providers: ProvidersContract;
 	/**
 	 * Whitelist of target ids that the chat-loop is allowed to drive. The
@@ -622,6 +642,31 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		emit({ type: "notice", level, surface: "transcript", text, ...(key === undefined ? {} : { key }) });
 	};
 
+	/**
+	 * Carry (or drop) the tool surface a skill declared once the turn that
+	 * loaded it settles, and say so once on the transcript. The operator needs
+	 * to know a narrowing is armed across their next messages, and needs one
+	 * line back when it lifts; the skill-activation ledger entry already
+	 * records provenance, so this is the notice, not a second UI.
+	 */
+	const armSkillSurface = (policy: PendingSkillToolPolicy | undefined, loadedBefore?: ReadonlySet<string>): void => {
+		const previous = skillSurfaceNames(state.activeSkillSurface).join(", ");
+		const next = armedSkillSurface(policy);
+		const current = skillSurfaceNames(next).join(", ");
+		state.activeSkillSurface = next;
+		const activated = skillSurfaceLabels(policy).filter((label) => !loadedBefore?.has(label.split(" ")[0] ?? label));
+		if (activated.length > 0) {
+			emitNotice(
+				current.length > 0
+					? `[Clio Coder] Skill activated: ${activated.join(", ")}. Its tool surface stays armed across your next turns until another skill replaces it or you run /skill off.`
+					: `[Clio Coder] Skill activated: ${activated.join(", ")}. It declares no tool narrowing.`,
+			);
+		}
+		if (current !== previous && current.length === 0 && previous.length > 0) {
+			emitNotice(`[Clio Coder] Skill tool surface cleared: ${previous}. The full tool surface is back.`);
+		}
+	};
+
 	/**
 	 * The same transcript notice every admission exit already emitted, carrying
 	 * the reason the turn never started. Text, level, and surface are unchanged,
@@ -648,7 +693,9 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 	const retrySettings = (): RetrySettings => normalizeRetrySettings(deps.getSettings().chat.retry);
 
 	const currentToolInvokeOptions = (): Partial<ToolInvokeOptions> => {
-		const options: Partial<ToolInvokeOptions> = {};
+		const options: Partial<ToolInvokeOptions> = {
+			toolResultMaxBytes: deps.getSettings().context.toolResultMaxBytes,
+		};
 		const sessionId = deps.session?.current()?.id ?? null;
 		if (sessionId) options.sessionId = sessionId;
 		const turnId = state.activeUserTurnId ?? state.lastTurnId;
@@ -743,6 +790,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		context,
 		middleware,
 		retrySettings,
+		sessionId: () => deps.session?.current()?.id,
 		emit: emitRuntimeEvent,
 		emitNotice,
 		toolStartTimes,
@@ -764,6 +812,12 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		deps.bus?.on(BusChannels.ConfigHotReload, () => {
 			context.invalidateSessionPromptCache();
 		}) ?? null;
+	// A committed extension generation with new content can change the skill
+	// and prompt inputs the session prompt compiles from; same invalidation.
+	const unsubscribeExtensionsReload =
+		deps.bus?.on(BusChannels.ExtensionsReloaded, (payload) => {
+			if (payload.changed) context.invalidateSessionPromptCache();
+		}) ?? null;
 
 	const unsubscribeSynthesisLock =
 		deps.bus?.on(BusChannels.LoopBlocked, (payload) => {
@@ -951,6 +1005,11 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		steer: (text) => queues.steer(text),
 		queueFollowUp: (text) => queues.queueFollowUp(text),
 		interruptRefusal: () => (state.streaming ? interruptRefusalReason() : null),
+		clearSkillSurface: () => {
+			const cleared = skillSurfaceNames(state.activeSkillSurface);
+			armSkillSurface(undefined);
+			return cleared;
+		},
 		clearQueuedFollowUps: () => queues.clearQueuedMirror().map((entry) => entry.text),
 		queuedMessages: () => queues.queuedMessages(),
 
@@ -1035,7 +1094,18 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			const images = options.images && options.images.length > 0 ? [...options.images] : undefined;
 			const pendingSkillRequests = options.pendingSkillRequests ?? [];
 			context.addWorkingContextPaths(options.workingContextPaths ?? []);
-			const pendingSkillPolicy = createPendingSkillToolPolicy(pendingSkillRequests);
+			// A skill the operator activated narrows the tools for the workflow
+			// it started, and that workflow outlives the turn it began in. A
+			// fresh /skill this turn replaces the armed surface; otherwise the
+			// armed surface is what this turn runs under.
+			const pendingSkillPolicy = withModelSkillActivation(
+				createPendingSkillToolPolicy(pendingSkillRequests) ?? state.activeSkillSurface,
+				modelMayActivateSkills(deps.getAutonomy?.() ?? deps.getSettings().safety.autonomy),
+			);
+			// What was already loaded when this turn started, so the settle-time
+			// notice names the skills this turn activated and not the ones a
+			// carried surface has been holding since an earlier message.
+			const skillsLoadedBeforeTurn = new Set(pendingSkillPolicy?.loadedSkillNames ?? []);
 			// Resolve the frozen session tool surface before turn_start so intent
 			// middleware sees the exact tools this request can actually call.
 			agentRuntime.agent.state.tools = resolveSessionTools(
@@ -1302,6 +1372,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				}
 				state.currentPendingSkillPolicy = priorPendingSkillPolicy;
 				state.currentAskUserPolicy = priorAskUserPolicy;
+				armSkillSurface(pendingSkillPolicy, skillsLoadedBeforeTurn);
 				state.activeUserTurnId = null;
 				// Safety net for thrown paths where agent_end never delivered;
 				// no-op when the agent_end flush already ran.
@@ -1417,6 +1488,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 
 		dispose(): void {
 			unsubscribeConfigReload?.();
+			unsubscribeExtensionsReload?.();
 			unsubscribeSynthesisLock?.();
 			unsubscribePrewarmCompaction();
 			prewarm.dispose();

package/src/interactive/chat-panel.ts

@@ -603,30 +603,53 @@ function hasStreamingText(entry: Extract<TranscriptEntry, { role: "assistant" }>
 }
 
 /**
- * Split a reply that opens with the skill-suggestion protocol line into that
- * line and the answer beneath it.
+ * Locate the skill-suggestion protocol line inside a reply.
  *
- * The prompt asks the model to *begin its reply* with the suggestion, so the
- * usual shape is one segment holding both. Classifying that whole segment as
- * advisory left the turn with no voice glyph at all: the suggestion did not
- * claim it and the answer never got the chance. Returns null when the segment
- * is only a suggestion, which stays advisory in full.
+ * The prompt asks the model to begin its reply with the line, but a model
+ * that narrates its work first puts the line at the end of the final message
+ * about half the time (round-4 skill batches: 1/2 and 0/2 opened, 2/2 fired).
+ * The line is recognized at the start of any line, provided it is complete
+ * (a newline follows it, or the segment is finalized), so a partially
+ * streamed line stays ordinary prose until it is whole. Returns the line's
+ * byte range or null.
+ */
+function findSkillSuggestionLine(seg: TextSegment): { start: number; end: number } | null {
+	const text = seg.text;
+	let at = text.startsWith(SKILL_SUGGESTION_PREFIX) ? 0 : text.indexOf(`\n${SKILL_SUGGESTION_PREFIX}`);
+	if (at < 0) return null;
+	if (at > 0) at += 1;
+	const lineEnd = text.indexOf("\n", at);
+	if (lineEnd < 0) return seg.finalized ? { start: at, end: text.length } : null;
+	return { start: at, end: lineEnd };
+}
+
+/**
+ * Split a reply that carries the skill-suggestion protocol line into that
+ * line and the answer around it.
+ *
+ * The usual shape is one segment holding both. Classifying that whole segment
+ * as advisory left the turn with no voice glyph at all: the suggestion did not
+ * claim it and the answer never got the chance. The suggestion renders first
+ * wherever the model put it, and the answer is the rest of the segment with
+ * that line removed. Returns null when the segment is only a suggestion,
+ * which stays advisory in full.
  */
 function skillSuggestionSplit(seg: TextSegment): { suggestion: string; answer: TextSegment } | null {
-	if (!seg.text.startsWith(SKILL_SUGGESTION_PREFIX)) return null;
-	const breakIndex = seg.text.indexOf("\n");
-	if (breakIndex < 0) return null;
+	const found = findSkillSuggestionLine(seg);
+	if (!found) return null;
+	const before = seg.text.slice(0, found.start).replace(/\n+$/, "");
+	const after = seg.text.slice(found.end + 1).replace(/^\n+/, "");
 	// A model that puts a blank line between the suggestion and the answer left
 	// the remainder opening with a newline, so the first rendered row was empty
 	// and took the glyph the answer's own text row was owed.
-	const answerText = seg.text.slice(breakIndex + 1).replace(/^\n+/, "");
+	const answerText = before.length > 0 && after.length > 0 ? `${before}\n${after}` : before + after;
 	if (answerText.trim().length === 0) return null;
 	const split = seg.suggestionSplit ?? {
 		suggestion: "",
 		answer: { kind: "text", text: answerText, finalized: seg.finalized } as TextSegment,
 	};
 	seg.suggestionSplit = split;
-	split.suggestion = seg.text.slice(0, breakIndex);
+	split.suggestion = seg.text.slice(found.start, found.end).replace(/\r$/, "");
 	const answer = split.answer;
 	if (answer.text === answerText && answer.finalized === seg.finalized) return split;
 	// The answer half follows the same cache rules as any other segment: the
@@ -1113,7 +1136,7 @@ function renderEntryLines(
 		const rendered =
 			seg.kind === "text" ? renderTextSegmentLines(seg, proseWidth) : renderErrorSegmentLines(seg, proseWidth);
 		if (rendered.length === 0) continue;
-		const isSkillSuggestion = seg.kind === "text" && seg.text.startsWith(SKILL_SUGGESTION_PREFIX);
+		const isSkillSuggestion = seg.kind === "text" && findSkillSuggestionLine(seg) !== null;
 		if (!labeled && !isSkillSuggestion) {
 			lines.push(...hangProseLines(rendered, clioPrefix));
 			labeled = true;

package/src/interactive/chat-renderer.ts

@@ -451,6 +451,7 @@ function richMessageFromEntry(entry: MessageEntry, maxTextChars?: number): Agent
 			"responseModelIdObservation",
 			"responseModel",
 			"responseId",
+			"gatewayRouting",
 			"diagnostics",
 			"contextUsageInvalidated",
 		]) {
@@ -460,15 +461,73 @@ function richMessageFromEntry(entry: MessageEntry, maxTextChars?: number): Agent
 	return message as unknown as AgentMessage;
 }
 
-function recordToolCallsFromMessage(message: AgentMessage, seen: Set<string>): void {
+function toolCallIdsFromMessage(message: AgentMessage): string[] {
 	const content = (message as { content?: unknown }).content;
-	if (!Array.isArray(content)) return;
+	if (!Array.isArray(content)) return [];
+	const ids: string[] = [];
 	for (const block of content) {
 		if (!block || typeof block !== "object") continue;
 		const b = block as Record<string, unknown>;
 		if (b.type !== "toolCall") continue;
-		if (typeof b.id === "string" && b.id.length > 0) seen.add(b.id);
+		if (typeof b.id === "string" && b.id.length > 0) ids.push(b.id);
 	}
+	return ids;
+}
+
+function recordToolCallsFromMessage(message: AgentMessage, seen: Set<string>): void {
+	for (const id of toolCallIdsFromMessage(message)) seen.add(id);
+}
+
+/**
+ * Replay sink that hands tool results to the model in the order the assistant
+ * issued the calls.
+ *
+ * The ledger appends a tool result when its tool finishes, while the live loop
+ * appends a parallel batch's results by call index (pi executes the batch and
+ * pushes results in the assistant's order). A two-call turn whose second call
+ * finished first is therefore recorded as [b, a] and was sent as [a, b]. A
+ * resume that replayed the ledger order sent different bytes from that point
+ * on, and the provider's prefix cache missed for the rest of the session.
+ * Results are staged until the next non-result message and released in call
+ * order; an id the staged assistant turn never issued keeps its ledger order
+ * after the known ones.
+ */
+function createOrderedReplaySink(): {
+	messages: AgentMessage[];
+	push(message: AgentMessage): void;
+	stageToolResult(message: AgentMessage): void;
+	flush(): void;
+} {
+	const messages: AgentMessage[] = [];
+	let callOrder: string[] = [];
+	let staged: AgentMessage[] = [];
+	const rank = (message: AgentMessage): number => {
+		const id = (message as { toolCallId?: unknown }).toolCallId;
+		const index = typeof id === "string" ? callOrder.indexOf(id) : -1;
+		return index < 0 ? Number.MAX_SAFE_INTEGER : index;
+	};
+	const flush = (): void => {
+		if (staged.length === 0) return;
+		staged.sort((a, b) => rank(a) - rank(b));
+		messages.push(...staged);
+		staged = [];
+		callOrder = [];
+	};
+	return {
+		messages,
+		flush,
+		push(message) {
+			flush();
+			messages.push(message);
+			// Consecutive assistant messages (one legacy standalone tool_call entry
+			// per call) share one batch; anything else starts a new one.
+			if (message.role === "assistant") callOrder.push(...toolCallIdsFromMessage(message));
+			else callOrder = [];
+		},
+		stageToolResult(message) {
+			staged.push(message);
+		},
+	};
 }
 
 function toolCallMessageFromEntry(entry: MessageEntry): AgentMessage {
@@ -998,7 +1057,12 @@ function bashContextText(entry: BashExecutionEntry): string {
 	return bashExecutionToText(message);
 }
 
-function appendContextMessage(out: AgentMessage[], role: "user" | "assistant", text: string, timestamp: string): void {
+function appendContextMessage(
+	out: { push(message: AgentMessage): void },
+	role: "user" | "assistant",
+	text: string,
+	timestamp: string,
+): void {
 	const trimmed = text.trim();
 	if (trimmed.length === 0) return;
 	out.push(makeTextMessage(role, truncateReplayText(trimmed), timestamp));
@@ -1014,7 +1078,7 @@ export function buildReplayAgentMessagesFromTurns(
 	turns: ReadonlyArray<SessionEntry>,
 	options: RehydrateChatPanelOptions = {},
 ): AgentMessage[] {
-	const out: AgentMessage[] = [];
+	const out = createOrderedReplaySink();
 	const seenToolCalls = new Set<string>();
 	for (const entry of selectReplayEntries(turns, options)) {
 		switch (entry.kind) {
@@ -1035,7 +1099,7 @@ export function buildReplayAgentMessagesFromTurns(
 						recordToolCallsFromMessage(message, seenToolCalls);
 					}
 				} else if (entry.role === "tool_result") {
-					out.push(toolResultMessageFromEntry(entry));
+					out.stageToolResult(toolResultMessageFromEntry(entry));
 				} else if (entry.role === "system") {
 					appendContextMessage(out, "user", `System note: ${text}`, entry.timestamp);
 				}
@@ -1082,7 +1146,8 @@ export function buildReplayAgentMessagesFromTurns(
 				break;
 		}
 	}
-	return out;
+	out.flush();
+	return out.messages;
 }
 
 /**

package/src/interactive/cost-overlay.ts

@@ -46,6 +46,7 @@ export interface CostRow {
 	prewarms: number;
 	/** Calls in this row that were proactive-memory steps on the background target. */
 	backgroundMemory: number;
+	failedCompaction: number;
 	cost: CostAggregate;
 }
 
@@ -79,6 +80,7 @@ export function aggregateCostEntries(entries: ReadonlyArray<CostEntry>): CostRow
 			if (entry.label === "handoff") existing.row.handoffs += 1;
 			if (entry.label === "prewarm") existing.row.prewarms += 1;
 			if (entry.label === "background-memory") existing.row.backgroundMemory += 1;
+			if (entry.label === "failed-compaction") existing.row.failedCompaction += 1;
 			for (const requestedModelId of entry.requestedModelIds) existing.requestedModelIds.add(requestedModelId);
 			addResponseModelIdObservationCounts(
 				existing.responseModelIdObservationCounts,
@@ -103,6 +105,7 @@ export function aggregateCostEntries(entries: ReadonlyArray<CostEntry>): CostRow
 				handoffs: entry.label === "handoff" ? 1 : 0,
 				prewarms: entry.label === "prewarm" ? 1 : 0,
 				backgroundMemory: entry.label === "background-memory" ? 1 : 0,
+				failedCompaction: entry.label === "failed-compaction" ? 1 : 0,
 			},
 			requestedModelIds: new Set(entry.requestedModelIds),
 			responseModelIdObservationCounts: { ...entry.responseModelIdObservationCounts },
@@ -143,6 +146,7 @@ function sumRows(
 			handoffs: acc.handoffs + row.handoffs,
 			prewarms: acc.prewarms + row.prewarms,
 			backgroundMemory: acc.backgroundMemory + row.backgroundMemory,
+			failedCompaction: acc.failedCompaction + row.failedCompaction,
 		}),
 		{
 			runs: 0,
@@ -157,6 +161,7 @@ function sumRows(
 			handoffs: 0,
 			prewarms: 0,
 			backgroundMemory: 0,
+			failedCompaction: 0,
 		},
 	);
 }
@@ -229,13 +234,26 @@ function summaryBlock(
 	return kvBlock([
 		[
 			"turns",
-			formatTokens(totals.runs - totals.sideQuestions - totals.handoffs - totals.prewarms - totals.backgroundMemory),
+			formatTokens(
+				totals.runs -
+					totals.sideQuestions -
+					totals.handoffs -
+					totals.prewarms -
+					totals.backgroundMemory -
+					totals.failedCompaction,
+			),
 		],
 		["model calls", formatTokens(totals.apiCalls)],
 		...(totals.sideQuestions > 0 ? [["side questions", formatTokens(totals.sideQuestions)] as const] : []),
 		...(totals.handoffs > 0 ? [["handoffs", formatTokens(totals.handoffs)] as const] : []),
 		...(totals.prewarms > 0 ? [["pre-warms", formatTokens(totals.prewarms)] as const] : []),
 		...(totals.backgroundMemory > 0 ? [["memory steps", formatTokens(totals.backgroundMemory)] as const] : []),
+		...(totals.failedCompaction > 0
+			? [
+					["failed compaction calls", formatTokens(totals.failedCompaction)] as const,
+					["compaction usage", "known subtotals; missing usage is unknown"] as const,
+				]
+			: []),
 		...(cost === null ? [] : [["cost", cost] as const]),
 		["input", formatTokens(totals.input)],
 		["output", formatTokens(totals.output)],
@@ -255,12 +273,18 @@ function modelBlock(row: CostRow): string[] {
 	return kvBlock([
 		["requested model ids", row.requestedModelIds.join(", ")],
 		["response model id observation", responseModelIdObservationCountsLabel(row.responseModelIdObservationCounts)],
-		["turns", formatTokens(row.runs - row.sideQuestions - row.handoffs - row.prewarms - row.backgroundMemory)],
+		[
+			"turns",
+			formatTokens(
+				row.runs - row.sideQuestions - row.handoffs - row.prewarms - row.backgroundMemory - row.failedCompaction,
+			),
+		],
 		["model calls", formatTokens(row.apiCalls)],
 		...(row.sideQuestions > 0 ? [["side questions", formatTokens(row.sideQuestions)] as const] : []),
 		...(row.handoffs > 0 ? [["handoffs", formatTokens(row.handoffs)] as const] : []),
 		...(row.prewarms > 0 ? [["pre-warms", formatTokens(row.prewarms)] as const] : []),
 		...(row.backgroundMemory > 0 ? [["memory steps", formatTokens(row.backgroundMemory)] as const] : []),
+		...(row.failedCompaction > 0 ? [["failed compaction calls", formatTokens(row.failedCompaction)] as const] : []),
 		...(cost === null ? [] : [["cost", cost] as const]),
 		["input", formatTokens(row.input)],
 		["output", formatTokens(row.output)],

package/src/interactive/dispatch-board.ts

@@ -6,6 +6,7 @@ import {
 	type DispatchProgressPayload,
 	type DispatchRunIdentity,
 } from "../core/bus-events.js";
+import { resolveDispatchFailureStatus } from "../core/dispatch-outcome.js";
 import type { SafeEventBus } from "../core/event-bus.js";
 import { rawDurationMs } from "../core/timers.js";
 import type { AgentAudience } from "../domains/agents/spec.js";
@@ -37,7 +38,7 @@ import {
 	type ObservabilityNotice,
 	type ObservabilitySnapshot,
 } from "../domains/observability/index.js";
-import { type CostProvenance, foregroundStreamUsage } from "../domains/providers/index.js";
+import { type CostProvenance, foregroundStreamUsage, resolveCostProvenance } 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";
@@ -121,7 +122,7 @@ export interface DispatchBoardRow {
 	gate?: { role: string; cycle: number };
 	council?: { group: string; label: string; color?: string; round: number };
 	/** Orchestrator-executed declared verification status. */
-	hostVerification?: "verified" | "rejected" | "skipped";
+	hostVerification?: "verified" | "rejected" | "skipped" | "not_implicated";
 	/**
 	 * The canonical trust projection of the sealed receipt, read back from
 	 * disk and authenticated against the ledger row. Absent while the run is
@@ -1285,12 +1286,6 @@ function resolveAgentEndStatus(rawMessages: unknown): DispatchBoardStatus | null
 	return null;
 }
 
-function resolveFailedStatus(reason: unknown): DispatchBoardStatus {
-	if (reason === "dead" || reason === "stalled") return "dead";
-	if (reason === "interrupted" || reason === "canceled") return "aborted";
-	return "failed";
-}
-
 function resolveFailureDetail(
 	payload: Partial<DispatchFailedPayload>,
 	fallback: string | null | undefined,
@@ -1601,7 +1596,7 @@ export function createDispatchBoardStore(
 			entry.durationMs = parseFiniteNumber(payload.durationMs, Math.max(0, rawDurationMs(entry.startedAtMs, now)));
 			entry.tokenCount = parseFiniteNumber(payload.tokenCount, entry.tokenCount);
 			entry.costUsd = parseFiniteNumber(payload.costUsd, entry.costUsd);
-			entry.costProvenance = payload.costProvenance ?? "unknown";
+			entry.costProvenance = resolveCostProvenance(payload.costProvenance, entry.costProvenance ?? "unknown");
 			entry.outcomeDetail = null;
 			if (payload.hostVerification !== undefined) entry.hostVerification = payload.hostVerification;
 			settleFromReceipt(entry);
@@ -1621,7 +1616,7 @@ export function createDispatchBoardStore(
 			const payload: Partial<DispatchFailedPayload> = raw ?? {};
 			const runId = parseRunId(payload.runId);
 			const previousStatus = runId !== null ? entries.get(runId)?.status : undefined;
-			const resolvedStatus = resolveFailedStatus(payload.reason);
+			const resolvedStatus = resolveDispatchFailureStatus(payload.reason);
 			const status = previousStatus === "dead" && resolvedStatus === "failed" ? "dead" : resolvedStatus;
 			const entry = upsertBase(payload, status, now);
 			if (!entry) return;
@@ -1630,7 +1625,7 @@ export function createDispatchBoardStore(
 			entry.durationMs = parseFiniteNumber(payload.durationMs, Math.max(0, rawDurationMs(entry.startedAtMs, now)));
 			entry.tokenCount = parseFiniteNumber(payload.tokenCount, entry.tokenCount);
 			entry.costUsd = parseFiniteNumber(payload.costUsd, entry.costUsd);
-			entry.costProvenance = payload.costProvenance ?? "unknown";
+			entry.costProvenance = resolveCostProvenance(payload.costProvenance, entry.costProvenance ?? "unknown");
 			entry.outcomeDetail = resolveFailureDetail(payload, entry.outcomeDetail);
 			if (payload.hostVerification !== undefined) entry.hostVerification = payload.hostVerification;
 			settleFromReceipt(entry);