@iowarp/clio-coder 0.3.9 → 0.4.1

package/src/domains/dispatch/transport.ts

@@ -26,13 +26,7 @@ import { AI_AGENT_NAME } from "../../core/agent-environment.js";
 import { shellQuote } from "../../core/shell-quote.js";
 import type { WorkerSpec } from "../../worker/spec-contract.js";
 import type { RunNodeIdentity } from "./types.js";
-import {
-	type SpawnedWorker,
-	type SpawnOptions,
-	spawnNativeWorker,
-	spawnWorkerProcess,
-	type WorkerProcessOptions,
-} from "./worker-spawn.js";
+import { type SpawnedWorker, spawnWorkerProcess, type WorkerProcessOptions } from "./worker-spawn.js";
 
 export type WorkerTransportKind = "local" | "ssh";
 
@@ -94,17 +88,6 @@ export function localNodeIdentity(): RunNodeIdentity {
 	return { id: LOCAL_NODE_ID, kind: "local" };
 }
 
-export function createLocalWorkerTransport(opts?: Omit<SpawnOptions, "cwd">): WorkerTransport {
-	return {
-		kind: "local",
-		node: localNodeIdentity(),
-		spawn(spec, spawnOpts) {
-			// The caller's per-spawn options ride over the transport's own defaults.
-			return spawnNativeWorker(spec, { ...opts, ...spawnOpts });
-		},
-	};
-}
-
 const DEFAULT_SSH_CONNECT_TIMEOUT_SEC = 10;
 const DEFAULT_REMOTE_CLIO_ENTRY = "clio-coder worker";
 
@@ -126,7 +109,7 @@ function remoteEnvAssignments(node: SshNodeEndpoint): string {
 	return `AI_AGENT=${AI_AGENT_NAME} CLIO_CODER_RESIDENCY=${residency} CLIO_CODER_WORKER_PGID=$$${labelAssignment}`;
 }
 
