@iowarp/clio-coder 0.4.6 → 0.4.8

package/src/domains/interop/projection.ts

@@ -0,0 +1,360 @@
+/**
+ * Shared per-resource projection for every inbound route: local-agent adoption
+ * and explicit foreign package import both turn host text into the same Clio
+ * recipe bytes through these helpers. Nothing here writes to a source tree.
+ */
+import { createHash } from "node:crypto";
+import { lstatSync, readdirSync, readFileSync, readlinkSync } from "node:fs";
+import path from "node:path";
+import { parse as parseToml } from "smol-toml";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { parseAgentRecipeSchema } from "../agents/index.js";
+import { inventoryText } from "./inventory.js";
+
+export const DATA_EXTENSIONS: ReadonlySet<string> = new Set([".md", ".txt", ".rst", ".csv", ".bib"]);
+export const FORBIDDEN_PARTS: ReadonlySet<string> = new Set([
+	"hooks",
+	"output-styles",
+	"scripts",
+	"tools",
+	"node_modules",
+	".git",
+	".claude-plugin",
+	".codex-plugin",
+]);
+/** Skill frontmatter keys that describe host execution policy, never recipe text. */
+export const HOST_SKILL_KEYS: ReadonlyArray<string> = [
+	"audit",
+	"installed-hash",
+	"source-url",
+	"installed-by",
+	"hooks",
+	"mcpServers",
+	"allowed-tools",
+	"tools",
+	"context",
+	"agent",
+	"model",
+	"effort",
+	"user-invocable",
+	"disable-model-invocation",
+	"argument-hint",
+	"paths",
+	"when_to_use",
+];
+/** Prompt (command) keys Clio reads; every other host key is reported as omitted. */
+const PROMPT_KEYS: ReadonlySet<string> = new Set(["description", "argument-hint", "argumentHint"]);
+
+export function safeName(name: string): string {
+	const value = name
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-|-$/g, "")
+		.slice(0, 45)
+		.replace(/-$/u, "");
+	if (!value) throw new Error("No safe resource identifier.");
+	return value;
+}
+
+function safeData(file: string): boolean {
+	return !file.split("/").some((part) => FORBIDDEN_PARTS.has(part)) && DATA_EXTENSIONS.has(path.extname(file));
+}
+
+/**
+ * Bounded text tree. `dataOnly` drops executable, host-specific and non-text
+ * files into `omitted` instead of failing; otherwise any of those is fatal.
+ */
+/** Names of every regular file below `dir`, relative to `root`; symlinks are listed, never followed. */
+function listFiles(root: string, dir: string, out: string[], depth = 0): void {
+	if (depth > 12 || out.length > 4096) return;
+	let names: string[];
+	try {
+		names = readdirSync(dir).sort();
+	} catch {
+		return;
+	}
+	for (const name of names) {
+		const file = path.join(dir, name);
+		const relative = path.relative(root, file).split(path.sep).join("/");
+		try {
+			const stat = lstatSync(file);
+			if (stat.isDirectory()) listFiles(root, file, out, depth + 1);
+			else out.push(relative);
+		} catch {
+			out.push(relative);
+		}
+	}
+}
+
+export function tree(root: string, dataOnly = false, omitted: string[] = []): Record<string, string> {
+	const files: Record<string, string> = {};
+	let bytes = 0;
+	const visit = (dir: string, depth: number): void => {
+		if (depth > 12) throw new Error("Source tree exceeds depth limit.");
+		if (lstatSync(dir).isSymbolicLink()) throw new Error("Symbolic links are not adoptable.");
+		for (const name of readdirSync(dir).sort()) {
+			const file = path.join(dir, name);
+			const relative = path.relative(root, file).split(path.sep).join("/");
+			if (dataOnly && relative.split("/").some((part) => FORBIDDEN_PARTS.has(part) || part === "fleets")) {
+				let isDirectory = false;
+				try {
+					isDirectory = lstatSync(file).isDirectory();
+				} catch {
+					/* unreadable entries are still listed as omitted */
+				}
+				if (isDirectory) listFiles(root, file, omitted);
+				else omitted.push(relative);
+				continue;
+			}
+			const stat = lstatSync(file);
+			if (stat.isSymbolicLink() || (!stat.isDirectory() && !stat.isFile()))
+				throw new Error("Symbolic links and special files are not adoptable.");
+			if (stat.isDirectory()) visit(file, depth + 1);
+			else {
+				if (dataOnly && relative !== "plugin.json" && (!safeData(relative) || (stat.mode & 0o111) !== 0)) {
+					omitted.push(relative);
+					continue;
+				}
+				if ((stat.mode & 0o111) !== 0) throw new Error(`Executable file is not adoptable: ${path.relative(root, file)}`);
+				const text = inventoryText(file);
+				bytes += Buffer.byteLength(text);
+				if (bytes > 16 * 1024 * 1024 || Object.keys(files).length >= 2048)
+					throw new Error("Source tree exceeds adoption limits.");
+				files[relative] = text;
+			}
+		}
+	};
+	visit(root, 0);
+	return files;
+}
+
+/**
+ * Review fingerprint of an entire source tree: every entry's path, type, mode
+ * bits and bounded raw bytes, including hidden vendor manifests and omitted
+ * runtime files. A change to policy or dependencies never slips past review
+ * merely because the projected text stayed equal.
+ */
+export function reviewFingerprint(root: string): string {
+	const hash = createHash("sha256");
+	let budget = 64 * 1024 * 1024;
+	let count = 0;
+	const visit = (dir: string, depth: number): void => {
+		if (depth > 12) throw new Error("Source tree exceeds depth limit.");
+		for (const name of readdirSync(dir).sort()) {
+			if (++count > 8192) throw new Error("Source tree exceeds review limits.");
+			const file = path.join(dir, name);
+			const relative = path.relative(root, file).split(path.sep).join("/");
+			const stat = lstatSync(file);
+			hash.update(relative).update("\0");
+			if (stat.isSymbolicLink()) hash.update(`symlink:${readlinkSync(file)}`);
+			else if (stat.isDirectory()) {
+				hash.update("dir");
+				visit(file, depth + 1);
+			} else if (stat.isFile()) {
+				hash.update(`file:${stat.mode & 0o777}:${stat.size}:`);
+				budget -= stat.size;
+				if (budget < 0) throw new Error("Source tree exceeds review limits.");
+				hash.update(readFileSync(file));
+			} else hash.update("special");
+			hash.update("\0");
+		}
+	};
+	visit(root, 0);
+	return hash.digest("hex");
+}
+
+export function digest(files: Readonly<Record<string, string>>): string {
+	const hash = createHash("sha256");
+	for (const key of Object.keys(files).sort())
+		hash
+			.update(key)
+			.update("\0")
+			.update(files[key] ?? "")
+			.update("\0");
+	return hash.digest("hex");
+}
+
+export function prose(text: string): { metadata: Record<string, unknown>; body: string } {
+	const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/.exec(text);
+	if (!match) return { metadata: {}, body: text };
+	const metadata: unknown = parseYaml(match[1] ?? "");
+	if (!metadata || typeof metadata !== "object" || Array.isArray(metadata))
+		throw new Error("Invalid resource frontmatter.");
+	return { metadata: metadata as Record<string, unknown>, body: match[2] ?? "" };
+}
+
+export interface ProjectedResource {
+	/** Clio resource id, safe for a component id and a file name. */
+	id: string;
+	/** Name the host would have used to invoke the resource. */
+	name: string;
+	/** Files relative to the projected package root. */
+	files: Record<string, string>;
+	componentPath: string;
+	omittedFields: string[];
+	omittedFiles: string[];
+	/** Companion files the retained text refers to; the recipe is unavailable without them. */
+	requiredOmissions: string[];
+	/** Skill names the host bound to this resource; the caller decides whether they are satisfiable. */
+	bindings: string[];
+}
+
+/**
+ * Project one skill directory. `source` is the bounded text tree of the skill
+ * directory; when `lenient` is set, non-text companions are dropped and
+ * reported rather than fatal.
+ */
+export function projectSkill(input: {
+	skillDir: string;
+	fallbackName: string;
+	lenient?: boolean;
+	/** Top-level entries that belong to sibling roots, not to this skill; neither projected nor omitted. */
+	excludeTopLevel?: ReadonlySet<string>;
+}): ProjectedResource {
+	const rawOmitted: string[] = [];
+	const rawSource = input.lenient ? tree(input.skillDir, true, rawOmitted) : tree(input.skillDir);
+	const foreign = (file: string): boolean => input.excludeTopLevel?.has(file.split("/")[0] ?? "") === true;
+	const source = Object.fromEntries(Object.entries(rawSource).filter(([file]) => !foreign(file)));
+	const omittedFiles = rawOmitted.filter((file) => !foreign(file));
+	delete source["plugin.json"];
+	if (!input.lenient && Object.keys(source).some((file) => !safeData(file)))
+		throw new Error("Not adoptable: skill contains executable or non-text companion files.");
+	const raw = source["SKILL.md"];
+	if (raw === undefined) throw new Error("Skill directory has no SKILL.md.");
+	const skill = prose(raw);
+	const name = typeof skill.metadata.name === "string" && skill.metadata.name.trim() ? skill.metadata.name.trim() : "";
+	if (!input.lenient && (!name || typeof skill.metadata.description !== "string"))
+		throw new Error("Skill requires name and description frontmatter.");
+	if (typeof skill.metadata.description !== "string" || !skill.metadata.description.trim())
+		throw new Error("Skill requires description frontmatter.");
+	const actualName = name || input.fallbackName;
+	const omittedFields: string[] = [];
+	// Never carry a foreign audit stamp across the approval boundary.
+	for (const key of ["clio-coder", "clio"]) if (key in skill.metadata) delete skill.metadata[key];
+	for (const key of HOST_SKILL_KEYS)
+		if (key in skill.metadata) {
+			omittedFields.push(key);
+			delete skill.metadata[key];
+		}
+	const id = safeName(actualName);
+	const body = skill.body;
+	// Deterministic reference check over every retained text, not only SKILL.md.
+	const retained = [
+		body,
+		...Object.entries(source)
+			.filter(([file]) => file !== "SKILL.md")
+			.map(([, text]) => text),
+	];
+	const requiredOmissions = omittedFiles.filter((file) => {
+		const base = path.basename(file);
+		return retained.some((text) => text.includes(file) || (base.includes(".") && text.includes(base)));
+	});
+	source["SKILL.md"] =
+		`---\n${stringifyYaml({ ...skill.metadata, name: actualName, "clio-coder": { audit: "unknown" } })}---\n${body}`;
+	return {
+		id,
+		name: actualName,
+		files: Object.fromEntries(Object.entries(source).map(([file, text]) => [`skills/${id}/${file}`, text])),
+		componentPath: `skills/${id}/SKILL.md`,
+		omittedFields,
+		omittedFiles,
+		requiredOmissions,
+		bindings: [],
+	};
+}
+
+/** Persona-only agent projection; host tools, model, permissions and skill bindings are omitted. */
+export function projectAgent(input: {
+	file: string;
+	name: string;
+	text?: string;
+	/** Package-local skill names to bind through the real Clio `skills` field. */
+	bindSkills?: ReadonlyArray<string>;
+}): ProjectedResource {
+	if (input.text === undefined && (lstatSync(input.file).mode & 0o111) !== 0)
+		throw new Error("Executable files are not adoptable.");
+	const raw = input.text ?? inventoryText(input.file);
+	const parsed = input.file.endsWith(".toml")
+		? (() => {
+				const data = parseToml(raw);
+				if (typeof data.developer_instructions !== "string") throw new Error("Agent developer_instructions is unknown.");
+				return { metadata: data as Record<string, unknown>, body: data.developer_instructions };
+			})()
+		: prose(raw);
+	if (!parsed.body.trim()) throw new Error("Empty resource body.");
+	const name =
+		typeof parsed.metadata.name === "string" && parsed.metadata.name.trim() ? parsed.metadata.name.trim() : input.name;
+	const id = safeName(name);
+	const omittedFields = Object.keys(parsed.metadata).filter(
+		(key) => !["name", "description", "developer_instructions", ...(input.bindSkills ? ["skills"] : [])].includes(key),
+	);
+	const metadata: Record<string, unknown> = {
+		description: typeof parsed.metadata.description === "string" ? parsed.metadata.description : `Adopted agent ${name}`,
+		version: 1,
+		name,
+		tools: { required: ["read"], optional: ["grep", "find", "ls"] },
+		skills: [...(input.bindSkills ?? [])],
+		audience: "custom",
+		category: "research",
+		capabilityClass: "read-only",
+		latencyClass: "balanced",
+		projectContextTier: "bounded",
+		budget: { toolCalls: 24, readReserve: 4, synthesis: true },
+		resultContract: { kind: "artifact-report" },
+		tags: ["interop"],
+	};
+	parseAgentRecipeSchema({
+		id,
+		source: "plugin",
+		filepath: input.file,
+		body: parsed.body,
+		frontmatter: metadata,
+	});
+	const componentPath = `agents/${id}.md`;
+	const declaredSkills = parsed.metadata.skills;
+	const bindings = Array.isArray(declaredSkills)
+		? declaredSkills.filter((skill): skill is string => typeof skill === "string")
+		: typeof declaredSkills === "string"
+			? declaredSkills
+					.split(",")
+					.map((skill) => skill.trim())
+					.filter(Boolean)
+			: [];
+	return {
+		id,
+		name,
+		files: { [componentPath]: `---\n${stringifyYaml(metadata)}---\n${parsed.body}` },
+		componentPath,
+		omittedFields,
+		omittedFiles: [],
+		requiredOmissions: [],
+		bindings,
+	};
+}
+
+/** Command markdown becomes a Clio prompt recipe; only description and argument hint survive. */
+export function projectPrompt(input: { file: string; name: string; text?: string }): ProjectedResource {
+	if (input.text === undefined && (lstatSync(input.file).mode & 0o111) !== 0)
+		throw new Error("Executable files are not adoptable.");
+	const parsed = prose(input.text ?? inventoryText(input.file));
+	if (!parsed.body.trim()) throw new Error("Empty resource body.");
+	const name = input.name;
+	const id = safeName(name);
+	const omittedFields = Object.keys(parsed.metadata).filter((key) => !PROMPT_KEYS.has(key));
+	const metadata: Record<string, unknown> = {
+		description: typeof parsed.metadata.description === "string" ? parsed.metadata.description : `Adopted prompt ${name}`,
+	};
+	const hint = parsed.metadata["argument-hint"] ?? parsed.metadata.argumentHint;
+	if (typeof hint === "string") metadata["argument-hint"] = hint;
+	const componentPath = `prompts/${id}.md`;
+	return {
+		id,
+		name,
+		files: { [componentPath]: `---\n${stringifyYaml(metadata)}---\n${parsed.body}` },
+		componentPath,
+		omittedFields,
+		omittedFiles: [],
+		requiredOmissions: [],
+		bindings: [],
+	};
+}

