@iowarp/clio-coder 0.4.2 → 0.4.4

package/src/domains/dispatch/fleet-run.ts

@@ -657,6 +657,7 @@ export async function executeFleetRun(input: ExecuteFleetRunInput): Promise<Flee
 							output: receipt.output?.state === "final" ? receipt.output.text : "",
 							succeeded: stepSucceeded,
 							integrityValid,
+							...(receipt.decisionRefs !== undefined ? { decisionRefs: receipt.decisionRefs } : {}),
 							...(failureReason !== undefined ? { failureReason } : {}),
 							...(gatePathHash !== undefined ? { gatePathHash } : {}),
 							...(delegationPlanHash !== undefined ? { delegationPlanHash } : {}),

package/src/domains/dispatch/host-verification.ts

@@ -5,6 +5,7 @@ import { dirname, join, resolve } from "node:path";
 import { PATH_BOUNDARY_MAX_ENTRIES, pathBoundaryCovers, resolvePathBoundary } from "../../core/path-boundary.js";
 import { withStateFileLockSync } from "../../core/state-file-lock.js";
 import { clioStateDir } from "../../core/xdg.js";
+import { judgeNumericTexts, judgePerfTexts } from "../../tools/verify/scripts.js";
 import { FLEET_COMMAND_BASE_ENV, type FleetCommand } from "../agents/fleet-commands.js";
 import { runCodeStep } from "./code-step.js";
 import type { DispatchRequest } from "./contract.js";
@@ -12,7 +13,7 @@ import type { RunHostVerification, RunHostVerificationAttribution, RunHostVerifi
 import { captureWorkspaceSnapshot } from "./write-boundary.js";
 
 const OUTPUT_TAIL_BYTES = 2_048;
-const MEMO_VERSION = 1;
+const MEMO_VERSION = 2;
 
 type ResolvedCheck = NonNullable<DispatchRequest["resolvedVerification"]>[number];
 
@@ -37,7 +38,7 @@ interface MemoEntry {
 }
 
 interface MemoFile {
-	version: 1;
+	version: typeof MEMO_VERSION;
 	entries: MemoEntry[];
 }
 
@@ -108,10 +109,10 @@ function storeMemoEntry(stateDir: string, entry: MemoEntry): void {
 	});
 }
 