-export function buildRemoteWorkerCommand(node: SshNodeEndpoint, cwd: string): string {
+function buildRemoteWorkerCommand(node: SshNodeEndpoint, cwd: string): string {
 	const entry =
 		node.clioCoderEntry !== undefined && node.clioCoderEntry.trim().length > 0
 			? node.clioCoderEntry.trim()

package/src/domains/dispatch/types.ts

@@ -225,6 +225,17 @@ export interface RunGateSubjectRef {
 	digest: string | null;
 }
 
+/** Storage route used for one compete candidate's isolated checkout. */
+export interface RunGateWorktreeProvenance {
+	backend: "herdr" | "native";
+	path: string;
+	branch: string;
+	/** Herdr workspace created around the worktree; absent for the native route. */
+	workspaceId?: string;
+	/** Why the native route was selected when mux was configured. */
+	fallback?: "mux-unavailable" | "mux-operation-failed";
+}
+
 /**
  * Review/compete gate provenance, carried on the request and sealed into the
  * receipt. References point backward only: a reviewer references the builder
@@ -244,6 +255,8 @@ export interface RunGateProvenance {
 	subjects?: RunGateSubjectRef[];
 	/** Reviewer verdict that caused this run; only on revise builders. */
 	verdict?: "pass" | "fail" | "revise";
+	/** Compete-only worktree route, sealed into the run receipt with the gate. */
+	worktree?: RunGateWorktreeProvenance;
 }
 
 export interface RunCouncilProvenance {
@@ -493,7 +506,7 @@ export interface RunEnvelope {
 
 /**
  * Per-tool aggregates folded into a receipt at run completion. Sourced from
- * the worker's ToolTelemetry stream (`clio_tool_finish` IPC events). Sorted
+ * the worker's ToolTelemetry stream (`clio_coder_tool_finish` IPC events). Sorted
  * by tool name on write so digests are deterministic across runs.
  */
 export interface ToolCallStat {
@@ -557,7 +570,7 @@ export interface RunReceiptDelegation {
 	toolCallsRequested: number;
 	toolCallsApproved: number;
 	toolCallsDenied: number;
-	toolGovernance: "clio-policy" | "agent-managed" | "deny-all";
+	toolGovernance: "clio-coder-policy" | "agent-managed" | "deny-all";
 	toolCallLog: DelegationToolCallLogEntry[];
 }
 
@@ -797,7 +810,7 @@ export interface RunReceipt {
 	dynamicHash?: string | null;
 	promptSignature?: string | null;
 	toolSignature?: string | null;
-	clioVersion: string;
+	clioCoderVersion: string;
 	piMonoVersion: string;
 	platform: string;
 	nodeVersion: string;

package/src/domains/dispatch/validation.ts

@@ -21,6 +21,7 @@ import {
 import { isExecutionRole } from "./execution-role.js";
 import { COMPETE_STANCES, type CompeteStance } from "./gate-role-prompts.js";
 import { type DispatchIntent, isDispatchIntent } from "./intent.js";
+import { classifyDispatchIntentCompatibility, dispatchIntentRefusals } from "./intent-compatibility.js";
 import { isRoutingIntent, type RoutingIntent } from "./routing-intent.js";
 import type {
 	DispatchRequestOrigin,
@@ -478,14 +479,21 @@ export function validateJobSpec(spec: unknown): Validated {
 			errors.push("writeRoots must be a non-empty array of non-empty strings");
 		}
 	}
-	if ("intent" in spec && spec.intent !== undefined && !isDispatchIntent(spec.intent)) {
-		errors.push("intent must be a normalized dispatch intent");
-	}
-	if (isDispatchIntent(spec.intent) && spec.intent.writeRoots.length > 0 && Array.isArray(spec.writeRoots)) {
-		const jobCwd = typeof spec.cwd === "string" && spec.cwd.length > 0 ? spec.cwd : process.cwd();
-		const legacy = [...new Set(spec.writeRoots.map((root) => resolvePathBoundary(jobCwd, String(root))))].sort();
-		const declared = [...new Set(spec.intent.writeRoots.map((root) => resolvePathBoundary(jobCwd, root)))].sort();
-		if (JSON.stringify(legacy) !== JSON.stringify(declared)) errors.push("intent_write_roots_contradiction");
+	// One owner for the typed-intent migration rules (#163). Every dispatch
+	// producer reaches a worker through this validator, so classifying here is
+	// what makes the compatibility table true of the fleet, CLI, ACP, and
+	// extension paths rather than only of the model-facing tool.
+	if ("intent" in spec) {
+		for (const refusal of dispatchIntentRefusals(
+			classifyDispatchIntentCompatibility({
+				intent: spec.intent,
+				...(spec.writeRoots !== undefined ? { writeRoots: spec.writeRoots } : {}),
+				...(spec.autonomy !== undefined ? { autonomy: spec.autonomy } : {}),
+				...(typeof spec.cwd === "string" && spec.cwd.length > 0 ? { cwd: spec.cwd } : {}),
+			}),
+		)) {
+			errors.push(refusal.message);
+		}
 	}
 
 	if ("requestOrigin" in spec && spec.requestOrigin !== undefined) {
@@ -696,6 +704,8 @@ function isValidProtectedArtifactRemap(value: unknown): value is ProtectedArtifa
 
 const VALID_GATE_ROLES = new Set(["builder", "reviewer", "candidate", "judge", "member", "synthesis"]);
 const VALID_GATE_VERDICTS = new Set(["pass", "fail", "revise"]);
+const VALID_WORKTREE_BACKENDS = new Set(["herdr", "native"]);
+const VALID_WORKTREE_FALLBACKS = new Set(["mux-unavailable", "mux-operation-failed"]);
 const VALID_PLAN_TOPOLOGIES = new Set([
 	"parallel",
 	"sequential",
@@ -724,6 +734,20 @@ function isValidGate(value: unknown): value is RunGateProvenance {
 	if (value.verdict !== undefined && (typeof value.verdict !== "string" || !VALID_GATE_VERDICTS.has(value.verdict))) {
 		return false;
 	}
+	if (value.worktree !== undefined) {
+		if (!isPlainObject(value.worktree)) return false;
+		if (typeof value.worktree.backend !== "string" || !VALID_WORKTREE_BACKENDS.has(value.worktree.backend)) return false;
+		if (typeof value.worktree.path !== "string" || !path.isAbsolute(value.worktree.path)) return false;
+		if (typeof value.worktree.branch !== "string" || value.worktree.branch.length === 0) return false;
+		if (value.worktree.workspaceId !== undefined && typeof value.worktree.workspaceId !== "string") return false;
+		if (
+			value.worktree.fallback !== undefined &&
+			(typeof value.worktree.fallback !== "string" || !VALID_WORKTREE_FALLBACKS.has(value.worktree.fallback))
+		) {
+			return false;
+		}
+		if (value.worktree.backend === "herdr" && typeof value.worktree.workspaceId !== "string") return false;
+	}
 	return true;
 }
 
@@ -734,6 +758,7 @@ function cloneGate(gate: RunGateProvenance): RunGateProvenance {
 		cycle: gate.cycle,
 		...(gate.subjects !== undefined ? { subjects: gate.subjects.map((subject) => ({ ...subject })) } : {}),
 		...(gate.verdict !== undefined ? { verdict: gate.verdict } : {}),
+		...(gate.worktree !== undefined ? { worktree: { ...gate.worktree } } : {}),
 	};
 }
 

package/src/domains/dispatch/worker-protocol.ts

@@ -69,7 +69,7 @@ export {
  */
 export function computeSettingsFingerprint(settings: unknown): string {
 	return createHash("sha256")
-		.update(`clio.settings:${canonicalJson(settings)}`, "utf8")
+		.update(`clio-coder.settings:${canonicalJson(settings)}`, "utf8")
 		.digest("hex");
 }
 
@@ -151,7 +151,7 @@ export function approvedIdentityForSpec(spec: {
 
 function workerSpecDigestOf(spec: unknown): string {
 	return createHash("sha256")
-		.update(`clio.workerSpec:${canonicalJson(spec)}`, "utf8")
+		.update(`clio-coder.workerSpec:${canonicalJson(spec)}`, "utf8")
 		.digest("hex");
 }
 

package/src/domains/eval/artifacts/store.ts

@@ -58,14 +58,15 @@ export function parseEvalArtifactV4(value: unknown, source: string): EvalArtifac
 		value.aggregates === undefined
 			? undefined
 			: (readArray(value, source, "aggregates") as NonNullable<EvalArtifactV4["aggregates"]>);
+	const clioCoder = asRecord(value.clioCoder ?? value.clio, `${source}.clioCoder`);
 	return {
 		version: 4,
 		evalId: readString(value, source, "evalId"),
 		suite: { id: readString(suite, `${source}.suite`, "id"), hash: readString(suite, `${source}.suite`, "hash") },
-		clio: {
-			version: readString(asRecord(value.clio, `${source}.clio`), `${source}.clio`, "version"),
-			commit: readNullableString(asRecord(value.clio, `${source}.clio`), `${source}.clio`, "commit"),
-			entry: readString(asRecord(value.clio, `${source}.clio`), `${source}.clio`, "entry"),
+		clioCoder: {
+			version: readString(clioCoder, `${source}.clioCoder`, "version"),
+			commit: readNullableString(clioCoder, `${source}.clioCoder`, "commit"),
+			entry: readString(clioCoder, `${source}.clioCoder`, "entry"),
 		},
 		environment: {
 			platform: readString(asRecord(value.environment, `${source}.environment`), `${source}.environment`, "platform"),

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

@@ -3,6 +3,7 @@ import { assertComparableTrackedMetricSources } from "../run-compare.js";
 import type { EvalArtifactV4 } from "../schema/artifact.js";
 import {
 	type EvalServingConfigurationV1,
+	evalServingConfigurationOf,
 	renderEvalServingConfiguration,
 	sameEvalServingConfiguration,
 } from "../schema/serving.js";
@@ -90,8 +91,8 @@ export function compareEvalArtifactsV4(
 ): EvalCompareV4Summary {
 	const baselineTokens = baseline.summary.tokens;
 	const candidateTokens = candidate.summary.tokens;
-	const baselineServing = servingConfigurationOf(baseline);
-	const candidateServing = servingConfigurationOf(candidate);
+	const baselineServing = evalServingConfigurationOf(baseline);
+	const candidateServing = evalServingConfigurationOf(candidate);
 	const configDrift = !sameEvalServingConfiguration(baselineServing, candidateServing);
 	if (configDrift && options.allowConfigDrift !== true) {
 		throw new EvalServingConfigurationDriftError(baselineServing, candidateServing);
@@ -330,20 +331,6 @@ function metricComparison(
 	};
 }
 
-function servingConfigurationOf(artifact: EvalArtifactV4): EvalServingConfigurationV1 {
-	return (
-		artifact.servingConfiguration ?? {
-			targetId: artifact.matrix.target,
-			runtimeId: null,
-			modelId: artifact.matrix.model,
-			serverBuild: null,
-			total_slots: null,
-			thinkingLevel: artifact.matrix.thinking,
-			compiledPromptHash: null,
-		}
-	);
-}
-
 function normalizeMetricFilter(metric: string | undefined): string | undefined {
 	if (metric === undefined) return undefined;
 	const trimmed = metric.trim();

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

@@ -62,14 +62,6 @@ export function resolveMetricAssertion(
 	return { actual, unresolved: actual === null, holds: comparisonHolds(assertion, actual) };
 }
 
-export function evaluateMetricAssertion(
-	assertion: EvalMetricAssertion,
-	metrics: Readonly<Record<string, unknown>>,
-	artifact?: EvalArtifactV4,
-): boolean {
-	return comparisonHolds(assertion, metricValue(assertion.metric, metrics, artifact));
-}
-
 function comparisonHolds(assertion: EvalMetricAssertion, actual: number | string | boolean | null): boolean {
 	switch (assertion.op) {
 		case "lt":

package/src/domains/eval/execution-provenance.ts

@@ -128,7 +128,7 @@ function promptFragmentIdentities(
 			.sort((left, right) => left.id.localeCompare(right.id));
 	}
 	if (recipe === null) return [];
-	const selected = ["identity.clio-worker", "operating.contract", "operating.worker"];
+	const selected = ["identity.clio-coder-worker", "operating.contract", "operating.worker"];
 	if (autonomy !== null) selected.push(`safety.${autonomy}`);
 	const fragments: EvalPromptFragmentIdentityV1[] = [];
 	try {

package/src/domains/eval/inventory.ts

@@ -0,0 +1,113 @@
+/**
+ * Bounded newest-first listing of the eval reports this installation stored.
+ *
+ * The store has always been addressed by id: `eval report <evalId>` and
+ * `eval compare <a> <b>` both require the operator to already know which report
+ * they want. Nothing enumerated the directory, so a surface that wants to offer
+ * the choice had to invent the enumeration. This is that enumeration, and it is
+ * a store concern rather than a wire concern: it decides which files are in the
+ * window and hands back parsed artifacts, and says nothing about which of their
+ * fields may leave the host.
+ */
+
+import { readdir } from "node:fs/promises";
+import { loadEvalArtifactV4 } from "./artifacts/store.js";
+import type { EvalArtifactV4 } from "./schema/artifact.js";
+import { evalRoot } from "./store.js";
+
+/**
+ * The exact shape `createEvalId` mints: an ISO stamp with its separators
+ * stripped, the first eight characters of the suite hash, and a random suffix.
+ */
+const EVAL_ID_PATTERN = /^eval-(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})(\d{3})Z-([0-9a-f]{8})-([0-9a-f]{12})$/u;
+
+export interface EvalStoredReport {
+	readonly evalId: string;
+	/**
+	 * The instant the run started, read back out of the id.
+	 *
+	 * Null unless the id is one this harness minted and its embedded suite-hash
+	 * prefix agrees with the suite the artifact names. An artifact has no
+	 * timestamp field of its own, so the id is the only record of when it ran,
+	 * and a stamp read off an id that does not otherwise match its contents is
+	 * not a fact worth reporting.
+	 */
+	readonly startedAt: string | null;
+	readonly artifact: EvalArtifactV4;
+}
+
+export interface EvalStoreListing {
+	/** False when the installation has no eval store at all, which reads differently from an empty one. */
+	readonly available: boolean;
+	/** Reports on disk before the window bound. */
+	readonly stored: number;
+	readonly reports: readonly EvalStoredReport[];
+	/**
+	 * Files inside the window the current parser refused.
+	 *
+	 * Counted rather than dropped silently. Routing accepts artifact v4 only, so
+	 * a retired shape still on disk is a real thing in this store, and a listing
+	 * that quietly skipped it would report a smaller store than the operator has.
+	 */
+	readonly unreadable: number;
+}
+
+/** The stamp an id carries, without checking it against anything. */
+function idStamp(evalId: string): { startedAt: string; suiteHashPrefix: string } | null {
+	const match = EVAL_ID_PATTERN.exec(evalId);
+	if (match === null) return null;
+	const [, year, month, day, hour, minute, second, millisecond, suiteHashPrefix] = match;
+	const startedAt = `${year}-${month}-${day}T${hour}:${minute}:${second}.${millisecond}Z`;
+	const parsed = new Date(startedAt);
+	if (Number.isNaN(parsed.getTime()) || parsed.toISOString() !== startedAt) return null;
+	return { startedAt, suiteHashPrefix: suiteHashPrefix as string };
+}
+
+/** Newest first. An id this harness did not mint sorts oldest rather than throwing. */
+function byNewest(left: string, right: string): number {
+	const leftStamp = idStamp(left)?.startedAt ?? "";
+	const rightStamp = idStamp(right)?.startedAt ?? "";
+	if (leftStamp !== rightStamp) return leftStamp < rightStamp ? 1 : -1;
+	return left < right ? 1 : -1;
+}
+
+export async function listEvalReports(dataDir: string, limit: number): Promise<EvalStoreListing> {
+	let entries: string[];
+	try {
+		entries = await readdir(evalRoot(dataDir));
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			return { available: false, stored: 0, reports: [], unreadable: 0 };
+		}
+		throw error;
+	}
+	const ids = entries
+		.filter((entry) => entry.endsWith(".json"))
+		.map((entry) => entry.slice(0, -".json".length))
+		.sort(byNewest);
+	const reports: EvalStoredReport[] = [];
+	let unreadable = 0;
+	for (const evalId of ids.slice(0, limit)) {
+		let artifact: EvalArtifactV4;
+		try {
+			artifact = await loadEvalArtifactV4(dataDir, evalId);
+		} catch {
+			unreadable += 1;
+			continue;
+		}
+		// The id inside the file is authoritative. A file whose stem disagrees with
+		// it was renamed or copied in, and the two names it now answers to are not
+		// the same report.
+		if (artifact.evalId !== evalId) {
+			unreadable += 1;
+			continue;
+		}
+		const stamp = idStamp(evalId);
+		reports.push({
+			evalId,
+			startedAt: stamp !== null && artifact.suite.hash.startsWith(stamp.suiteHashPrefix) ? stamp.startedAt : null,
+			artifact,
+		});
+	}
+	return { available: true, stored: ids.length, reports, unreadable };
+}

package/src/domains/eval/metrics/token-stream.ts

@@ -90,13 +90,6 @@ export function createTokenUsageFold(): EvalTokenUsageFold {
 	};
 }
 
-/** Whole-buffer form of {@link createTokenUsageFold}. */
-export function tokenUsageFromJsonl(stream: string): EvalTokenStreamUsage {
-	const fold = createTokenUsageFold();
-	fold.push(stream);
-	return fold.usage();
-}
-
 export function addTokenStreamUsage(left: EvalTokenStreamUsage, right: EvalTokenStreamUsage): EvalTokenStreamUsage {
 	return {
 		measured: left.measured || right.measured,

package/src/domains/eval/report.ts

@@ -14,7 +14,7 @@ export function renderEvalReport(artifact: EvalRunArtifact, artifactPath?: strin
 	lines.splice(
 		2,
 		0,
-		`clio: ${artifact.clio.version} commit=${artifact.clio.commit ?? "unknown"} entry=${artifact.clio.entry}`,
+		`clioCoder: ${artifact.clioCoder.version} commit=${artifact.clioCoder.commit ?? "unknown"} entry=${artifact.clioCoder.entry}`,
 	);
 	lines.splice(3, 0, `environment: ${artifact.environment.platform} node=${artifact.environment.node}`);
 	const evidenceIds = uniqueEvidenceIds(artifact);

package/src/domains/eval/runner.ts

@@ -43,7 +43,7 @@ export async function runEvalTasks(options: RunEvalOptions): Promise<EvalRunArti
 		evalId: options.evalId,
 		taskFile: options.loadedTaskFile.path,
 		taskFileHash: options.loadedTaskFile.contentHash,
-		clio: evalClioProvenance(options.provenance),
+		clioCoder: evalClioProvenance(options.provenance),
 		environment: evalEnvironmentProvenance(),
 		target: options.provenance?.target ?? null,
 		model: options.provenance?.model ?? null,

package/src/domains/eval/runners/clio-run.ts

@@ -1,4 +1,5 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
+import { normalizeClioCoderEventRecord } from "../../../core/naming-events.js";
 import { shellQuote } from "../../../core/shell-quote.js";
 import { clioStateDir } from "../../../core/xdg.js";
 import {
@@ -92,7 +93,7 @@ type ToolCallMetrics = {
 type ToolOutcome = "ok" | "error" | "blocked";
 
 /** Fold the terminal tool events emitted by `clio-coder run --json`. */
-export function toolCallMetricsFromJsonl(stdout: string): ToolCallMetrics {
+function toolCallMetricsFromJsonl(stdout: string): ToolCallMetrics {
 	const executionEnds: ToolCallMetrics = { totalCalls: 0, failed: 0, blocked: 0 };
 	const canonicalFinishes: ToolCallMetrics = { totalCalls: 0, failed: 0, blocked: 0 };
 	const seenExecutionEnds = new Set<string>();
@@ -104,7 +105,7 @@ export function toolCallMetricsFromJsonl(stdout: string): ToolCallMetrics {
 		try {
 			const parsed: unknown = JSON.parse(line);
 			if (!isRecord(parsed)) continue;
-			event = parsed;
+			event = normalizeClioCoderEventRecord(parsed);
 		} catch {
 			continue;
 		}
@@ -119,7 +120,7 @@ export function toolCallMetricsFromJsonl(stdout: string): ToolCallMetrics {
 			continue;
 		}
 
-		if (event.type !== "clio_tool_finish" || !isRecord(event.payload)) continue;
+		if (event.type !== "clio_coder_tool_finish" || !isRecord(event.payload)) continue;
 		const outcome = toolOutcome(event.payload);
 		if (outcome === undefined) continue;
 		const callId = stringField(event.payload, "toolCallId") ?? stringField(event, "toolCallId");
@@ -148,7 +149,7 @@ interface BehavioralToolTerminal {
  * bounded counters against the suite's explicit public allowlist and decoy
  * list; they never become behavioral fact values or evidence excerpts.
  */
-export function toolBehaviorMetricEntriesFromJsonl(
+function toolBehaviorMetricEntriesFromJsonl(
 	stdout: string,
 	cwd: string,
 	readObservation?: { allowedPaths: string[]; decoyPaths: string[] },
@@ -166,7 +167,7 @@ export function toolBehaviorMetricEntriesFromJsonl(
 		try {
 			const parsed: unknown = JSON.parse(line);
 			if (!isRecord(parsed)) continue;
-			event = parsed;
+			event = normalizeClioCoderEventRecord(parsed);
 		} catch {
 			continue;
 		}
@@ -188,7 +189,7 @@ export function toolBehaviorMetricEntriesFromJsonl(
 			executionEnds.push({ callId, tool, outcome: toolOutcome(event) ?? (event.isError === true ? "error" : "ok") });
 			continue;
 		}
-		if (event.type !== "clio_tool_finish" || !isRecord(event.payload)) continue;
+		if (event.type !== "clio_coder_tool_finish" || !isRecord(event.payload)) continue;
 		const outcome = toolOutcome(event.payload);
 		const tool = stringField(event.payload, "tool");
 		if (outcome === undefined || tool === undefined) continue;

package/src/domains/eval/runners/external-command.ts

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { performance } from "node:perf_hooks";
+import { normalizeClioCoderEventType } from "../../../core/naming-events.js";
 import type { RunReceipt } from "../../dispatch/types.js";
 import type { SessionEntry } from "../../session/entries.js";
 import { createEvalCallLedgerFold } from "../metrics/call-ledger-stream.js";
@@ -226,7 +227,7 @@ export interface JsonlMetricCapture {
  * split JSON arbitrarily; oversized non-metric lines are discarded without
  * growing memory.
  */
-export function createJsonlMetricCapture(): JsonlMetricCapture {
+function createJsonlMetricCapture(): JsonlMetricCapture {
 	const lines: string[] = [];
 	let storedBytes = 0;
 	let pending = "";
@@ -287,7 +288,7 @@ export function createJsonlMetricCapture(): JsonlMetricCapture {
 }
 
 function compactMetricEvent(event: Record<string, unknown>): Record<string, unknown> | null {
-	const type = event.type;
+	const type = typeof event.type === "string" ? normalizeClioCoderEventType(event.type) : event.type;
 	if (type === "tool_execution_start") {
 		const toolName = stringField(event, "toolName");
 		if (toolName !== "dispatch" && toolName !== "code_nav" && toolName !== "read" && toolName !== "grep") {
@@ -315,7 +316,7 @@ function compactMetricEvent(event: Record<string, unknown>): Record<string, unkn
 			...(stringField(event, "outcome") !== undefined ? { outcome: stringField(event, "outcome") } : {}),
 		};
 	}
-	if (type !== "clio_tool_finish" || !isRecord(event.payload)) return null;
+	if (type !== "clio_coder_tool_finish" || !isRecord(event.payload)) return null;
 	return {
 		type,
 		payload: {

package/src/domains/eval/schema/artifact.ts

@@ -69,7 +69,7 @@ export interface EvalArtifactV4 {
 		id: string;
 		hash: string;
 	};
-	clio: EvalClioProvenance;
+	clioCoder: EvalClioProvenance;
 	environment: EvalEnvironmentProvenance;
 	matrix: {
 		target: string;

package/src/domains/eval/schema/behavioral-metrics.ts

@@ -1,7 +1,8 @@
 import type { EvalArtifactResultV4 } from "./artifact.js";
 import type { EvalBehaviorCategoryV1, EvalBehaviorLabelV1 } from "./behavioral.js";
+import { normalizeEvalSchemaId } from "./naming.js";
 
-export const EVAL_BEHAVIOR_METRICS_SCHEMA_V1 = "clio.eval.behavior.metrics.v1" as const;
+export const EVAL_BEHAVIOR_METRICS_SCHEMA_V1 = "clio-coder.eval.behavior.metrics.v1" as const;
 
 export const EVAL_BEHAVIOR_METRIC_DEFINITIONS_V1 = [
 	{
@@ -136,7 +137,7 @@ export function buildEvalBehaviorMetricsV1(
 
 export function parseEvalBehaviorMetricsV1(value: unknown, source = "behavioral metrics"): EvalBehaviorMetricsV1 {
 	const record = asRecord(value, source);
-	if (record.schema !== EVAL_BEHAVIOR_METRICS_SCHEMA_V1) {
+	if (normalizeEvalSchemaId(record.schema) !== EVAL_BEHAVIOR_METRICS_SCHEMA_V1) {
 		throw new Error(`${source}.schema: expected ${EVAL_BEHAVIOR_METRICS_SCHEMA_V1}`);
 	}
 	const target = asRecord(record.target, `${source}.target`);

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

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
+import { normalizeEvalSchemaId } from "./naming.js";
 import { EVAL_VERDICT_SCHEMA_V1, type EvalVerdictEnvelopeV1 } from "./verdict.js";
 
-export const EVAL_BEHAVIOR_SCENARIO_SCHEMA_V1 = "clio.eval.scenario.v1" as const;
-export const EVAL_BEHAVIOR_SCHEMA_V1 = "clio.eval.behavior.v1" as const;
+export const EVAL_BEHAVIOR_SCENARIO_SCHEMA_V1 = "clio-coder.eval.scenario.v1" as const;
+export const EVAL_BEHAVIOR_SCHEMA_V1 = "clio-coder.eval.behavior.v1" as const;
 
 export const EVAL_BEHAVIOR_CATEGORIES = [
 	"tool_choice",
@@ -102,7 +103,7 @@ export interface EvalBehaviorVerdictV1 {
 
 export function parseEvalBehaviorScenarioV1(value: unknown, source = "behavioral scenario"): EvalBehaviorScenarioV1 {
 	const record = asRecord(value, source);
-	if (record.schema !== EVAL_BEHAVIOR_SCENARIO_SCHEMA_V1) {
+	if (normalizeEvalSchemaId(record.schema) !== EVAL_BEHAVIOR_SCENARIO_SCHEMA_V1) {
 		throw new Error(`${source}.schema: expected ${EVAL_BEHAVIOR_SCENARIO_SCHEMA_V1}`);
 	}
 	const corpus = asRecord(record.corpus, `${source}.corpus`);
@@ -153,7 +154,7 @@ export function parseEvalBehaviorScenarioV1(value: unknown, source = "behavioral
 	};
 }
 
-export function canonicalizeEvalBehaviorJudgeInputV1(
+function canonicalizeEvalBehaviorJudgeInputV1(
 	value: unknown,
 	scenario: EvalBehaviorScenarioV1,
 	source = "behavioral judge input",
@@ -221,10 +222,10 @@ export function judgeEvalBehaviorV1(
 
 export function parseEvalBehaviorVerdictV1(value: unknown, source = "behavioral verdict"): EvalBehaviorVerdictV1 {
 	const record = asRecord(value, source);
-	if (record.schema !== EVAL_BEHAVIOR_SCHEMA_V1)
+	if (normalizeEvalSchemaId(record.schema) !== EVAL_BEHAVIOR_SCHEMA_V1)
 		throw new Error(`${source}.schema: expected ${EVAL_BEHAVIOR_SCHEMA_V1}`);
 	const verdictRef = asRecord(record.verdictRef, `${source}.verdictRef`);
-	if (verdictRef.schema !== EVAL_VERDICT_SCHEMA_V1) {
+	if (normalizeEvalSchemaId(verdictRef.schema) !== EVAL_VERDICT_SCHEMA_V1) {
 		throw new Error(`${source}.verdictRef.schema: expected ${EVAL_VERDICT_SCHEMA_V1}`);
 	}
 	const corpus = asRecord(record.corpus, `${source}.corpus`);

package/src/domains/eval/schema/execution-envelope.ts

@@ -1,4 +1,6 @@
-export const EVAL_EXECUTION_ENVELOPE_SCHEMA_V1 = "clio.eval.execution-envelope.v1" as const;
+import { normalizeEvalSchemaId } from "./naming.js";
+
+export const EVAL_EXECUTION_ENVELOPE_SCHEMA_V1 = "clio-coder.eval.execution-envelope.v1" as const;
 
 export const EVAL_EXECUTION_MATRIX_DIMENSIONS_V1 = [
 	"prompt",
@@ -56,7 +58,7 @@ export interface EvalExecutionEnvelopeV1 {
 
 export function parseEvalExecutionEnvelopeV1(value: unknown, source = "execution envelope"): EvalExecutionEnvelopeV1 {
 	const record = asRecord(value, source);
-	if (record.schema !== EVAL_EXECUTION_ENVELOPE_SCHEMA_V1) {
+	if (normalizeEvalSchemaId(record.schema) !== EVAL_EXECUTION_ENVELOPE_SCHEMA_V1) {
 		throw new Error(`${source}.schema: expected ${EVAL_EXECUTION_ENVELOPE_SCHEMA_V1}`);
 	}
 	const prompt = asRecord(record.prompt, `${source}.prompt`);

package/src/domains/eval/schema/naming.ts

@@ -0,0 +1,10 @@
+/** Legacy eval identifiers are normalized only after decoding; writers use canonical schema constants. */
+export function normalizeEvalSchemaId(value: unknown): unknown {
+	return typeof value === "string" && value.startsWith("clio.eval.")
+		? `clio-coder.eval.${value.slice("clio.eval.".length)}`
+		: value;
+}
+
+export function normalizeEvalRunnerKind(value: unknown): unknown {
+	return value === "clio-run" ? "clio-coder-run" : value;
+}

package/src/domains/eval/schema/serving.ts

@@ -30,6 +30,37 @@ export function parseEvalServingConfigurationV1(value: unknown, source: string):
 	};
 }
 
+/**
+ * The serving facts an artifact was produced under.
+ *
+ * An artifact written before the observation existed has no record of its own,
+ * so the matrix it declared is the best available reading and the missing
+ * fields stay null rather than being invented. This lives beside
+ * `sameEvalServingConfiguration` because the two are one rule: what a
+ * comparison reads, and when it decides two readings agree. Anything asking
+ * whether two eval runs are comparable must go through both, or it is answering
+ * a different question from the one `eval compare` answers.
+ *
+ * The parameter is structural rather than `EvalArtifactV4` so this module stays
+ * free of an import cycle through `schema/artifact.ts`.
+ */
+export function evalServingConfigurationOf(artifact: {
+	readonly servingConfiguration?: EvalServingConfigurationV1;
+	readonly matrix: { readonly target: string; readonly model: string | null; readonly thinking: string | null };
+}): EvalServingConfigurationV1 {
+	return (
+		artifact.servingConfiguration ?? {
+			targetId: artifact.matrix.target,
+			runtimeId: null,
+			modelId: artifact.matrix.model,
+			serverBuild: null,
+			total_slots: null,
+			thinkingLevel: artifact.matrix.thinking,
+			compiledPromptHash: null,
+		}
+	);
+}
+
 export function sameEvalServingConfiguration(
 	left: EvalServingConfigurationV1,
 	right: EvalServingConfigurationV1,