@iowarp/clio-coder 0.4.0 → 0.4.2

package/src/interactive/slash-spec.ts

@@ -11,15 +11,55 @@ export interface CommandFlagSpec {
 	values?: ReadonlyArray<string>;
 	/** Usage placeholder, e.g. "profile" renders as `[--agent-profile <profile>]`. */
 	valueName?: string;
+	/** Runtime completion source attached by name; providers are wired separately. */
+	completionSlot?: CompletionSlotName;
 }
 
 export interface CommandPositionalSpec {
 	name: string; // e.g. "agent", "task"
 	required: boolean;
+	/** Closed values in semantic/manifest order. */
+	values?: ReadonlyArray<string>;
 	/** Greedy tail: consumes the rest of the line verbatim (task text, compact instructions). */
 	rest?: boolean;
+	/** Runtime completion source attached by name; providers are wired separately. */
+	completionSlot?: CompletionSlotName;
 }
 
+/**
+ * Stable grammar/provider seam. Slice 10 names every dynamic noun; slice 11
+ * supplies read-only implementations for these slots.
+ */
+export const COMPLETION_SLOT_NAMES = [
+	"agents",
+	"agent-profiles",
+	"worker-runtimes",
+	"targets",
+	"models",
+	"capabilities",
+	"external-agents",
+	"rosters",
+	"shareable-runs",
+	"skills",
+	"fleet-contracts",
+	"fleet-vars",
+	"fleet-var-values",
+	"tasks",
+	"context-refs",
+	"receipts",
+	"pane-runs-agents",
+	"pane-presets",
+	"pane-targets",
+	"library-tabs",
+	"thinking-levels",
+	"settings-areas",
+	"settings-groups",
+	"help-queries",
+	"paths",
+] as const;
+
+export type CompletionSlotName = (typeof COMPLETION_SLOT_NAMES)[number];
+
 export interface CommandArgsSpec {
 	flags?: ReadonlyArray<CommandFlagSpec>;
 	positionals?: ReadonlyArray<CommandPositionalSpec>;
@@ -299,16 +339,86 @@ export function parseArgs(spec: CommandArgsSpec, argsLine: string): ParsedArgs {
 }
 
 export interface ArgCompletion {
-	/** Replacement for the trailing (possibly empty) token under the cursor. */
+	/** Canonical replacement for the token under the cursor. */
 	token: string;
 	/** Grammar hint rendered beside the suggestion, e.g. a flag's value placeholder. */
 	hint?: string;
+	completionSlot?: CompletionSlotName;
+	description?: string;
+	disabledReason?: string;
+	/** A completion with another grammatical slot receives a space on Tab. */
+	hasNextSlot: boolean;
 }
 
 export interface ArgCompletionResult {
 	completions: ArgCompletion[];
-	/** Index in the argument text where the token under the cursor begins. */
+	/** Half-open replacement range in argumentText. Quotes are outside the range. */
 	tokenStart: number;
+	tokenEnd: number;
+	quote?: '"' | "'";
+	/** Structured second-level list, rather than a flat top-level command row. */
+	submenu?: { parent: string; canGoBack: true };
+}
+
+interface CompletionToken {
+	value: string;
+	start: number;
+	end: number;
+	contentStart: number;
+	contentEnd: number;
+	quote?: '"' | "'";
+}
+
+/** Tokenize without losing source ranges; unterminated quotes intentionally run to EOL. */
+function completionTokens(text: string): CompletionToken[] {
+	const tokens: CompletionToken[] = [];
+	let index = 0;
+	while (index < text.length) {
+		while (index < text.length && /\s/.test(text[index] ?? "")) index++;
+		if (index >= text.length) break;
+		const start = index;
+		let quote: '"' | "'" | undefined;
+		if (text[index] === '"' || text[index] === "'") {
+			quote = text[index] as '"' | "'";
+			index++;
+		}
+		const contentStart = index;
+		let value = "";
+		while (index < text.length) {
+			const char = text[index] ?? "";
+			if (quote) {
+				if (char === quote) break;
+			} else if (/\s/.test(char)) {
+				break;
+			} else if (char === '"' || char === "'") {
+				// Quotes embedded in a token group their contents but are not values.
+				const embedded = char;
+				index++;
+				while (index < text.length && text[index] !== embedded) value += text[index++] ?? "";
+				if (text[index] === embedded) index++;
+				continue;
+			}
+			value += char;
+			index++;
+		}
+		const contentEnd = index;
+		if (quote && text[index] === quote) index++;
+		tokens.push({ value, start, end: index, contentStart, contentEnd, ...(quote ? { quote } : {}) });
+	}
+	return tokens;
+}
+
+function tokenAtCursor(text: string, cursor: number): { current: CompletionToken; completed: CompletionToken[] } {
+	const safeCursor = Math.max(0, Math.min(cursor, text.length));
+	const tokens = completionTokens(text);
+	const containing = tokens.find((token) => safeCursor >= token.start && safeCursor <= token.end);
+	if (containing) {
+		return { current: containing, completed: tokens.filter((token) => token.end <= containing.start) };
+	}
+	return {
+		current: { value: "", start: safeCursor, end: safeCursor, contentStart: safeCursor, contentEnd: safeCursor },
+		completed: tokens.filter((token) => token.end <= safeCursor),
+	};
 }
 
 /**
@@ -352,10 +462,14 @@ function walkCompletedTokens(spec: CommandArgsSpec, tokens: ReadonlyArray<string
 
 function flagCompletions(spec: CommandArgsSpec, walk: CompletionWalk, current: string): ArgCompletion[] {
 	const available = (spec.flags ?? []).filter((flag) => flag.repeatable === true || !walk.usedFlags.has(flag.name));
-	const rows = available.filter((flag) => flag.name.startsWith(current)).map((flag) => ({ flag, name: flag.name }));
+	const lower = current.toLowerCase();
+	const rows = available
+		.filter((flag) => flag.name.toLowerCase().startsWith(lower))
+		.map((flag) => ({ flag, name: flag.name }));
 	return rows.map(({ flag, name }) => ({
 		token: name,
 		...(flag.takesValue ? { hint: `<${getFlagValuePlaceholder(flag)}>` } : {}),
+		hasNextSlot: flag.takesValue === true,
 	}));
 }
 
@@ -367,27 +481,38 @@ function flagCompletions(spec: CommandArgsSpec, walk: CompletionWalk, current: s
  * null closes the suggestion list. The walk mirrors parseArgs so a completion
  * is always a token the parser would accept.
  */
-export function completeArgs(spec: CommandArgsSpec, argumentText: string): ArgCompletionResult | null {
-	const trailing = argumentText.match(/\S*$/)?.[0] ?? "";
-	const tokenStart = argumentText.length - trailing.length;
-	const current = trailing;
-	const completed = argumentText
-		.slice(0, tokenStart)
-		.split(/\s+/)
-		.filter((token) => token.length > 0);
+export function completeArgs(
+	spec: CommandArgsSpec,
+	argumentText: string,
+	cursor = argumentText.length,
+): ArgCompletionResult | null {
+	const { current: currentToken, completed: completedTokens } = tokenAtCursor(argumentText, cursor);
+	const current = currentToken.value.slice(0, Math.max(0, cursor - currentToken.contentStart));
+	const completed = completedTokens.map((token) => token.value);
+	const range = {
+		tokenStart: currentToken.contentStart,
+		tokenEnd: currentToken.contentEnd,
+		...(currentToken.quote ? { quote: currentToken.quote } : {}),
+	};
 
 	const completions: ArgCompletion[] = [];
 	let active = spec;
 	let walkTokens = completed;
+	let submenu: ArgCompletionResult["submenu"];
 
 	if (spec.subcommands) {
 		const first = completed[0];
 		if (first === undefined) {
 			for (const [name, subSpec] of Object.entries(spec.subcommands)) {
-				if (!name.startsWith(current)) continue;
+				if (!name.toLowerCase().startsWith(current.toLowerCase())) continue;
 				const hint = renderArgsSpec(subSpec);
-				completions.push({ token: name, ...(hint.length > 0 ? { hint } : {}) });
+				completions.push({
+					token: name,
+					...(hint.length > 0 ? { hint } : {}),
+					hasNextSlot: hint.length > 0,
+				});
 			}
+			submenu = { parent: "", canGoBack: true };
 		} else if (spec.subcommands[first]) {
 			active = spec.subcommands[first];
 			walkTokens = completed.slice(1);
@@ -397,25 +522,43 @@ export function completeArgs(spec: CommandArgsSpec, argumentText: string): ArgCo
 	const walk = walkCompletedTokens(active, walkTokens);
 
 	if (walk.restBegun) {
-		return completions.length > 0 ? { completions, tokenStart } : null;
+		return completions.length > 0 ? { completions, ...range, ...(submenu ? { submenu } : {}) } : null;
 	}
 
 	if (walk.awaitingValue) {
 		for (const value of walk.awaitingValue.values ?? []) {
-			if (value.startsWith(current)) completions.push({ token: value });
+			if (value.toLowerCase().startsWith(current.toLowerCase())) completions.push({ token: value, hasNextSlot: true });
 		}
-		return completions.length > 0 ? { completions, tokenStart } : null;
+		if (walk.awaitingValue.completionSlot) {
+			completions.push({ token: current, completionSlot: walk.awaitingValue.completionSlot, hasNextSlot: true });
+		}
+		return completions.length > 0 ? { completions, ...range, ...(submenu ? { submenu } : {}) } : null;
 	}
 
 	const atRest = (active.positionals ?? [])[walk.positionalIndex]?.rest === true;
+	const positional = (active.positionals ?? [])[walk.positionalIndex];
+	for (const value of positional?.values ?? []) {
+		if (value.toLowerCase().startsWith(current.toLowerCase())) {
+			completions.push({ token: value, hasNextSlot: walk.positionalIndex + 1 < (active.positionals?.length ?? 0) });
+		}
+	}
+	if (positional?.completionSlot && !current.startsWith("-")) {
+		completions.push({
+			token: current,
+			completionSlot: positional.completionSlot,
+			hasNextSlot: walk.positionalIndex + 1 < (active.positionals?.length ?? 0),
+		});
+	}
 	const flagsParseable = !atRest || active.parseFlagsBeforeRest === true;
 	if (flagsParseable && (current.length === 0 || current.startsWith("-"))) {
 		completions.push(...flagCompletions(active, walk, current));
 	}
 
-	return completions.length > 0 ? { completions, tokenStart } : null;
+	return completions.length > 0 ? { completions, ...range, ...(submenu ? { submenu } : {}) } : null;
 }
 
+export type CompletionAcceptance = "accept" | "accept-remainder" | "submit" | "close" | "none" | "disabled";
+
 export function matchFromSpec(
 	entry: {
 		name: string;

package/src/interactive/status/controller.ts

@@ -92,8 +92,8 @@ export function createStatusController(deps: StatusControllerDeps): StatusContro
 	const currentTarget = (): { targetId: string; modelId: string } => {
 		const settings = deps.getSettings?.();
 		return {
-			targetId: settings?.orchestrator?.target ?? "",
-			modelId: settings?.orchestrator?.model ?? "",
+			targetId: settings?.chat?.target ?? "",
+			modelId: settings?.chat?.model ?? "",
 		};
 	};
 

package/src/interactive/stream-pacing-policy.ts

@@ -1,28 +1,6 @@
-import type { SmoothStreaming } from "../core/defaults.js";
-
-export const SMOOTH_STREAM_ENV = "CLIO_CODER_SMOOTH_STREAM";
-
-/**
- * One-process override precedence: a valid environment value wins, while an
- * invalid value can never accidentally enable animation. `0` is the immediate
- * escape hatch; `1` is accepted as the explicit `on` spelling.
- */
-export function resolveSmoothStreamingMode(
-	configured: SmoothStreaming,
-	env: NodeJS.ProcessEnv = process.env,
-): SmoothStreaming {
-	const raw = env[SMOOTH_STREAM_ENV]?.trim().toLowerCase();
-	if (!raw) return configured;
-	if (raw === "0" || raw === "off" || raw === "false") return "off";
-	if (raw === "auto") return "auto";
-	if (raw === "1" || raw === "on" || raw === "true") return "on";
-	return "off";
-}
-
 export interface AutoPacingEnvironment {
 	isTTY: boolean;
 	term?: string;
-	termProgram?: string;
 	sshConnection?: string;
 	sshTty?: string;
 	tmux?: string;
@@ -39,7 +17,7 @@ export interface AutoPacingEnvironment {
  * accessibility markers always bypass pacing. Remote/multiplexed and already
  * saturated outputs keep the proven coalescer behavior.
  */
-export function autoPacingAllowed(environment: AutoPacingEnvironment): boolean {
+function autoPacingAllowed(environment: AutoPacingEnvironment): boolean {
 	if (!environment.isTTY || environment.backpressureObserved) return false;
 	const term = environment.term?.trim().toLowerCase();
 	if (!term || term === "dumb" || term === "unknown") return false;
@@ -53,7 +31,6 @@ export function processAutoPacingAllowed(backpressureObserved: boolean, env: Nod
 	return autoPacingAllowed({
 		isTTY: process.stdout.isTTY === true,
 		...(env.TERM === undefined ? {} : { term: env.TERM }),
-		...(env.TERM_PROGRAM === undefined ? {} : { termProgram: env.TERM_PROGRAM }),
 		...(env.SSH_CONNECTION === undefined ? {} : { sshConnection: env.SSH_CONNECTION }),
 		...(env.SSH_TTY === undefined ? {} : { sshTty: env.SSH_TTY }),
 		...(env.TMUX === undefined ? {} : { tmux: env.TMUX }),

package/src/interactive/tasks-overlay.ts

@@ -14,6 +14,7 @@ import {
 	type OverlayHandle,
 	type TUI,
 	truncateToWidth,
+	visibleWidth,
 	wrapTextWithAnsi,
 } from "../engine/tui.js";
 import { buildHint, showClioOverlayFrame } from "./overlay-frame.js";
@@ -92,23 +93,31 @@ function taskRow(task: TaskBoardTask, width: number, selected?: boolean): string
 	);
 }
 
-function taskReceiptRow(task: TaskBoardTask, width: number): string | null {
+function wrapTaskProse(prefix: string, prose: string, width: number): string[] {
+	const prefixWidth = visibleWidth(prefix);
+	const proseWidth = Math.max(1, width - prefixWidth);
+	return wrapTextWithAnsi(prose, proseWidth).map((line, index) =>
+		fitContentLine(`${index === 0 ? prefix : " ".repeat(prefixWidth)}${line}`, width),
+	);
+}
+
+function taskReceiptRows(task: TaskBoardTask, width: number): string[] {
 	const theme = clioTheme();
 	if (task.status === "completed" && task.evidence) {
 		// The evidence prose already carries any run id it mentions, so no derived
 		// `evidence:<runId>` suffix is appended; it would repeat that id on one line.
-		return fitContentLine(`       ${dim("evidence")} ${muted(task.evidence)}`, width);
+		return wrapTaskProse(`       ${dim("evidence")} `, muted(task.evidence), width);
 	}
 	if (task.status === "blocked" && task.reason) {
-		return fitContentLine(`       ${dim("blocked")} ${theme.fg("warning", task.reason)}`, width);
+		return wrapTaskProse(`       ${dim("blocked")} `, theme.fg("warning", task.reason), width);
 	}
 	if (task.status === "cancelled" && task.reason) {
-		return fitContentLine(`       ${dim("dropped")} ${muted(task.reason)}`, width);
+		return wrapTaskProse(`       ${dim("dropped")} `, muted(task.reason), width);
 	}
-	return null;
+	return [];
 }
 
-export function formatTasksOverlayBodyLines(
+function formatTasksOverlayBodyLines(
 	board: TaskBoardSnapshot | null,
 	contentWidth = DEFAULT_CONTENT_WIDTH,
 	selectedTaskId?: string | null,
@@ -151,8 +160,7 @@ export function formatTasksOverlayBodyLines(
 	}
 	for (const task of board.tasks) {
 		lines.push(taskRow(task, width, selectedTaskId === undefined ? undefined : selectedTaskId === task.id));
-		const receipt = taskReceiptRow(task, width);
-		if (receipt) lines.push(receipt);
+		lines.push(...taskReceiptRows(task, width));
 	}
 	return lines;
 }
@@ -235,7 +243,7 @@ const USER_TASK_PRESENTATION: Record<UserTask["status"], { glyph: string; token:
 };
 
 /** Pure composite renderer; callers provide already-captured history/artifact/user snapshots. */
-export function formatCompositeTasksOverlayBodyLines(
+function formatCompositeTasksOverlayBodyLines(
 	state: CompositeTasksOverlayState,
 	contentWidth = DEFAULT_CONTENT_WIDTH,
 ): string[] {
@@ -259,8 +267,7 @@ export function formatCompositeTasksOverlayBodyLines(
 				width,
 			),
 		);
-		const receipt = taskReceiptRow(row.task, width);
-		if (receipt) lines.push(receipt);
+		lines.push(...taskReceiptRows(row.task, width));
 	}
 
 	lines.push("", sectionHeading("Artifacts", width));
@@ -288,7 +295,7 @@ export function formatCompositeTasksOverlayBodyLines(
 				width,
 			),
 		);
-		if (task.note) lines.push(fitContentLine(`       ${dim("note")} ${muted(task.note)}`, width));
+		if (task.note) lines.push(...wrapTaskProse(`       ${dim("note")} `, muted(task.note), width));
 	}
 	return lines;
 }
@@ -342,7 +349,7 @@ class TasksOverlayBody implements Component {
 			body.push("", fitContentLine(clioTheme().fg("accent", "New operator task"), width));
 			body.push(...this.addInput.render(Math.max(1, width)).map((line) => fitContentLine(line, width)));
 		}
-		if (this.status) body.push("", fitContentLine(clioTheme().fg("warning", this.status), width));
+		if (this.status) body.push("", ...wrapTextWithAnsi(clioTheme().fg("warning", this.status), Math.max(1, width)));
 		return body;
 	}
 

package/src/interactive/terminal-lease.ts

@@ -127,7 +127,7 @@ class BootSubmissionPanel implements Component {
 }
 
 function stageZeroRoot(
-	mode: Readonly<ClioSettings>["terminal"]["tuiMode"],
+	mode: Readonly<ClioSettings>["interface"]["mode"],
 	editor: ClioEditor,
 	pending: Component,
 	shutdownArmed: () => boolean,
@@ -179,9 +179,8 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 	const keybindings = createKeybindingManager(settings);
 	let editorChrome: EditorChrome = {
 		getModelLabel: () =>
-			[settings.orchestrator.target, settings.orchestrator.model].filter((part) => part && part.length > 0).join("·") ||
-			"starting",
-		getThinkingLabel: () => settings.orchestrator.thinkingLevel ?? "off",
+			[settings.chat.target, settings.chat.model].filter((part) => part && part.length > 0).join("·") || "starting",
+		getThinkingLabel: () => settings.chat.thinkingLevel ?? "off",
 		getSubmitKeyLabel: () => keybindings.getKeys("tui.input.submit")[0] ?? "Enter",
 		getNewlineKeyLabel: () => keybindings.getKeys("tui.input.newLine")[0] ?? "Shift+Enter",
 	};
@@ -199,7 +198,7 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 	const shell =
 		options.testing?.shell ??
 		createProcessInteractiveShell({
-			tuiMode: settings.terminal.tuiMode,
+			tuiMode: settings.interface.mode,
 			...(options.onStage0Commit ? { onFirstFrameCommit: options.onStage0Commit } : {}),
 		});
 	const tui = shell.tui as TUI;
@@ -207,7 +206,7 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 	editor.focused = true;
 	const pendingPanel = new BootSubmissionPanel();
 	let shutdownArmed = false;
-	const stage0 = stageZeroRoot(settings.terminal.tuiMode, editor, pendingPanel, () => shutdownArmed);
+	const stage0 = stageZeroRoot(settings.interface.mode, editor, pendingPanel, () => shutdownArmed);
 	const host = new RootHost(stage0);
 
 	let state: TerminalLeaseState = "created";
@@ -288,7 +287,7 @@ export function createProcessTerminalLease(options: CreateProcessTerminalLeaseOp
 			handleStage0CtrlC();
 			return { consume: true };
 		}
-		if (keybindings.matches(data, "clio.exit") && editor.getText().length === 0) {
+		if (keybindings.matches(data, "clio-coder.exit") && editor.getText().length === 0) {
 			requestShutdown();
 			return { consume: true };
 		}

package/src/interactive/turn-context.ts

@@ -81,7 +81,7 @@ import {
 	type SessionPromptCompileRecord,
 } from "../domains/session/prompt-manifest.js";
 import type { AgentMessage, Usage } from "../engine/types.js";
-import type { ToolRegistry } from "../tools/registry.js";
+import { resolveToolPromptHint, type ToolRegistry } from "../tools/registry.js";
 import {
 	backendCacheVerdict,
 	extractUserText,
@@ -90,6 +90,7 @@ import {
 	toolNamesFromAgentState,
 } from "./chat-loop-messages.js";
 import { buildModelReplayAgentMessagesFromTurns } from "./model-session-replay.js";
+import { attachedToolSchemasFromState, mainPromptCacheIdentity } from "./prompt-cache-identity.js";
 import { renderCompactionSummaryLine, renderEvictionSkipLine } from "./renderers/compaction-summary.js";
 import type { TurnMiddleware } from "./turn-middleware.js";
 import type { AgentRuntime, ChatTurnState } from "./turn-state.js";
@@ -270,8 +271,8 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 	// before the operator did.
 	let lastPrewarm: PrewarmStats | null = null;
 	// The session system prompt, compiled once per session. Recompiles happen
-	// only on explicit events: the compile key (target, model, safety level,
-	// session id) changes, or a config hot-reload invalidates the cache. A
+	// only when the canonical identity of every live compile input changes, or
+	// a config hot-reload invalidates compiler-owned inputs. A
 	// recompile that changes the prompt text appends a "promptRecompiled"
 	// ledger entry so a cold provider cache is always explainable.
 	let sessionPrompt: CompiledSessionPrompt | null = null;
@@ -488,13 +489,13 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 
 	const resolveWindowWithoutRuntime = (): ContextWindowDetails | null => {
 		const settings = deps.getSettings();
-		const targetId = settings.orchestrator?.target?.trim();
-		const wireModelId = settings.orchestrator?.model?.trim();
+		const targetId = settings.chat?.target?.trim();
+		const wireModelId = settings.chat?.model?.trim();
 		if (!targetId || !wireModelId) return null;
 		const resolved = resolveRuntimeTarget(deps.providers, {
 			targetId,
 			wireModelId,
-			requestedThinkingLevel: settings.orchestrator?.thinkingLevel ?? "off",
+			requestedThinkingLevel: settings.chat?.thinkingLevel ?? "off",
 			use: "orchestrator",
 			requireTools: false,
 			requireOutputBudget: true,
@@ -679,7 +680,7 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		const activeAutoTurnId = force ? null : state.activeUserTurnId;
 		if (activeAutoTurnId && emptyAutoCompactTurnId === activeAutoTurnId) return false;
 		const settings = deps.getSettings();
-		const cfg = settings.compaction;
+		const cfg = settings.context.compaction;
 		const autoEnabled = cfg?.auto !== false;
 		if (!force && !autoEnabled) return false;
 		let preSummaryStageActed = false;
@@ -709,7 +710,7 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 				if (process.env.CLIO_CODER_LEGACY_MASK === "1") {
 					let masked: ReturnType<typeof maskStaleObservations>;
 					try {
-						masked = maskStaleObservations(deps.readSessionEntries() ?? [], cfg?.excludeLastTurns ?? 6);
+						masked = maskStaleObservations(deps.readSessionEntries() ?? [], 6);
 					} catch (error) {
 						middleware.fireCompactionHook("mask_observations", trigger, estimate.tokens);
 						deps.bus?.emit(BusChannels.CompactionBegin, { trigger, at: Date.now() });
@@ -1021,8 +1022,8 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 
 		/**
 		 * Ensure the session system prompt is compiled and applied to the live
-		 * agent. Compiles only when the compile key (target, model, safety
-		 * level, session id) changes or a config hot-reload invalidated the
+		 * agent. Compiles only when the canonical live-input identity changes
+		 * or a config hot-reload invalidated compiler-owned inputs in the
 		 * cache; every other submit reuses the cached prompt byte-for-byte. A
 		 * compile whose text differs from the previous prompt queues a
 		 * "promptRecompiled" ledger entry (written once the session exists).
@@ -1030,16 +1031,11 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		async ensureSessionPrompt(agentRuntime: AgentRuntime): Promise<CompiledSessionPrompt | null> {
 			if (!deps.prompts) return null;
 			const settings = deps.getSettings();
-			const autonomy = settings.autonomy ?? "auto-edit";
+			const autonomy = settings.safety.autonomy ?? "auto-edit";
 			const sessionId = deps.session?.current()?.id ?? "";
-			const workingContextKey = [...sessionWorkingContextPaths].sort().join("\0");
-			const key = `${agentRuntime.targetId}|${agentRuntime.wireModelId}|${autonomy}|${sessionId}|${workingContextKey}`;
-			if (sessionPrompt && sessionPromptKey === key) {
-				lastSystemPromptReused = true;
-				return sessionPrompt;
-			}
+			const cwd = process.cwd();
 			const modelState = agentRuntime.agent.state.model as
-				| (typeof agentRuntime.agent.state.model & { clio?: { quirks?: LocalModelQuirks } })
+				| (typeof agentRuntime.agent.state.model & { clioCoder?: { quirks?: LocalModelQuirks } })
 				| undefined;
 			// `Context window: N` is the window the backend will actually serve
 			// this session, taken from the resolution the turn already ran rather
@@ -1057,13 +1053,14 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			const contextWindow = typeof resolvedWindow === "number" && resolvedWindow > 0 ? resolvedWindow : null;
 			const contextWindowSource: ContextWindowSource | null =
 				contextWindow === null ? null : windowDetails.contextWindowSource;
-			const guidance = modelState?.clio?.quirks?.thinking?.guidance;
+			const guidance = modelState?.clioCoder?.quirks?.thinking?.guidance;
 			// Per-tool prompt hints come from registry metadata, derived once from
 			// the frozen surface per compile. The compiler renders them sorted by
 			// tool name, so the compiled text stays byte-stable for a given surface.
 			const toolNames = toolNamesFromAgentState(agentRuntime.agent.state.tools);
+			const attachedToolSchemas = attachedToolSchemasFromState(agentRuntime.agent.state.tools);
 			const toolPromptHints = toolNames.flatMap((name) => {
-				const hint = deps.toolRegistry?.get(name as ToolName)?.metadata?.promptHint;
+				const hint = resolveToolPromptHint(deps.toolRegistry?.get(name as ToolName)?.metadata?.promptHint, "session");
 				return hint ? [{ tool: name, hint }] : [];
 			});
 			const sessionInputs: SessionPromptInputs = {
@@ -1085,11 +1082,29 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 					);
 				}
 			}
+			const key = mainPromptCacheIdentity({
+				targetId: agentRuntime.targetId,
+				runtimeId: agentRuntime.runtimeId,
+				wireModelId: agentRuntime.wireModelId,
+				autonomy,
+				sessionId,
+				cwd,
+				workingContextPaths: [...sessionWorkingContextPaths],
+				contextWindowSource,
+				promptInputEpoch: deps.prompts.inputEpoch(),
+				sessionInputs,
+				attachedToolSchemas,
+			});
+			if (sessionPrompt && sessionPromptKey === key) {
+				lastSystemPromptReused = true;
+				return sessionPrompt;
+			}
 			try {
 				const result = await deps.prompts.compileSessionPrompt({
+					sessionId,
 					sessionInputs,
 					autonomy,
-					cwd: process.cwd(),
+					cwd,
 					workingContextPaths: [...sessionWorkingContextPaths],
 				});
 				const previousHash = sessionPromptHash ?? lastRecordedPromptHash();
@@ -1175,7 +1190,7 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			if (before.contextWindow <= 0 || before.tokens <= 0) return undefined;
 
 			const settings = deps.getSettings();
-			const threshold = settings.compaction?.threshold ?? DEFAULT_COMPACTION_THRESHOLD;
+			const threshold = settings.context.compaction?.threshold ?? DEFAULT_COMPACTION_THRESHOLD;
 			const verdict = shouldCompact(before.tokens, threshold, before.contextWindow);
 			let compacted = false;
 			if (verdict.shouldCompact) {
@@ -1218,8 +1233,8 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 
 		contextLedger(): ContextLedger {
 			const settings = deps.getSettings();
-			const compactionThreshold = settings.compaction?.threshold ?? null;
-			const compactionAuto = settings.compaction?.auto !== false;
+			const compactionThreshold = settings.context.compaction?.threshold ?? null;
+			const compactionAuto = settings.context.compaction?.auto !== false;
 			// Without a runtime (before the first turn of this process, /resume
 			// included) the window comes from the live resolution or the resumed
 			// snapshot, and the token facts from the snapshot: the resumed
@@ -1231,8 +1246,8 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 						contextWindowSlots: state.runtime.runtimeResolution.contextWindowDetails.contextWindowSlots,
 					}
 				: windowWithoutRuntime();
-			const provider = state.runtime?.targetId ?? settings.orchestrator?.target ?? null;
-			const model = state.runtime?.wireModelId ?? settings.orchestrator?.model ?? null;
+			const provider = state.runtime?.targetId ?? settings.chat?.target ?? null;
+			const model = state.runtime?.wireModelId ?? settings.chat?.model ?? null;
 			const liveToolCount = state.runtime?.agent.state.tools.length ?? 0;
 
 			if (!currentContextSnapshot) {

package/src/interactive/turn-persistence.ts

@@ -296,8 +296,8 @@ export function createTurnPersistence(deps: TurnPersistenceDeps): TurnPersistenc
 			if (!deps.session.current()) {
 				const settings = deps.getSettings();
 				const input: { cwd: string; target?: string; model?: string } = { cwd: process.cwd() };
-				if (settings.orchestrator.target) input.target = settings.orchestrator.target;
-				if (settings.orchestrator.model) input.model = settings.orchestrator.model;
+				if (settings.chat.target) input.target = settings.chat.target;
+				if (settings.chat.model) input.model = settings.chat.model;
 				deps.session.create(input);
 			}
 			const userTurn = appendTurn(deps.session, {

package/src/interactive/turn-prewarm.ts

@@ -151,7 +151,7 @@ export function createTurnPrewarm(deps: TurnPrewarmDeps): TurnPrewarm {
 	const dispatchActive = (): boolean => dispatchesInFlight > 0 || deps.hasActiveDispatch();
 
 	const admissionRefusal = (): PrewarmSkipReason | null => {
-		if (deps.getSettings().prewarm?.enabled === false) return "disabled";
+		if (deps.getSettings().chat.prewarm === false) return "disabled";
 		if (!deps.isLatencySurface()) return "surface";
 		if (deps.state.streaming || deps.isTurnActive()) return "turn-active";
 		// Fleet interaction. Without per-endpoint slot accounting a pre-warm cannot
@@ -165,7 +165,7 @@ export function createTurnPrewarm(deps: TurnPrewarmDeps): TurnPrewarm {
 		// resolved runtime is checked again below, but asking here means a target
 		// that was never eligible costs no capability probe, no agent, and no
 		// notice from either.
-		const targetId = deps.getSettings().orchestrator?.target?.trim();
+		const targetId = deps.getSettings().chat?.target?.trim();
 		const runtimeId = targetId ? deps.providers.getTarget(targetId)?.runtime : undefined;
 		if (runtimeId === undefined || deps.providers.getRuntime(runtimeId)?.tier !== "local-native") return "tier";
 		return null;