-function memoKey(command: FleetCommand, fingerprint: string, env: NodeJS.ProcessEnv): string {
+function memoKey(command: FleetCommand, judgment: string, fingerprint: string, env: NodeJS.ProcessEnv): string {
 	const names = [...FLEET_COMMAND_BASE_ENV, ...command.env];
 	const values = Object.fromEntries(names.map((name) => [name, env[name] ?? null]));
-	return sha256(JSON.stringify({ fingerprint, argv: command.argv, cwd: command.cwd, env: values }));
+	return sha256(JSON.stringify({ fingerprint, judgment, env: values }));
 }
 
 export function hostVerificationRejection(
@@ -124,10 +125,63 @@ export function hostVerificationRejection(
 		detail:
 			failedCheck === undefined
 				? "host verification rejected"
-				: `host verification check '${failedCheck.check}' rejected with exit code ${failedCheck.exitCode}`,
+				: failedCheck.report !== undefined
+					? `host verification check '${failedCheck.check}' rejected: ${failedCheck.report.summary}`
+					: `host verification check '${failedCheck.check}' rejected with exit code ${failedCheck.exitCode}`,
 	};
 }
 
+function readSealedFile(absolutePath: string): string | undefined {
+	try {
+		return readFileSync(absolutePath, "utf8");
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * The kind-specific verdict for a resolved check that already ran. A command
+ * check keeps its exit code. A numeric-compare check judges captured stdout
+ * against the sealed reference; a perf-budget check judges the measured
+ * duration against the sealed budget or baseline. Either judgement turns a
+ * clean exit into exit 1 when it fails, and a judgement that cannot be made
+ * (missing reference, unparseable output) fails with the reason in the tail.
+ */
+function judgeResolvedCheck(
+	resolvedCheck: ResolvedCheck,
+	exitCode: number,
+	durationMs: number,
+	stdout: string,
+): { exitCode: number; report?: RunHostVerificationCheck["report"]; outputTail?: string } {
+	if (resolvedCheck.kind === undefined || resolvedCheck.kind === "command" || exitCode !== 0) return { exitCode };
+	if (resolvedCheck.kind === "numeric-compare" && resolvedCheck.numeric !== undefined) {
+		const referenceText = readSealedFile(resolvedCheck.numeric.reference);
+		if (referenceText === undefined) {
+			return { exitCode: 1, outputTail: `numeric-compare: reference '${resolvedCheck.numeric.reference}' cannot be read` };
+		}
+		const report = judgeNumericTexts(
+			stdout,
+			referenceText,
+			resolvedCheck.numeric.tolerance,
+			`reference '${resolvedCheck.numeric.reference}'`,
+		);
+		if (report instanceof Error) return { exitCode: 1, outputTail: `numeric-compare: ${report.message}` };
+		return { exitCode: report.passed ? 0 : 1, report, outputTail: outputTail(report.summary) };
+	}
+	if (resolvedCheck.kind === "perf-budget" && resolvedCheck.perf !== undefined) {
+		const baselinePath = resolvedCheck.perf.baseline;
+		const report = judgePerfTexts(
+			durationMs,
+			resolvedCheck.perf,
+			baselinePath === undefined ? undefined : readSealedFile(baselinePath),
+			`baseline '${baselinePath ?? ""}'`,
+		);
+		if (report instanceof Error) return { exitCode: 1, outputTail: `perf-budget: ${report.message}` };
+		return { exitCode: report.passed ? 0 : 1, report, outputTail: outputTail(report.summary) };
+	}
+	return { exitCode: 1, outputTail: `${resolvedCheck.kind}: sealed check carries no parameters` };
+}
+
 async function runResolvedCheck(input: {
 	runId: string;
 	index: number;
@@ -145,9 +199,9 @@ async function runResolvedCheck(input: {
 		env: [],
 		description: `Host verification check ${resolvedCheck.check}.`,
 	};
+	const judgmentKey = checkDedupeKey(resolvedCheck);
 	const fingerprint = workspaceFingerprint(resolvedCheck.cwd);
-	const key =
-		fingerprint === null ? null : memoKey({ ...command, cwd: resolve(resolvedCheck.cwd) }, fingerprint, input.env);
+	const key = fingerprint === null ? null : memoKey(command, judgmentKey, fingerprint, input.env);
 	const hit =
 		key === null
 			? undefined
@@ -168,17 +222,24 @@ async function runResolvedCheck(input: {
 		env: input.env,
 	});
 	const artifactPath = outcome.record.artifactPaths[0];
+	const judgement = judgeResolvedCheck(
+		resolvedCheck,
+		outcome.record.exitCode,
+		outcome.record.durationMs,
+		outcome.stdout,
+	);
 	const check: RunHostVerificationCheck = {
 		check: resolvedCheck.check,
 		argv: [...outcome.record.argv],
 		cwd: outcome.record.cwd,
-		exitCode: outcome.record.exitCode,
+		exitCode: judgement.exitCode,
 		durationMs: outcome.record.durationMs,
 		memo: false,
-		outputTail: outputTail(outcome.report.outputExcerpt),
+		outputTail: judgement.outputTail ?? outputTail(outcome.report.outputExcerpt),
 		...(artifactPath !== undefined ? { artifactPath } : {}),
+		...(judgement.report !== undefined ? { report: judgement.report } : {}),
 	};
-	if (check.exitCode === 0 && key !== null) {
+	if (check.exitCode === 0 && key !== null && checkDedupeKey(resolvedCheck) === judgmentKey) {
 		try {
 			storeMemoEntry(input.stateDir, { key, runId: input.runId, check });
 		} catch (error) {
@@ -229,14 +290,45 @@ function implicatedPaths(outputExcerpt: string, checkCwd: string): string[] {
 	return [...paths].sort();
 }
 
-/** Identity of a resolved check across batch members: same command, same cwd, same bound. */
+/** Identity shared by memo reuse and batch deduplication, including the declared judgment and its input files. */
 function checkDedupeKey(resolvedCheck: ResolvedCheck): string {
+	const numeric = resolvedCheck.numeric;
+	const perf = resolvedCheck.perf;
 	return sha256(
 		JSON.stringify({
 			check: resolvedCheck.check,
 			argv: [...resolvedCheck.argv],
 			cwd: resolve(resolvedCheck.cwd),
 			timeoutMs: resolvedCheck.timeoutMs,
+			kind: resolvedCheck.kind ?? "command",
+			numeric:
+				numeric === undefined
+					? undefined
+					: {
+							reference: numeric.reference,
+							referenceDigest: sha256(JSON.stringify(readSealedFile(numeric.reference) ?? null)),
+							tolerance: {
+								absolute: numeric.tolerance.absolute,
+								relative: numeric.tolerance.relative,
+								ulp: numeric.tolerance.ulp,
+							},
+						},
+			perf:
+				perf === undefined
+					? undefined
+					: {
+							budget:
+								perf.budget === undefined
+									? undefined
+									: {
+											wallTimeMs: perf.budget.wallTimeMs,
+											tolerance: perf.budget.tolerance,
+										},
+							baseline: perf.baseline,
+							baselineDigest:
+								perf.baseline === undefined ? undefined : sha256(JSON.stringify(readSealedFile(perf.baseline) ?? null)),
+							tolerance: perf.tolerance,
+						},
 		}),
 	);
 }
@@ -304,6 +396,12 @@ function memberBoundary(participant: BatchVerificationParticipant): string[] {
  * the tree. `basis` is the weakest evidence behind the charge set, never the
  * strongest, so `write_roots` on a receipt means every charged run has a named
  * path inside its own declared boundary.
+ *
+ * A `worktree: true` member's write roots resolve against its own checkout
+ * (`request.cwd`) while the shared check ran in the parent frame, so none of
+ * its roots can cover a path the check named: attribution cannot exculpate
+ * anyone on its account and every declarer is charged, the conservative
+ * fallback those receipts sealed before batch settlement existed.
  */
 function attributeFailure(input: {
 	implicated: ReadonlyArray<string>;
@@ -421,9 +519,11 @@ export function createBatchVerificationGate(
 			string,
 			{ resolvedCheck: ResolvedCheck; owner: BatchVerificationParticipant; index: number }
 		>();
+		const checkKeys = new Map<ResolvedCheck, string>();
 		for (const member of contributors) {
 			for (const resolvedCheck of member.request.resolvedVerification ?? []) {
 				const key = checkDedupeKey(resolvedCheck);
+				checkKeys.set(resolvedCheck, key);
 				if (!distinct.has(key)) distinct.set(key, { resolvedCheck, owner: member, index: distinct.size });
 			}
 		}
@@ -448,7 +548,7 @@ export function createBatchVerificationGate(
 		for (const [key, entry] of ran) {
 			if (entry.check.exitCode === 0) continue;
 			const declarers = contributors.filter((member) =>
-				(member.request.resolvedVerification ?? []).some((candidate) => checkDedupeKey(candidate) === key),
+				(member.request.resolvedVerification ?? []).some((candidate) => checkKeys.get(candidate) === key),
 			);
 			const implicated = implicatedPaths(entry.outputExcerpt, entry.check.cwd);
 			const verdict = attributeFailure({ implicated, declarers, wave: members });
@@ -478,7 +578,8 @@ export function createBatchVerificationGate(
 			let rejected = false;
 			let unimplicated = false;
 			for (const resolvedCheck of member.request.resolvedVerification ?? []) {
-				const key = checkDedupeKey(resolvedCheck);
+				const key = checkKeys.get(resolvedCheck);
+				if (key === undefined) throw new Error("host verification: declared check has no batch identity");
 				const shared = ran.get(key);
 				if (shared === undefined) continue;
 				own.push(

package/src/domains/dispatch/intent.ts

@@ -271,13 +271,34 @@ export function normalizeDispatchIntent(
 	if (!Array.isArray(writeRoots)) return writeRoots;
 	const relevantPaths = normalizePathList(raw.relevant_paths, "intent.relevant_paths");
 	if (!Array.isArray(relevantPaths)) return relevantPaths;
-	const expectedOutputs = normalizePathList(
-		raw.expected_outputs,
-		"intent.expected_outputs",
-		normalizeExpectedOutputEntry,
-	);
+	const expectedOutputs = normalizeIntentExpectedOutputs(raw.expected_outputs);
 	if (!Array.isArray(expectedOutputs)) return expectedOutputs;
-	const rawVerification = raw.verification ?? [];
+	const verification = normalizeIntentVerification(raw.verification, checks);
+	if (!Array.isArray(verification)) return verification;
+
+	return {
+		ok: true,
+		intent: {
+			version: 2,
+			readRoots,
+			writeRoots,
+			relevantPaths,
+			pathProvenance: declaredIntentPathProvenance({ readRoots, writeRoots, relevantPaths }),
+			expectedOutputs,
+			verification,
+		},
+	};
+}
+
+export function normalizeIntentExpectedOutputs(raw: unknown): string[] | DispatchIntentNormalizationResult {
+	return normalizePathList(raw, "intent.expected_outputs", normalizeExpectedOutputEntry);
+}
+
+export function normalizeIntentVerification(
+	raw: unknown,
+	checks: ReadonlyMap<string, DispatchIntentCheckBound>,
+): DispatchIntentVerification[] | DispatchIntentNormalizationResult {
+	const rawVerification = raw ?? [];
 	if (!Array.isArray(rawVerification)) {
 		return fail("verification_malformed", "intent.verification must be an array");
 	}
@@ -321,16 +342,5 @@ export function normalizeDispatchIntent(
 			timeoutMs: Math.min(declared.timeoutMs, Math.max(DISPATCH_INTENT_TIMEOUT_MIN_MS, requested)),
 		});
 	}
-	return {
-		ok: true,
-		intent: {
-			version: 2,
-			readRoots,
-			writeRoots,
-			relevantPaths,
-			pathProvenance: declaredIntentPathProvenance({ readRoots, writeRoots, relevantPaths }),
-			expectedOutputs,
-			verification,
-		},
-	};
+	return verification;
 }

package/src/domains/dispatch/orphan-recovery.ts

@@ -49,6 +49,7 @@ function receiptsDir(): string {
  */
 function envelopeFromReceipt(receipt: RunReceipt, status: RunStatus, receiptPath: string): RunEnvelope {
 	const envelope: RunEnvelope = {
+		version: 1,
 		id: receipt.runId,
 		agentId: receipt.agentId,
 		executionRole: receipt.executionRole,
@@ -97,6 +98,7 @@ function envelopeFromReceipt(receipt: RunReceipt, status: RunStatus, receiptPath
 	if (receipt.gate !== undefined) envelope.gate = receipt.gate;
 	if (receipt.plan !== undefined) envelope.plan = receipt.plan;
 	if (receipt.personaOverride !== undefined) envelope.personaOverride = receipt.personaOverride;
+	if (receipt.decisionRefs !== undefined) envelope.decisionRefs = receipt.decisionRefs;
 	return envelope;
 }
 

package/src/domains/dispatch/receipt-integrity.ts

@@ -99,6 +99,9 @@ export const RECEIPT_INTEGRITY_FIELD_COVERAGE = {
 	plan: true,
 	fleetGate: true,
 	personaOverride: true,
+	// Absent unless the parent board held decisions, so older receipts and
+	// decision-free runs digest exactly as before.
+	decisionRefs: true,
 	projectContext: true,
 	// Always set on receipts written after #104 landed; absent only on older
 	// receipts, which omit these fields from canonical serialization.
@@ -193,6 +196,7 @@ function ledgerDigestFields(envelope: RunEnvelope): Record<string, unknown> {
 		executionRole: envelope.executionRole,
 		task: envelope.task,
 		...(envelope.budget !== undefined ? { budget: envelope.budget } : {}),
+		...(envelope.decisionRefs !== undefined ? { decisionRefs: envelope.decisionRefs } : {}),
 		targetId: envelope.targetId,
 		wireModelId: envelope.wireModelId,
 		runtimeId: envelope.runtimeId,

package/src/domains/dispatch/reservation-store.ts

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { withStateFileLockSync } from "../../core/state-file-lock.js";
+import { withStateFileLock, withStateFileLockSync } from "../../core/state-file-lock.js";
 import { endpointLabel } from "../providers/endpoint-capacity.js";
 import {
 	acquireCapacityLease,
@@ -361,8 +361,10 @@ export function rebindDispatchReservationMember(input: {
 	costUpperBoundUsd: number;
 	capacity: ReservationCapacitySnapshot;
 	nowMs?: number;
-}): DispatchReservationRecord {
-	return withStateFileLockSync(capacityStateLockPath(), () => {
+}): Promise<DispatchReservationRecord> {
+	// Retry admission runs inside the async dispatch attempt, so it can yield
+	// while waiting for the cross-process lock instead of blocking the event loop.
+	return withStateFileLock(capacityStateLockPath(), () => {
 		const nowMs = input.nowMs ?? Date.now();
 		const records = expireRecords(readStore(), nowMs, false);
 		const record = records.find((entry) => entry.ownerId === input.ownerId);

package/src/domains/dispatch/state.ts

@@ -52,6 +52,7 @@ export interface LedgerOptions {
 
 export type CreateRunInput = Omit<
 	RunEnvelope,
+	| "version"
 	| "id"
 	| "startedAt"
 	| "endedAt"
@@ -143,6 +144,10 @@ export function listFleetRuns(limit = MAX_FLEET_RUN_SCAN): FleetRunRecord[] {
 	return records.slice(0, Math.max(0, limit));
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // `RunEnvelope.heartbeatAt` deliberately persists only the absolute wall-clock
 // anchor used for operator display and crash recovery. The monotonic heartbeat
 // stamp belongs to the live transport in this process; serializing it would
@@ -152,9 +157,16 @@ function readRuns(): RunEnvelope[] {
 	if (!existsSync(path)) return [];
 	const raw = readFileSync(path, "utf8").trim();
 	if (raw.length === 0) return [];
-	const parsed = JSON.parse(raw) as RunEnvelope[];
+	const parsed = JSON.parse(raw) as unknown;
 	if (!Array.isArray(parsed)) return [];
-	return parsed;
+	const envelopes: RunEnvelope[] = [];
+	for (const entry of parsed) {
+		if (!isRecord(entry)) continue;
+		const version = entry.version === undefined ? 1 : entry.version;
+		if (version !== 1) continue;
+		envelopes.push({ ...(entry as unknown as RunEnvelope), version: 1 });
+	}
+	return envelopes;
 }
 
 function resolveMaxRuns(opt?: number | undefined): number {
@@ -241,6 +253,7 @@ export function openLedger(opts?: LedgerOptions): Ledger {
 	return {
 		create(input: CreateRunInput): RunEnvelope {
 			const envelope: RunEnvelope = {
+				version: 1,
 				id: input.id ?? newRunId(),
 				agentId: input.agentId,
 				executionRole: input.executionRole,

package/src/domains/dispatch/types.ts

@@ -6,9 +6,11 @@
  * are pure data: no class methods, no engine refs.
  */
 
+import type { GatewayRoutingObservation } from "../../core/gateway-routing.js";
 import type { ResponseModelIdObservation } from "../../core/response-model-id.js";
 import type { SkillActivation } from "../../core/skill-activation.js";
 import type { ToolProfileName } from "../../tools/profiles.js";
+import type { DeclaredCheckReport } from "../../tools/verify/scripts.js";
 import type { AgentAudience } from "../agents/spec.js";
 import type { EvidenceTag } from "../evidence/index.js";
 import type { CostProvenance, RuntimeTargetSnapshot } from "../providers/index.js";
@@ -441,6 +443,7 @@ export interface RunReceiptFindingsSummary {
 }
 
 export interface RunEnvelope {
+	version: 1;
 	id: string;
 	agentId: string;
 	/** Semantic role this attempt's route statistics belong to. */
@@ -482,6 +485,8 @@ export interface RunEnvelope {
 	plan?: RunPlanProvenance;
 	/** Ad-hoc specialist provenance; present only when a persona override composed the stable prompt. */
 	personaOverride?: RunPersonaOverride;
+	/** Decision refs active on the parent decision board at dispatch; absent when the board was empty. */
+	decisionRefs?: ReadonlyArray<string>;
 	exitCode: number | null;
 	pid: number | null;
 	heartbeatAt: string | null;
@@ -652,6 +657,8 @@ export interface RunReceiptUpstreamResponse {
 	responseModelIdObservation: ResponseModelIdObservation;
 	differingResponseModelId: string | null;
 	providerResponseId: string | null;
+	/** Physical route and proxy attempts reported by LiteLLM, when this call used that gateway. */
+	gatewayRouting?: GatewayRoutingObservation;
 }
 
 /**
@@ -707,11 +714,14 @@ export interface RunHostVerificationCheck {
 	check: string;
 	argv: string[];
 	cwd: string;
+	/** For a numeric-compare or perf-budget check, 1 when the judgement failed even though the command exited 0. */
 	exitCode: number;
 	durationMs: number;
 	memo: boolean;
 	outputTail: string;
 	artifactPath?: string;
+	/** Structured verdict of a numeric-compare or perf-budget check; absent for a command check. Covered by the receipt digest through `hostVerification`. */
+	report?: DeclaredCheckReport;
 	/** Run that owns the evidence when it did not come from this run: a memo hit, or the batch member the shared check ran under. */
 	evidenceRunId?: string;
 }
@@ -808,8 +818,14 @@ export interface RunReceipt {
 	node?: RunNodeIdentity;
 	/**
 	 * Route and node identity attested by the worker process that executed the
-	 * run. Absent only when no worker announced, which is the stubbed-spawn path
-	 * contract tests use; every native and remote transport attests.
+	 * run. Every native and remote worker transport attests, so a receipt from
+	 * the worker path carries this field. It is legitimately absent on receipts
+	 * that no worker process produced: the print-mode main-agent receipt
+	 * (src/cli/modes/print.ts), which runs in the orchestrator process, and ACP
+	 * delegation receipts, whose external agent never sends an announce frame.
+	 * The eval process invariants (src/domains/eval/metrics/invariants.ts) rely
+	 * on that absence to skip the main-agent path when counting orphaned
+	 * workers. Contract tests that stub the spawn also leave it absent.
 	 */
 	attestation?: RunReceiptAttestation;
 	/** Dead-node failover hops, oldest first; absent when the run was never rerouted. */
@@ -825,6 +841,8 @@ export interface RunReceipt {
 	fleetGate?: { path: string; pathHash: string };
 	/** Ad-hoc specialist provenance; present only when a persona override composed the stable prompt. */
 	personaOverride?: RunPersonaOverride;
+	/** Decision refs active on the parent decision board at dispatch; absent when the board was empty. */
+	decisionRefs?: ReadonlyArray<string>;
 	/** Effective project-context tier for this run; absent on receipts written before this field landed. */
 	projectContext?: RunProjectContextProvenance;
 	/**

package/src/domains/dispatch/worker-model-metadata.ts

@@ -0,0 +1,38 @@
+import type { ProvidersContract } from "../providers/contract.js";
+
+/** Preparation owns its wait; a late HTTP body cannot start an expired worker. */
+export async function prepareWorkerModelMetadata(
+	providers: ProvidersContract,
+	targetId: string,
+	deadlineAt: number,
+	signal?: AbortSignal,
+	now: () => number = Date.now,
+): Promise<void> {
+	signal?.throwIfAborted();
+	const status = providers.list().find((entry) => entry.target.id === targetId);
+	if (status?.target.runtime !== "litellm" || status.health.lastCheckAt !== null) return;
+	const remainingMs = deadlineAt - now();
+	const deadlineError = new Error("dispatch: admission deadline expired during worker model metadata preparation");
+	if (remainingMs <= 0) throw deadlineError;
+	const controller = new AbortController();
+	const abort = (): void => controller.abort(signal?.reason);
+	signal?.addEventListener("abort", abort, { once: true });
+	const timer = setTimeout(() => controller.abort(deadlineError), Math.min(remainingMs, 2_147_483_647));
+	let rejectAborted!: (reason: unknown) => void;
+	const aborted = new Promise<never>((_resolve, reject) => {
+		rejectAborted = reject;
+	});
+	const onAbort = (): void => rejectAborted(controller.signal.reason);
+	controller.signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		// The provider also fences publication after each await. Promise.race
+		// observes the probe's eventual rejection if an HTTP body settles late.
+		await Promise.race([providers.probeTarget(targetId, { reasoning: false, signal: controller.signal }), aborted]);
+		controller.signal.throwIfAborted();
+		if (now() >= deadlineAt) throw deadlineError;
+	} finally {
+		clearTimeout(timer);
+		signal?.removeEventListener("abort", abort);
+		controller.signal.removeEventListener("abort", onAbort);
+	}
+}

package/src/domains/eval/metrics/call-ledger-stream.ts

@@ -6,7 +6,11 @@ export interface EvalCallLedgerFold {
 	entries(): SessionEntry[];
 }
 
-/** Fold structured assistant completions into the eval's per-call ledger. */
+/**
+ * Fold stdout assistant completions into a fallback ledger. These spans start
+ * at the provider's message_start, which may follow its response-header wait;
+ * they are not complete request latency. Native eval prefers session timing.
+ */
 export function createEvalCallLedgerFold(now: () => number = () => performance.now()): EvalCallLedgerFold {
 	const entries: SessionEntry[] = [];
 	let pending = "";
@@ -21,7 +25,7 @@ export function createEvalCallLedgerFold(now: () => number = () => performance.n
 			activeFirstOutputAt = null;
 			return;
 		}
-		if (event.type === "message_update" && activeStartedAt !== null && activeFirstOutputAt === null) {
+		if (isAssistantOutput(event) && activeStartedAt !== null && activeFirstOutputAt === null) {
 			activeFirstOutputAt = now();
 			return;
 		}
@@ -42,19 +46,25 @@ export function createEvalCallLedgerFold(now: () => number = () => performance.n
 		};
 		if (isRecord(message.backendTimings)) promptCache.backend = structuredClone(message.backendTimings);
 		const previous = entries.at(-1);
+		const timestamp = messageTimestamp(message.timestamp);
 		entries.push({
 			kind: "message",
 			role: "assistant",
 			turnId: `eval-call-${entries.length + 1}`,
 			parentTurnId: previous?.turnId ?? null,
-			timestamp: messageTimestamp(message.timestamp),
+			timestamp: timestamp ?? new Date(0).toISOString(),
 			payload: {
+				// Retain the legacy ISO placeholder without treating it as observed
+				// chronology. Per-call monotonic timing remains usable on its own.
+				...(timestamp === null ? { timestampEstimated: true } : {}),
 				promptCache,
-				timing: {
-					ttftMs:
-						activeStartedAt === null ? null : Math.round(Math.max(0, (activeFirstOutputAt ?? endedAt) - activeStartedAt)),
-					apiMs: activeStartedAt === null ? 0 : Math.round(Math.max(0, endedAt - activeStartedAt)),
-				},
+				timing:
+					activeStartedAt === null
+						? null
+						: {
+								ttftMs: activeFirstOutputAt === null ? null : Math.round(Math.max(0, activeFirstOutputAt - activeStartedAt)),
+								apiMs: Math.round(Math.max(0, endedAt - activeStartedAt)),
+							},
 				usage: structuredClone(usage),
 			},
 		});
@@ -82,15 +92,28 @@ export function createEvalCallLedgerFold(now: () => number = () => performance.n
 	};
 }
 
+function isAssistantOutput(event: Record<string, unknown>): boolean {
+	// Headless chat projects updates to text/thinking deltas; worker stdout
+	// retains the nested update. Structural events are not token observations.
+	const output = event.type === "message_update" ? event.assistantMessageEvent : event;
+	if (!isRecord(output)) return false;
+	if (output.type === "toolcall_start") return event.type === "message_update";
+	return (
+		(output.type === "text_delta" || output.type === "thinking_delta" || output.type === "toolcall_delta") &&
+		typeof output.delta === "string" &&
+		output.delta.length > 0
+	);
+}
+
 function isAssistantMessage(value: unknown): value is Record<string, unknown> & { role: "assistant" } {
 	return isRecord(value) && value.role === "assistant";
 }
 
-function messageTimestamp(value: unknown): string {
+function messageTimestamp(value: unknown): string | null {
 	const milliseconds = nonNegativeNumber(value);
-	if (milliseconds === null) return new Date(0).toISOString();
+	if (milliseconds === null) return null;
 	const date = new Date(milliseconds);
-	return Number.isFinite(date.getTime()) ? date.toISOString() : new Date(0).toISOString();
+	return Number.isFinite(date.getTime()) ? date.toISOString() : null;
 }
 
 function nonNegativeNumber(value: unknown): number | null {