@iowarp/clio-coder 0.4.3 → 0.4.5

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

@@ -10,6 +10,7 @@ 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";
@@ -442,6 +443,7 @@ export interface RunReceiptFindingsSummary {
 }
 
 export interface RunEnvelope {
+	version: 1;
 	id: string;
 	agentId: string;
 	/** Semantic role this attempt's route statistics belong to. */
@@ -483,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;
@@ -663,9 +667,10 @@ export interface RunReceiptUpstreamResponse {
  * `state: "final"` means the text is a completed assistant message (the last
  * `message_end`); `state: "partial"` means mid-stream text from a message that
  * never completed (abort, stall, kill) and must never be presented as final.
- * `bytes` is the UTF-8 length of the full captured text before the
- * WORKER_OUTPUT_MAX_BYTES bound; `truncated` records that the bound clipped
- * `text`, so truncation is always explicit. Absent when no assistant text was
+ * `bytes` is the UTF-8 length of the full captured text before the run's
+ * capture bound (WORKER_OUTPUT_MAX_BYTES, or the larger bound a mutation-report
+ * contract's summary allowance implies); `truncated` records that the bound
+ * clipped `text`, so truncation is always explicit. Absent when no assistant text was
  * captured. Covered by the receipt integrity digest like every other field.
  */
 export interface RunReceiptOutput {
@@ -710,11 +715,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;
 }
@@ -811,8 +819,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. */
@@ -828,6 +842,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-spawn.ts

@@ -465,27 +465,58 @@ export function spawnWorkerProcess(
 		},
 	};
 
-	const promise = new Promise<SpawnedWorkerResult>((resolve) => {
-		child.on("close", (code, signal) => {
+	let settled = false;
+	let abortStarted = false;
+	let killTimer: ReturnType<typeof setTimeout> | null = null;
+	let pendingClose: (() => void) | null = null;
+
+	// The leader may exit while a same-group descendant has closed all inherited
+	// pipes. Neither exit nor close proves that cancellation reached the group.
+	function hasOwnedProcesses(): boolean {
+		if (pid === null) return false;
+		if (process.platform !== "win32") {
 			try {
-				child.stdin?.end();
-			} catch {
-				// stdin may already be closed.
-			}
-			end();
-			if (sawSpawnError) {
-				resolve({ exitCode: null, signal: null, ...diagnostics() });
-				return;
+				process.kill(-pid, 0);
+				return true;
+			} catch (error) {
+				if ((error as NodeJS.ErrnoException).code === "EPERM") return true;
 			}
-			if (!announceAccepted && !announceFailed) {
-				announceFailed = true;
-				appendStderr("[worker] Missing worker attestation: peer exited before announcing its route identity\n");
-			}
-			if (announceFailed) {
-				resolve({ exitCode: code !== null && code !== 0 ? code : 1, signal: signal ?? null, ...diagnostics() });
+		}
+		return isAlive();
+	}
+
+	const promise = new Promise<SpawnedWorkerResult>((resolve) => {
+		child.on("close", (code, signal) => {
+			const finish = (): void => {
+				if (settled) return;
+				settled = true;
+				try {
+					child.stdin?.end();
+				} catch {
+					// stdin may already be closed.
+				}
+				end();
+				if (sawSpawnError) {
+					resolve({ exitCode: null, signal: null, ...diagnostics() });
+					return;
+				}
+				if (!announceAccepted && !announceFailed) {
+					announceFailed = true;
+					appendStderr("[worker] Missing worker attestation: peer exited before announcing its route identity\n");
+				}
+				if (announceFailed) {
+					resolve({ exitCode: code !== null && code !== 0 ? code : 1, signal: signal ?? null, ...diagnostics() });
+					return;
+				}
+				resolve({ exitCode: code ?? 0, signal: signal ?? null, ...diagnostics() });
+			};
+			if (killTimer !== null && hasOwnedProcesses()) {
+				pendingClose = finish;
 				return;
 			}
-			resolve({ exitCode: code ?? 0, signal: signal ?? null, ...diagnostics() });
+			if (killTimer !== null) clearTimeout(killTimer);
+			killTimer = null;
+			finish();
 		});
 	});
 
@@ -543,15 +574,17 @@ export function spawnWorkerProcess(
 	};
 
 	const abort = (): void => {
-		if (!isAlive()) return;
+		if (settled || abortStarted || !hasOwnedProcesses()) return;
+		abortStarted = true;
 		try {
 			child.stdin?.end();
 		} catch {
 			// process may already be closing
 		}
 		signalProcessGroup(child, "SIGTERM");
-		const killTimer = setTimeout(() => {
-			if (isAlive()) {
+		killTimer = setTimeout(() => {
+			killTimer = null;
+			if (hasOwnedProcesses()) {
 				signalProcessGroup(child, "SIGKILL");
 				try {
 					opts?.onForcedKill?.();
@@ -559,8 +592,12 @@ export function spawnWorkerProcess(
 					// fallback is best-effort; the local channel is already dead
 				}
 			}
+			const finish = pendingClose;
+			pendingClose = null;
+			finish?.();
 		}, shutdownGraceMs);
-		killTimer.unref?.();
+		// Keep this timer referenced: callers await settlement before process exit,
+		// even when the leader and every inherited pipe have already closed.
 	};
 
 	return {

package/src/domains/dispatch/workspace-checkpoint.ts

@@ -0,0 +1,57 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { buildSafeToolEnv } from "../../core/safe-exec.js";
+
+/** Stable recovery namespace; labels never enter Git's ref grammar unchecked. */
+export function workspaceCheckpointRef(kind: "loop" | "compete", identity: string): string {
+	return `refs/clio-coder/${kind}/${createHash("sha256").update(identity).digest("hex")}`;
+}
+
+/** Capture tracked and nonignored untracked state without modifying HEAD or the user's index.
+ * The immutable ref makes retries idempotent and keeps the object alive across GC. */
+export function captureWorkspaceCheckpoint(cwd: string, ref: string, message: string): string {
+	if (!/^refs\/clio-coder\/(loop|compete)\/[a-f0-9]{64}$/.test(ref)) throw new Error("invalid workspace checkpoint ref");
+	const directory = mkdtempSync(join(tmpdir(), "clio-checkpoint-index-"));
+	const env = buildSafeToolEnv({
+		GIT_INDEX_FILE: join(directory, "index"),
+		GIT_AUTHOR_NAME: "Clio checkpoint",
+		GIT_AUTHOR_EMAIL: "checkpoint@clio.invalid",
+		GIT_COMMITTER_NAME: "Clio checkpoint",
+		GIT_COMMITTER_EMAIL: "checkpoint@clio.invalid",
+	});
+	const config = ["-c", "core.hooksPath=/dev/null", "-c", "core.fsmonitor=false"];
+	const git = (args: string[]) =>
+		execFileSync("git", ["-C", cwd, ...config, ...args], {
+			env,
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "pipe"],
+			timeout: 30000,
+			maxBuffer: 1024 * 1024,
+		}).trim();
+	try {
+		try {
+			git(["rev-parse", "--verify", ref]);
+			return ref;
+		} catch {
+			/* First capture owns this immutable reference. */
+		}
+		const head = git(["rev-parse", "HEAD"]);
+		// Automatic preservation must not run repository-configured filter commands.
+		// Names stay argv values; Git's ordinary text normalization still applies.
+		const filterKeys = git(["config", "--null", "--name-only", "--list"])
+			.split("\0")
+			.filter((key) => /^filter\..*\.(?:clean|process|required)$/.test(key));
+		for (const key of filterKeys) config.push("-c", `${key}=${key.endsWith(".required") ? "false" : ""}`);
+		git(["read-tree", head]);
+		git(["add", "-A", "--", "."]);
+		const tree = git(["write-tree"]);
+		const commit = git(["commit-tree", tree, "-p", head, "-m", message]);
+		git(["update-ref", ref, commit, ""]);
+		return ref;
+	} finally {
+		rmSync(directory, { recursive: true, force: true });
+	}
+}

package/src/domains/eval/compare/behavioral.ts

@@ -31,7 +31,10 @@ export interface EvalBehaviorMetricDistributionV1 {
 export interface EvalBehaviorMetricComparisonV1 {
 	scenarioId: string;
 	role: string;
+	/** Representative route retained for existing consumers; both sides are recorded below. */
 	target: { id: string; model: string | null };
+	baselineTargets: Array<{ id: string; model: string | null }>;
+	candidateTargets: Array<{ id: string; model: string | null }>;
 	metric: EvalBehaviorMetricNameV1;
 	family: EvalBehaviorMetricFamilyV1;
 	direction: "higher" | "lower";
@@ -40,6 +43,8 @@ export interface EvalBehaviorMetricComparisonV1 {
 	candidate: EvalBehaviorMetricDistributionV1;
 	change: EvalMetricChangeV1;
 	meanDelta: number | null;
+	/** Two standard errors of the difference; unresolved is not proof of equivalence. Safety stays exact. */
+	noiseBand: number;
 	varianceChange: EvalMetricChangeV1;
 	varianceDelta: number | null;
 	comparability: EvalEnvelopeComparabilityV1;
@@ -52,6 +57,8 @@ export interface EvalBehaviorHardGateV1 {
 		scenarioId: string;
 		role: string;
 		target: { id: string; model: string | null };
+		baselineTargets: Array<{ id: string; model: string | null }>;
+		candidateTargets: Array<{ id: string; model: string | null }>;
 		metric: EvalBehaviorMetricNameV1;
 		change: "regressed" | "incomparable";
 	}>;
@@ -61,6 +68,7 @@ interface BehaviorGroup {
 	scenarioId: string;
 	role: string;
 	target: { id: string; model: string | null };
+	targets: Array<{ id: string; model: string | null }>;
 	results: EvalArtifactResultV4[];
 }
 
@@ -72,26 +80,47 @@ export function compareEvalBehaviorMetricsV1(
 	hardGate: EvalBehaviorHardGateV1;
 	envelopeMismatches: EvalEnvelopeMismatchV1[];
 } {
-	const baselineGroups = behaviorGroups(baseline);
-	const candidateGroups = behaviorGroups(candidate);
+	const baselineDimensions = baseline.matrix.dimensions ?? ([] as EvalExecutionMatrixDimensionV1[]);
+	const candidateDimensions = candidate.matrix.dimensions ?? ([] as EvalExecutionMatrixDimensionV1[]);
+	const varying = new Set(baselineDimensions.filter((dimension) => candidateDimensions.includes(dimension)));
+	const baselineGroups = behaviorGroups(baseline, varying);
+	const candidateGroups = behaviorGroups(candidate, varying);
 	const keys = new Set([...baselineGroups.keys(), ...candidateGroups.keys()]);
 	const comparisons: EvalBehaviorMetricComparisonV1[] = [];
 	const envelopeMismatches: EvalEnvelopeMismatchV1[] = [];
-	const baselineDimensions = baseline.matrix.dimensions ?? ([] as EvalExecutionMatrixDimensionV1[]);
-	const candidateDimensions = candidate.matrix.dimensions ?? ([] as EvalExecutionMatrixDimensionV1[]);
 	for (const key of [...keys].sort((left, right) => left.localeCompare(right))) {
 		const baselineGroup = baselineGroups.get(key);
 		const candidateGroup = candidateGroups.get(key);
-		const identity = baselineGroup ?? candidateGroup;
-		if (identity === undefined) continue;
-		const envelopeMismatch = compareEvalExecutionEnvelopesV1(
+		const group = baselineGroup ?? candidateGroup;
+		if (group === undefined) continue;
+		const identity = {
+			scenarioId: group.scenarioId,
+			role: group.role,
+			target: { id: group.target.id, model: group.target.model },
+		};
+		const routes = {
+			baselineTargets: baselineGroup?.targets ?? [],
+			candidateTargets: candidateGroup?.targets ?? [],
+		};
+		let envelopeMismatch = compareEvalExecutionEnvelopesV1(
 			identity,
 			baselineGroup?.results ?? [],
 			candidateGroup?.results ?? [],
 			baselineDimensions,
 			candidateDimensions,
 		);
-		if (envelopeMismatch !== null) envelopeMismatches.push(envelopeMismatch);
+		// Ignoring a dimension may align one route per side, but cannot choose between
+		// multiple routes or pool their trials into an apparently comparable distribution.
+		if (routes.baselineTargets.length > 1 || routes.candidateTargets.length > 1) {
+			envelopeMismatch = {
+				...identity,
+				fields: ["behavioralMetrics.ambiguousRouteGroup", ...(envelopeMismatch?.fields ?? [])],
+			};
+		}
+		if (envelopeMismatch !== null) {
+			envelopeMismatch = { ...envelopeMismatch, ...routes };
+			envelopeMismatches.push(envelopeMismatch);
+		}
 		const comparability: EvalEnvelopeComparabilityV1 = {
 			comparable: envelopeMismatch === null,
 			mismatchedFields: envelopeMismatch?.fields ?? [],
@@ -99,10 +128,13 @@ export function compareEvalBehaviorMetricsV1(
 		for (const definition of EVAL_BEHAVIOR_METRIC_DEFINITIONS_V1) {
 			const baselineDistribution = behaviorDistribution(baselineGroup?.results ?? [], definition);
 			const candidateDistribution = behaviorDistribution(candidateGroup?.results ?? [], definition);
+			const noiseBand =
+				definition.family === "safety" ? 0 : distributionNoiseBand(baselineDistribution, candidateDistribution);
 			comparisons.push({
 				scenarioId: identity.scenarioId,
 				role: identity.role,
 				target: identity.target,
+				...routes,
 				metric: definition.name,
 				family: definition.family,
 				direction: definition.direction,
@@ -111,9 +143,10 @@ export function compareEvalBehaviorMetricsV1(
 				candidate: candidateDistribution,
 				change:
 					envelopeMismatch === null
-						? classifyChange(baselineDistribution.mean, candidateDistribution.mean, definition.direction)
+						? classifyChange(baselineDistribution.mean, candidateDistribution.mean, definition.direction, noiseBand)
 						: "incomparable",
 				meanDelta: subtractNullable(candidateDistribution.mean, baselineDistribution.mean),
+				noiseBand,
 				varianceChange:
 					envelopeMismatch === null
 						? classifyChange(baselineDistribution.variance, candidateDistribution.variance, "lower")
@@ -132,6 +165,8 @@ export function compareEvalBehaviorMetricsV1(
 						scenarioId: comparison.scenarioId,
 						role: comparison.role,
 						target: comparison.target,
+						baselineTargets: comparison.baselineTargets,
+						candidateTargets: comparison.candidateTargets,
 						metric: comparison.metric,
 						change: comparison.change,
 					},
@@ -153,25 +188,33 @@ export function classifyChange(
 	baseline: number | null,
 	candidate: number | null,
 	direction: "higher" | "lower",
+	noiseBand = 0,
 ): EvalMetricChangeV1 {
 	if (baseline === null || candidate === null) return "incomparable";
-	if (baseline === candidate) return "unchanged";
+	if (Math.abs(candidate - baseline) <= noiseBand) return "unchanged";
 	if (direction === "higher") return candidate > baseline ? "improved" : "regressed";
 	return candidate < baseline ? "improved" : "regressed";
 }
 
-function behaviorGroups(artifact: EvalArtifactV4): Map<string, BehaviorGroup> {
+function behaviorGroups(
+	artifact: EvalArtifactV4,
+	varying: ReadonlySet<EvalExecutionMatrixDimensionV1>,
+): Map<string, BehaviorGroup> {
 	const groups = new Map<string, BehaviorGroup>();
 	for (const result of artifact.results) {
 		const behavioral = result.behavioralMetrics;
 		if (behavioral === undefined) continue;
-		const key = groupKey(behavioral.scenarioId, behavioral.role, behavioral.target);
+		const key = groupKey(behavioral.scenarioId, behavioral.role, behavioral.target, varying);
 		const group = groups.get(key) ?? {
 			scenarioId: behavioral.scenarioId,
 			role: behavioral.role,
 			target: behavioral.target,
+			targets: [],
 			results: [],
 		};
+		if (!group.targets.some((target) => target.id === behavioral.target.id && target.model === behavioral.target.model)) {
+			group.targets.push(behavioral.target);
+		}
 		group.results.push(result);
 		groups.set(key, group);
 	}
@@ -215,10 +258,34 @@ function behaviorDistribution(
 	};
 }
 
-function groupKey(scenarioId: string, role: string, target: { id: string; model: string | null }): string {
-	return JSON.stringify([scenarioId, role, target.id, target.model]);
+function groupKey(
+	scenarioId: string,
+	role: string,
+	target: { id: string; model: string | null },
+	varying: ReadonlySet<EvalExecutionMatrixDimensionV1>,
+): string {
+	return JSON.stringify([
+		scenarioId,
+		role,
+		varying.has("target") ? null : target.id,
+		varying.has("wireModel") ? null : target.model,
+	]);
 }
 
 function subtractNullable(left: number | null, right: number | null): number | null {
 	return left === null || right === null ? null : left - right;
 }
+
+function distributionNoiseBand(
+	baseline: EvalBehaviorMetricDistributionV1,
+	candidate: EvalBehaviorMetricDistributionV1,
+): number {
+	// Missing coverage and single trials cannot establish empirical variation.
+	if (baseline.measured < 2 || candidate.measured < 2 || baseline.unmeasured > 0 || candidate.unmeasured > 0) return 0;
+	// Stored variance is population variance. Divide by n-1 to obtain the
+	// unbiased estimate of variance of each sample mean.
+	return (
+		2 *
+		Math.sqrt((baseline.variance ?? 0) / (baseline.measured - 1) + (candidate.variance ?? 0) / (candidate.measured - 1))
+	);
+}

package/src/domains/eval/compare/compare.ts

@@ -132,7 +132,7 @@ export function compareEvalArtifactsV4(
 export function renderEvalComparisonV4(summary: EvalCompareV4Summary): string {
 	const envelopeFailures = summary.envelopeMismatches.map(
 		(mismatch) =>
-			`  incomparable envelope: ${mismatch.scenarioId} ${mismatch.role} ${mismatch.target.id}/${mismatch.target.model ?? "none"} fields=${mismatch.fields.join(",")}`,
+			`  incomparable envelope: ${mismatch.scenarioId} ${mismatch.role} ${renderEvalComparisonRoutesV1(mismatch)} fields=${mismatch.fields.join(",")}`,
 	);
 	const affected = summary.affectedCorpusResults.map(
 		(result) =>
@@ -142,7 +142,7 @@ export function renderEvalComparisonV4(summary: EvalCompareV4Summary): string {
 	const roleReports = renderRollups("per-role baseline/candidate report", summary.roleReports);
 	const hardFailures = summary.hardGate.failures.map(
 		(failure) =>
-			`  hard failure: ${failure.scenarioId} ${failure.role} ${failure.target.id}/${failure.target.model ?? "none"} ${failure.metric} ${failure.change}`,
+			`  hard failure: ${failure.scenarioId} ${failure.role} ${renderEvalComparisonRoutesV1(failure)} ${failure.metric} ${failure.change}`,
 	);
 	const tracked = summary.trackedMetrics.flatMap((row, index) => [
 		...(index === 0
@@ -172,14 +172,13 @@ export function renderEvalComparisonV4(summary: EvalCompareV4Summary): string {
 		...(index === 0
 			? [
 					"behavioral metrics:",
-					"scenario role target model family metric baseline_mean baseline_variance baseline_coverage candidate_mean candidate_variance candidate_coverage mean_delta variance_delta change variance_change comparability gate source",
+					"scenario role baseline_target/model -> candidate_target/model family metric baseline_mean baseline_variance baseline_coverage candidate_mean candidate_variance candidate_coverage mean_delta variance_delta noise_band change variance_change comparability gate source",
 				]
 			: []),
 		[
 			row.scenarioId,
 			row.role,
-			row.target.id,
-			row.target.model ?? "none",
+			renderEvalComparisonRoutesV1(row),
 			row.family,
 			row.metric,
 			formatMetric(row.baseline.mean),
@@ -190,6 +189,7 @@ export function renderEvalComparisonV4(summary: EvalCompareV4Summary): string {
 			`${row.candidate.measured}/${row.candidate.observations}`,
 			formatSignedMetric(row.meanDelta),
 			formatSignedMetric(row.varianceDelta),
+			formatMetric(row.noiseBand),
 			row.change,
 			row.varianceChange,
 			row.comparability.comparable ? "comparable" : `incomparable:${row.comparability.mismatchedFields.join(",")}`,
@@ -218,6 +218,16 @@ export function renderEvalComparisonV4(summary: EvalCompareV4Summary): string {
 	].join("\n");
 }
 
+export function renderEvalComparisonRoutesV1(identity: {
+	target: { id: string; model: string | null };
+	baselineTargets?: ReadonlyArray<{ id: string; model: string | null }>;
+	candidateTargets?: ReadonlyArray<{ id: string; model: string | null }>;
+}): string {
+	const render = (targets: ReadonlyArray<{ id: string; model: string | null }>) =>
+		targets.map((target) => `${target.id}/${target.model ?? "none"}`).join(",") || "missing";
+	return `${render(identity.baselineTargets ?? [identity.target])} -> ${render(identity.candidateTargets ?? [identity.target])}`;
+}
+
 function behaviorRollups(
 	rows: ReadonlyArray<EvalBehaviorMetricComparisonV1>,
 	keyOf: (row: EvalBehaviorMetricComparisonV1) => string,

package/src/domains/eval/compare/envelope.ts

@@ -5,6 +5,8 @@ export interface EvalEnvelopeMismatchV1 {
 	scenarioId: string;
 	role: string;
 	target: { id: string; model: string | null };
+	baselineTargets?: Array<{ id: string; model: string | null }>;
+	candidateTargets?: Array<{ id: string; model: string | null }>;
 	fields: string[];
 }
 
@@ -20,10 +22,15 @@ export function compareEvalExecutionEnvelopesV1(
 	baselineDimensions: ReadonlyArray<EvalExecutionMatrixDimensionV1>,
 	candidateDimensions: ReadonlyArray<EvalExecutionMatrixDimensionV1>,
 ): EvalEnvelopeMismatchV1 | null {
+	const mismatchIdentity = {
+		scenarioId: identity.scenarioId,
+		role: identity.role,
+		target: { id: identity.target.id, model: identity.target.model },
+	};
 	const leftDimensions = [...baselineDimensions].sort();
 	const rightDimensions = [...candidateDimensions].sort();
 	if (stableJson(leftDimensions) !== stableJson(rightDimensions)) {
-		return { ...identity, fields: ["matrix.dimensions"] };
+		return { ...mismatchIdentity, fields: ["matrix.dimensions"] };
 	}
 	if (
 		(baseline.some((result) => result.executionEnvelope !== undefined) &&
@@ -31,22 +38,22 @@ export function compareEvalExecutionEnvelopesV1(
 		(candidate.some((result) => result.executionEnvelope !== undefined) &&
 			candidate.some((result) => result.executionEnvelope === undefined))
 	) {
-		return { ...identity, fields: ["executionEnvelope.missingTrial"] };
+		return { ...mismatchIdentity, fields: ["executionEnvelope.missingTrial"] };
 	}
 	const ignored = new Set(leftDimensions);
 	const baselineEnvelopes = uniqueEnvelopes(baseline, ignored);
 	const candidateEnvelopes = uniqueEnvelopes(candidate, ignored);
 	if (baselineEnvelopes.length === 0 && candidateEnvelopes.length === 0) return null;
 	if (baselineEnvelopes.length === 0 || candidateEnvelopes.length === 0) {
-		return { ...identity, fields: ["executionEnvelope"] };
+		return { ...mismatchIdentity, fields: ["executionEnvelope"] };
 	}
 	if (baselineEnvelopes.length > 1 || candidateEnvelopes.length > 1) {
-		return { ...identity, fields: ["executionEnvelope.withinRunVariance"] };
+		return { ...mismatchIdentity, fields: ["executionEnvelope.withinRunVariance"] };
 	}
 	const left = baselineEnvelopes[0];
 	const right = candidateEnvelopes[0];
 	if (left === undefined || right === undefined || stableJson(left) === stableJson(right)) return null;
-	return { ...identity, fields: differingFields(left, right, ignored) };
+	return { ...mismatchIdentity, fields: differingFields(left, right, ignored) };
 }
 
 function uniqueEnvelopes(

package/src/domains/eval/metrics/context.ts

@@ -1,3 +1,6 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { enumerateWorkspaceFiles } from "../../../core/workspace-files.js";
 import { readCodewiki, structuralCodewikiHash } from "../../context/codewiki/artifact.js";
 import { renderCodewikiDigest } from "../../context/codewiki/digest.js";
@@ -10,13 +13,31 @@ export function collectContextMetrics(cwd: string): Record<string, number | stri
 		const visiblePaths = new Set(enumerateWorkspaceFiles(cwd));
 		const artifactSourceFiles = codewiki.files.filter((file) => file.lang !== "config");
 		const indexedFiles = artifactSourceFiles.filter((file) => visiblePaths.has(file.path)).length;
-		const staleFiles = artifactSourceFiles.length - indexedFiles;
+		let contentValidFiles = 0;
+		let missingFiles = 0;
+		for (const file of artifactSourceFiles) {
+			try {
+				// Match the indexer's UTF-8 source identity, including legacy records
+				// whose missing hash cannot establish content validity.
+				const hash = createHash("sha256")
+					.update(readFileSync(join(cwd, file.path), "utf8"))
+					.digest("hex")
+					.slice(0, 16);
+				if (visiblePaths.has(file.path) && file.hash === hash) contentValidFiles += 1;
+			} catch (error) {
+				const code = (error as NodeJS.ErrnoException).code;
+				if (code === "ENOENT" || code === "ENOTDIR") missingFiles += 1;
+			}
+		}
+		const staleFiles = artifactSourceFiles.length - contentValidFiles;
 		const sourceFiles = detectProjectProfile(cwd).sourceFiles;
 		const digest = renderCodewikiDigest(codewiki);
 		return {
 			"context.indexedFiles": indexedFiles,
 			"context.artifactFiles": artifactSourceFiles.length,
 			"context.staleFiles": staleFiles,
+			"context.contentValidFiles": contentValidFiles,
+			"context.missingFiles": missingFiles,
 			"context.coverage": sourceFiles === 0 ? (artifactSourceFiles.length === 0 ? 1 : 0) : indexedFiles / sourceFiles,
 			"context.structuralHash": structuralCodewikiHash(codewiki),
 			"context.digestTokens": Math.ceil(digest.length / 4),
@@ -26,6 +47,8 @@ export function collectContextMetrics(cwd: string): Record<string, number | stri
 			"context.indexedFiles": 0,
 			"context.artifactFiles": 0,
 			"context.staleFiles": 0,
+			"context.contentValidFiles": 0,
+			"context.missingFiles": 0,
 			"context.coverage": 0,
 			"context.structuralHash": null,
 			"context.digestTokens": 0,