@iowarp/clio-coder 0.4.1 → 0.4.3

package/src/interactive/prompt-cache-identity.ts

@@ -0,0 +1,88 @@
+import type { SessionPromptInputs } from "../domains/prompts/compiler.js";
+import { canonicalJson, sha256 } from "../domains/prompts/hash.js";
+import type { ContextWindowSource } from "../domains/providers/index.js";
+import type { AutonomyLevel } from "../domains/safety/autonomy.js";
+
+/** The exact schema bytes pi attaches to a provider request for one tool. */
+export interface AttachedToolSchema {
+	name: string;
+	description: string;
+	parameters: unknown;
+}
+
+/**
+ * Project the live agent tools onto the schema fields sent to the provider.
+ * Array order is preserved because providers serialize the attached tools in
+ * that order, so reordering them changes prompt-prefix bytes too.
+ */
+export function attachedToolSchemasFromState(tools: ReadonlyArray<unknown>): AttachedToolSchema[] {
+	const schemas: AttachedToolSchema[] = [];
+	for (const tool of tools) {
+		if (!tool || typeof tool !== "object" || Array.isArray(tool)) continue;
+		const record = tool as Record<string, unknown>;
+		schemas.push({
+			name: typeof record.name === "string" ? record.name : "",
+			description: typeof record.description === "string" ? record.description : "",
+			parameters: record.parameters ?? null,
+		});
+	}
+	return schemas;
+}
+
+/**
+ * Serialize the exact ordered schema sequence attached to a provider request.
+ *
+ * `canonicalJson` is deliberately not used here: provider JSON preserves tool
+ * array order and nested object insertion order, so canonicalizing parameters
+ * can alias two byte-distinct request prefixes. Standard `JSON.stringify`
+ * matches the request serialization boundary and throws for unsupported
+ * values such as circular references and bigint.
+ */
+export function attachedToolSchemaBytes(schemas: ReadonlyArray<AttachedToolSchema>): string {
+	try {
+		const bytes = JSON.stringify(schemas);
+		if (bytes === undefined) throw new Error("JSON.stringify returned undefined");
+		return bytes;
+	} catch (err) {
+		const reason = err instanceof Error ? err.message : String(err);
+		throw new Error(`attached tool schemas are not JSON-serializable: ${reason}`, { cause: err });
+	}
+}
+
+export interface MainPromptCacheIdentityInput {
+	targetId: string;
+	runtimeId: string;
+	wireModelId: string;
+	autonomy: AutonomyLevel;
+	sessionId: string;
+	cwd: string;
+	workingContextPaths: ReadonlyArray<string>;
+	contextWindowSource: ContextWindowSource | null;
+	promptInputEpoch: string;
+	sessionInputs: SessionPromptInputs;
+	attachedToolSchemas: ReadonlyArray<AttachedToolSchema>;
+}
+
+/**
+ * Canonical identity for the interactive session-prompt compile cache.
+ * Config hot reload explicitly invalidates compiler-owned fragments and
+ * rosters; this identity covers every live/caller input resolved per turn.
+ */
+export function mainPromptCacheIdentity(input: MainPromptCacheIdentityInput): string {
+	return sha256(
+		canonicalJson({
+			version: 2,
+			targetId: input.targetId,
+			runtimeId: input.runtimeId,
+			wireModelId: input.wireModelId,
+			autonomy: input.autonomy,
+			sessionId: input.sessionId,
+			cwd: input.cwd,
+			workingContextPaths: [...input.workingContextPaths].sort((a, b) => a.localeCompare(b)),
+			contextWindowSource: input.contextWindowSource,
+			promptInputEpoch: input.promptInputEpoch,
+			sessionInputs: input.sessionInputs,
+			attachedToolSchemaBytes: attachedToolSchemaBytes(input.attachedToolSchemas),
+		}),
+	);
+}

package/src/interactive/renderers/worker-entry.ts

@@ -206,6 +206,36 @@ function researchReport(value: Record<string, unknown>): PresentedContractAnswer
 	return { lines: lines.length === 0 ? ["No findings reported."] : lines, footer: `source ${value.source}` };
 }
 
