@iowarp/clio-coder 0.4.0 → 0.4.2

package/src/domains/dispatch/run-event-journal.ts

@@ -40,6 +40,7 @@
 
 import { appendFileSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { normalizeClioCoderEventType } from "../../core/naming-events.js";
 import { clioStateDir, stateRootRemoved } from "../../core/xdg.js";
 
 /** Directory name under the state root holding one subdirectory per run. */
@@ -50,9 +51,6 @@ export const RUN_EVENT_JOURNAL_FILE = "events.ndjson";
 export const RUN_EVENT_JOURNAL_CAP_BYTES = 2 * 1024 * 1024;
 /** Pending bytes that trigger a flush of droppable lines. */
 export const RUN_EVENT_JOURNAL_FLUSH_BYTES = 8 * 1024;
-/** Per-process env override, resolved ahead of settings (see runEventJournalEnabled). */
-export const RUN_EVENT_JOURNAL_ENV_VAR = "CLIO_CODER_RUN_JOURNAL";
-
 interface JournalLineBase {
 	seq: number;
 	at: string;
@@ -118,7 +116,7 @@ export interface RunEventJournal extends RunEventJournalSink {
 let configuredEnabled: boolean | undefined;
 
 /**
- * Install the `panes.journal` setting. Called from the composition root beside
+ * Install the `fleet.history.journal` setting. Called from the composition root beside
  * `configureGuardrails` so the journal never reads settings.yaml itself; a
  * settings read on the dispatch event path would be both a cost and a throw
  * site (readSettings rejects an invalid file).
@@ -127,17 +125,9 @@ export function configureRunEventJournal(enabled: boolean | undefined): void {
 	configuredEnabled = enabled;
 }
 
-function parseEnvFlag(raw: string | undefined): boolean | undefined {
-	if (raw === undefined) return undefined;
-	const normalized = raw.trim().toLowerCase();
-	if (normalized === "1" || normalized === "true" || normalized === "on") return true;
-	if (normalized === "0" || normalized === "false" || normalized === "off") return false;
-	return undefined;
-}
-
-/** env override > configured settings > on. */
-export function runEventJournalEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
-	return parseEnvFlag(env[RUN_EVENT_JOURNAL_ENV_VAR]) ?? configuredEnabled ?? true;
+/** Effective settings projection, then the shipped default. */
+function runEventJournalEnabled(): boolean {
+	return configuredEnabled ?? true;
 }
 
 // ---------------------------------------------------------------------------
@@ -150,7 +140,7 @@ export function runEventJournalRoot(): string {
 }
 
 /** One run's journal directory. */
-export function runEventJournalDir(runId: string, root?: string): string {
+function runEventJournalDir(runId: string, root?: string): string {
 	return join(root ?? runEventJournalRoot(), runId);
 }
 
@@ -247,10 +237,10 @@ export interface CreateRunEventJournalOptions {
 	isEnabled?: () => boolean;
 }
 
-export function createRunEventJournal(options: CreateRunEventJournalOptions = {}): RunEventJournal {
+function createRunEventJournal(options: CreateRunEventJournalOptions = {}): RunEventJournal {
 	const capBytes = options.capBytes ?? RUN_EVENT_JOURNAL_CAP_BYTES;
 	const flushBytes = options.flushBytes ?? RUN_EVENT_JOURNAL_FLUSH_BYTES;
-	const warn = options.warn ?? ((message: string) => process.stderr.write(`[clio:journal] ${message}\n`));
+	const warn = options.warn ?? ((message: string) => process.stderr.write(`[clio-coder:journal] ${message}\n`));
 	const now = options.now ?? (() => new Date());
 	const isEnabled = options.isEnabled ?? (() => runEventJournalEnabled());
 	const runs = new Map<string, RunJournalState>();
@@ -494,7 +484,7 @@ function parseJournalLine(raw: string): RunEventJournalLine | null {
 				seq: record.seq,
 				at: record.at,
 				kind: "event",
-				type: record.type,
+				type: normalizeClioCoderEventType(record.type),
 				...(detail === undefined ? {} : { detail }),
 			};
 		}

package/src/domains/dispatch/state.ts

@@ -6,8 +6,8 @@
  *   receipts/<runId>.json        per-run RunReceipt
  *
  * The ledger holds an in-memory mirror of runs.json. `create()` and `update()`
- * mutate memory only; `persist()` writes the bounded ring (default 1000, env
- * override `CLIO_CODER_MAX_DISPATCH_RUNS`) atomically via engine.atomicWrite.
+ * mutate memory only; `persist()` writes the settings-bounded ring (default
+ * 1000) atomically via engine.atomicWrite.
  *
  * No worker spawning, no domain wire-up, no SafeEventBus emission yet. Those
  * land in P6S3 and P6S5. This slice is a pure persistence primitive.
@@ -159,7 +159,6 @@ function readRuns(): RunEnvelope[] {
 
 function resolveMaxRuns(opt?: number | undefined): number {
 	if (opt !== undefined && opt > 0) return Math.floor(opt);
-	// env (CLIO_CODER_MAX_DISPATCH_RUNS) > settings guardrails > default; see core/guardrails.ts.
 	return resolveGuardrail("maxDispatchRuns");
 }
 

package/src/domains/dispatch/tool-stats.ts

@@ -1,7 +1,7 @@
 /**
  * Pure aggregation helpers for the per-tool stats folded into a RunReceipt.
  *
- * Sourced from the worker's ToolTelemetry stream (`clio_tool_finish` IPC
+ * Sourced from the worker's ToolTelemetry stream (`clio_coder_tool_finish` IPC
  * events). Kept as a small standalone module so receipts have a single source
  * of truth for the aggregation invariants, and so loops, retries, errors,
  * blocked admissions, and parallel-batch tool calls all flow through one

package/src/domains/dispatch/transport.ts

@@ -10,9 +10,9 @@
  *
  * SSH tier invariants:
  *   - The remote environment is a whitelist, never the orchestrator's
- *     process.env. Remote workers default to CLIO_CODER_RESIDENCY=observe so a
- *     worker on a node that serves models for the operator can never evict a
- *     resident model.
+ *     process.env. Remote workers default to a user-managed target lifecycle
+ *     so a worker on a node that serves models for the operator can never
+ *     evict a resident model.
  *   - The orchestrator cwd is entered on the remote node (shared-filesystem
  *     assumption; path parity is a doctor preflight, and placement refuses
  *     nodes that have not passed it).
@@ -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";
 
@@ -68,9 +62,9 @@ export interface SshNodeEndpoint {
 	 */
 	clioCoderEntry?: string;
 	/**
-	 * Residency posture exported to the remote worker. Defaults to "observe":
-	 * remote workers must never evict models resident on their node. "manage"
-	 * is an explicit per-node opt-in.
+	 * Residency posture projected into the remote worker's target lifecycle.
+	 * Defaults to "observe": remote workers must never evict models resident on
+	 * their node. "manage" is an explicit per-node opt-in.
 	 */
 	residency?: "observe" | "manage";
 	connectTimeoutSec?: number;
@@ -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";
 
@@ -116,17 +99,36 @@ const DEFAULT_REMOTE_CLIO_ENTRY = "clio-coder worker";
  * orchestrator-supplied credential.
  */
 function remoteEnvAssignments(node: SshNodeEndpoint): string {
-	const residency = node.residency ?? "observe";
 	// `$$` is the login shell's pid, and it leads the process group the remote
 	// command runs in. `exec` replaces that shell in place, so the worker
 	// inherits both the pid and the group leadership, and the value it announces
 	// is the group an abort must signal.
 	const labels = (node.labels ?? []).map((label) => label.trim()).filter((label) => label.length > 0);
 	const labelAssignment = labels.length > 0 ? ` CLIO_CODER_WORKER_LABELS=${shellQuote(labels.join(","))}` : "";
-	return `AI_AGENT=${AI_AGENT_NAME} CLIO_CODER_RESIDENCY=${residency} CLIO_CODER_WORKER_PGID=$$${labelAssignment}`;
+	return `AI_AGENT=${AI_AGENT_NAME} CLIO_CODER_WORKER_PGID=$$${labelAssignment}`;
 }
 
-export function buildRemoteWorkerCommand(node: SshNodeEndpoint, cwd: string): string {
+type TargetLifecycle = NonNullable<WorkerSpec["target"]["lifecycle"]>;
+
+export function resolveSshTargetLifecycle(
+	residency: SshNodeEndpoint["residency"],
+	targetLifecycle: WorkerSpec["target"]["lifecycle"],
+): TargetLifecycle {
+	if (targetLifecycle === "user-managed" || residency !== "manage") return "user-managed";
+	return "clio-coder-managed";
+}
+
+function workerSpecForSshNode(node: SshNodeEndpoint, spec: WorkerSpec): WorkerSpec {
+	return {
+		...spec,
+		target: {
+			...spec.target,
+			lifecycle: resolveSshTargetLifecycle(node.residency, spec.target.lifecycle),
+		},
+	};
+}
+
+function buildRemoteWorkerCommand(node: SshNodeEndpoint, cwd: string): string {
 	const entry =
 		node.clioCoderEntry !== undefined && node.clioCoderEntry.trim().length > 0
 			? node.clioCoderEntry.trim()
@@ -191,20 +193,25 @@ export function createSshWorkerTransport(node: SshNodeEndpoint, opts?: SshTransp
 			// are the transport's own and compose with the caller's rather than
 			// replacing them; every other option is forwarded as handed.
 			const { cwd: _consumedCwd, onAnnounce, onForcedKill, ...forwarded } = spawnOpts ?? {};
-			return spawnWorkerProcess(sshBinary, buildSshArgs(node, buildRemoteWorkerCommand(node, cwd)), spec, {
-				...(opts?.shutdownGraceMs !== undefined ? { shutdownGraceMs: opts.shutdownGraceMs } : {}),
-				...forwarded,
-				env: process.env,
-				onAnnounce: (attestation) => {
-					remote.pid = attestation.pid;
-					remote.processGroupId = attestation.processGroupId;
-					onAnnounce?.(attestation);
-				},
-				onForcedKill: () => {
-					killRemote();
-					onForcedKill?.();
+			return spawnWorkerProcess(
+				sshBinary,
+				buildSshArgs(node, buildRemoteWorkerCommand(node, cwd)),
+				workerSpecForSshNode(node, spec),
+				{
+					...(opts?.shutdownGraceMs !== undefined ? { shutdownGraceMs: opts.shutdownGraceMs } : {}),
+					...forwarded,
+					env: process.env,
+					onAnnounce: (attestation) => {
+						remote.pid = attestation.pid;
+						remote.processGroupId = attestation.processGroupId;
+						onAnnounce?.(attestation);
+					},
+					onForcedKill: () => {
+						killRemote();
+						onForcedKill?.();
+					},
 				},
-			});
+			);
 		},
 	};
 }

package/src/domains/dispatch/types.ts

@@ -506,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 {
@@ -570,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[];
 }
 
@@ -584,7 +584,7 @@ export interface RunReceiptSafetySummary {
 	 * (reason code `guard_block`); a call that required permission and was denied
 	 * non-interactively is counted under `permissionRequested`, not `blocked`, so
 	 * scripts can tell "approval would have been needed" apart from a policy
-	 * block (see docs/safety-model.md). Such a call still appears in
+	 * block (see docs/architecture/safety-model.md). Such a call still appears in
 	 * `blockedAttempts` because its outcome was blocked, so `decisions.blocked`
 	 * is not a proxy for the number of blocked attempts; use `blockedAttempts`
 	 * or the `toolStats`/`toolActivity` blocked counts for that.
@@ -712,14 +712,66 @@ export interface RunHostVerificationCheck {
 	memo: boolean;
 	outputTail: string;
 	artifactPath?: string;
-	/** Original evidence owner on a memo hit. */
+	/** 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;
 }
 
+/**
+ * Why a batch-settled failing check was or was not charged to a run. It is a
+ * batch-wide fact and is sealed identically on every receipt in the batch; each
+ * receipt's own `status` is what that run is judged by.
+ */
+export interface RunHostVerificationAttribution {
+	/** Declared check id that failed. */
+	check: string;
+	/**
+	 * Absolute repository paths the check's own output named, capped at 32. The
+	 * paths that decided the charge come first so a truncated list still contains
+	 * the evidence behind the verdict; each group is sorted.
+	 */
+	implicated: string[];
+	/** Run ids the failure is charged to, sorted; empty when every named path belongs to a run that did not declare the check. */
+	charged: string[];
+	/**
+	 * The weakest evidence behind the charge set, never the strongest, so the
+	 * record cannot claim a certainty it does not have.
+	 *
+	 * `write_roots`: every charged run has an implicated path inside its own
+	 * declared write roots. `attributed_elsewhere`: nothing is charged because
+	 * every implicated path falls inside the write roots of a live batch member
+	 * that did not declare this check. `unattributable`: the charge is not backed
+	 * by per-run path evidence, which covers a failure that named no path, one
+	 * that named only paths no member claims, and one charged to a run that
+	 * declared no write roots at all. The first two of those charge every run that
+	 * declared the check: a real failure with no owner is charged to everyone
+	 * rather than excused for everyone.
+	 */
+	basis: "write_roots" | "attributed_elsewhere" | "unattributable";
+}
+
 export interface RunHostVerification {
-	status: "verified" | "rejected" | "skipped";
+	/**
+	 * `verified` states that every declared check passed, which is the claim
+	 * `trust-status.ts:619` turns into "validated by host-verification".
+	 * `not_implicated` is the batch-settled exculpation: a declared check failed
+	 * for the batch and this run's `checks` carries its non-zero exit code, but
+	 * the failure was charged elsewhere, so no validator speaks for this run.
+	 */
+	status: "verified" | "rejected" | "skipped" | "not_implicated";
 	reason?: string;
 	checks: RunHostVerificationCheck[];
+	/**
+	 * How the declared checks were run. Absent means the single-run strategy every
+	 * receipt carried before batch settlement existed: the checks ran for this run
+	 * alone, straight after it finished. `batch-settled` means they ran once for
+	 * the whole parallel batch after every live member had finished. The field is
+	 * omitted rather than stamped `"single"` so a single-task receipt digests
+	 * exactly as it did before (`receipt-integrity.ts:145-147` is the same
+	 * reasoning applied one field over).
+	 */
+	strategy?: "batch-settled";
+	/** Per-failing-check attribution for a batch-settled run; absent when nothing failed. */
+	attribution?: RunHostVerificationAttribution[];
 }
 
 export interface RunReceipt {
@@ -810,7 +862,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/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

@@ -11,6 +11,11 @@ import { parseEvalVerdictEnvelopeV1 } from "../schema/verdict.js";
 import { evalRoot } from "../store.js";
 import { redactArtifactForStorage } from "./redact.js";
 
+// This is the documented location (docs/architecture/artifact-versions.md's
+// Eval Artifact row): <dataDir>/evals/<evalId>.json, flat. The legacy version-1
+// shape skills-eval writes lives at evalRoot()/skills-eval/ instead
+// (store.ts's evalArtifactPath) so the two writers can never resolve to the
+// same file for the same id.
 function evalArtifactPathV4(dataDir: string, evalId: string): string {
 	assertSafeId(evalId, "eval");
 	return join(evalRoot(dataDir), `${evalId}.json`);
@@ -58,14 +63,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/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/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;
+}