package/src/domains/interop/registry.ts

@@ -1,4 +1,104 @@
-import type { InteropAgentId, InteropAgentKind } from "./types.js";
+import type { InteropAgentId, InteropAgentKind, InteropInventoryLayout } from "./types.js";
+
+const MARKDOWN_ROOTS: InteropInventoryLayout["roots"] = [
+	{ path: "skills", kind: "skill", extensions: [".md"] },
+	{ path: "agents", kind: "agent", extensions: [".md", ".toml"] },
+	{ path: "commands", kind: "prompt", extensions: [".md"] },
+];
+const INVENTORIES: Partial<Record<InteropAgentId, InteropInventoryLayout>> = {
+	"claude-code": {
+		userDeclarations: [{ path: ".claude.json", kind: "mcp", key: "mcpServers" }],
+		projectDeclarations: [{ path: ".mcp.json", kind: "mcp", key: "mcpServers" }],
+		userRoot: ".claude",
+		homeEnv: "CLAUDE_CONFIG_DIR",
+		projectRoots: [".claude"],
+		roots: [...MARKDOWN_ROOTS, { path: "output-styles", kind: "output-style", extensions: [".md"] }],
+		declarations: [
+			{ path: "settings.json", kind: "hook", key: "hooks" },
+			{ path: "settings.local.json", kind: "hook", key: "hooks" },
+			{ path: "hooks/hooks.json", kind: "hook", key: "hooks" },
+			{ path: ".mcp.json", kind: "mcp", key: "mcpServers" },
+		],
+		pluginDirs: [],
+		pluginManifests: ["plugin.json", ".claude-plugin/plugin.json"],
+		installedRegistry: "plugins/installed_plugins.json",
+		listCommand: ["plugin", "list", "--json"],
+	},
+	codex: {
+		additionalUserRoots: [".agents"],
+		settingsRegistry: "codex",
+		cacheMarketplace: true,
+		userRoot: ".codex",
+		homeEnv: "CODEX_HOME",
+		projectRoots: [".codex", ".agents"],
+		roots: [
+			...MARKDOWN_ROOTS.filter((r) => r.kind !== "prompt"),
+			{ path: "prompts", kind: "prompt", extensions: [".md"] },
+		],
+		declarations: [
+			{ path: "config.toml", kind: "mcp" },
+			{ path: "mcp.json", kind: "mcp", key: "mcpServers" },
+			{ path: "hooks/hooks.json", kind: "hook", key: "hooks" },
+		],
+		pluginDirs: ["plugins/cache"],
+		pluginManifests: ["plugin.json", ".codex-plugin/plugin.json"],
+		listCommand: ["plugin", "list", "--json"],
+	},
+	antigravity: {
+		settingsRegistry: "antigravity",
+		userRoot: ".gemini/config",
+		homeEnv: "ANTIGRAVITY_HOME",
+		projectRoots: [".agents"],
+		roots: MARKDOWN_ROOTS,
+		declarations: [
+			{ path: "hooks.json", kind: "hook", key: "hooks" },
+			{ path: "mcp_config.json", kind: "mcp", key: "mcpServers" },
+		],
+		pluginDirs: ["plugins"],
+		pluginManifests: ["plugin.json"],
+		listCommand: ["plugin", "list"],
+	},
+	copilot: {
+		settingsRegistry: "copilot",
+		userRoot: ".copilot",
+		homeEnv: "COPILOT_HOME",
+		projectRoots: [".github", ".copilot"],
+		roots: [...MARKDOWN_ROOTS, { path: "hooks", kind: "hook", extensions: [".json"] }],
+		declarations: [
+			{ path: "mcp-config.json", kind: "mcp", key: "mcpServers" },
+			{ path: ".mcp.json", kind: "mcp", key: "mcpServers" },
+		],
+		pluginDirs: ["installed-plugins", "plugins"],
+		pluginManifests: ["plugin.json", ".claude-plugin/plugin.json"],
+		listCommand: ["plugin", "list"],
+	},
+	opencode: {
+		projectDeclarations: [
+			{ path: "opencode.json", kind: "mcp", key: "mcp" },
+			{ path: "opencode.jsonc", kind: "mcp", key: "mcp" },
+		],
+		projectModuleConfig: "opencode.json",
+		xdgConfigSubdir: "opencode",
+		moduleConfig: "opencode.json",
+		userRoot: ".config/opencode",
+		homeEnv: "OPENCODE_CONFIG_DIR",
+		projectRoots: [".opencode"],
+		roots: [
+			...MARKDOWN_ROOTS,
+			{ path: "agent", kind: "agent", extensions: [".md"] },
+			{ path: "command", kind: "prompt", extensions: [".md"] },
+			{ path: "plugins", kind: "executable", extensions: [".js", ".ts", ".mjs"] },
+			{ path: "tools", kind: "executable", extensions: [".js", ".ts"] },
+		],
+		declarations: [
+			{ path: "opencode.json", kind: "mcp", key: "mcp" },
+			{ path: "opencode.jsonc", kind: "mcp", key: "mcp" },
+		],
+		pluginDirs: [],
+		pluginManifests: [],
+		listCommand: ["agent", "list"],
+	},
+};
 
 /**
  * The known agents, in preference order. Order is load-bearing: equal-precedence
@@ -95,7 +195,7 @@ export const INTEROP_AGENT_KINDS: ReadonlyArray<InteropAgentKind> = [
 		label: "Antigravity CLI",
 		binaryNames: ["agy"],
 		userDir: ".gemini/antigravity-cli",
-		legacyUserDirs: [".antigravitycli"],
+		legacyUserDirs: [".antigravitycli", ".gemini/config"],
 		projectDir: ".gemini/antigravity-cli",
 		legacyProjectDirs: [".antigravitycli"],
 		instructionFiles: [],
@@ -112,7 +212,10 @@ export const INTEROP_AGENT_KINDS: ReadonlyArray<InteropAgentKind> = [
 		adoptionProvider: "agents",
 		skillSource: "agents",
 	},
-];
+].map((kind) => ({
+	...kind,
+	...(INVENTORIES[kind.id as InteropAgentId] ? { inventory: INVENTORIES[kind.id as InteropAgentId] } : {}),
+})) as ReadonlyArray<InteropAgentKind>;
 
 const BY_ID = new Map<InteropAgentId, InteropAgentKind>(INTEROP_AGENT_KINDS.map((kind) => [kind.id, kind]));
 

package/src/domains/interop/types.ts

@@ -27,6 +27,7 @@ export interface InteropAcpRecipe {
  * and instruction files in the tree is a projection of this table.
  */
 export interface InteropAgentKind {
+	inventory?: InteropInventoryLayout;
 	id: InteropAgentId;
 	label: string;
 	/** Executables whose presence means the agent is installed. Empty for conventions with no CLI. */
@@ -54,6 +55,7 @@ export interface InteropAgentKind {
 export type InteropPresence = "present" | "absent" | "unknown";
 
 export interface InteropAgentFacts {
+	inventory?: InteropInventory;
 	kind: InteropAgentId;
 	presence: InteropPresence;
 	binary?: string;
@@ -102,6 +104,8 @@ export interface InteropDecisionResult {
 }
 
 export interface InteropDetectInput {
+	/** Explicit inventory sweep; bootstrap remains lightweight. */
+	inventory?: boolean;
 	cwd?: string;
 	home?: string;
 	/** Run a bounded `<bin> --version` for kinds whose binary already resolved. */
@@ -111,3 +115,50 @@ export interface InteropDetectInput {
 	/** Foreign artifact providers already scanned by the context domain. */
 	artifactProviders?: ReadonlyArray<AdoptionProvider>;
 }
+
+export type InteropResourceKind =
+	| "skill"
+	| "agent"
+	| "prompt"
+	| "plugin"
+	| "output-style"
+	| "hook"
+	| "mcp"
+	| "executable";
+export interface InteropInventoryItem {
+	kind: InteropResourceKind;
+	name: string;
+	path: string;
+	scope: "user" | "project";
+	plugin?: string;
+	version?: string;
+	marketplace?: string;
+	installation?: "installed" | "unknown";
+	enabled?: boolean;
+}
+export interface InteropInventory {
+	status: "known" | "unknown";
+	items: InteropInventoryItem[];
+	diagnostics: string[];
+	listing: "unknown";
+}
+export interface InteropInventoryLayout {
+	userRoot: string;
+	additionalUserRoots?: string[];
+	xdgConfigSubdir?: string;
+	homeEnv?: string;
+	projectRoots: string[];
+	roots: Array<{ path: string; kind: InteropResourceKind; extensions: string[] }>;
+	declarations: Array<{ path: string; kind: "hook" | "mcp"; key?: string }>;
+	userDeclarations?: Array<{ path: string; kind: "hook" | "mcp"; key?: string }>;
+	projectDeclarations?: Array<{ path: string; kind: "hook" | "mcp"; key?: string }>;
+	projectModuleConfig?: string;
+	pluginDirs: string[];
+	pluginManifests: string[];
+	installedRegistry?: string;
+	/** Evidence command, never an agent work command. */
+	listCommand: string[];
+	cacheMarketplace?: boolean;
+	settingsRegistry?: "copilot" | "codex" | "antigravity";
+	moduleConfig?: string;
+}

package/src/domains/lifecycle/migrations/index.ts

@@ -34,7 +34,6 @@ import { join } from "node:path";
 
 import lmStudioRuntimeId from "./2026-08-18-lmstudio-runtime-id.js";
 import clioCoderNaming from "./2026-09-01-clio-coder-naming.js";
-import extensionInstallDigests from "./2026-09-01-extension-install-digests.js";
 import retirePanesKnobs from "./2026-09-01-retire-panes-knobs.js";
 import settingsV2 from "./2026-09-01-settings-v2.js";
 
@@ -62,7 +61,6 @@ export interface MigrationRunResult {
 // migration independently and for manifest continuity; it is a no-op on v2.
 const REGISTRY: ReadonlyArray<Migration> = Object.freeze([
 	settingsV2,
-	extensionInstallDigests,
 	clioCoderNaming,
 	retirePanesKnobs,
 	lmStudioRuntimeId,

package/src/domains/lifecycle/naming-resources.ts

@@ -162,7 +162,7 @@ export function inspectInstalledNamingResources(options: NamingResourceOptions =
 				});
 				continue;
 			}
-			const canonicalBundleDir = path.join(packageRoot, "skills", "meta", canonicalName);
+			const canonicalBundleDir = path.join(packageRoot, "library", "skills", "meta", canonicalName);
 			if (!existingDirectory(canonicalBundleDir) || !provesUnmodifiedShippedCopy(legacyPath, canonicalBundleDir)) {
 				reports.push({
 					kind: "skill",

package/src/domains/middleware/hooks.ts

@@ -10,8 +10,8 @@
  *
  * There is no arbitrary script execution: `command` takes an argv array and is
  * run without a shell, so there is no string to inject into. Hooks never
- * replace the safety policy. They register after the guard hooks and can only
- * add effects (including requesting `block_tool`); the durable safety contract
+ * replace the safety policy. They can only add effects (including requesting
+ * `block_tool`); the durable safety contract
  * still classifies every tool call independently and a hook cannot grant a
  * permission safety would deny.
  *

package/src/domains/middleware/marketplace-offer.ts

@@ -314,7 +314,7 @@ export function createMarketplaceOfferRegistration(deps: MarketplaceOfferDeps):
 					{
 						kind: "inject_reminder",
 						severity: "info",
-						message: `[Marketplace] Skill "${match.entry.name}" matches this request; install with clio-coder skills install ${match.entry.name}.`,
+						message: `[Marketplace] Skill "${match.entry.name}" matches this request; install with clio-coder library install ${match.entry.name}.`,
 					},
 				];
 			}

package/src/domains/mux/contract.ts

@@ -9,7 +9,7 @@
  *
  * Two ownership rules run through the whole file. Clio acts only on panes it
  * created, tracked in `pane-registry.ts` and tagged with the `clio_coder_owner`
- * metadata token so `clio doctor` can find orphans. The one documented
+ * metadata token so `clio-coder doctor` can find orphans. The one documented
  * exception is Clio's own hosting pane in guest mode, which `reportSelf`
  * writes to under SA-3 of the v0.4.0 cycle plan.
  *

package/src/domains/observability/background-memory-usage.ts

@@ -27,6 +27,7 @@ export interface BackgroundMemoryStepUsage {
 	output: number;
 	cacheRead: number;
 	cacheWrite: number;
+	cacheWrite1h?: number;
 	reasoning: number;
 	totalTokens: number;
 	costUsd: number;
@@ -83,6 +84,7 @@ export function backgroundMemoryUsageRow(
 			output: usage.output,
 			cacheRead: usage.cacheRead,
 			cacheWrite: usage.cacheWrite,
+			...(usage.cacheWrite1h === undefined ? {} : { cacheWrite1h: usage.cacheWrite1h }),
 			reasoning: usage.reasoning,
 			totalTokens: usage.totalTokens,
 			costUsd: usage.costUsd,
@@ -122,6 +124,7 @@ export function recordBackgroundMemoryStep(input: RecordBackgroundMemoryStepInpu
 			output: input.usage.output,
 			cacheRead: input.usage.cacheRead,
 			cacheWrite: input.usage.cacheWrite,
+			...(input.usage.cacheWrite1h === undefined ? {} : { cacheWrite1h: input.usage.cacheWrite1h }),
 			reasoningTokens: input.usage.reasoning,
 			totalTokens: input.usage.totalTokens,
 			apiCalls: 1,

package/src/domains/observability/compaction-usage.ts

@@ -29,6 +29,7 @@ function observedUsage(call: CompactionCallObservation): OutOfTurnUsage {
 		output: reading(raw.output),
 		cacheRead: reading(raw.cacheRead),
 		cacheWrite: reading(raw.cacheWrite),
+		...(raw.cacheWrite1h === undefined ? {} : { cacheWrite1h: reading(raw.cacheWrite1h) }),
 		reasoning: reasoning !== null && reasoning > 0 ? reasoning : null,
 		totalTokens: reading(raw.totalTokens),
 		costUsd,
@@ -72,6 +73,7 @@ export function recordFailedCompactionCalls(
 				output: usage.output ?? 0,
 				cacheRead: usage.cacheRead ?? 0,
 				cacheWrite: usage.cacheWrite ?? 0,
+				...(typeof usage.cacheWrite1h === "number" ? { cacheWrite1h: usage.cacheWrite1h } : {}),
 				reasoningTokens: usage.reasoning ?? 0,
 				totalTokens: usage.totalTokens ?? 0,
 				apiCalls: 1,