@iowarp/clio-coder 0.4.0 → 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/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/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/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 });