@iowarp/clio-coder 0.3.9 → 0.4.1

package/src/core/session-routing.ts

@@ -18,7 +18,7 @@
 
 import type { ClioSettings } from "./config.js";
 
-type SessionThinkingLevel = ClioSettings["orchestrator"]["thinkingLevel"];
+type SessionThinkingLevel = ClioSettings["chat"]["thinkingLevel"];
 
 export interface SessionRoutingTarget {
 	target: string | null;
@@ -28,7 +28,7 @@ export interface SessionRoutingTarget {
 
 export interface SessionRoutingState {
 	orchestrator: SessionRoutingTarget;
-	background: SessionRoutingTarget;
+	background: Pick<SessionRoutingTarget, "target" | "model">;
 	workersDefault: SessionRoutingTarget;
 	scope: string[];
 }
@@ -40,7 +40,7 @@ export interface SessionRoutingState {
  */
 export interface RoutingPatch {
 	orchestrator?: Partial<SessionRoutingTarget>;
-	background?: Partial<SessionRoutingTarget>;
+	background?: Partial<Pick<SessionRoutingTarget, "target" | "model">>;
 	workersDefault?: Partial<SessionRoutingTarget>;
 	scope?: string[];
 }
@@ -59,10 +59,10 @@ function targetFrom(source: {
 
 export function seedSessionRouting(saved: Readonly<ClioSettings>): SessionRoutingState {
 	return {
-		orchestrator: targetFrom(saved.orchestrator),
-		background: targetFrom(saved.background),
-		workersDefault: targetFrom(saved.workers.default),
-		scope: [...(saved.scope ?? [])],
+		orchestrator: targetFrom(saved.chat),
+		background: { target: saved.context.memory.target, model: saved.context.memory.model },
+		workersDefault: targetFrom(saved.fleet.default),
+		scope: [...saved.chat.modelPicker.cycleSet],
 	};
 }
 
@@ -73,16 +73,15 @@ export function seedSessionRouting(saved: Readonly<ClioSettings>): SessionRoutin
  */
 export function applySessionRouting(saved: Readonly<ClioSettings>, routing: SessionRoutingState): ClioSettings {
 	const view = structuredClone(saved) as ClioSettings;
-	view.orchestrator.target = routing.orchestrator.target;
-	view.orchestrator.model = routing.orchestrator.model;
-	view.orchestrator.thinkingLevel = routing.orchestrator.thinkingLevel;
-	view.background.target = routing.background.target;
-	view.background.model = routing.background.model;
-	view.background.thinkingLevel = routing.background.thinkingLevel;
-	view.workers.default.target = routing.workersDefault.target;
-	view.workers.default.model = routing.workersDefault.model;
-	view.workers.default.thinkingLevel = routing.workersDefault.thinkingLevel;
-	view.scope = [...routing.scope];
+	view.chat.target = routing.orchestrator.target;
+	view.chat.model = routing.orchestrator.model;
+	view.chat.thinkingLevel = routing.orchestrator.thinkingLevel;
+	view.context.memory.target = routing.background.target;
+	view.context.memory.model = routing.background.model;
+	view.fleet.default.target = routing.workersDefault.target;
+	view.fleet.default.model = routing.workersDefault.model;
+	view.fleet.default.thinkingLevel = routing.workersDefault.thinkingLevel;
+	view.chat.modelPicker.cycleSet = [...routing.scope];
 	return view;
 }
 
@@ -107,14 +106,21 @@ export type SessionOverrides = Map<string, unknown>;
 
 /** True for the dotted paths owned by the session routing state (never overrides). */
 export function isRoutingPath(path: string): boolean {
-	return (
-		path === "scope" ||
-		path.startsWith("orchestrator.") ||
-		path.startsWith("background.") ||
-		path.startsWith("workers.default.")
-	);
+	return ROUTING_PATHS.has(path);
 }
 
+const ROUTING_PATHS = new Set<string>([
+	"chat.target",
+	"chat.model",
+	"chat.thinkingLevel",
+	"context.memory.target",
+	"context.memory.model",
+	"fleet.default.target",
+	"fleet.default.model",
+	"fleet.default.thinkingLevel",
+	"chat.modelPicker.cycleSet",
+]);
+
 /** Read a leaf from a settings blob by dotted object path. Missing ⇒ undefined. */
 export function getAtPath(source: Readonly<ClioSettings>, path: string): unknown {
 	let cursor: unknown = source;
@@ -159,10 +165,10 @@ export function applyOverrides(base: Readonly<ClioSettings>, overrides: SessionO
 
 /** Write-through of a routing patch onto a (cloned) saved-settings blob. */
 export function mergeRoutingPatchIntoSettings(settings: ClioSettings, patch: RoutingPatch): void {
-	if (patch.orchestrator) Object.assign(settings.orchestrator, patch.orchestrator);
-	if (patch.background) Object.assign(settings.background, patch.background);
-	if (patch.workersDefault) Object.assign(settings.workers.default, patch.workersDefault);
-	if (patch.scope) settings.scope = [...patch.scope];
+	if (patch.orchestrator) Object.assign(settings.chat, patch.orchestrator);
+	if (patch.background) Object.assign(settings.context.memory, patch.background);
+	if (patch.workersDefault) Object.assign(settings.fleet.default, patch.workersDefault);
+	if (patch.scope) settings.chat.modelPicker.cycleSet = [...patch.scope];
 }
 
 /**
@@ -176,26 +182,24 @@ export function mergeRoutingPatchIntoSettings(settings: ClioSettings, patch: Rou
  */
 export function routingPatchForId(path: string, settings: Readonly<ClioSettings>): RoutingPatch | null {
 	switch (path) {
-		case "orchestrator.target":
-			return { orchestrator: { target: settings.orchestrator.target, model: settings.orchestrator.model } };
-		case "orchestrator.model":
-			return { orchestrator: { model: settings.orchestrator.model } };
-		case "orchestrator.thinkingLevel":
-			return { orchestrator: { thinkingLevel: settings.orchestrator.thinkingLevel } };
-		case "background.target":
-			return { background: { target: settings.background.target, model: settings.background.model } };
-		case "background.model":
-			return { background: { model: settings.background.model } };
-		case "background.thinkingLevel":
-			return { background: { thinkingLevel: settings.background.thinkingLevel } };
-		case "workers.default.target":
-			return { workersDefault: { target: settings.workers.default.target, model: settings.workers.default.model } };
-		case "workers.default.model":
-			return { workersDefault: { model: settings.workers.default.model } };
-		case "workers.default.thinkingLevel":
-			return { workersDefault: { thinkingLevel: settings.workers.default.thinkingLevel } };
-		case "scope":
-			return { scope: [...(settings.scope ?? [])] };
+		case "chat.target":
+			return { orchestrator: { target: settings.chat.target, model: settings.chat.model } };
+		case "chat.model":
+			return { orchestrator: { model: settings.chat.model } };
+		case "chat.thinkingLevel":
+			return { orchestrator: { thinkingLevel: settings.chat.thinkingLevel } };
+		case "context.memory.target":
+			return { background: { target: settings.context.memory.target, model: settings.context.memory.model } };
+		case "context.memory.model":
+			return { background: { model: settings.context.memory.model } };
+		case "fleet.default.target":
+			return { workersDefault: { target: settings.fleet.default.target, model: settings.fleet.default.model } };
+		case "fleet.default.model":
+			return { workersDefault: { model: settings.fleet.default.model } };
+		case "fleet.default.thinkingLevel":
+			return { workersDefault: { thinkingLevel: settings.fleet.default.thinkingLevel } };
+		case "chat.modelPicker.cycleSet":
+			return { scope: [...settings.chat.modelPicker.cycleSet] };
 		default:
 			return null;
 	}
@@ -224,13 +228,17 @@ function scopeEquals(a: ReadonlyArray<string>, b: ReadonlyArray<string>): boolea
  */
 export function diffRouting(prev: Readonly<ClioSettings>, next: Readonly<ClioSettings>): RoutingPatch | null {
 	const patch: RoutingPatch = {};
-	const orchestrator = diffTarget(prev.orchestrator, next.orchestrator);
+	const orchestrator = diffTarget(prev.chat, next.chat);
 	if (orchestrator) patch.orchestrator = orchestrator;
-	const background = diffTarget(prev.background, next.background);
+	const background = diffTarget(
+		{ ...prev.context.memory, thinkingLevel: "off" },
+		{ ...next.context.memory, thinkingLevel: "off" },
+	);
 	if (background) patch.background = background;
-	const workersDefault = diffTarget(prev.workers.default, next.workers.default);
+	const workersDefault = diffTarget(prev.fleet.default, next.fleet.default);
 	if (workersDefault) patch.workersDefault = workersDefault;
-	if (!scopeEquals(prev.scope ?? [], next.scope ?? [])) patch.scope = [...(next.scope ?? [])];
+	if (!scopeEquals(prev.chat.modelPicker.cycleSet, next.chat.modelPicker.cycleSet))
+		patch.scope = [...next.chat.modelPicker.cycleSet];
 	return Object.keys(patch).length > 0 ? patch : null;
 }
 
@@ -241,16 +249,15 @@ export function diffRouting(prev: Readonly<ClioSettings>, next: Readonly<ClioSet
  * saved routing defaults with this session's live routing.
  */
 export function restoreRoutingFields(target: ClioSettings, source: Readonly<ClioSettings>): void {
-	target.orchestrator.target = source.orchestrator.target;
-	target.orchestrator.model = source.orchestrator.model;
-	target.orchestrator.thinkingLevel = source.orchestrator.thinkingLevel;
-	target.background.target = source.background.target;
-	target.background.model = source.background.model;
-	target.background.thinkingLevel = source.background.thinkingLevel;
-	target.workers.default.target = source.workers.default.target;
-	target.workers.default.model = source.workers.default.model;
-	target.workers.default.thinkingLevel = source.workers.default.thinkingLevel;
-	target.scope = [...(source.scope ?? [])];
+	target.chat.target = source.chat.target;
+	target.chat.model = source.chat.model;
+	target.chat.thinkingLevel = source.chat.thinkingLevel;
+	target.context.memory.target = source.context.memory.target;
+	target.context.memory.model = source.context.memory.model;
+	target.fleet.default.target = source.fleet.default.target;
+	target.fleet.default.model = source.fleet.default.model;
+	target.fleet.default.thinkingLevel = source.fleet.default.thinkingLevel;
+	target.chat.modelPicker.cycleSet = [...source.chat.modelPicker.cycleSet];
 }
 
 const ROUTING_FIELD_LABELS: ReadonlyArray<{
@@ -258,20 +265,23 @@ const ROUTING_FIELD_LABELS: ReadonlyArray<{
 	label: string;
 	read: (settings: Readonly<ClioSettings>) => unknown;
 }> = [
-	{ field: "orchestrator.target", label: "chat target", read: (s) => s.orchestrator.target ?? null },
-	{ field: "orchestrator.model", label: "chat model", read: (s) => s.orchestrator.model ?? null },
-	{ field: "orchestrator.thinkingLevel", label: "chat thinking", read: (s) => s.orchestrator.thinkingLevel ?? "off" },
-	{ field: "background.target", label: "background target", read: (s) => s.background.target ?? null },
-	{ field: "background.model", label: "background model", read: (s) => s.background.model ?? null },
-	{ field: "background.thinkingLevel", label: "background thinking", read: (s) => s.background.thinkingLevel ?? "off" },
-	{ field: "workers.default.target", label: "fleet target", read: (s) => s.workers.default.target ?? null },
-	{ field: "workers.default.model", label: "fleet model", read: (s) => s.workers.default.model ?? null },
+	{ field: "chat.target", label: "chat target", read: (s) => s.chat.target ?? null },
+	{ field: "chat.model", label: "chat model", read: (s) => s.chat.model ?? null },
+	{ field: "chat.thinkingLevel", label: "chat thinking", read: (s) => s.chat.thinkingLevel ?? "off" },
+	{ field: "context.memory.target", label: "memory target", read: (s) => s.context.memory.target ?? null },
+	{ field: "context.memory.model", label: "memory model", read: (s) => s.context.memory.model ?? null },
+	{ field: "fleet.default.target", label: "fleet target", read: (s) => s.fleet.default.target ?? null },
+	{ field: "fleet.default.model", label: "fleet model", read: (s) => s.fleet.default.model ?? null },
 	{
-		field: "workers.default.thinkingLevel",
+		field: "fleet.default.thinkingLevel",
 		label: "fleet thinking",
-		read: (s) => s.workers.default.thinkingLevel ?? "off",
+		read: (s) => s.fleet.default.thinkingLevel ?? "off",
+	},
+	{
+		field: "chat.modelPicker.cycleSet",
+		label: "Alt+J/Alt+K cycle set",
+		read: (s) => s.chat.modelPicker.cycleSet.join(","),
 	},
-	{ field: "scope", label: "Alt+J/Alt+K scope", read: (s) => (s.scope ?? []).join(",") },
 ];
 
 /**
@@ -282,7 +292,7 @@ const ROUTING_FIELD_LABELS: ReadonlyArray<{
  * writer — a second session, the CLI, or a manual edit — moved the defaults
  * out from under this session.
  */
-export function externalRoutingDivergence(
+function externalRoutingDivergence(
 	changedPaths: ReadonlyArray<string>,
 	saved: Readonly<ClioSettings>,
 	effective: Readonly<ClioSettings>,
@@ -325,7 +335,7 @@ export function routingChangeNotices(
 			text: `settings.yaml changed (${diverged.join(", ")}). This session keeps its routing; new sessions use the saved defaults.${hint}`,
 		});
 	}
-	const activeTarget = effective.orchestrator.target;
+	const activeTarget = effective.chat.target;
 	const targetsTouched = changedPaths.some((path) => path === "targets" || path.startsWith("targets."));
 	if (activeTarget && targetsTouched && !saved.targets.some((entry) => entry.id === activeTarget)) {
 		const hint = options?.commandHints ? " (/model)" : "";

package/src/core/skill-activation.ts

@@ -19,6 +19,24 @@ export const SKILL_SUGGESTION_ANCHOR = "Suggested skill: /skill <name>";
  */
 export const SKILL_SUGGESTION_PREFIX = SKILL_SUGGESTION_ANCHOR.slice(0, SKILL_SUGGESTION_ANCHOR.indexOf("<name>"));
 
+/**
+ * The four fixed answer labels of a marketplace install offer. Every surface
+ * that teaches or reads the offer (the marketplace-offer middleware, the
+ * skills fragment, the context listing footer) cites these exact strings, so
+ * the after_tool observer that records declines and runs consented installs
+ * recognizes the operator's choice by label identity, never by paraphrase.
+ */
+export const SKILL_INSTALL_OFFER_OPTION_PROJECT = "Install for this project";
+export const SKILL_INSTALL_OFFER_OPTION_USER = "Install globally";
+export const SKILL_INSTALL_OFFER_OPTION_NOT_NOW = "Not now";
+export const SKILL_INSTALL_OFFER_OPTION_NEVER = "Never offer this skill";
+export const SKILL_INSTALL_OFFER_OPTIONS = [
+	SKILL_INSTALL_OFFER_OPTION_PROJECT,
+	SKILL_INSTALL_OFFER_OPTION_USER,
+	SKILL_INSTALL_OFFER_OPTION_NOT_NOW,
+	SKILL_INSTALL_OFFER_OPTION_NEVER,
+] as const;
+
 export interface PendingSkillRequest {
 	name: string;
 	args: string;

package/src/core/termination.ts

@@ -37,7 +37,7 @@ const SIGNAL_EXIT_CODES: Partial<Record<NodeJS.Signals, number>> = {
  * Break `text` into lines no wider than `width` columns, at spaces where
  * possible and mid-word when a single token is wider than the terminal.
  */
-export function wrapToWidth(text: string, width: number): string[] {
+function wrapToWidth(text: string, width: number): string[] {
 	if (!Number.isFinite(width) || width < 1) return [text];
 	const lines: string[] = [];
 	let current = "";
@@ -156,7 +156,7 @@ class TerminationCoordinator {
 		const log = (msg: string): void => {
 			if (!debug) return;
 			const ms = Number(process.hrtime.bigint() - mark) / 1e6;
-			process.stderr.write(`[clio:shutdown] +${ms.toFixed(1)}ms ${msg}\n`);
+			process.stderr.write(`[clio-coder:shutdown] +${ms.toFixed(1)}ms ${msg}\n`);
 		};
 
 		this.phase = "draining";
@@ -193,12 +193,12 @@ class TerminationCoordinator {
 			const t0 = process.hrtime.bigint();
 			const completed = await runWithBudget(hook, budgetMs, (err) => {
 				const message = err instanceof Error ? err.message : String(err);
-				writeShutdownNotice(`[clio:termination] ${phase}[${i}] failed: ${message}`);
+				writeShutdownNotice(`[clio-coder:termination] ${phase}[${i}] failed: ${message}`);
 				if (err instanceof Error && err.stack) log(err.stack);
 			});
 			const dt = Number(process.hrtime.bigint() - t0) / 1e6;
 			if (!completed) {
-				writeShutdownNotice(`[clio:termination] ${phase}[${i}] exceeded ${budgetMs}ms budget; shutdown continues`);
+				writeShutdownNotice(`[clio-coder:termination] ${phase}[${i}] exceeded ${budgetMs}ms budget; shutdown continues`);
 			}
 			log(`  ${phase}[${i}] ${dt.toFixed(1)}ms${completed ? "" : " (timed out)"}`);
 		}

package/src/core/theme-token-hex.ts

@@ -0,0 +1,43 @@
+/** Semantic colors shared by Clio's terminal surfaces and generated companion profiles. */
+export type ClioToken =
+	| "accent"
+	| "accentDeep"
+	| "action"
+	| "success"
+	| "warning"
+	| "error"
+	| "info"
+	| "reason"
+	| "dim"
+	| "muted"
+	| "title"
+	| "frame"
+	| "frameStrong";
+
+/**
+ * The palette's lowercase hex projection.
+ *
+ * Keep this leaf free of interactive imports. Generated companion profiles
+ * need the color vocabulary without becoming a second reacher of the terminal
+ * renderer and splitting the instant shell's Stage 0 chunk.
+ */
+const TOKEN_HEX: Readonly<Record<ClioToken, `#${string}`>> = {
+	accent: "#46e5d0",
+	accentDeep: "#1fb7a6",
+	action: "#ff7e29",
+	success: "#57e389",
+	warning: "#ffb454",
+	error: "#ff5c66",
+	info: "#5ba8ff",
+	reason: "#9d8cff",
+	dim: "#6a7a85",
+	muted: "#8a99a4",
+	title: "#46e5d0",
+	frame: "#2f5d5a",
+	frameStrong: "#2aab9e",
+};
+
+/** The canonical lowercase `#rrggbb` value for one Clio theme token. */
+export function tokenHex(token: ClioToken): `#${string}` {
+	return TOKEN_HEX[token];
+}

package/src/core/timers.ts

@@ -14,8 +14,6 @@ export function sleep(ms: number): Promise<void> {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-let negativeDurations = 0;
-
 /**
  * Elapsed between two reads of the same clock, signed.
  *
@@ -23,16 +21,8 @@ let negativeDurations = 0;
  * an NTP correction, a resume, or a duration derived across two hosts — and it
  * is a bug in the caller, not a value to be silently swallowed. Clamping with
  * `Math.max(0, …)` hides that, so the clamp belongs at the render boundary and
- * nothing else. Every occurrence is counted; nothing is written to stderr,
- * because the TUI owns that stream and this sits on hot measurement paths.
+ * nothing else.
  */
 export function rawDurationMs(start: number, end: number): number {
-	const elapsed = end - start;
-	if (elapsed < 0) negativeDurations += 1;
-	return elapsed;
-}
-
-/** How many negative durations this process has produced since it started. */
-export function negativeDurationCount(): number {
-	return negativeDurations;
+	return end - start;
 }

package/src/core/tool-names.ts

@@ -7,7 +7,7 @@
  *   OBSERVE      read, grep, find, ls, code_nav, context, credential_present
  *   MUTATE       write, edit
  *   EXECUTE      bash, git, verify
- *   ORCHESTRATE  dispatch, monitor, steer, tasks
+ *   ORCHESTRATE  dispatch, monitor, steer, tasks, panes
  *   RETRIEVE     web_fetch
  *   INTERACT     ask_user
  *   ARTIFACT     artifact
@@ -35,6 +35,7 @@ export const ToolNames = {
 	Steer: "steer",
 	Tasks: "tasks",
 	Ledger: "ledger",
+	Panes: "panes",
 	// RETRIEVE
 	WebFetch: "web_fetch",
 	// INTERACT

package/src/core/xdg.ts

@@ -20,7 +20,7 @@ import { join } from "node:path";
  *
  * Role contents: config holds user-authored files (settings, credentials,
  * agents, skills, prompts, extensions, runtimes); data holds durable artifacts
- * (memory, evidence, evals); state holds machine-produced session state
+ * (memory, evidence, evals, vendored tools); state holds machine-produced session state
  * (sessions, audit, receipts, runs.json, recent-models.json, install.json,
  * interviews, scratch); cache holds disposable derived files.
  */

package/src/domains/agents/catalog.ts

@@ -1,5 +1,4 @@
-import type { AgentRecipe } from "./recipe.js";
-import { type AgentSpec, isUserVisibleAgent, normalizeAgentSpec } from "./spec.js";
+import { type AgentSpec, isUserVisibleAgent } from "./spec.js";
 
 const DEFAULT_DISPATCH_AGENT_ID = "coder";
 
@@ -20,10 +19,6 @@ export interface AgentCatalogSections {
 	volatile: string;
 }
 
-function renderAgentCatalogSections(recipes: ReadonlyArray<AgentRecipe>): AgentCatalogSections {
-	return renderAgentCatalogSectionsFromSpecs(recipes.map(normalizeAgentSpec));
-}
-
 /** Keeps one roster line short enough that the whole fleet block stays near its token budget. */
 const FLEET_PROMPT_PURPOSE_MAX_CHARS = 64;
 
@@ -129,7 +124,7 @@ export function renderFleetPromptSection(input: ReadonlyArray<AgentSpec>): strin
 /**
  * Spec-based roster used when the caller already holds normalized specs.
  * `AgentsContract.listSpecs()` includes ACP delegation agents synthesized from
- * settings.delegation.agents[], which never exist as recipe files; rendering
+ * settings.integrations.externalAgents.entries[], which never exist as recipe files; rendering
  * from specs keeps those dispatchable targets discoverable in the fleet block.
  */
 export function renderAgentCatalogSectionsFromSpecs(input: ReadonlyArray<AgentSpec>): AgentCatalogSections {
@@ -178,8 +173,3 @@ function formatSpecLine(spec: AgentSpec, suffix: string): string {
 	const budget = `, budget=${spec.budget.toolCalls}/${spec.budget.readReserve}${maximum}/${spec.budget.synthesis ? "synthesize" : "stop"}`;
 	return `- ${spec.name} [${spec.id}] (${spec.audience}, ${spec.category}, ${spec.capabilityClass}, ${spec.latencyClass}, ${spec.source}${tags}${skills}${budget})${suffix}`;
 }
-
-export function renderAgentCatalog(recipes: ReadonlyArray<AgentRecipe>): string {
-	const sections = renderAgentCatalogSections(recipes);
-	return [sections.stable, sections.volatile].filter((part) => part.trim().length > 0).join("\n\n");
-}

package/src/domains/agents/extension.ts

@@ -15,7 +15,7 @@ export function createAgentsBundle(_context: DomainContext): DomainBundle<Agents
 		const nextDiagnostics: AgentRecipeDiagnostic[] = [];
 		const merged = discoverAgentRecipes(process.cwd(), nextDiagnostics);
 		const config = _context.getContract<ConfigContract>("config");
-		assertAgentIdNamespace(merged, config?.get()?.delegation?.agents ?? []);
+		assertAgentIdNamespace(merged, config?.get()?.integrations.externalAgents?.entries ?? []);
 		recipes = merged;
 		specs = recipes.map(normalizeAgentSpec);
 		diagnostics = nextDiagnostics;
@@ -40,7 +40,7 @@ export function createAgentsBundle(_context: DomainContext): DomainBundle<Agents
 		},
 		listSpecs() {
 			const config = _context.getContract<ConfigContract>("config");
-			const delegationAgents = config?.get()?.delegation?.agents ?? [];
+			const delegationAgents = config?.get()?.integrations.externalAgents?.entries ?? [];
 			const delegationSpecs = delegationAgents.map((agent) => ({
 				version: 1 as const,
 				id: agent.id,
@@ -67,7 +67,7 @@ export function createAgentsBundle(_context: DomainContext): DomainBundle<Agents
 			const found = specs.find((r) => r.id === id);
 			if (found) return found;
 			const config = _context.getContract<ConfigContract>("config");
-			const agent = config?.get()?.delegation?.agents?.find((entry) => entry.id === id);
+			const agent = config?.get()?.integrations.externalAgents?.entries?.find((entry) => entry.id === id);
 			if (agent) {
 				return {
 					version: 1 as const,

package/src/domains/agents/fleets/build-review.md

@@ -29,6 +29,3 @@ task above. Nothing you write here persuades it.
 
 If it fails you, you receive its failed checks as input data and get exactly one
 revision. Close the findings it reported and nothing else.
-
-Answer with your `mutation-report`. Include `commitMessage`: one imperative
-subject line describing this change, as you would write it in the log.

package/src/domains/agents/fleets/build-test.md

@@ -30,6 +30,3 @@ If the suite comes back red you will receive its output as input data. Repair
 exactly what it reported. Do not restate the failure, do not weaken or delete a
 test to make it pass, and do not widen the change beyond the repair. You get at
 most two repair attempts before the run fails with the suite still red.
-
-Answer with your `mutation-report`. Include `commitMessage`: one imperative
-subject line describing this change, as you would write it in the log.

package/src/domains/agents/registry.ts

@@ -94,7 +94,7 @@ export function loadRecipesFromDir(
 			if (source.source === "builtin") throw error;
 			const message = error instanceof Error ? error.message : String(error);
 			diagnostics.push({ source: source.source, filepath, message });
-			process.stderr.write(`[clio:agents] quarantine path=${filepath} source=${source.source} reason=${message}\n`);
+			process.stderr.write(`[clio-coder:agents] quarantine path=${filepath} source=${source.source} reason=${message}\n`);
 		}
 	}
 
@@ -102,7 +102,7 @@ export function loadRecipesFromDir(
 	return recipes;
 }
 
-export function mergeRecipes(...sources: ReadonlyArray<ReadonlyArray<AgentRecipe>>): ReadonlyArray<AgentRecipe> {
+function mergeRecipes(...sources: ReadonlyArray<ReadonlyArray<AgentRecipe>>): ReadonlyArray<AgentRecipe> {
 	const byId = new Map<string, AgentRecipe>();
 	const builtinById = new Map<string, AgentRecipe>();
 	for (const group of sources) {
@@ -113,23 +113,23 @@ export function mergeRecipes(...sources: ReadonlyArray<ReadonlyArray<AgentRecipe
 	for (const group of sources) {
 		for (const recipe of group) {
 			if (recipe.source !== "builtin" && RESERVED_CUSTOM_AGENT_IDS.has(recipe.id)) {
-				process.stderr.write(`[clio:agents] ignore id=${recipe.id} by=${recipe.source} reason=reserved-agent-id\n`);
+				process.stderr.write(`[clio-coder:agents] ignore id=${recipe.id} by=${recipe.source} reason=reserved-agent-id\n`);
 				continue;
 			}
 			const builtin = builtinById.get(recipe.id);
 			if (recipe.source === "extension" && builtin) {
-				process.stderr.write(`[clio:agents] ignore override id=${recipe.id} by=extension reason=reserved-builtin\n`);
+				process.stderr.write(`[clio-coder:agents] ignore override id=${recipe.id} by=extension reason=reserved-builtin\n`);
 				continue;
 			}
 			if (recipe.source === "user" && builtin && isShadowAgent(normalizeAgentSpec(builtin))) {
-				process.stderr.write(`[clio:agents] ignore override id=${recipe.id} by=user reason=reserved-shadow\n`);
+				process.stderr.write(`[clio-coder:agents] ignore override id=${recipe.id} by=user reason=reserved-shadow\n`);
 				continue;
 			}
 			if (recipe.source === "project" && builtin) {
-				process.stderr.write(`[clio:agents] ignore override id=${recipe.id} by=project reason=reserved-builtin\n`);
+				process.stderr.write(`[clio-coder:agents] ignore override id=${recipe.id} by=project reason=reserved-builtin\n`);
 				continue;
 			}
-			if (byId.has(recipe.id)) process.stderr.write(`[clio:agents] override id=${recipe.id} by=${recipe.source}\n`);
+			if (byId.has(recipe.id)) process.stderr.write(`[clio-coder:agents] override id=${recipe.id} by=${recipe.source}\n`);
 			byId.set(recipe.id, recipe);
 		}
 	}

package/src/domains/agents/result-contract-filesystem.ts

@@ -0,0 +1,32 @@
+/**
+ * The one live-disk implementation of `ResultContractFilesystem`.
+ *
+ * `result-contract.ts` takes filesystem access as an argument so the validators
+ * stay deterministic and testable without touching a disk. That leaves every
+ * caller to supply the same three accessors, and the worker and the
+ * orchestrator had each written their own copy. A capability added to the
+ * interface then lands in one of them and not the other, which is how a Scout
+ * citation could ground inside the worker's repair rounds and fail the
+ * orchestrator's sealed revalidation of the identical result. One factory, both
+ * callers, no drift.
+ */
+import { existsSync, readFileSync, statSync } from "node:fs";
+import type { ResultContractFilesystem } from "./result-contract.js";
+
+export function nodeResultContractFilesystem(): ResultContractFilesystem {
+	return {
+		readFile(filePath) {
+			try {
+				return readFileSync(filePath, "utf8");
+			} catch {
+				return null;
+			}
+		},
+		pathExists(filePath) {
+			return existsSync(filePath);
+		},
+		isDirectory(filePath) {
+			return statSync(filePath, { throwIfNoEntry: false })?.isDirectory() === true;
+		},
+	};
+}