@iowarp/clio-coder 0.4.0 → 0.4.2

package/src/domains/agents/extension.ts

@@ -1,3 +1,4 @@
+import { BusChannels } from "../../core/bus-events.js";
 import type { DomainBundle, DomainContext, DomainExtension } from "../../core/domain-loader.js";
 import { assertAgentIdNamespace } from "../config/agent-namespace.js";
 import type { ConfigContract } from "../config/contract.js";
@@ -10,25 +11,46 @@ export function createAgentsBundle(_context: DomainContext): DomainBundle<Agents
 	let recipes: ReadonlyArray<AgentRecipe> = [];
 	let specs: ReadonlyArray<AgentSpec> = [];
 	let diagnostics: ReadonlyArray<AgentRecipeDiagnostic> = [];
+	let revision = 0;
 
 	function discover(): void {
 		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;
+		revision += 1;
 	}
 
+	let unsubscribeExtensionsReload: (() => void) | null = null;
 	const extension: DomainExtension = {
 		async start() {
 			discover();
+			// Recipes are cached at start; extension agent roots come from the
+			// committed extension generation, so a changed generation rediscovers.
+			unsubscribeExtensionsReload = _context.bus.on(BusChannels.ExtensionsReloaded, (payload: unknown) => {
+				if ((payload as { changed?: unknown } | undefined)?.changed !== true) return;
+				try {
+					discover();
+				} catch (error) {
+					process.stderr.write(
+						`[clio-coder:agents] rediscovery after extension reload failed: ${error instanceof Error ? error.message : String(error)}\n`,
+					);
+				}
+			});
+		},
+		async stop() {
+			unsubscribeExtensionsReload?.();
+			unsubscribeExtensionsReload = null;
 		},
-		async stop() {},
 	};
 
 	const contract: AgentsContract = {
+		revision() {
+			return revision;
+		},
 		list() {
 			return recipes;
 		},
@@ -40,7 +62,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 +89,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/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.ts

@@ -1601,7 +1601,7 @@ export interface ResultContractRepairInput {
  * One repair directive. It states the validator's reason and exact shape. Tool
  * use remains closed unless dispatch preauthorized a larger revision phase.
  */
-export function resultContractRepairMessage(input: ResultContractRepairInput): string {
+function resultContractRepairMessage(input: ResultContractRepairInput): string {
 	const last = input.attempt >= RESULT_CONTRACT_REPAIR_LIMIT;
 	const lines = [
 		last

package/src/domains/agents/spec.ts

@@ -137,17 +137,6 @@ export function isAgentProduct(value: unknown): value is AgentProduct {
 	return includes(AGENT_PRODUCTS, value);
 }
 
-/**
- * Default tier per capability class. Reproduces the historical dispatch
- * allowlist byte-for-byte: workers that act on the workspace get the bounded
- * projection; read-only, orchestration, and internal classes get none.
- */
-export function defaultProjectContextTier(capability: AgentCapabilityClass): AgentProjectContextTier {
-	return capability === "workspace-edit" || capability === "verification" || capability === "artifact-write"
-		? "bounded"
-		: "none";
-}
-
 function actionClassesForTools(tools: ReadonlyArray<ToolName>): ReadonlySet<ActionClass> {
 	const actions = new Set<ActionClass>();
 	for (const tool of tools) actions.add(classify({ tool }).actionClass);

package/src/domains/config/classify.ts

@@ -1,13 +1,10 @@
 import type { ClioSettings } from "../../core/config.js";
 
 /**
- * Classifies a settings change into one of three buckets per spec §13:
- *   - hotReload   : theme, keybindings, safety rules, prompt fragments,
- *                   audit verbosity. Apply immediately (≤100ms).
- *   - nextTurn    : model selection, thinking level, budget ceiling. Apply before the
- *                   next turn starts.
- *   - restartRequired : provider credentials, active provider list, runtime enable/disable,
- *                       engine settings. Needs a restart nudge.
+ * Classifies a version-2 settings change into one of three effect buckets:
+ *   - hotReload: a live reader observes the value without rebuilding runtime state.
+ *   - nextTurn: the next request, dispatch, or explicit open observes the value.
+ *   - restartRequired: process or pane-host setup must be rebuilt.
  *
  * Output is an exhaustive per-bucket list. A single patch can touch multiple buckets;
  * the caller emits the event(s) for every non-empty bucket.
@@ -22,59 +19,50 @@ export interface ConfigDiff {
 }
 
 const HOT_RELOAD_FIELDS = new Set<string>([
-	"theme",
-	"keybindings",
-	"autonomy",
-	"modelSelector",
-	"terminal.smoothStreaming",
-	"attribution.gitCommits",
+	"interface.keybindings",
+	"safety.autonomy",
+	"chat.modelPicker",
+	"interface.smoothStreaming",
+	"interface.panes.notifications",
+	"integrations.git.commitAttribution",
 	// The bridge reads these on every explicit open; no mux re-detection is
 	// needed because the host capability rung remains `panes.enabled`.
-	"panes.yazi",
+	"interface.panes.files",
 	// The watchdog registration reads its settings live on every trigger, so
 	// enabling it, retargeting it, or changing its cadence takes effect on the
 	// next turn boundary without a restart or a session-routing patch.
-	"watchdog",
+	"safety.review",
 ]);
 
 const NEXT_TURN_FIELDS = new Set<string>([
-	"identity",
 	"targets",
-	"orchestrator.target",
-	"orchestrator.model",
-	"orchestrator.thinkingLevel",
-	"background.target",
-	"background.model",
-	"background.thinkingLevel",
-	"memory",
-	"workers.default.target",
-	"workers.default.model",
-	"workers.default.thinkingLevel",
-	"workers.profiles",
-	"workers.agentBindings",
-	"workers.maxRetries",
-	"workers.onPermission",
-	"fleet",
-	"routing",
-	"scope",
-	"budget.sessionCeilingUsd",
-	"defaults",
-	"terminal",
-	"skills",
-	"delegation",
-	"compaction",
+	"chat",
+	"fleet.default",
+	"fleet.profiles",
+	"fleet.rosters",
+	"fleet.agentProfiles",
+	"fleet.adaptiveRouting",
+	"fleet.nodes",
+	"fleet.permissions",
+	"fleet.retry",
+	"fleet.limits",
+	"fleet.history",
 	"context",
-	// The pre-warm reads its setting when a trigger fires, and every trigger sits
-	// on a turn boundary, so a change takes effect before the next turn runs.
-	"prewarm",
-	"retry",
+	"safety.limits",
+	"interface.outputDetail",
+	"interface.terminalProgress",
+	"interface.desktopNotifications",
+	"integrations.projectResources",
+	"integrations.externalAgents",
+	"integrations.library",
 ]);
 
 const RESTART_REQUIRED_FIELDS = new Set<string>([
-	"budget.concurrency",
-	"runtimePlugins",
-	"terminal.tuiMode",
-	"terminal.fullscreenScrollbar",
+	"fleet.concurrency",
+	"interface.mode",
+	"interface.fullscreenScrollbar",
+	"interface.panes.enabled",
+	"integrations.runtimePlugins",
 ]);
 
 function matchesPrefix(path: string, fields: Set<string>): boolean {

package/src/domains/config/extension.ts

@@ -29,7 +29,7 @@ export function createConfigBundle(
 
 	function assertAgentNamespace(settings: Readonly<ClioSettings>): void {
 		const agents = context.getContract<NativeAgentNamespace>("agents");
-		if (agents) assertAgentIdNamespace(agents.list(), settings.delegation.agents);
+		if (agents) assertAgentIdNamespace(agents.list(), settings.integrations.externalAgents.entries);
 	}
 
 	function dispatch(kind: ChangeKind, payload: ConfigChangePayload): void {
@@ -45,7 +45,7 @@ export function createConfigBundle(
 			try {
 				listener(payload);
 			} catch (err) {
-				console.error(`[clio:config] listener for ${kind} threw:`, err);
+				console.error(`[clio-coder:config] listener for ${kind} threw:`, err);
 			}
 		}
 	}
@@ -84,7 +84,7 @@ export function createConfigBundle(
 		}
 		publishReloadFailure(null);
 		snapshot = next;
-		setGitCommitAttributionEnabled(next.attribution.gitCommits);
+		setGitCommitAttributionEnabled(next.integrations.git.commitAttribution);
 		if (!prev) return;
 		const diff = diffSettings(prev, next);
 		if (diff.hotReload.length > 0) dispatch("hotReload", { diff, settings: next });
@@ -96,7 +96,7 @@ export function createConfigBundle(
 		async start() {
 			if (initialSettings) snapshot = structuredClone(initialSettings);
 			else snapshot = readStrictLayeredSettings(process.cwd()).settings;
-			setGitCommitAttributionEnabled(snapshot.attribution.gitCommits);
+			setGitCommitAttributionEnabled(snapshot.integrations.git.commitAttribution);
 			watcher = startConfigWatcher(() => onWatcherFire());
 		},
 		async stop() {
@@ -124,7 +124,7 @@ export function createConfigBundle(
 			// a route may name a target supplied only by this workspace.
 			const normalized = updateLayeredSettings(process.cwd(), mutate);
 			snapshot = normalized;
-			setGitCommitAttributionEnabled(normalized.attribution.gitCommits);
+			setGitCommitAttributionEnabled(normalized.integrations.git.commitAttribution);
 			const diff = diffSettings(previous, normalized);
 			if (diff.hotReload.length > 0) dispatch("hotReload", { diff, settings: normalized });
 			if (diff.nextTurn.length > 0) dispatch("nextTurn", { diff, settings: normalized });

package/src/domains/config/keybindings.ts

@@ -4,8 +4,9 @@
  * can resolve both against user overrides stored in `settings.yaml`.
  *
  * The `Keybindings` interface in pi-tui is extensible via declaration merging.
- * Adding `clio.*` ids here makes them typed everywhere the manager is used:
- * pass a wrong id to `matches("clio.typo", ...)` and the compiler complains.
+ * Adding `clio-coder.*` ids here makes them typed everywhere the manager is
+ * used: pass a wrong id to `matches("clio-coder.typo", ...)` and the compiler
+ * complains.
  */
 
 import type { KeybindingDefinitions } from "../../engine/tui.js";
@@ -18,28 +19,29 @@ import { TUI_KEYBINDINGS } from "../../engine/tui.js";
  * live in `resolveCtrlCAction` and are not a simple keybinding.
  */
 export interface ClioAppKeybindings {
-	"clio.thinking.cycle": true;
-	"clio.exit": true;
-	"clio.status.toggle": true;
-	"clio.session.tree": true;
-	"clio.dispatchBoard.toggle": true;
-	"clio.tasks.open": true;
-	"clio.decisions.open": true;
-	"clio.dispatch.background": true;
-	"clio.model.select": true;
-	"clio.model.cycleForward": true;
-	"clio.model.cycleBackward": true;
-	"clio.tool.expand": true;
-	"clio.tool.expandAll": true;
-	"clio.tool.liveOutput": true;
-	"clio.thinking.expand": true;
-	"clio.thinking.expandAll": true;
-	"clio.editor.external": true;
-	"clio.message.followUp": true;
-	"clio.message.interrupt": true;
-	"clio.message.dequeue": true;
-	"clio.notifications.dismiss": true;
-	"clio.leader": true;
+	"clio-coder.thinking.cycle": true;
+	"clio-coder.exit": true;
+	"clio-coder.status.toggle": true;
+	"clio-coder.session.tree": true;
+	"clio-coder.dispatchBoard.toggle": true;
+	"clio-coder.files.toggle": true;
+	"clio-coder.tasks.open": true;
+	"clio-coder.decisions.open": true;
+	"clio-coder.dispatch.background": true;
+	"clio-coder.model.select": true;
+	"clio-coder.model.cycleForward": true;
+	"clio-coder.model.cycleBackward": true;
+	"clio-coder.tool.expand": true;
+	"clio-coder.tool.expandAll": true;
+	"clio-coder.tool.liveOutput": true;
+	"clio-coder.thinking.expand": true;
+	"clio-coder.thinking.expandAll": true;
+	"clio-coder.editor.external": true;
+	"clio-coder.message.followUp": true;
+	"clio-coder.message.interrupt": true;
+	"clio-coder.message.dequeue": true;
+	"clio-coder.notifications.dismiss": true;
+	"clio-coder.leader": true;
 }
 
 export type ClioKeybinding = keyof ClioAppKeybindings;
@@ -47,7 +49,7 @@ export type ClioKeybinding = keyof ClioAppKeybindings;
 /**
  * Declaration merge: pi-tui's `Keybindings` interface is open so downstream
  * packages register their action ids. After this block, `KeybindingsManager`
- * returned from `createKeybindingManager` accepts `clio.*` ids with full
+ * returned from `createKeybindingManager` accepts `clio-coder.*` ids with full
  * TypeScript checking.
  */
 declare module "@earendil-works/pi-tui" {
@@ -69,37 +71,44 @@ declare module "@earendil-works/pi-tui" {
  * net for user rebinds.
  */
 export const CLIO_APP_KEYBINDINGS = {
-	"clio.thinking.cycle": {
+	"clio-coder.thinking.cycle": {
 		defaultKeys: "shift+tab",
 		description: "Cycle orchestrator thinking level",
 	},
-	"clio.exit": {
+	"clio-coder.exit": {
 		defaultKeys: "ctrl+d",
 		description: "Exit when the editor is empty",
 	},
-	"clio.status.toggle": {
+	"clio-coder.status.toggle": {
 		defaultKeys: "alt+u",
 		description: "Toggle the footer dashboard (compact / expanded)",
 	},
-	"clio.session.tree": {
+	"clio-coder.session.tree": {
 		defaultKeys: "alt+t",
 		description: "Open the /tree navigator",
 	},
-	"clio.dispatchBoard.toggle": {
+	"clio-coder.dispatchBoard.toggle": {
 		defaultKeys: "alt+w",
 		description: "Toggle the dispatch (workers) board overlay",
 	},
-	"clio.tasks.open": {
+	"clio-coder.files.toggle": {
+		// Alt+F is a pi-tui editor reserve (word-forward), so the files pane
+		// takes the next letter that reads as "explorer" and stays inside the
+		// Alt+<letter> scheme, which also earns it the Ctrl+G leader fallback.
+		defaultKeys: "alt+e",
+		description: "Toggle the files pane beside the session (a --with-panes session inside herdr)",
+	},
+	"clio-coder.tasks.open": {
 		// Approved application-boundary override of pi-tui editor word-back.
 		defaultKeys: "alt+b",
 		description: "Open the composite session and operator task board",
 	},
-	"clio.decisions.open": {
+	"clio-coder.decisions.open": {
 		// Approved application-boundary override of pi-tui editor word-delete.
 		defaultKeys: "alt+d",
 		description: "Open the settled interview decision board",
 	},
-	"clio.dispatch.background": {
+	"clio-coder.dispatch.background": {
 		// Ctrl+B alone is pi-tui's editor cursor-left, so the Claude Code chord
 		// cannot be the primary here. Alt+S ("send to background") keeps the app
 		// scheme and earns the Ctrl+G leader fallback, which only alt+<letter>
@@ -107,56 +116,56 @@ export const CLIO_APP_KEYBINDINGS = {
 		defaultKeys: ["alt+s", "ctrl+alt+b"],
 		description: "Send the running attached dispatch to the background as a detached batch",
 	},
-	"clio.model.select": {
+	"clio-coder.model.select": {
 		defaultKeys: "alt+l",
 		description: "Open the model + targets selector",
 	},
-	"clio.model.cycleForward": {
+	"clio-coder.model.cycleForward": {
 		defaultKeys: "alt+j",
 		description: "Cycle to next scoped model",
 	},
-	"clio.model.cycleBackward": {
+	"clio-coder.model.cycleBackward": {
 		defaultKeys: "alt+k",
 		description: "Cycle to previous scoped model",
 	},
-	"clio.tool.expand": {
+	"clio-coder.tool.expand": {
 		defaultKeys: "alt+o",
 		description:
 			"Fold or unfold the newest tool call or worker block between its one-line summary and full details, overriding the /output level for that block",
 	},
-	"clio.tool.expandAll": {
+	"clio-coder.tool.expandAll": {
 		// Alt+Shift+letter is commonly consumed by OS keyboard-layout switching.
 		// Keep it discoverable, but pair it with the legacy-safe Ctrl+Alt form.
 		defaultKeys: ["ctrl+alt+o", "alt+shift+o"],
 		description:
 			"Fold or unfold every tool call and worker block at once, overriding the /output level; changing /output clears the overrides",
 	},
-	"clio.tool.liveOutput": {
+	"clio-coder.tool.liveOutput": {
 		defaultKeys: "alt+p",
 		description: "Toggle streaming partial tool output in expanded tool bodies",
 	},
-	"clio.thinking.expand": {
+	"clio-coder.thinking.expand": {
 		defaultKeys: "alt+r",
 		description:
 			"Toggle the latest thinking block between hidden marker and full body (no effect while /output verbose pins it open)",
 	},
-	"clio.thinking.expandAll": {
+	"clio-coder.thinking.expandAll": {
 		// Ctrl+Alt+R is the fallback for terminals/OSes that do not forward
 		// Alt+Shift+R as a distinct key event.
 		defaultKeys: ["ctrl+alt+r", "alt+shift+r"],
 		description:
 			"Toggle all thinking blocks between hidden markers and full bodies, overriding the /output level; changing /output clears the overrides",
 	},
-	"clio.editor.external": {
+	"clio-coder.editor.external": {
 		defaultKeys: "alt+g",
 		description: "Open the current input in an external editor",
 	},
-	"clio.message.followUp": {
+	"clio-coder.message.followUp": {
 		defaultKeys: "alt+enter",
 		description:
 			"End of turn: queue the current input for delivery when the active run settles (Enter delivers it at the next slot, between tool batches)",
 	},
-	"clio.message.interrupt": {
+	"clio-coder.message.interrupt": {
 		// Alt+I keeps the app scheme and earns the Ctrl+G leader fallback. A
 		// Ctrl+Enter chord was rejected because legacy terminals send it as a
 		// plain Enter, which would turn every send into a cancel.
@@ -164,15 +173,15 @@ export const CLIO_APP_KEYBINDINGS = {
 		description:
 			"Interrupt: cancel the active run and deliver the current input now (refused while an attached dispatch runs or a permission ask is parked; the input then queues for the next slot)",
 	},
-	"clio.message.dequeue": {
+	"clio-coder.message.dequeue": {
 		defaultKeys: "alt+up",
 		description: "Restore queued steering and follow-up messages to the editor",
 	},
-	"clio.notifications.dismiss": {
+	"clio-coder.notifications.dismiss": {
 		defaultKeys: "alt+x",
 		description: "Dismiss footer notifications",
 	},
-	"clio.leader": {
+	"clio-coder.leader": {
 		defaultKeys: "ctrl+g",
 		description: "Start portable leader-key fallback for Alt shortcuts",
 	},

package/src/domains/config/watcher.ts

@@ -28,7 +28,7 @@ export function startConfigWatcher(cb: WatcherCallback): ConfigWatcher {
 			}, 80);
 		});
 	} catch (err) {
-		console.error("[clio:config] watcher setup failed:", err);
+		console.error("[clio-coder:config] watcher setup failed:", err);
 	}
 
 	return {

package/src/domains/context/codewiki/indexer.ts

@@ -752,7 +752,7 @@ function mergeTreeSitterWithRegexImports(
 	};
 }
 
-export function fallbackExtraction(language: CodewikiLanguage, relPath: string, text: string): LanguageExtraction {
+function fallbackExtraction(language: CodewikiLanguage, relPath: string, text: string): LanguageExtraction {
 	return extractWithExtractors(fallbackExtractors, language, relPath, text);
 }
 

package/src/domains/context/extension.ts

@@ -59,9 +59,6 @@ function persistState(
  * because nothing inside it awaited.
  */
 async function ensureCodewikiFresh(cwd: string): Promise<void> {
-	// The bootstrap model-generation child runs a headless session purely to draft
-	// CLIO-CODER.md; it must not re-index while the parent context-init owns the rebuild.
-	if (process.env.CLIO_CODER_BOOTSTRAP_GENERATE_CHILD === "1") return;
 	const state = readClioState(cwd);
 	if (!state && !existsSync(codewikiPath(cwd))) return;
 	const indexedAt = new Date().toISOString();
@@ -146,15 +143,15 @@ function collectStartupHints(cwd: string, options: ContextBundleOptions = {}): s
 		projectType !== "unknown" &&
 		options.noContextFiles !== true
 	) {
-		hints.push("clio: No CLIO-CODER.md detected. Run /context init to explore the repo and bootstrap context.");
+		hints.push("clio-coder: No CLIO-CODER.md detected. Run /context init to explore the repo and bootstrap context.");
 	}
 	for (const issue of clio.errors) {
-		hints.push(`clio: malformed ${issue.path} ignored: ${issue.error}`);
+		hints.push(`clio-coder: malformed ${issue.path} ignored: ${issue.error}`);
 	}
 	const state = readClioState(cwd);
 	if (!state) return hints;
 	if (state.contextSources !== undefined && adoptionSourcesChanged(state.contextSources, { cwd })) {
-		hints.push("clio: Imported agent context changed. Run /context init --adopt to refresh.");
+		hints.push("clio-coder: Imported agent context changed. Run /context init --adopt to refresh.");
 	}
 	return hints;
 }

package/src/domains/context/prompt-context.ts

@@ -32,7 +32,7 @@ export function renderPromptContext(cwd: string): ProjectPromptContext {
 	const clioMd: ParsedClioMd | null = loadedClioMd.value;
 	for (const file of loadedClioMd.files) pieces.push(renderProjectContextFragment(file.value, file.path));
 	for (const issue of loadedClioMd.errors) {
-		warnings.push(`clio: malformed ${issue.path} ignored: ${issue.error}`);
+		warnings.push(`clio-coder: malformed ${issue.path} ignored: ${issue.error}`);
 	}
 	// Said where the handbook would have been: a model that sees no project
 	// context spends its first tool call reading CLIO-CODER.md and gets

package/src/domains/context/wiki/assemble.ts

@@ -39,7 +39,7 @@ const SOURCE_CITATION =
 const INTERNAL_LINK = /\[[^\]]*\]\((?![a-z][a-z\d+.-]*:|\/\/|#)([^)\s]+\.md)(?:#[^)\s]*)?\)/gi;
 
 /** Marker line carrying a page's unrepaired references; regenerated every pass. */
-const REPAIR_NOTE = /^<!-- clio:wiki .*-->$/gm;
+const REPAIR_NOTE = /^<!-- (?:clio-coder|clio):wiki .*-->$/gm;
 
 export interface WikiPageIssue {
 	page: string;
@@ -79,7 +79,7 @@ function renderRepairNote(issues: ReadonlyArray<WikiPageIssue>): string {
 	const parts: string[] = [];
 	if (links.length > 0) parts.push(`unresolved links: ${[...new Set(links)].join(", ")}`);
 	if (citations.length > 0) parts.push(`unresolved sources: ${[...new Set(citations)].join(", ")}`);
-	return parts.length === 0 ? "" : `\n<!-- clio:wiki ${parts.join("; ")} -->\n`;
+	return parts.length === 0 ? "" : `\n<!-- clio-coder:wiki ${parts.join("; ")} -->\n`;
 }
 
 /**

package/src/domains/context/working-set/path-index.ts

@@ -241,6 +241,7 @@ function observedPath(op: PathOp, args: Record<string, unknown> | null, cwd: str
 		return explicit === null ? "" : canonicalize(explicit, cwd);
 	}
 	if (op === "code_nav") {
+		if (stringField(args, "source") === "clio") return "";
 		const mode = stringField(args, "mode");
 		if (mode === null || !CODE_NAV_PATH_MODES.has(mode)) return "";
 		const query = stringField(args, "query");

package/src/domains/context/working-set/replay/metrics.ts

@@ -144,10 +144,6 @@ function measure(input: ReplayMeasurement): MeasuredTrace {
 	};
 }
 
-export function measureReplayTrace(input: ReplayMeasurement): ReplayMetrics {
-	return measure(input).metrics;
-}
-
 function mean(values: ReadonlyArray<number>): number {
 	return values.length === 0 ? 0 : values.reduce((sum, value) => sum + value, 0) / values.length;
 }

package/src/domains/context/working-set/replay/report.ts

@@ -49,7 +49,7 @@ function metricObject(metrics: ReplayMetrics, turnsToFirstSummaryCount: number):
 export function renderReplayJson(input: ReplayReportInput): string {
 	const filtered = Object.fromEntries(Object.entries(input.cascade.filtered).sort(([a], [b]) => a.localeCompare(b)));
 	const artifact = {
-		schema: "clio-context-replay-v2",
+		schema: "clio-coder-context-replay-v2",
 		config: {
 			policies: [...input.config.policies],
 			budgets: [...input.config.budgets],

package/src/domains/context/working-set/replay/synthetic.ts

@@ -93,7 +93,7 @@ export const SYNTHETIC_CORPORA: ReadonlyArray<SyntheticCorpusSpec> = [
 	},
 ];
 
-export function syntheticCorpus(id: string): SyntheticCorpusSpec | undefined {
+function syntheticCorpus(id: string): SyntheticCorpusSpec | undefined {
 	return SYNTHETIC_CORPORA.find((spec) => spec.id === id);
 }
 
@@ -258,7 +258,7 @@ function testOutput(files: ReadonlyArray<RepoFile>, failing: RepoFile | null): s
 }
 
 /** Generate one trace of the corpus. `index` selects the trace; the spec's seed and index fix every byte. */
-export function generateSyntheticTrace(spec: SyntheticCorpusSpec, index: number): Trace {
+function generateSyntheticTrace(spec: SyntheticCorpusSpec, index: number): Trace {
 	const rnd = mulberry32(spec.seed * 1000 + index);
 	const between = (low: number, high: number): number => low + Math.floor(rnd() * (high - low + 1));
 	const pick = <T>(items: ReadonlyArray<T>): T => items[Math.floor(rnd() * items.length)] as T;