+function worldKnowledgeReport(value: Record<string, unknown>): PresentedContractAnswer | null {
+	if (
+		(value.discovery !== "performed" &&
+			value.discovery !== "caller-supplied-only" &&
+			value.discovery !== "unavailable") ||
+		!Array.isArray(value.facts) ||
+		!isStringArray(value.synthesis) ||
+		!isStringArray(value.uncertainties) ||
+		!isStringArray(value.followUpVerification)
+	) {
+		return null;
+	}
+	const lines: string[] = [];
+	for (const raw of value.facts) {
+		if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+		const fact = raw as Record<string, unknown>;
+		const claim = reportString(fact.claim);
+		const evidence = reportString(fact.evidence);
+		if (claim === null || evidence === null || !isStringArray(fact.sources)) return null;
+		lines.push(`- ${claim}`, `  support: ${evidence}`);
+		if (fact.sources.length > 0) lines.push(`  sources: ${fact.sources.join(", ")}`);
+	}
+	if (value.synthesis.length > 0) lines.push("Synthesis:", ...value.synthesis.map((item) => `- ${item}`));
+	if (value.uncertainties.length > 0) lines.push("Uncertainties:", ...value.uncertainties.map((item) => `- ${item}`));
+	if (value.followUpVerification.length > 0) {
+		lines.push("Verify next:", ...value.followUpVerification.map((item) => `- ${item}`));
+	}
+	return { lines: lines.length === 0 ? ["No findings reported."] : lines, footer: `discovery ${value.discovery}` };
+}
+
 function scoutReport(value: Record<string, unknown>): PresentedContractAnswer | null {
 	if (!Array.isArray(value.findings) || typeof value.needsSplit !== "boolean") return null;
 	const lines: string[] = [];
@@ -250,6 +280,8 @@ function presentedContractAnswer(entry: WorkerEntryState): PresentedContractAnsw
 			return verifierReport(value);
 		case "research-report":
 			return researchReport(value);
+		case "world-knowledge-report":
+			return worldKnowledgeReport(value);
 		case "scout-report":
 			return scoutReport(value);
 	}

package/src/interactive/slash-commands.ts

@@ -13,12 +13,12 @@ import type { ReceiptIntegrityOutcome } from "../domains/evidence/trust-status.j
 import type { InstalledExtension } from "../domains/extensions/index.js";
 import type { InteropAgentId, InteropProposal, InteropReport } from "../domains/interop/index.js";
 import {
-	isPanesPresetId,
 	PANES_PRESET_IDS,
 	PANES_PRESETS,
 	type PanesOperations,
 	type PanesPresetId,
 	type PanesStatus,
+	resolvePanesPresetId,
 } from "../domains/mux/operations.js";
 import type { ProvidersContract, ResolvedModelRef } from "../domains/providers/index.js";
 import { resolveModelReference } from "../domains/providers/index.js";
@@ -28,9 +28,10 @@ import type {
 	PromptTemplateExpansion,
 	ResourceList,
 } from "../domains/resources/index.js";
-import { parseSkillCommand } from "../domains/resources/index.js";
+import { parseSkillCommand, SKILL_SURFACE_CLEAR_ARG } from "../domains/resources/index.js";
 import type { ShareImportPlan } from "../domains/share/index.js";
 import type { UserTask } from "../domains/user-tasks/store.js";
