@iowarp/clio-coder 0.3.9 → 0.4.1

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

@@ -129,7 +129,7 @@ export const CANONICAL_METRIC_PREFIXES = ["tools.calls.", "tools.blocked."] as c
 
 export type EvalMetricName = (typeof CANONICAL_METRICS)[number];
 export type EvalAssertionOp = "lt" | "lte" | "gt" | "gte" | "eq" | "neq";
-export type EvalRunnerKind = "clio-run" | "context-index" | "context-init" | "external-command";
+export type EvalRunnerKind = "clio-coder-run" | "context-index" | "context-init" | "external-command";
 export type EvalWorkspaceKind = "local" | "git" | "temp-copy";
 
 export interface EvalMetricAssertion {
@@ -189,7 +189,7 @@ export interface EvalRunnerV2 {
 	/** One-run headless authority used to exercise allow and deny recovery. */
 	autonomy?: "read-only" | "suggest" | "auto-edit" | "full-auto";
 	/**
-	 * Fleet agent recipe id for the clio-run runner. When set the runner
+	 * Fleet agent recipe id for the clio-coder-run runner. When set the runner
 	 * invokes `clio-coder run --agent <id> --json`, whose stream ends with the full
 	 * sealed RunReceipt, so receipt-derived evidence metrics resolve. Without
 	 * it the main-agent headless path runs and emits no receipt.

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

@@ -1,5 +1,6 @@
 import { parseEvalBehaviorScenarioV1 } from "./behavioral.js";
 import { parseEvalExecutionMatrixDimensionsV1 } from "./execution-envelope.js";
+import { normalizeEvalRunnerKind } from "./naming.js";
 import {
 	EVAL_SUITE_V2_VERSION,
 	type EvalAssertionOp,
@@ -10,7 +11,7 @@ import {
 	type EvalWorkspaceKind,
 } from "./suite.js";
 
-const RUNNER_KINDS = new Set<EvalRunnerKind>(["clio-run", "context-index", "context-init", "external-command"]);
+const RUNNER_KINDS = new Set<EvalRunnerKind>(["clio-coder-run", "context-index", "context-init", "external-command"]);
 const WORKSPACE_KINDS = new Set<EvalWorkspaceKind>(["local", "git", "temp-copy"]);
 const OPS = new Set<EvalAssertionOp>(["lt", "lte", "gt", "gte", "eq", "neq"]);
 
@@ -203,9 +204,12 @@ function readRunner(
 		issues.push({ path, message: "expected object" });
 		return null;
 	}
-	const kind = value.kind;
+	const kind = normalizeEvalRunnerKind(value.kind);
 	if (typeof kind !== "string" || !RUNNER_KINDS.has(kind as EvalRunnerKind)) {
-		issues.push({ path: `${path}.kind`, message: "expected clio-run, context-index, context-init, or external-command" });
+		issues.push({
+			path: `${path}.kind`,
+			message: "expected clio-coder-run, context-index, context-init, or external-command",
+		});
 		return null;
 	}
 	const prompt = optionalString(value, "prompt");
@@ -214,8 +218,8 @@ function readRunner(
 	if (autonomy !== undefined && !["read-only", "suggest", "auto-edit", "full-auto"].includes(autonomy)) {
 		issues.push({ path: `${path}.autonomy`, message: "expected read-only, suggest, auto-edit, or full-auto" });
 	}
-	if (agent !== undefined && kind !== "clio-run") {
-		issues.push({ path: `${path}.agent`, message: "agent is only valid on the clio-run runner" });
+	if (agent !== undefined && kind !== "clio-coder-run") {
+		issues.push({ path: `${path}.agent`, message: "agent is only valid on the clio-coder-run runner" });
 	}
 	const command = optionalString(value, "command");
 	return {

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

@@ -1,4 +1,6 @@
-export const EVAL_VERDICT_SCHEMA_V1 = "clio.eval.verdict.v1" as const;
+import { normalizeEvalSchemaId } from "./naming.js";
+
+export const EVAL_VERDICT_SCHEMA_V1 = "clio-coder.eval.verdict.v1" as const;
 
 export const EVAL_TRACKED_METRIC_NAMES = [
 	"modelCalls",
@@ -68,7 +70,7 @@ export type EvalVerdictParseResult = { ok: true; verdict: EvalVerdictEnvelopeV1
 /** Parse the v1 verdict and reject contradictions that could publish a false pass. */
 export function parseEvalVerdictEnvelopeV1(value: unknown, source = "verdict"): EvalVerdictEnvelopeV1 {
 	const record = asRecord(value, source);
-	if (record.schema !== EVAL_VERDICT_SCHEMA_V1) {
+	if (normalizeEvalSchemaId(record.schema) !== EVAL_VERDICT_SCHEMA_V1) {
 		throw new Error(`${source}.schema: expected ${EVAL_VERDICT_SCHEMA_V1}`);
 	}
 	const scenarioId = readNonEmptyString(record, source, "scenarioId");

package/src/domains/eval/store.ts

@@ -118,7 +118,7 @@ function parseArtifact(value: unknown, source: string): EvalRunArtifact {
 		evalId: readString(value, source, "evalId"),
 		taskFile: readString(value, source, "taskFile"),
 		taskFileHash: readString(value, source, "taskFileHash"),
-		clio: parseClioProvenance(readRequiredArtifactField(value, source, "clio"), `${source}.clio`),
+		clioCoder: parseClioProvenance(readEvalProvenance(value, source), `${source}.clioCoder`),
 		environment: parseEnvironmentProvenance(
 			readRequiredArtifactField(value, source, "environment"),
 			`${source}.environment`,
@@ -235,7 +235,7 @@ function parseRunPaths(value: unknown, source: string): EvalRunPaths {
 function readRequiredArtifactField(
 	record: Record<string, unknown>,
 	source: string,
-	field: "clio" | "environment" | "paths",
+	field: "environment" | "paths",
 ): unknown {
 	const value = record[field];
 	if (value === undefined) {
@@ -246,6 +246,16 @@ function readRequiredArtifactField(
 	return value;
 }
 
+function readEvalProvenance(record: Record<string, unknown>, source: string): unknown {
+	const value = record.clioCoder ?? record.clio;
+	if (value === undefined) {
+		throw new Error(
+			`eval artifact has an invalid schema: missing required field 'clioCoder' in ${source}. Re-run the evaluation suite to generate a complete artifact.`,
+		);
+	}
+	return value;
+}
+
 function parseHarnessMetrics(value: unknown, source: string): EvalHarnessMetrics {
 	if (!isRecord(value)) throw new Error(`${source}: expected object`);
 	return {

package/src/domains/eval/suites/run.ts

@@ -1,6 +1,7 @@
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { resolve } from "node:path";
+import { namingCompatibilityEnvironment } from "../../../core/naming-compat.js";
 import { resolveMetricAssertion } from "../compare/thresholds.js";
 import { buildEvalExecutionEnvelopeV1, type EvalExecutionObservationV1 } from "../execution-provenance.js";
 import { aggregateEvalVerdicts } from "../metrics/aggregate.js";
@@ -32,6 +33,7 @@ import { type EvalRunnerOutput, runExternalCommandRunner } from "../runners/exte
 import { adaptSuiteV2ResultToBehaviorV1, adaptSuiteV2ResultToVerdictV1 } from "../schema/adapter.js";
 import type { EvalArtifactResultV4, EvalArtifactV4 } from "../schema/artifact.js";
 import { buildEvalBehaviorMetricsV1 } from "../schema/behavioral-metrics.js";
+import { normalizeEvalSchemaId } from "../schema/naming.js";
 import type { EvalServingConfigurationV1 } from "../schema/serving.js";
 import type { EvalMetricAssertion, EvalSuiteTargetV2, LoadedEvalSuiteV2 } from "../schema/suite.js";
 import { createEvalId } from "../store.js";
@@ -102,7 +104,7 @@ export async function runEvalSuiteV2(
 }
 
 /** Known receipt cost of one finished matrix item; unpriced runs count zero. */
-export function resultCostUsd(result: Pick<EvalArtifactResultV4, "metrics">): number {
+function resultCostUsd(result: Pick<EvalArtifactResultV4, "metrics">): number {
 	const value = result.metrics["cost.usd"];
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 }
@@ -156,7 +158,7 @@ async function runMatrixItem(
 	// state directory would mix sibling processes' runs and yesterday's sessions
 	// into the reading; pinning it here also means an item leaves nothing behind
 	// in the operator's own state.
-	const stateDir = await mkdtemp(resolve(tempCopy?.tempRoot ?? tmpdir(), "clio-eval-state-"));
+	const stateDir = await mkdtemp(resolve(tempCopy?.tempRoot ?? tmpdir(), "clio-coder-eval-state-"));
 	try {
 		workspace = await prepareWorkspace(loaded.baseDir, task, freshWorkspace, tempCopy);
 		const setup = await runCommandVerifiers(task.workspace.setup ?? [], workspace.dir, task.timeoutMs);
@@ -178,7 +180,11 @@ async function runMatrixItem(
 		// the workers it attested are still running.
 		const journalMetrics = invariantMetrics(stateDir, receiptExitCode);
 		const measurement = await measureTaskOutcome(task, workspace.dir, {
-			CLIO_EVAL_RUNNER_STDOUT_FILE: runnerStdoutFile,
+			...namingCompatibilityEnvironment(
+				"CLIO_CODER_EVAL_RUNNER_STDOUT_FILE",
+				"CLIO_EVAL_RUNNER_STDOUT_FILE",
+				runnerStdoutFile,
+			),
 		});
 		executionObservation = measurement.executionObservation;
 		const metrics: Record<string, number | string | boolean | null> = {
@@ -407,13 +413,13 @@ function graderBehaviorMeasurement(stdout: string): {
 			continue;
 		}
 		if (!isRecord(value)) continue;
-		if (value.schema === "clio.eval.measure.v1" && isRecord(value.metrics)) {
+		if (normalizeEvalSchemaId(value.schema) === "clio-coder.eval.measure.v1" && isRecord(value.metrics)) {
 			for (const [key, metric] of Object.entries(value.metrics)) {
 				if (key !== "claims.unsupported" && key !== "completion.reported") continue;
 				if (typeof metric === "boolean" || (typeof metric === "number" && Number.isFinite(metric))) metrics[key] = metric;
 			}
 		}
-		if (value.schema === "clio.eval.execution-observation.v1") {
+		if (normalizeEvalSchemaId(value.schema) === "clio-coder.eval.execution-observation.v1") {
 			executionObservation = parseExecutionObservation(value);
 		}
 	}
@@ -503,7 +509,7 @@ function buildArtifact(
 		version: 4,
 		evalId,
 		suite: { id: loaded.suite.suite.id, hash: loaded.hash },
-		clio: evalClioProvenance({ entry: clioEntry }),
+		clioCoder: evalClioProvenance({ entry: clioEntry }),
 		environment: evalEnvironmentProvenance(),
 		matrix: {
 			...artifactMatrixIdentity(loaded.suite.matrix.targets),

package/src/domains/eval/types.ts

@@ -126,7 +126,7 @@ export interface EvalRunArtifact {
 	evalId: string;
 	taskFile: string;
 	taskFileHash: string;
-	clio: EvalClioProvenance;
+	clioCoder: EvalClioProvenance;
 	environment: EvalEnvironmentProvenance;
 	target: string | null;
 	model: string | null;

package/src/domains/eval/workspaces/git.ts

@@ -7,7 +7,7 @@ import type { PreparedEvalWorkspace } from "./local.js";
 
 export async function prepareGitWorkspace(workspace: EvalWorkspaceV2): Promise<PreparedEvalWorkspace> {
 	if (workspace.url === undefined) throw new Error("git workspace requires url");
-	const dest = await mkdtemp(resolve(tmpdir(), "clio-eval-git-"));
+	const dest = await mkdtemp(resolve(tmpdir(), "clio-coder-eval-git-"));
 	try {
 		await runGit(["clone", "--quiet", workspace.url, dest], process.cwd());
 		const ref = workspace.checkout ?? workspace.commit;

package/src/domains/eval/workspaces/temp-copy.ts

@@ -33,7 +33,7 @@ export async function prepareTempCopyWorkspace(
 	options: PrepareTempCopyWorkspaceOptions = {},
 ): Promise<PreparedEvalWorkspace> {
 	const source = resolve(baseDir, workspace.path ?? ".");
-	const dest = await mkdtemp(resolve(options.tempRoot ?? tmpdir(), "clio-eval-workspace-"));
+	const dest = await mkdtemp(resolve(options.tempRoot ?? tmpdir(), "clio-coder-eval-workspace-"));
 	try {
 		const selection = await gitCopySelection(source);
 		const excludes = workspace.excludes ?? [];

package/src/domains/evidence/build.ts

@@ -56,6 +56,7 @@ const MAX_TASK_CHARS = 500;
 const TRANSCRIPT_TEXT_MAX_CHARS = 500;
 const TOOL_PREVIEW_MAX_CHARS = 240;
 const TASK_LEDGER_ROW_LIMIT = 200;
+const MODEL_PRIVATE_MARKER = "[not sent to model]";
 
 export interface BuildEvidenceOptions {
 	/** Evidence bundles are written under <dataDir>/evidence/. */
@@ -892,6 +893,7 @@ function sessionToolEvents(entries: ReadonlyArray<LinkedSessionEntry>): Evidence
 	for (const linked of entries) {
 		const entry = linked.entry;
 		if (entry.kind === "bashExecution") {
+			const contextMarker = entry.excludeFromContext === true ? `${MODEL_PRIVATE_MARKER} ` : "";
 			events.push({
 				source: "session-entry",
 				runId: linked.link.runId,
@@ -906,8 +908,8 @@ function sessionToolEvents(entries: ReadonlyArray<LinkedSessionEntry>): Evidence
 				timestamp: entry.timestamp,
 				linkKind: "session-bash-execution",
 				confidence: "exact",
-				argsPreview: truncateText(entry.command, TOOL_PREVIEW_MAX_CHARS),
-				resultPreview: truncateText(entry.output, TOOL_PREVIEW_MAX_CHARS),
+				argsPreview: truncateText(`${contextMarker}${entry.command}`, TOOL_PREVIEW_MAX_CHARS),
+				resultPreview: truncateText(`${contextMarker}${entry.output}`, TOOL_PREVIEW_MAX_CHARS),
 			});
 			continue;
 		}
@@ -1354,9 +1356,10 @@ function renderSessionTranscriptEntry(linked: LinkedSessionEntry): string[] {
 	}
 	if (entry.kind === "bashExecution") {
 		const status = entry.cancelled ? "cancelled" : entry.exitCode === null ? "exit=?" : `exit=${entry.exitCode}`;
+		const contextMarker = entry.excludeFromContext === true ? ` ${MODEL_PRIVATE_MARKER}` : "";
 		return [
-			`${prefix} bash ${status}: $ ${truncateText(entry.command, TRANSCRIPT_TEXT_MAX_CHARS)}`,
-			`  output: ${previewUnknown(entry.output)}`,
+			`${prefix} bash ${status}${contextMarker}: $ ${truncateText(entry.command, TRANSCRIPT_TEXT_MAX_CHARS)}`,
+			`  output${contextMarker}: ${previewUnknown(entry.output)}`,
 		];
 	}
 	if (entry.kind === "branchSummary")
@@ -1625,7 +1628,7 @@ function parseRunReceipt(value: unknown, source: string): RunReceipt {
 		costUsd: readNumber(value, source, "costUsd"),
 		compiledPromptHash: readNullableString(value, source, "compiledPromptHash"),
 		staticCompositionHash: readNullableString(value, source, "staticCompositionHash"),
-		clioVersion: readString(value, source, "clioVersion"),
+		clioCoderVersion: readReceiptVersion(value, source),
 		piMonoVersion: readString(value, source, "piMonoVersion"),
 		platform: readString(value, source, "platform"),
 		nodeVersion: readString(value, source, "nodeVersion"),
@@ -1640,6 +1643,11 @@ function parseRunReceipt(value: unknown, source: string): RunReceipt {
 	};
 }
 
+function readReceiptVersion(value: Record<string, unknown>, source: string): string {
+	if (typeof value.clioCoderVersion === "string") return value.clioCoderVersion;
+	return readString(value, source, "clioVersion");
+}
+
 function readToolStats(record: Record<string, unknown>, source: string, field: string): ToolCallStat[] {
 	const value = record[field];
 	if (!Array.isArray(value)) throw new Error(`${source}.${field}: expected array`);

package/src/domains/evidence/store.ts

@@ -205,6 +205,11 @@ function parseOverview(value: unknown, source: string): EvidenceOverview {
 	const totals = readTotals(value.totals, `${source}.totals`);
 	const tags = readStringArray(value, source, "tags") as EvidenceOverview["tags"];
 	const files = readStringArray(value, source, "files");
+	// Additive since the redaction pass landed, so a bundle written before it
+	// simply has no count. Reading it optionally is what keeps the declared
+	// field reachable: it was written to disk and then dropped on the way back.
+	const redactionCount =
+		typeof value.redactionCount === "number" && Number.isFinite(value.redactionCount) ? value.redactionCount : undefined;
 	return {
 		version: 1,
 		evidenceId,
@@ -224,6 +229,7 @@ function parseOverview(value: unknown, source: string): EvidenceOverview {
 		totals,
 		tags,
 		files,
+		...(redactionCount === undefined ? {} : { redactionCount }),
 	};
 }
 

package/src/domains/interop/consent.ts

@@ -24,7 +24,7 @@ export const INHERITED_PROJECT_CONTEXT = "none";
 /** The delegation entry a given agent kind would be wired as. */
 export function delegationEntryForKind(
 	kind: InteropAgentKind,
-	defaults: ClioSettings["delegation"]["defaults"],
+	defaults: ClioSettings["integrations"]["externalAgents"]["defaults"],
 ): DelegationAgentConfig {
 	const recipe = kind.acp;
 	if (recipe === undefined) throw new Error(`interop kind ${kind.id} has no ACP recipe`);
@@ -35,7 +35,7 @@ export function delegationEntryForKind(
 		connectTimeoutMs: defaults.connectTimeoutMs,
 		turnTimeoutMs: defaults.turnTimeoutMs,
 		permissionTimeoutMs: defaults.permissionTimeoutMs,
-		toolGovernance: "clio-policy",
+		toolGovernance: "clio-coder-policy",
 	};
 }
 
@@ -45,7 +45,7 @@ export function delegationEntryForKind(
  * declined agent whose binary or version moved comes back as a fresh proposal.
  */
 export function interopProposals(report: InteropReport, settings: ClioSettings): ReadonlyArray<InteropProposal> {
-	const configured = new Set(settings.delegation.agents.map((agent) => agent.id));
+	const configured = new Set(settings.integrations.externalAgents.entries.map((agent) => agent.id));
 	const proposals: InteropProposal[] = [];
 	for (const record of report.agents) {
 		const kind = interopAgentKind(record.kind);
@@ -57,7 +57,7 @@ export function interopProposals(report: InteropReport, settings: ClioSettings):
 			kind: kind.id,
 			label: kind.label,
 			fingerprint: record.fingerprint,
-			entry: delegationEntryForKind(kind, settings.delegation.defaults),
+			entry: delegationEntryForKind(kind, settings.integrations.externalAgents.defaults),
 			needsNetworkInstall: record.adapter !== "present",
 		});
 	}
@@ -149,7 +149,7 @@ export function interopBootHint(report: InteropReport, settings: ClioSettings):
 		(record) => ({ ...record, hintedFingerprint: record.fingerprint }),
 	);
 	const names = fresh.map((proposal) => proposal.entry.id).join(", ");
-	return `clio: ${names} detected on PATH and not configured. Run /interop to review.`;
+	return `clio-coder: ${names} detected on PATH and not configured. Run /interop to review.`;
 }
 
 /**
@@ -167,8 +167,8 @@ export function acceptInteropAgents(ids: ReadonlyArray<InteropAgentId>, report:
 	const wired: string[] = [];
 	updateSettings((settings) => {
 		for (const proposal of proposals) {
-			if (settings.delegation.agents.some((agent) => agent.id === proposal.entry.id)) continue;
-			settings.delegation.agents.push({ ...proposal.entry, args: [...proposal.entry.args] });
+			if (settings.integrations.externalAgents.entries.some((agent) => agent.id === proposal.entry.id)) continue;
+			settings.integrations.externalAgents.entries.push({ ...proposal.entry, args: [...proposal.entry.args] });
 			wired.push(proposal.entry.id);
 		}
 	});

package/src/domains/interop/extension.ts

@@ -39,7 +39,7 @@ export function createInteropBundle(_context: DomainContext): DomainBundle<Inter
 		// from the proposals, which read the file, and not yet in the configured
 		// list, which read the snapshot, so it was in neither until a reopen.
 		configured() {
-			return readSettings().delegation.agents;
+			return readSettings().integrations.externalAgents.entries;
 		},
 		accept(ids) {
 			const result = acceptInteropAgents(ids, detected ?? readInteropReport() ?? EMPTY_REPORT);

package/src/domains/lifecycle/doctor.ts

@@ -491,7 +491,7 @@ export async function runDoctorFleetChecks(projectRoot: string = process.cwd()):
 	}
 	const nodes = settings.fleet?.nodes ?? [];
 	if (nodes.length === 0) return [];
-	const { recordFleetPreflight, runFleetNodePreflight } = await import("../dispatch/fleet-preflight.js");
+	const { runFleetNodePreflight } = await import("../dispatch/fleet-preflight.js");
 	// Endpoint facts are per node. Every configured target is probed from every
 	// node, because a `localhost` URL names a different machine on each one and
 	// an orchestrator-side probe would describe none of them.
@@ -502,12 +502,6 @@ export async function runDoctorFleetChecks(projectRoot: string = process.cwd()):
 		...(target.defaultModel !== undefined ? { wireModelId: target.defaultModel } : {}),
 	}));
 	const records = await Promise.all(nodes.map((node) => runFleetNodePreflight(node, projectRoot, { targets })));
-	try {
-		recordFleetPreflight(records);
-	} catch {
-		// The findings below still tell the operator what happened; a store
-		// write failure just means placement will keep denying these nodes.
-	}
 	return records.map((record) => ({
 		ok: true,
 		level: record.ok ? "ok" : "warn",
@@ -533,14 +527,26 @@ export async function runDoctorInteropChecks(projectRoot: string = process.cwd()
 	} catch {
 		return [];
 	}
-	const skills = loadSkills({ cwd: projectRoot });
+	const configDir = resolveClioDirs().config;
+	// Extension discovery resolves through the ensuring config accessor. With no
+	// config root there cannot be user Clio extensions or skills to inspect, so
+	// keep the broken partial home untouched and retain the binary checks below.
+	const skills = existsSync(configDir) ? loadSkills({ cwd: projectRoot, configDir }) : { items: [], diagnostics: [] };
 	const foreign = skills.items.filter((skill) => FOREIGN_SKILL_SOURCES.has(skill.source));
-	const report = await detectInteropAgents({
-		cwd: projectRoot,
-		probeVersion: true,
-		skillSources: skills.items.map((skill) => skill.source),
-	});
-	const configured = new Set(settings.delegation.agents.map((agent) => agent.id));
+	const report = await detectInteropAgents(
+		{
+			cwd: projectRoot,
+			// Version probes use the shared command runner, which prepares managed Git
+			// hooks before spawning. Doctor promises observation only, so PATH presence
+			// is the strongest safe fact here.
+			probeVersion: false,
+			skillSources: skills.items.map((skill) => skill.source),
+		},
+		// Reading the prior report resolves through the ensuring state accessor.
+		// Existing decisions are irrelevant to doctor's presence-only projection.
+		[],
+	);
+	const configured = new Set(settings.integrations.externalAgents.entries.map((agent) => agent.id));
 	const findings: DoctorFinding[] = report.agents.map((agent) => {
 		const kind = interopAgentKind(agent.kind);
 		const status = configured.has(agent.kind)
@@ -557,7 +563,7 @@ export async function runDoctorInteropChecks(projectRoot: string = process.cwd()
 					: "";
 		return { ok: true, level: "ok", name: `interop ${agent.kind}`, detail: `${head} (${status})${where}` };
 	});
-	for (const agent of settings.delegation.agents) {
+	for (const agent of settings.integrations.externalAgents.entries) {
 		if (resolveOnPath([agent.command]).presence === "present") continue;
 		findings.push({
 			ok: true,
@@ -618,14 +624,14 @@ function configuredModelRoles(
 ): ConfiguredModelRole[] {
 	const roles: ConfiguredModelRole[] = [];
 	if (target.defaultModel) roles.push({ role: "defaultModel", model: target.defaultModel });
-	if (settings.orchestrator.target === target.id && settings.orchestrator.model) {
-		roles.push({ role: "orchestrator.model", model: settings.orchestrator.model });
+	if (settings.chat.target === target.id && settings.chat.model) {
+		roles.push({ role: "orchestrator.model", model: settings.chat.model });
 	}
-	if (settings.background.target === target.id && settings.background.model) {
-		roles.push({ role: "background.model", model: settings.background.model });
+	if (settings.context.memory.target === target.id && settings.context.memory.model) {
+		roles.push({ role: "background.model", model: settings.context.memory.model });
 	}
-	if (settings.workers.default.target === target.id && settings.workers.default.model) {
-		roles.push({ role: "workers.default.model", model: settings.workers.default.model });
+	if (settings.fleet.default.target === target.id && settings.fleet.default.model) {
+		roles.push({ role: "workers.default.model", model: settings.fleet.default.model });
 	}
 	return roles;
 }

package/src/domains/lifecycle/migrations/2026-09-01-clio-coder-naming.ts

@@ -0,0 +1,155 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { settingsPath, withSettingsLock } from "../../../core/config.js";
+import { safeResourceWrite } from "../../../core/safe-resource-write.js";
+import { type MutableNamingStateReport, migrateMutableNamingState } from "../naming-mutable-state.js";
+import { inspectInstalledNamingResources, type NamingResourceReport } from "../naming-resources.js";
+import { inspectToolMarkerNaming, type ToolMarkerNamingReport } from "../naming-tool-markers.js";
+import { regenerateYaziNamingProfile, type YaziNamingRegenerationReport } from "../naming-yazi.js";
+import type { Migration } from "./index.js";
+
+export const CLIO_CODER_NAMING_MIGRATION_ID = "2026-09-01-clio-coder-naming";
+export const CLIO_CODER_NAMING_SETTINGS_BACKUP_SUFFIX = ".pre-clio-coder-naming.bak";
+
+export interface NamingSettingsTransform {
+	document: Record<string, unknown>;
+	replacements: string[];
+	conflicts: string[];
+}
+
+export interface NamingSettingsFileReport {
+	path: string;
+	changed: boolean;
+	backupPath: string | null;
+	replacements: string[];
+	conflicts: string[];
+}
+
+export interface ClioCoderNamingMigrationReport {
+	migrationId: typeof CLIO_CODER_NAMING_MIGRATION_ID;
+	version: 1;
+	settings: NamingSettingsFileReport[];
+	toolMarkers: ToolMarkerNamingReport[];
+	resources: NamingResourceReport[];
+	yazi: YaziNamingRegenerationReport[];
+	mutableState: MutableNamingStateReport[];
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function visitNamingValues(value: unknown, path: string, replacements: string[], conflicts: string[]): void {
+	if (Array.isArray(value)) {
+		for (const [index, entry] of value.entries()) visitNamingValues(entry, `${path}[${index}]`, replacements, conflicts);
+		return;
+	}
+	if (!isPlainObject(value)) return;
+
+	for (const [key, entry] of Object.entries(value)) {
+		const entryPath = path ? `${path}.${key}` : key;
+		if (key === "lifecycle" && entry === "clio-managed") {
+			value[key] = "clio-coder-managed";
+			replacements.push(`${entryPath}: clio-managed -> clio-coder-managed`);
+			continue;
+		}
+		if (key === "toolGovernance" && entry === "clio-policy") {
+			value[key] = "clio-coder-policy";
+			replacements.push(`${entryPath}: clio-policy -> clio-coder-policy`);
+			continue;
+		}
+		if (key === "keybindings" && isPlainObject(entry)) {
+			for (const legacyKey of Object.keys(entry).filter((name) => name.startsWith("clio."))) {
+				const canonicalKey = `clio-coder.${legacyKey.slice("clio.".length)}`;
+				const legacyPath = `${entryPath}.${legacyKey}`;
+				if (Object.hasOwn(entry, canonicalKey)) {
+					delete entry[legacyKey];
+					conflicts.push(`${legacyPath}: discarded because canonical ${entryPath}.${canonicalKey} wins`);
+					continue;
+				}
+				entry[canonicalKey] = entry[legacyKey];
+				delete entry[legacyKey];
+				replacements.push(`${legacyPath} -> ${entryPath}.${canonicalKey}`);
+			}
+		}
+		visitNamingValues(entry, entryPath, replacements, conflicts);
+	}
+}
+
+/** Pure deterministic settings transform shared by upgrade and doctor --fix. */
+export function transformNamingSettingsDocument(raw: unknown): NamingSettingsTransform {
+	if (!isPlainObject(raw)) throw new Error("Clio Coder naming migration expected a YAML map at the document root");
+	const document = structuredClone(raw);
+	const replacements: string[] = [];
+	const conflicts: string[] = [];
+	visitNamingValues(document, "", replacements, conflicts);
+	return { document, replacements, conflicts };
+}
+
+/**
+ * Rewrite one settings file atomically when it contains deterministic released
+ * aliases. The caller owns any cross-process lock needed for the selected file.
+ */
+export function migrateNamingSettingsFile(path: string): NamingSettingsFileReport {
+	if (!existsSync(path)) return { path, changed: false, backupPath: null, replacements: [], conflicts: [] };
+	let parsed: unknown;
+	try {
+		parsed = parseYaml(readFileSync(path, "utf8"));
+	} catch (error) {
+		throw new Error(
+			`Clio Coder naming migration could not read and parse ${path}: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+	const transformed = transformNamingSettingsDocument(parsed);
+	const changed = transformed.replacements.length > 0 || transformed.conflicts.length > 0;
+	if (!changed) {
+		return {
+			path,
+			changed: false,
+			backupPath: null,
+			replacements: transformed.replacements,
+			conflicts: transformed.conflicts,
+		};
+	}
+	const backupPath = `${path}${CLIO_CODER_NAMING_SETTINGS_BACKUP_SUFFIX}`;
+	safeResourceWrite(path, stringifyYaml(transformed.document), {
+		encoding: "utf8",
+		mode: 0o644,
+		backup: { path: backupPath },
+	});
+	return {
+		path,
+		changed: true,
+		backupPath,
+		replacements: transformed.replacements,
+		conflicts: transformed.conflicts,
+	};
+}
+
+function namingMigrationReportPath(stateDir: string): string {
+	return join(stateDir, "migration-reports", `${CLIO_CODER_NAMING_MIGRATION_ID}.json`);
+}
+
+const migration: Migration = {
+	id: CLIO_CODER_NAMING_MIGRATION_ID,
+	async up(stateDir: string): Promise<void> {
+		const settings: NamingSettingsFileReport[] = [];
+		withSettingsLock(() => settings.push(migrateNamingSettingsFile(settingsPath())));
+		const report: ClioCoderNamingMigrationReport = {
+			migrationId: CLIO_CODER_NAMING_MIGRATION_ID,
+			version: 1,
+			settings,
+			toolMarkers: inspectToolMarkerNaming({ fix: true }),
+			resources: inspectInstalledNamingResources({ fix: true }),
+			yazi: [regenerateYaziNamingProfile()],
+			mutableState: migrateMutableNamingState(stateDir),
+		};
+		const target = namingMigrationReportPath(stateDir);
+		mkdirSync(join(stateDir, "migration-reports"), { recursive: true });
+		safeResourceWrite(target, `${JSON.stringify(report, null, 2)}\n`, { encoding: "utf8", mode: 0o644 });
+	},
+};
+
+export default migration;