@iowarp/clio-coder 0.4.1 → 0.4.3

package/src/domains/session/compaction/compact.ts

@@ -10,10 +10,11 @@
  * boundary; this module does not import pi-ai directly.
  */
 
-import { stream } from "../../../engine/ai.js";
+import { streamSimple } from "../../../engine/ai.js";
 import type { EngineModel, Usage } from "../../../engine/types.js";
 import { foldWorkingSet } from "../../context/working-set/fold.js";
 import { recallableRefListing } from "../../context/working-set/recall.js";
+import { extractReasoningTokens } from "../context-accounting.js";
 import type { CompactionUsage, SessionEntry } from "../entries.js";
 import { serializeConversation } from "./branch-summary.js";
 import { findCutPoint } from "./cut-point.js";
@@ -86,6 +87,14 @@ In addition to that carried-forward context, summarize ONLY the active-turn deta
 
 Do NOT answer the user. Do NOT summarize unrelated older history.`;
 
+/** One invoked summary stream, including failed calls that produce no checkpoint. */
+export interface CompactionCallObservation {
+	outcome: "success" | "error" | "aborted";
+	usage: unknown;
+	timestamp: string;
+	durationMs: number;
+}
+
 export interface CompactInput {
 	/** Ordered session entries to compact. The caller reads these from the session domain. */
 	entries: ReadonlyArray<SessionEntry>;
@@ -105,6 +114,8 @@ export interface CompactInput {
 	reserveTokens?: number;
 	/** Override the built-in keep-recent default (DEFAULT_KEEP_RECENT_TOKENS). */
 	keepRecentTokens?: number;
+	/** Accounting observer; called once per invoked stream, including failures. */
+	onCall?: (call: CompactionCallObservation) => void;
 }
 
 export interface CompactResult {
@@ -367,6 +378,24 @@ function addCompactionUsage(total: CompactionUsage | undefined, raw: unknown): C
 	};
 }
 
+/** Keep attributable partial facts if a failed terminal object resets missing fields to zero. */
+function retainReportedUsage(previous: Record<string, unknown>, raw: unknown): Record<string, unknown> {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return previous;
+	const usage = raw as Record<string, unknown>;
+	const known = { ...previous };
+	for (const field of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"]) {
+		const value = numberOrZero(usage[field]);
+		if (value > 0) known[field] = value;
+	}
+	const reasoning = extractReasoningTokens({ ...usage, reasoningTokens: undefined });
+	if (reasoning !== null && reasoning > 0) known.reasoning = reasoning;
+	if (usage.cost && typeof usage.cost === "object" && "total" in usage.cost) {
+		const cost = numberOrZero(usage.cost.total);
+		if (cost > 0) known.cost = { total: cost };
+	}
+	return known;
+}
+
 async function runSummaryStream(
 	input: CompactInput,
 	userText: string,
@@ -383,26 +412,47 @@ async function runSummaryStream(
 		messages: [buildUserMessage(userText)],
 	};
 
-	const events = stream(
-		input.model,
-		context as unknown as Parameters<typeof stream>[1],
-		options as unknown as Parameters<typeof stream>[2],
-	);
-
-	let summary = "";
+	const timestamp = new Date().toISOString();
+	const started = performance.now();
 	let usage: unknown;
-	for await (const event of events) {
-		if (event.type === "done") {
-			summary = textFromAssistant(event.message);
-			usage = (event.message as { usage?: unknown }).usage;
-			break;
-		}
-		if (event.type === "error") {
-			const reason = event.error.errorMessage ?? "unknown error";
-			throw new Error(`compaction stream failed: ${reason}`);
+	let reported: Record<string, unknown> = {};
+	let outcome: CompactionCallObservation["outcome"] = "error";
+	try {
+		// Summarization requests thinking off, as its resolver does. Bare stream
+		// infers an active level from model.reasoning and would undo that choice.
+		const events = streamSimple(
+			input.model,
+			context as unknown as Parameters<typeof streamSimple>[1],
+			options as unknown as Parameters<typeof streamSimple>[2],
+		);
+		for await (const event of events) {
+			// Some transports throw after yielding a partial response. Retain the
+			// last reported usage even without a terminal error message.
+			if ("partial" in event) {
+				usage = event.partial.usage ?? usage;
+				reported = retainReportedUsage(reported, usage);
+			}
+			if (event.type === "done") {
+				usage = event.message.usage ?? usage;
+				outcome = "success";
+				return { text: textFromAssistant(event.message).trim(), usage };
+			}
+			if (event.type === "error") {
+				usage = event.error.usage ?? usage;
+				reported = retainReportedUsage(reported, usage);
+				outcome = event.error.stopReason === "aborted" ? "aborted" : "error";
+				throw new Error(`compaction stream failed: ${event.error.errorMessage ?? "unknown error"}`);
+			}
 		}
+		throw new Error("compaction stream ended without a terminal response");
+	} finally {
+		input.onCall?.({
+			outcome: outcome === "error" && input.signal?.aborted ? "aborted" : outcome,
+			usage: outcome === "success" ? usage : reported,
+			timestamp,
+			durationMs: Math.max(0, performance.now() - started),
+		});
 	}
-	return { text: summary.trim(), usage };
 }
 
 /**
@@ -464,16 +514,16 @@ export async function compact(input: CompactInput): Promise<CompactResult> {
 		const userText = buildUserText(conversationText, input.instructions, previousContextText);
 		const historySummary = await runSummaryStream(input, userText, systemPrompt, maxTokens);
 		usage = addCompactionUsage(usage, historySummary.usage);
-		if (historySummary.text.length > 0) summaryParts.push(historySummary.text);
+		if (historySummary.text.length === 0) throw new Error("compaction returned an empty history summary");
+		summaryParts.push(historySummary.text);
 	}
 	if (turnPrefix.length > 0) {
 		const conversationText = serializeConversation(turnPrefix);
 		const userText = buildTurnPrefixUserText(conversationText, input.instructions, previousContextText);
 		const prefixSummary = await runSummaryStream(input, userText, systemPrompt, maxTokens);
 		usage = addCompactionUsage(usage, prefixSummary.usage);
-		if (prefixSummary.text.length > 0) {
-			summaryParts.push(`**Turn Context (split turn):**\n\n${prefixSummary.text}`);
-		}
+		if (prefixSummary.text.length === 0) throw new Error("compaction returned an empty split-turn summary");
+		summaryParts.push(`**Turn Context (split turn):**\n\n${prefixSummary.text}`);
 	}
 
 	const summary = `${summaryParts.join("\n\n---\n\n").trim()}${formatFileOperations(fileOps)}${formatRecallableRefs(

package/src/domains/session/entries.ts

@@ -101,6 +101,10 @@ export type CompactionTrigger = "auto" | "force" | "overflow";
  * `usage` carries and the ledger usage fold reads both from one place.
  */
 export interface CompactionUsage {
+	/** Executing route; absent on legacy checkpoints that used the active chat model. */
+	targetId?: string;
+	/** Requested wire model ID, not a verified physical backend identity. */
+	modelId?: string;
 	input: number;
 	output: number;
 	cacheRead: number;
@@ -515,6 +519,8 @@ function isOptionalCompactionUsage(value: unknown): boolean {
 	if (!isRecord(value)) return false;
 	const cost = value.cost;
 	return (
+		isOptionalString(value.targetId) &&
+		isOptionalString(value.modelId) &&
 		isNumber(value.input) &&
 		isNumber(value.output) &&
 		isNumber(value.cacheRead) &&

package/src/domains/session/task-board.ts

@@ -421,10 +421,8 @@ function applyMutation(
 	// Completion is the ledger's only load-bearing claim, so it carries two
 	// structural conditions rather than a bare status flip. Evidence is
 	// mandatory: a completed row becomes a passed validation record, and a row
-	// without evidence would assert a validation that nobody performed. The
-	// task must also have been started, because work that was never entered
-	// cannot have produced a result; the honest closes for it are block and
-	// drop, which record a reason instead.
+	// without evidence would assert a validation that nobody performed. Work
+	// that did not happen is closed with block or drop, which record a reason.
 	if (mutation.op === "done") {
 		if (mutation.evidence.trim().length === 0) {
 			return {
@@ -432,13 +430,16 @@ function applyMutation(
 					"done requires note as the evidence that the task actually finished (the command you ran, the file:line you verified). If the work did not happen, use block with a reason or drop it.",
 			};
 		}
-		if (target.status === "pending") {
-			return {
-				error: `task ${target.id} was never started, so it cannot be completed. Start it and do the work, or record the truth with block (reason) or drop.`,
-			};
-		}
 	}
 	const notes: string[] = [];
+	// A model that did the work without announcing it on the board closes
+	// several tasks in a row at the end of the turn. Refusing done on a pending
+	// task cost a live session six start/done pairs of pure ceremony; the
+	// evidence note is the load-bearing claim, so the start is recorded
+	// implicitly and named in the notes.
+	if (mutation.op === "done" && target.status === "pending") {
+		notes.push(`started ${target.id} implicitly: done on a pending task records the start and the completion together`);
+	}
 	const tasks = board.tasks.map((task): TaskBoardTask => {
 		if (task.id !== target.id) {
 			// One active task at a time: starting a task parks any other active

package/src/domains/session/usage.ts

@@ -101,9 +101,9 @@ export function ledgerUsageCalls(
 			const usage = entry.usage;
 			if (!usage || usage.totalTokens <= 0) continue;
 			calls.push({
-				providerId: currentTarget ?? "unknown",
-				attributedModelId: currentModel ?? "unknown",
-				requestedModelId: currentModel ?? "unknown",
+				providerId: usage.targetId ?? currentTarget ?? "unknown",
+				attributedModelId: usage.modelId ?? currentModel ?? "unknown",
+				requestedModelId: usage.modelId ?? currentModel ?? "unknown",
 				responseModelIdObservation: { state: "not-observed" },
 				input: usage.input,
 				output: usage.output,

package/src/domains/share/archive.ts

@@ -1,5 +1,17 @@
 import { createHash } from "node:crypto";
-import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, type Stats, statSync } from "node:fs";
+import {
+	existsSync,
+	lstatSync,
+	mkdirSync,
+	mkdtempSync,
+	readdirSync,
+	readFileSync,
+	realpathSync,
+	rmSync,
+	type Stats,
+	statSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
 import path from "node:path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 import { type ClioSettings, readSettings, settingsPath, updateSettings, validateSettings } from "../../core/config.js";
@@ -18,6 +30,10 @@ import {
 	parseAgentRecipeSchema,
 	parseFleetContract,
 } from "../agents/index.js";
+import { loadManifestFromRoot } from "../extensions/discovery.js";
+import { extensionContentDigest } from "../extensions/integrity.js";
+import { extensionBaseDir, installExtension, listInstalledExtensions } from "../extensions/state.js";
+import type { ExtensionScope } from "../extensions/types.js";
 import { migrateSettingsV1Document } from "../lifecycle/migrations/2026-09-01-settings-v2.js";
 
 export type ShareScope = "project" | "user";
@@ -331,7 +347,14 @@ export function createShareArchive(options: ShareExportOptions = {}): ClioShareA
 		for (const scope of scopes) {
 			const root =
 				scope === "user" ? path.join(clioConfigDir(), "extensions") : path.join(cwd, ".clio-coder", "extensions");
-			addTree(files, "extension", scope, root, `${scope}/extensions`, (rel) => path.basename(rel) !== "state.json");
+			addTree(
+				files,
+				"extension",
+				scope,
+				root,
+				`${scope}/extensions`,
+				(relativePath) => !relativePath.split("/")[0]?.startsWith(".") && path.basename(relativePath) !== "state.json",
+			);
 		}
 	}
 	if (includes.includeSettings) {
@@ -453,6 +476,15 @@ interface ShareImportPreparedPlan {
 	actions: ShareImportAction[];
 	diagnostics: ShareDiagnostic[];
 	targets: ShareImportPreparedTarget[];
+	extensionPackages: ShareImportPreparedExtensionPackage[];
+}
+
+interface ShareImportPreparedExtensionPackage {
+	id: string;
+	scope: ExtensionScope;
+	files: Array<{ relativePath: string; buffer: Buffer }>;
+	contentDigest: string;
+	install: boolean;
 }
 
 function configDirPath(): string {
@@ -608,6 +640,91 @@ function preflightImportTargets(
 	return { targets, diagnostics };
 }
 
+function withStagedExtensionPackage<T>(
+	input: { id: string; files: ReadonlyArray<{ relativePath: string; buffer: Buffer }> },
+	fn: (root: string) => T,
+): T {
+	const stagingParent = mkdtempSync(path.join(tmpdir(), "clio-share-extension-"));
+	const root = path.join(stagingParent, input.id);
+	try {
+		mkdirSync(root, { recursive: true });
+		for (const file of input.files) safeResourceWrite(path.join(root, file.relativePath), file.buffer);
+		return fn(root);
+	} finally {
+		rmSync(stagingParent, { recursive: true, force: true });
+	}
+}
+
+function prepareExtensionPackages(
+	targets: ReadonlyArray<ShareImportPreparedTarget>,
+	options: ShareImportOptions,
+): { packages: ShareImportPreparedExtensionPackage[]; diagnostics: ShareDiagnostic[] } {
+	const diagnostics: ShareDiagnostic[] = [];
+	const grouped = new Map<string, Omit<ShareImportPreparedExtensionPackage, "contentDigest" | "install">>();
+	for (const target of targets) {
+		if (target.entry.type !== "extension") continue;
+		const segments = relativePathSegments(target.entry.relativePath);
+		const id = segments?.[0];
+		const packagePath = segments?.slice(1).join("/");
+		if (!id || !packagePath) {
+			diagnostics.push({
+				type: "error",
+				message: `extension archive path must be <id>/<package-path>: ${pathDiagnostic(target.entry)}`,
+				path: target.entry.relativePath,
+			});
+			continue;
+		}
+		const scope = target.scope as ExtensionScope;
+		const key = `${scope}\0${id}`;
+		const group = grouped.get(key) ?? { id, scope, files: [] };
+		if (group.files.some((file) => file.relativePath === packagePath)) {
+			diagnostics.push({ type: "error", message: `duplicate extension archive path ${target.entry.relativePath}` });
+			continue;
+		}
+		group.files.push({ relativePath: packagePath, buffer: target.buffer });
+		grouped.set(key, group);
+	}
+
+	const packages: ShareImportPreparedExtensionPackage[] = [];
+	for (const group of [...grouped.values()].sort((a, b) => `${a.scope}/${a.id}`.localeCompare(`${b.scope}/${b.id}`))) {
+		try {
+			const contentDigest = withStagedExtensionPackage(group, (root) => {
+				const candidate = loadManifestFromRoot(root);
+				if (!candidate.valid || !candidate.manifest) {
+					throw new Error(candidate.diagnostics.map((diagnostic) => diagnostic.message).join("; ") || "manifest is invalid");
+				}
+				if (candidate.manifest.id !== group.id) {
+					throw new Error(`manifest id ${candidate.manifest.id} does not match archive package ${group.id}`);
+				}
+				return extensionContentDigest(root);
+			});
+			const cwd = path.resolve(options.cwd ?? process.cwd());
+			const targetRoot = path.join(extensionBaseDir(group.scope, cwd), group.id);
+			const existing = listInstalledExtensions(cwd, { scope: group.scope, all: true }).find(
+				(extension) => extension.id === group.id && extension.rootPath === targetRoot,
+			);
+			const alreadyVerified =
+				existing?.valid === true &&
+				existing.provenance?.contentDigest === contentDigest &&
+				existing.observedContentDigest === contentDigest;
+			if (existsSync(targetRoot) && !alreadyVerified && !options.force) {
+				diagnostics.push({
+					type: "conflict",
+					message: `extension ${group.id} is not already installed with the archive's verified digest; re-run with --force to use the canonical installer`,
+					path: targetRoot,
+				});
+			}
+			packages.push({ ...group, contentDigest, install: !alreadyVerified });
+		} catch (error) {
+			diagnostics.push({
+				type: "error",
+				message: `extension ${group.id} in share archive is invalid: ${error instanceof Error ? error.message : String(error)}`,
+			});
+		}
+	}
+	return { packages, diagnostics };
+}
+
 function versionDiagnostics(archive: ClioShareArchive): ShareDiagnostic[] {
 	const current = readClioVersion();
 	const [curMajor, curMinor] = current.split(".");
@@ -657,13 +774,20 @@ function prepareShareImport(filePath: string, options: ShareImportOptions = {}):
 			actions: [],
 			diagnostics: [{ type: "error", message: err instanceof Error ? err.message : String(err), path: filePath }],
 			targets: [],
+			extensionPackages: [],
 		};
 	}
 	const diagnostics: ShareDiagnostic[] = [...versionDiagnostics(archive)];
 	const actions: ShareImportAction[] = [];
 	const preflight = preflightImportTargets(archive, options);
 	if (preflight.diagnostics.length > 0) {
-		return { archive, actions: [], diagnostics: [...diagnostics, ...preflight.diagnostics], targets: [] };
+		return {
+			archive,
+			actions: [],
+			diagnostics: [...diagnostics, ...preflight.diagnostics],
+			targets: [],
+			extensionPackages: [],
+		};
 	}
 	for (const targetInfo of preflight.targets) {
 		const { entry, target, scope, buffer } = targetInfo;
@@ -706,7 +830,9 @@ function prepareShareImport(filePath: string, options: ShareImportOptions = {}):
 		}
 		actions.push({ action: "write", type: entry.type, scope, path: target });
 	}
-	return { archive, actions, diagnostics, targets: preflight.targets };
+	const extensions = prepareExtensionPackages(preflight.targets, options);
+	diagnostics.push(...extensions.diagnostics);
+	return { archive, actions, diagnostics, targets: preflight.targets, extensionPackages: extensions.packages };
 }
 
 function publicImportPlan(prepared: ShareImportPreparedPlan, recovery?: ShareImportRecovery): ShareImportPlan {
@@ -750,10 +876,41 @@ export function importShareArchive(filePath: string, options: ShareImportOptions
 	};
 	let failed: string | undefined;
 	try {
+		for (const extensionPackage of prepared.extensionPackages) {
+			if (!extensionPackage.install) continue;
+			const cwd = path.resolve(options.cwd ?? process.cwd());
+			failed = path.join(extensionBaseDir(extensionPackage.scope, cwd), extensionPackage.id);
+			const result = withStagedExtensionPackage(extensionPackage, (root) =>
+				installExtension(root, {
+					cwd,
+					scope: extensionPackage.scope,
+					...(options.force !== undefined ? { force: options.force } : {}),
+				}),
+			);
+			for (const backup of [result.recovery?.stateBackup, result.recovery?.packageBackup]) {
+				if (backup && !backups.includes(backup)) backups.push(backup);
+			}
+			const errors = result.diagnostics.filter((diagnostic) => diagnostic.type === "error");
+			if (!result.extension || errors.length > 0) {
+				throw new Error(errors.map((diagnostic) => diagnostic.message).join("; ") || "canonical install failed");
+			}
+			if (result.extension.provenance?.contentDigest !== extensionPackage.contentDigest) {
+				throw new Error(`canonical install digest mismatch for extension ${extensionPackage.id}`);
+			}
+			for (const diagnostic of result.diagnostics) {
+				prepared.diagnostics.push({
+					type: "warning",
+					message: diagnostic.message,
+					...(diagnostic.path ? { path: diagnostic.path } : {}),
+				});
+			}
+			if (!written.includes(result.extension.rootPath)) written.push(result.extension.rootPath);
+			failed = undefined;
+		}
 		for (let index = 0; index < prepared.targets.length; index += 1) {
 			const targetInfo = prepared.targets[index];
 			const action = prepared.actions[index];
-			if (!targetInfo || !action || action.action === "skip") continue;
+			if (!targetInfo || !action || action.action === "skip" || targetInfo.entry.type === "extension") continue;
 			failed = targetInfo.target;
 			if (targetInfo.entry.type === "settings") {
 				const path = mergeSettingsFragment(targetInfo.buffer);
@@ -768,7 +925,7 @@ export function importShareArchive(filePath: string, options: ShareImportOptions
 			);
 			failed = undefined;
 		}
-		return plan;
+		return publicImportPlan(prepared, backups.length > 0 ? { written, backups } : undefined);
 	} catch (err) {
 		if (failed) {
 			const expectedBackup = safeResourceBackupPath(failed);
@@ -787,7 +944,7 @@ export function importShareArchive(filePath: string, options: ShareImportOptions
 					...prepared.diagnostics,
 					{
 						type: "error",
-						message: `share import failed while writing${failed ? ` ${failed}` : ""}: ${reason}`,
+						message: `share import failed${failed ? ` while importing ${failed}` : ""}: ${reason}`,
 						...(failed ? { path: failed } : {}),
 					},
 				],

package/src/engine/acp/server.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { realpathSync } from "node:fs";
 import { isAbsolute, resolve as resolvePath } from "node:path";
 import {
+	type AccountabilityEvidenceReadyPayload,
 	BusChannels,
 	type DispatchCompletedPayload,
 	type DispatchEnqueuedPayload,
@@ -209,6 +210,8 @@ interface AcpServerUsage {
 	cacheRead: number;
 	cacheWrite: number;
 	reasoning: number;
+	totalTokens: number;
+	costUsd: number;
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -333,7 +336,10 @@ const ACP_MAX_REPLAY_TOOL_CALLS = 8192;
  * the list is the allowlist, and a client's requested kinds are intersected
  * with it rather than trusted. `safety.loopBlocked` was the first member; the
  * dispatch lifecycle joined it so a client can draw a live fleet board from
- * reported facts instead of inferring one from tool titles or timing.
+ * reported facts instead of inferring one from tool titles or timing;
+ * `accountability.evidenceReady` follows a run's terminal event once its
+ * evidence bundle has landed, so the board can show first-pass success and a
+ * finding count without reading Clio's state tree.
  */
 const ACP_FORWARDABLE_EVENT_KINDS = [
 	"safety.loopBlocked",
@@ -342,6 +348,7 @@ const ACP_FORWARDABLE_EVENT_KINDS = [
 	"dispatch.progress",
 	"dispatch.completed",
 	"dispatch.failed",
+	"accountability.evidenceReady",
 ] as const;
 
 type AcpForwardableEventKind = (typeof ACP_FORWARDABLE_EVENT_KINDS)[number];
@@ -359,6 +366,9 @@ const ACP_MAX_DISPATCH_TASK_PREVIEW_BYTES = 160;
 
 /** Wire bound for the short identifiers a dispatch event carries. */
 const ACP_MAX_DISPATCH_ID_BYTES = 128;
+/** Evidence tags are a closed vocabulary of short identifiers; anything wider is not a tag. */
+const ACP_MAX_EVIDENCE_TAGS = 32;
+const ACP_MAX_EVIDENCE_TAG_BYTES = 64;
 
 /**
  * Progress events forwarded per run before the stream is capped. One run
@@ -521,8 +531,8 @@ function utf8Bytes(value: string): number {
 	return Buffer.byteLength(value, "utf8");
 }
 
-function emptyUsage(): AcpServerUsage {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0 };
+export function emptyUsage(): AcpServerUsage {
+	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, totalTokens: 0, costUsd: 0 };
 }
 
 function createActivePromptState(): ActivePrompt {
@@ -552,15 +562,33 @@ function finite(value: unknown): number {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 }
 
-function mergeUsage(into: AcpServerUsage, usage: unknown): void {
+/** Only field `sumRunUsage` (chat-loop-messages.ts) reads for a dollar figure; matched here so ACP never re-derives cost through a separate path. */
+function costTotal(usage: Record<string, unknown>): number {
+	const cost = usage.cost;
+	return isRecord(cost) ? finite(cost.total) : 0;
+}
+
+export function mergeUsage(into: AcpServerUsage, usage: unknown): void {
 	if (!isRecord(usage)) return;
-	into.input +=
+	const input =
 		finite(usage.input) + finite(usage.inputTokens) + finite(usage.input_tokens) + finite(usage.prompt_tokens);
-	into.output +=
+	const output =
 		finite(usage.output) + finite(usage.outputTokens) + finite(usage.output_tokens) + finite(usage.completion_tokens);
-	into.cacheRead += finite(usage.cacheRead) + finite(usage.cacheReadTokens) + finite(usage.cache_read_tokens);
-	into.cacheWrite += finite(usage.cacheWrite) + finite(usage.cacheWriteTokens) + finite(usage.cache_write_tokens);
-	into.reasoning += finite(usage.reasoning) + finite(usage.reasoningTokens) + finite(usage.reasoning_tokens);
+	const cacheRead = finite(usage.cacheRead) + finite(usage.cacheReadTokens) + finite(usage.cache_read_tokens);
+	const cacheWrite = finite(usage.cacheWrite) + finite(usage.cacheWriteTokens) + finite(usage.cache_write_tokens);
+	const reasoning = finite(usage.reasoning) + finite(usage.reasoningTokens) + finite(usage.reasoning_tokens);
+	into.input += input;
+	into.output += output;
+	into.cacheRead += cacheRead;
+	into.cacheWrite += cacheWrite;
+	into.reasoning += reasoning;
+	// Same fallback sumRunUsage uses: prefer the provider's own total, otherwise
+	// sum the four merged categories for this message (reasoning excluded,
+	// matching sumRunUsage, since a provider that reports reasoning separately
+	// still counts it inside output for billing).
+	const explicitTotal = finite(usage.totalTokens) + finite(usage.total_tokens);
+	into.totalTokens += explicitTotal > 0 ? explicitTotal : input + output + cacheRead + cacheWrite;
+	into.costUsd += costTotal(usage);
 }
 
 function mergeMessageUsage(into: AcpServerUsage, message: unknown, seen?: WeakSet<object>): void {
@@ -1857,6 +1885,29 @@ export async function serveClioAcpAgent(options: ClioAcpServerOptions): Promise<
 				});
 			}),
 		);
+		unsubscribeEvents.push(
+			bus.on(BusChannels.AccountabilityEvidenceReady, (payload: AccountabilityEvidenceReadyPayload) => {
+				// Arrives after dispatch.completed or dispatch.failed for the same run,
+				// so it is terminal too: nothing about that run follows it. The
+				// bundle's prose (findings, overview) stays behind; only the summary
+				// counters the projection itself carries cross, and the tags are
+				// filtered to bounded identifiers rather than truncated into new ones.
+				const runId = safeStoredIdentifier(payload.runId, ACP_MAX_DISPATCH_ID_BYTES);
+				const evidenceId = safeStoredIdentifier(payload.evidenceId, ACP_MAX_DISPATCH_ID_BYTES);
+				if (runId === null || evidenceId === null) return;
+				const tags = (Array.isArray(payload.tags) ? payload.tags : [])
+					.map((tag) => safeStoredIdentifier(tag, ACP_MAX_EVIDENCE_TAG_BYTES))
+					.filter((tag): tag is string => tag !== null)
+					.slice(0, ACP_MAX_EVIDENCE_TAGS);
+				forwardEvent("accountability.evidenceReady", null, true, {
+					runId,
+					evidenceId,
+					firstPassSuccess: payload.firstPassSuccess === true,
+					findingCount: safeCount(payload.findingCount),
+					tags,
+				});
+			}),
+		);
 	}
 	const unsubscribeEventStream = (): void => {
 		for (const unsubscribe of unsubscribeEvents) unsubscribe();
@@ -2607,6 +2658,8 @@ function promptResponse(stopReason: string, active: ActivePrompt): AcpPromptResp
 				cacheRead: active.usage.cacheRead,
 				cacheWrite: active.usage.cacheWrite,
 				reasoning: active.usage.reasoning,
+				totalTokens: active.usage.totalTokens,
+				costUsd: active.usage.costUsd,
 			},
 		},
 	};

package/src/engine/agent.ts

@@ -14,7 +14,11 @@ import { Agent, type AgentOptions, type StreamFn } from "@earendil-works/pi-agen
 import { isDispositionedToolResultError } from "../tools/result-disposition.js";
 import { engineStreamSimple } from "./api-registry.js";
 
-export type EngineAgentOptions = Omit<AgentOptions, "streamFn"> & { streamFn?: StreamFn };
+export type EngineAgentOptions = Omit<AgentOptions, "streamFn"> & {
+	streamFn?: StreamFn;
+	/** Called immediately before each native stream delegate invocation. */
+	onStreamInvocation?: () => void;
+};
 
 export interface EngineAgentHandle {
 	agent: Agent;
@@ -34,9 +38,15 @@ function dispositionAwareAfterToolCall(
 }
 
 export function createEngineAgent(options: EngineAgentOptions = {}): EngineAgentHandle {
+	const { streamFn = engineStreamSimple, onStreamInvocation, ...agentOptions } = options;
 	const agent = new Agent({
-		streamFn: engineStreamSimple,
-		...options,
+		...agentOptions,
+		streamFn: onStreamInvocation
+			? (...args) => {
+					onStreamInvocation();
+					return streamFn(...args);
+				}
+			: streamFn,
 		afterToolCall: dispositionAwareAfterToolCall(options.afterToolCall),
 	});
 	return {