+import type { ExtensionReloadOutcome } from "../entry/extension-reload.js";
 import { isToolProfileName, TOOL_PROFILE_NAMES, type ToolProfileName } from "../tools/profiles.js";
 import type { NoticeLevel } from "./command-output.js";
 import {
@@ -115,8 +116,10 @@ type SlashCommandVariant =
 	/** `ref` is the turnId an `[evicted ...]` marker names. */
 	| { kind: "context-recall"; ref: string }
 	| { kind: "skill-selector" }
-	| { kind: "resources"; family?: "skills" | "prompts" | "extensions"; tab?: LibraryEntryKind }
+	| { kind: "resources"; family?: "skills" | "prompts" | "extensions"; tab?: LibraryEntryKind; action?: "reload" }
 	| { kind: "skill-invocation"; text: string }
+	/** `/skill off`: drop the tool surface an activated skill armed for the session. */
+	| { kind: "skill-surface-clear" }
 	| ShareCommandVariant
 	| ArchiveCommandVariant
 	/** `source` is the line the operator typed, echoed above the run's transcript block. */
@@ -161,6 +164,9 @@ type SlashCommandVariant =
 	| { kind: "panes-zoom"; target: string }
 	| { kind: "panes-close"; target: string }
 	| { kind: "panes-usage"; reason?: string }
+	/** `/files`: toggle the files pane; `pick` borrows it for one selection; `close` closes it. */
+	| { kind: "files"; action: "toggle" | "open" | "close" | "pick" }
+	| { kind: "files-usage"; reason: string }
 	| { kind: "thinking-set"; level: string }
 	| { kind: "thinking-picker" }
 	| { kind: "output-set"; verbosity: string }
@@ -591,6 +597,12 @@ export interface SlashCommandContext {
 	 */
 	runContextRecall?: (ref: string) => void;
 	openSkillsHub?: (tab?: LibraryEntryKind) => void;
+	/**
+	 * `/skill off`: drop the tool surface an activated skill armed for the
+	 * session. Returns the names that were armed. Absent on a host with no
+	 * chat loop, where nothing can be armed in the first place.
+	 */
+	clearSkillSurface?: () => ReadonlyArray<string>;
 	listPrompts: () => ResourceList<PromptTemplate>;
 	/**
 	 * Resolve a `/name` against the loaded prompt templates. Absent when the host
@@ -599,6 +611,13 @@ export interface SlashCommandContext {
 	 */
 	expandPromptTemplate?: (text: string) => PromptTemplateExpansion;
 	listExtensions?: () => ReadonlyArray<InstalledExtension>;
+	/**
+	 * `/resources extensions reload`: build, validate, and commit the next
+	 * extension generation together with its user hooks, or report why it was
+	 * refused. Absent on a host without the reload coordinator, in which case
+	 * the command says so instead of pretending.
+	 */
+	reloadExtensions?: () => ExtensionReloadOutcome;
 	/** Detection report, pending proposals, and the two consent actions `/interop` drives. */
 	interop?: {
 		report: () => InteropReport | null;
@@ -901,9 +920,9 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 	},
 	{
 		name: "skill",
-		description: "Open the Skills Hub or invoke a skill",
+		description: "Open the Skills Hub, invoke a skill, or `off` to drop an active skill's tool surface",
 		group: "Work",
-		kinds: ["skill-selector", "skill-invocation"],
+		kinds: ["skill-selector", "skill-invocation", "skill-surface-clear"],
 		args: {
 			positionals: [
 				{ name: "name", required: false },
@@ -915,16 +934,26 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 				return { kind: "skill-selector" };
 			}
 			const command = parseSkillCommand(trimmed);
-			if (command) {
-				return { kind: "skill-invocation", text: trimmed };
+			if (!command) return null;
+			// `off` is the one reserved name: an installed skill called `off`
+			// would still be reachable from the hub, and clearing the armed
+			// surface has to stay typeable without a second command.
+			if (command.name === SKILL_SURFACE_CLEAR_ARG && command.args.length === 0) {
+				return { kind: "skill-surface-clear" };
 			}
-			return null;
+			return { kind: "skill-invocation", text: trimmed };
 		},
 		handle(command, ctx) {
 			if (command.kind === "skill-selector") {
 				ctx.openSkillsHub?.();
 			} else if (command.kind === "skill-invocation") {
 				ctx.submitChat(command.text);
+			} else if (command.kind === "skill-surface-clear") {
+				const cleared = ctx.clearSkillSurface?.() ?? [];
+				ctx.notice(
+					"info",
+					cleared.length > 0 ? `Skill tool surface cleared: ${cleared.join(", ")}.` : "No skill tool surface is active.",
+				);
 			}
 		},
 	},
@@ -937,22 +966,27 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			skills: "Browse installed skills",
 			prompts: "Browse prompt templates",
 			library: "Browse resource libraries",
-			extensions: "Browse installed extensions",
+			extensions: "Browse installed extensions; `reload` commits a new extension generation",
 		},
 		args: {
 			subcommands: {
 				skills: {},
 				prompts: {},
 				library: { positionals: [{ name: "kind", required: false }] },
-				extensions: {},
+				extensions: { positionals: [{ name: "action", required: false, values: ["reload"] }] },
 			},
 		},
 		fromArgs(parsed) {
 			if (parsed.error) return { kind: "usage-error", command: "resources", reason: parsed.error };
 			if (parsed.subcommand === undefined || parsed.subcommand === "skills")
 				return { kind: "resources", family: "skills" };
-			if (parsed.subcommand === "prompts" || parsed.subcommand === "extensions")
-				return { kind: "resources", family: parsed.subcommand };
+			if (parsed.subcommand === "prompts") return { kind: "resources", family: "prompts" };
+			if (parsed.subcommand === "extensions") {
+				const action = parsed.positionals[0];
+				if (action === undefined) return { kind: "resources", family: "extensions" };
+				if (action === "reload") return { kind: "resources", family: "extensions", action: "reload" };
+				return { kind: "usage-error", command: "resources", reason: `Unknown action: ${action} (one of reload)` };
+			}
 			const tab = parsed.positionals[0];
 			if (tab === undefined) return { kind: "resources" };
 			if (!isLibraryTab(tab)) {
@@ -964,8 +998,10 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		handle(command, ctx) {
 			if (command.kind !== "resources") return;
 			if (command.family === "prompts") ctx.openPrompts();
-			else if (command.family === "extensions") ctx.openExtensions();
-			else ctx.openSkillsHub?.(command.tab);
+			else if (command.family === "extensions") {
+				if (command.action === "reload") reloadExtensionsCommand(ctx);
+				else ctx.openExtensions();
+			} else ctx.openSkillsHub?.(command.tab);
 		},
 	},
 	{
@@ -1643,7 +1679,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 		},
 		subcommandDescriptions: {
 			show: "watch a live run or agent in the watch pane",
-			open: `open a utility pane (${PANES_PRESET_IDS.join(", ")}, or a command)`,
+			open: `open a utility pane (${PANES_PRESET_IDS.join(", ")}, \`files --once\` for one pick, or a command)`,
 			zoom: "toggle zoom on a Clio-owned pane (default: the watch pane)",
 			close: "close a Clio-owned pane, or all of them",
 		},
@@ -1659,9 +1695,10 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 				const first = argv[0] ?? "";
 				// A bare preset name is a preset; anything else is operator argv,
 				// which the tool surface deliberately cannot ask for.
-				if (argv.length === 1 && isPanesPresetId(first)) return { kind: "panes-open", preset: first };
-				if (argv.length === 2 && first === "yazi" && argv[1] === "--once") {
-					return { kind: "panes-open", preset: "yazi", once: true };
+				const preset = resolvePanesPresetId(first);
+				if (argv.length === 1 && preset !== null) return { kind: "panes-open", preset };
+				if (argv.length === 2 && preset === "files" && argv[1] === "--once") {
+					return { kind: "panes-open", preset: "files", once: true };
 				}
 				return { kind: "panes-open", argv };
 			}
@@ -1691,7 +1728,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 				// every `--with-panes` session, even one where no pane host answered.
 				ctx.notice(
 					"info",
-					"panes are inactive: this session started without them. Restart with `clio-coder --with-panes`, or set panes.enabled=auto",
+					"panes are inactive: this session started without them. Restart with `clio-coder --with-panes`, or set interface.panes.enabled=auto",
 				);
 				return;
 			}
@@ -1728,7 +1765,14 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 						// The in-terminal chooser has already restored the TUI by the
 						// time this resolves. A pick emitted its composer notice; an empty
 						// chooser was cancellation and deliberately stays silent.
-						if (result.paneId !== null) ctx.notice("success", `opened pane ${result.label} (${result.paneId})`);
+						if (result.paneId !== null) {
+							ctx.notice(
+								"success",
+								result.existing
+									? `focused pane ${result.label} (${result.paneId})`
+									: `opened pane ${result.label} (${result.paneId})`,
+							);
+						}
 					} else if (result.status === "missing-binary") {
 						// This is a synchronous slash-surface line, not a transient pane-host
 						// notification. It remains visible when no pane was ever created and
@@ -1768,6 +1812,62 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 			});
 		},
 	},
+	{
+		name: "files",
+		description: "Toggle the files pane; picks land in the composer as @ mentions",
+		group: "Inspect",
+		kinds: ["files", "files-usage"],
+		args: { positionals: [{ name: "action", required: false }] },
+		subcommandDescriptions: {
+			open: "open the files pane, or focus it when it is already open",
+			close: "close the files pane",
+			pick: "borrow the files pane for one selection, then close it",
+		},
+		fromArgs(parsed) {
+			if (parsed.error) return { kind: "files-usage", reason: parsed.error };
+			const action = parsed.positionals[0];
+			if (action === undefined) return { kind: "files", action: "toggle" };
+			if (action === "open" || action === "close" || action === "pick" || action === "toggle") {
+				return { kind: "files", action };
+			}
+			return { kind: "files-usage", reason: `Unexpected argument: ${action}` };
+		},
+		handle(command, ctx) {
+			if (command.kind === "files-usage") {
+				ctx.notice("info", `${command.reason}\nusage: /files [open|close|pick]`);
+				return;
+			}
+			if (command.kind !== "files") return;
+			const panes = ctx.panes;
+			if (!panes) {
+				ctx.notice(
+					"info",
+					"the files pane is inactive: this session started without panes. Restart with `clio-coder --with-panes`, or set interface.panes.enabled=auto",
+				);
+				return;
+			}
+			const runLocal = ctx.runLocalOperation ?? ((operation: () => Promise<void>) => void operation());
+			runLocal(async () => {
+				const result = await panes.files(command.action);
+				if (result.status === "opened") {
+					// The in-terminal chooser reports through its own composer notice.
+					if (result.paneId !== null) {
+						ctx.notice(
+							"success",
+							result.existing ? `files pane focused (${result.paneId})` : `files pane opened (${result.paneId})`,
+						);
+					}
+				} else if (result.status === "closed") {
+					ctx.notice("info", "files pane closed");
+				} else if (result.status === "missing-binary") {
+					ctx.io.stdout(`${result.detail}\n`);
+					ctx.render();
+				} else {
+					ctx.notice("warn", result.reason);
+				}
+			});
+		},
+	},
 	{
 		name: "thinking",
 		description: "Set the chat thinking level",
@@ -2069,6 +2169,39 @@ function retiredCommandHint(token: string): string | undefined {
 }
 
 /** Pure slash-command parser: no I/O, no side effects. Walks the registry in order. */
+/**
+ * One notice line for a reload outcome. Success when the generation committed
+ * cleanly; warn when it committed with dropped hooks or declaration issues;
+ * error when it was refused and the previous generation stays active.
+ */
+export function formatExtensionReloadNotice(outcome: ExtensionReloadOutcome): [NoticeLevel, string] {
+	if (outcome.status !== "committed") {
+		return ["error", `extensions: reload rejected (${outcome.reason}); generation ${outcome.generation} stays active`];
+	}
+	const delta = outcome.changed
+		? `changed: +${outcome.added.length} -${outcome.removed.length} ~${outcome.modified.length}`
+		: "unchanged";
+	const issueCount = outcome.hooks.fileIssues + outcome.hooks.issues;
+	const hookParts = [`${outcome.hooks.registered} registered`];
+	if (outcome.hooks.dropped > 0) hookParts.push(`${outcome.hooks.dropped} dropped`);
+	if (issueCount > 0) hookParts.push(`${issueCount} issue${issueCount === 1 ? "" : "s"}`);
+	if (outcome.hooks.overridden > 0) hookParts.push(`${outcome.hooks.overridden} overridden`);
+	const level: NoticeLevel = outcome.hooks.dropped > 0 || issueCount > 0 ? "warn" : "success";
+	return [level, `extensions: generation ${outcome.generation} committed (${delta}); hooks: ${hookParts.join(", ")}`];
+}
+
+function reloadExtensionsCommand(ctx: SlashCommandContext): void {
+	if (!ctx.reloadExtensions) {
+		ctx.notice("warn", "extensions: reload is unavailable in this session; restart to pick up installed changes");
+		return;
+	}
+	const outcome = ctx.reloadExtensions();
+	const [level, text] = formatExtensionReloadNotice(outcome);
+	ctx.notice(level, text);
+	for (const line of outcome.lines) ctx.notice("warn", line);
+	if (outcome.status === "committed") ctx.openExtensions();
+}
+
 export function parseSlashCommand(input: string): SlashCommand {
 	const trimmed = input.trim();
 	if (trimmed.length === 0) return { kind: "empty" };

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;
@@ -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/theme/labels.ts

@@ -1,23 +1,29 @@
 /**
  * Abbreviate a wire model id for chips and dashboards without amputating a
- * version suffix. Whole dash-separated parts are kept while the joined result
- * stays within 18 characters, so `claude-sonnet-5` and `claude-opus-4-8`
- * survive intact and `qwen3-coder-30b-a3b-instruct` collapses to
- * `qwen3-coder-30b`. A single part longer than 18 characters is hard-clipped.
+ * meaningful placement prefix or version suffix. `dynamo/qwen3.8-27b` remains
+ * visible as selected; only the leaf is shortened when the complete route is
+ * wider than 24 characters.
  */
 export function abbreviateModelId(modelId: string | null | undefined): string {
-	const base = (modelId ?? "").trim().split("/").filter(Boolean).pop() ?? "";
+	const segments = (modelId ?? "").trim().split("/").filter(Boolean);
+	const base = segments.pop() ?? "";
 	if (base.length === 0) return "model";
+	const prefix = segments[0];
+	const maxLeaf = prefix ? Math.max(8, 24 - prefix.length - 1) : 18;
 	const parts = base.split("-").filter((part) => part.length > 0);
-	if (parts.length <= 1) return base.length > 18 ? base.slice(0, 18) : base;
-	const kept: string[] = [];
-	for (const part of parts) {
-		const next = [...kept, part].join("-");
-		if (kept.length > 0 && next.length > 18) break;
-		kept.push(part);
+	let leaf: string;
+	if (parts.length <= 1) leaf = base.length > maxLeaf ? base.slice(0, maxLeaf) : base;
+	else {
+		const kept: string[] = [];
+		for (const part of parts) {
+			const next = [...kept, part].join("-");
+			if (kept.length > 0 && next.length > maxLeaf) break;
+			kept.push(part);
+		}
+		const joined = kept.join("-");
+		leaf = joined.length > maxLeaf ? joined.slice(0, maxLeaf) : joined;
 	}
-	const joined = kept.join("-");
-	return joined.length > 18 ? joined.slice(0, 18) : joined;
+	return prefix ? `${prefix}/${leaf}` : leaf;
 }
 
 export interface TargetLabelOptions {

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;
@@ -640,8 +641,8 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		if (!usage || !deps.observability) return;
 		if (usage.totalTokens <= 0 && usage.cost.total <= 0) return;
 		deps.observability.recordTokens(
-			agentRuntime.targetId,
-			agentRuntime.wireModelId,
+			usage.targetId ?? agentRuntime.targetId,
+			usage.modelId ?? agentRuntime.wireModelId,
 			usage.totalTokens,
 			usage.cost.total,
 			{
@@ -653,7 +654,11 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 				totalTokens: usage.totalTokens,
 				apiCalls: Math.max(1, Math.round(usage.apiCalls)),
 			},
-			agentRuntime.runtimeResolution.costProvenance,
+			usage.targetId === undefined && usage.modelId === undefined
+				? agentRuntime.runtimeResolution.costProvenance
+				: usage.cost.total > 0
+					? "estimated"
+					: "unknown",
 		);
 	};
 
@@ -914,8 +919,8 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 		if (!summaryLifecycleStarted) startSummaryLifecycle();
 		deps.bus?.emit(BusChannels.CompactionEnd, { trigger, at: Date.now() });
 
-		// The summarization call spends tokens on the same target the turn would
-		// have. The ledger entry carries its usage for a later reseed; this is the
+		// The checkpoint identifies the selected summary route; older results
+		// fall back to the active chat route. The ledger carries usage for reseed; this is the
 		// live sink, so `/cost` and the footer move the moment /context compact
 		// returns instead of staying byte-identical to before it ran.
 		recordCompactionUsage(agentRuntime, result);
@@ -1021,8 +1026,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).
@@ -1032,14 +1037,9 @@ export function createTurnContext(deps: TurnContextDeps): TurnContext {
 			const settings = deps.getSettings();
 			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 +1057,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 +1086,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();