cyber-agentkit 1.0.0 → 1.2.0

package/dist/cli.js

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, rmdirSync, statSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, posix, relative, resolve, sep, win32 } from "node:path";
+import { copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, rmdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join, posix, relative, resolve, sep, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
 import { inspect, styleText } from "node:util";
 import { homedir } from "node:os";
@@ -938,7 +938,7 @@ function countFollowing(entry, o) {
 	return o.inline.length === 0 && takesValue$1(optionType(entry)) ? 1 : 0;
 }
 const flag = t.boolean().optional();
-const text = t.string();
+const text$1 = t.string();
 function optionType(entry) {
 	return entry.type ?? flag;
 }
@@ -956,7 +956,7 @@ function fillArguments(state) {
 	const args = [...state.rawArgs._];
 	const argSpecs = command.arguments || [];
 	for (const s of argSpecs) {
-		const type = s.type ?? text;
+		const type = s.type ?? text$1;
 		if (args.length === 0) {
 			if (!type.isOptional) state.errors.push({
 				type: "missing-argument",
@@ -10124,6 +10124,35 @@ function headingPaths(body) {
 	return paths;
 }
 //#endregion
+//#region src/references/reference-format.ts
+/** Extensions other than Markdown that answer a name, in the order they answer within one folder. */
+const dataExtensions = [
+	{
+		extension: ".json",
+		format: "json"
+	},
+	{
+		extension: ".yaml",
+		format: "yaml"
+	},
+	{
+		extension: ".yml",
+		format: "yaml"
+	},
+	{
+		extension: ".toml",
+		format: "toml"
+	},
+	{
+		extension: ".txt",
+		format: "txt"
+	}
+];
+/** The format a file name holds, by its extension; Markdown for `.md` and a folder's `README.md`. */
+function formatOfFile(file) {
+	return dataExtensions.find(({ extension }) => file.endsWith(extension))?.format ?? "markdown";
+}
+//#endregion
 //#region src/references/reference-interface.ts
 const interfaceSuffix = ".interface";
 const implementsPattern = /^([a-z0-9]+(?:[-.][a-z0-9]+)*)@(\d+)$/i;
@@ -10291,6 +10320,8 @@ function parseReferenceName(value) {
 		invalid: reason
 	});
 	if (value.endsWith(".md")) return invalid(`"${value}" names a file. Ask for the reference by name, without the .md extension.`);
+	const extension = dataExtensions.find((item) => value.endsWith(item.extension));
+	if (extension) return invalid(`"${value}" names a file. Ask for the reference by name, without the ${extension.extension} extension.`);
 	const parts = value.split("/");
 	if (parts.length > 2 || value.includes("\\")) return invalid(`"${value}" is a path. A name is letters, digits, hyphens, and dots, optionally after "<plugin>/".`);
 	const [first, second] = parts;
@@ -10324,7 +10355,12 @@ function tryRead$1(path) {
 }
 /** The files that answer a name in a layer, in the order they answer. */
 function candidateFiles(layer, name) {
-	return layer.tier === "default" ? [`${name}${defaultSuffix}.md`] : [`${name}.md`, `${name}/README.md`];
+	if (layer.whole) return [`${name}.md`, ...dataExtensions.map(({ extension }) => `${name}${extension}`)];
+	return layer.tier === "default" ? [`${name}${defaultSuffix}.md`, ...dataExtensions.map(({ extension }) => `${name}${defaultSuffix}${extension}`)] : [
+		`${name}.md`,
+		`${name}/README.md`,
+		...dataExtensions.map(({ extension }) => `${name}${extension}`)
+	];
 }
 function contributionLabel(layer, path, display) {
 	if (layer.tier === "plugin") return `plugin ${layer.plugin}`;
@@ -10508,6 +10544,90 @@ function plan(ref, tiered, holders, lookup, defaultContribution, warn) {
 	}
 	return planFromPlugins(holders, lookup, defaultContribution, ref.name, warn);
 }
+/**
+* The stack of an `assets/` name: no `extends` orders anything, so the highest tier holding the name
+* answers whole. Below the tiers, one plugin answers over the skill's own file; several plugins make
+* the name ambiguous unless a tier answers or a qualified name picks one.
+*/
+function planWhole(ref, layers, tiered, holders, lookup, defaultContribution, warn) {
+	const entry = (target, contribution) => ({
+		target,
+		contribution,
+		operation: "replace",
+		from: "default"
+	});
+	const lowest = defaultContribution ? [entry("default", defaultContribution)] : [];
+	if (ref.plugin !== void 0) {
+		const found = lookup(ref.plugin);
+		if ("reason" in found) return {
+			status: "missing",
+			message: `the plugin ${ref.plugin} ${found.reason}`
+		};
+		return {
+			entries: [entry(ref.plugin, found)],
+			builtBy: "qualified name",
+			replaced: [],
+			replacedBy: ""
+		};
+	}
+	if (tiered.some(({ hasBody }) => hasBody)) return {
+		entries: lowest,
+		builtBy: "none",
+		replaced: [],
+		replacedBy: ""
+	};
+	const chosen = readAssetSelection(layers, ref.name, warn);
+	if (chosen !== void 0) {
+		if (chosen === "default" && defaultContribution) return {
+			entries: lowest,
+			builtBy: "selection",
+			replaced: [],
+			replacedBy: ""
+		};
+		const held = holders.get(chosen);
+		if (held) return {
+			entries: [...lowest, entry(chosen, held)],
+			builtBy: "selection",
+			replaced: [],
+			replacedBy: ""
+		};
+		warn("selection-invalid", `the selection of "${ref.name}" names ${chosen}, which holds no such asset; it is ignored`);
+	}
+	const plugins = [...holders.entries()];
+	if (plugins.length > 1) {
+		const names = plugins.map(([plugin]) => plugin);
+		return {
+			status: "ambiguous",
+			cause: "unordered",
+			message: `the plugins ${names.join(", ")} hold it; run "asset select ${ref.name} <option>" (options: ${names.join(", ")}${defaultContribution ? ", default" : ""}), ask for ${names[0]}/${ref.name}, or put the file in a project or user assets folder`
+		};
+	}
+	const [only] = plugins;
+	return {
+		entries: [...lowest, ...only ? [entry(only[0], only[1])] : []],
+		builtBy: "none",
+		replaced: [],
+		replacedBy: ""
+	};
+}
+/** The plugin or `default` a managed, project, or user `<name>.select` file names; the highest one wins. */
+function readAssetSelection(layers, name, warn) {
+	for (const layer of layers) {
+		if (layer.skipped || ![
+			"managed",
+			"project",
+			"user"
+		].includes(layer.tier)) continue;
+		const raw = tryRead$1(join(layer.dir, `${name}.select`));
+		if (raw === void 0) continue;
+		const value = raw.trim();
+		if (!namePattern.test(value)) {
+			warn("selection-invalid", `${layer.tier} ${name}.select holds "${value}", which is not a plugin name or default; it is ignored`);
+			continue;
+		}
+		return value;
+	}
+}
 function planFromPlugins(holders, lookup, defaultContribution, name, warn) {
 	const defaultEntry = () => defaultContribution ? [{
 		target: "default",
@@ -10651,7 +10771,7 @@ function resolveReference(input, source, { display = (path) => path, without, be
 	};
 	const options = () => [...[...holders.keys()].map((plugin) => `${plugin}/${ref.name}`), ...defaultContribution ? ["default"] : []];
 	if (interfaceIdOf(ref.name) !== void 0) return resolveInterface(ref, contributions, holders, defaultContribution, result, warn, options);
-	const decided = plan(ref, tiered, holders, lookup, defaultContribution, warn);
+	const decided = layers.some(({ whole }) => whole) ? planWhole(ref, layers, tiered, holders, lookup, defaultContribution, warn) : plan(ref, tiered, holders, lookup, defaultContribution, warn);
 	if ("status" in decided) {
 		if (decided.status === "ambiguous") {
 			for (const { entry } of contributions) if (entry.outcome === "") entry.outcome = "ambiguous";
@@ -10694,8 +10814,32 @@ function resolveReference(input, source, { display = (path) => path, without, be
 	let applied = [];
 	let removedBy;
 	const used = [];
+	let whole;
 	for (const { contribution, operation, from } of order) {
 		const { entry } = contribution;
+		if (contribution.whole && contribution.hasBody) {
+			entry.operation = "replace";
+			entry.operationFrom = "default";
+			for (const below of applied) below.entry.outcome = `shadowed by ${contribution.label} (replace)`;
+			applied = [contribution];
+			composed = {
+				...emptyComposed(),
+				removed: composed.removed
+			};
+			whole = contribution;
+			removedBy = void 0;
+			entry.outcome = "used";
+			used.push(contribution);
+			continue;
+		}
+		if (whole && operation !== "remove" && contribution.hasBody) {
+			entry.operation = operation;
+			entry.operationFrom = from;
+			entry.outcome = `not used (format differs from ${whole.format})`;
+			warnAt(contribution.label)("format-mismatch", `it is ignored: ${whole.label} is ${whole.format}, which a Markdown contribution cannot compose with`);
+			continue;
+		}
+		if (operation === "remove") whole = void 0;
 		entry.operation = operation;
 		entry.operationFrom = from;
 		const warnHere = warnAt(contribution.label);
@@ -10768,12 +10912,20 @@ function resolveReference(input, source, { display = (path) => path, without, be
 		path,
 		contributions: sources
 	})), ...trace.sections];
+	if (whole) return {
+		...result,
+		status: "found",
+		content: whole.body,
+		format: whole.format,
+		metadata: {}
+	};
 	const single = applied.length === 1 && !composed.removed.length ? applied[0].body : void 0;
 	const content = single !== void 0 && stripMergeMarkers(single) === single ? withNewline(trimLeadingBlank(single)) : renderComposed(composed);
 	return {
 		...result,
 		status: "found",
 		content,
+		format: "markdown",
 		metadata: composedMetadata(shown)
 	};
 }
@@ -10802,6 +10954,29 @@ function readContribution(layer, name, entry, { display, without, warnAt }) {
 	for (const other of ignored) warnAt(display(other.path))("file-ignored", `it is ignored: ${hit.file} answers first in that folder`);
 	const label = contributionLabel(layer, hit.path, display);
 	const warn = warnAt(label);
+	const format = formatOfFile(hit.file);
+	if (format !== "markdown" || layer.whole) {
+		Object.assign(entry, {
+			path: hit.path,
+			file: hit.file,
+			outcome: ""
+		});
+		const held = hit.raw.trim().length > 0;
+		if (!held) entry.empty = true;
+		return {
+			layer,
+			entry,
+			label,
+			path: hit.path,
+			metadata: {},
+			body: hit.raw,
+			hasBody: held,
+			whole: true,
+			format,
+			merge: "replace",
+			steps: void 0
+		};
+	}
 	const { metadata, body } = parseDocument(hit.raw, warn);
 	const merge = readMergeOperation(metadata, warn);
 	const steps = readExtends(metadata["extends"], warn);
@@ -10823,6 +10998,8 @@ function readContribution(layer, name, entry, { display, without, warnAt }) {
 		metadata,
 		body,
 		hasBody: bodyHeld,
+		format,
+		whole: false,
 		merge,
 		steps
 	};
@@ -10902,13 +11079,14 @@ function layerNames(layer) {
 		return [];
 	}
 	const names = /* @__PURE__ */ new Set();
-	const isDefault = layer.tier === "default";
+	const isDefault = layer.tier === "default" && !layer.whole;
 	for (const entry of entries) {
 		let name;
 		if (isDefault) {
-			if (entry.name.endsWith(`.default.md`)) name = entry.name.slice(0, -`${defaultSuffix}.md`.length);
-		} else if (entry.name.endsWith(".md") && !entry.isDirectory()) name = entry.name.slice(0, -3);
-		else if (!entry.isFile() && tryRead$1(join(layer.dir, entry.name, "README.md")) !== void 0) name = entry.name;
+			const suffix = [`${defaultSuffix}.md`, ...dataExtensions.map((item) => `${defaultSuffix}${item.extension}`)].find((item) => entry.name.endsWith(item));
+			if (suffix) name = entry.name.slice(0, -suffix.length);
+		} else if (!entry.isDirectory() && [".md", ...dataExtensions.map((item) => item.extension)].some((extension) => entry.name.endsWith(extension))) name = entry.name.slice(0, entry.name.lastIndexOf("."));
+		else if (!layer.whole && !entry.isFile() && tryRead$1(join(layer.dir, entry.name, "README.md")) !== void 0) name = entry.name;
 		if (name === void 0 || parseReferenceName(name).invalid) continue;
 		names.add(name);
 	}
@@ -12681,14 +12859,14 @@ function canonical(path) {
 * instruction text an agent follows. Only a package with a plugin manifest is a plugin, named by
 * that manifest; one that ships `references/` without a manifest is shown, not read.
 */
-function dependencyLayers(root, skip) {
+function dependencyLayers(root, skip, folder) {
 	const manifestPath = nearestManifest(root);
 	if (!manifestPath) return [];
 	const layers = [];
 	for (const pkg of declaredDependencies(readJson$1(manifestPath))) {
 		const dir = packageDir(pkg, manifestPath);
 		if (!dir || skip.has(canonical(dir))) continue;
-		const references = join(dir, "references");
+		const references = join(dir, folder);
 		if (!isDirectory(references)) continue;
 		const plugin = pluginManifestName(dir);
 		layers.push(plugin ? {
@@ -12747,6 +12925,16 @@ function skillDefaults(harnesses, options, pluginRoots) {
 		unverified: `the skill folders ${unverified.join(", ")} ${unverified.length === 1 ? "reads are" : "read are"} not verified, so ${unverified.length === 1 ? "its" : "their"} skills' defaults are not listed`
 	} : { skills };
 }
+/** The layer with its `references` folder swapped for `folder`; a layer that names no folder is left as it is. */
+function inFolder(layer, folder) {
+	if (folder === "references" || basename(layer.dir) !== "references") return layer;
+	const dir = join(dirname(layer.dir), folder);
+	return {
+		...layer,
+		dir,
+		whole: true
+	};
+}
 /** The `default` tier for the skill at `folder`; a folder that does not exist warns and adds no contribution. */
 function defaultLayer(folder) {
 	const dir = join(folder, "references");
@@ -12766,7 +12954,7 @@ function defaultLayer(folder) {
 		skill: skillName(folder) ?? basename(folder)
 	};
 }
-async function referenceLayers({ root, home, platform, plugin, defaultSkill, env = process.env }) {
+async function referenceLayers({ root, home, platform, plugin, defaultSkill, folder = "references", env = process.env }) {
 	const harnesses = detectedHarnesses(env);
 	const chain = projectChain(root);
 	const ownRoot = plugin && canonical(plugin.root);
@@ -12781,7 +12969,7 @@ async function referenceLayers({ root, home, platform, plugin, defaultSkill, env
 		...enabled.flatMap(({ dir, skipped }) => skipped ? [] : [dirname(dir)]),
 		...dependencyPluginRoots(root)
 	];
-	const skills = skillDefaults(harnesses, {
+	const skills = folder === "assets" ? void 0 : skillDefaults(harnesses, {
 		chain,
 		home,
 		platform,
@@ -12802,13 +12990,13 @@ async function referenceLayers({ root, home, platform, plugin, defaultSkill, env
 			dir: join(plugin.root, "references"),
 			plugin: plugin.name
 		}] : [],
-		...enabled.filter(({ dir, skipped }) => skipped || isDirectory(dir) && canonical(dirname(dir)) !== ownRoot),
-		...dependencyLayers(root, new Set(ownRoot ? [ownRoot] : [])),
+		...enabled.filter((layer) => layer.skipped || isDirectory(inFolder(layer, folder).dir) && canonical(dirname(layer.dir)) !== ownRoot),
+		...dependencyLayers(root, new Set(ownRoot ? [ownRoot] : []), folder),
 		...defaultSkill === void 0 ? [] : [defaultLayer(resolve(defaultSkill))]
 	];
 	const seen = /* @__PURE__ */ new Set();
 	return {
-		layers: layers.filter(({ dir }) => !seen.has(dir) && seen.add(dir)),
+		layers: layers.map((layer) => inFolder(layer, folder)).filter(({ dir }) => !seen.has(dir) && seen.add(dir)),
 		harnesses,
 		skills
 	};
@@ -12897,6 +13085,7 @@ function listReferences(source, options = {}) {
 			description: resolved.status === "found" ? firstLine$1(resolved.metadata?.["description"]) : "",
 			status: resolved.status
 		};
+		if (resolved.format && resolved.format !== "markdown") row.format = resolved.format;
 		if (resolved.options) {
 			const skills = held.map(({ skill }) => `default of ${skill.name}`);
 			row.options = [.../* @__PURE__ */ new Set([...resolved.options.filter((option) => option !== "default"), ...skills])];
@@ -13244,7 +13433,7 @@ const reaches = {
 	user: "only you, in every repository"
 };
 /** The project and user files a customization of `name` is written to, with the document below each. */
-function whereReference(input, source, { root, display = (path) => path }) {
+function whereReference(input, source, { root, display = (path) => path, assets }) {
 	const name = typeof input === "string" ? parseReferenceName(input) : input;
 	const resolved = resolveReference(name, source, { display });
 	const report = {
@@ -13257,7 +13446,7 @@ function whereReference(input, source, { root, display = (path) => path }) {
 	if (resolved.options) report.options = resolved.options;
 	if (name.invalid) return report;
 	const layers = Array.isArray(source) ? source : source.layers;
-	const projectDir = projectReferencesDir(root);
+	const projectDir = assets ? join(dirname(projectReferencesDir(root)), "assets") : projectReferencesDir(root);
 	const userDir = layers.find(({ tier }) => tier === "user")?.dir;
 	const targets = [{
 		scope: "project",
@@ -13268,17 +13457,18 @@ function whereReference(input, source, { root, display = (path) => path }) {
 	}] : []];
 	for (const { scope, dir } of targets) {
 		const path = join(dir, `${name.name}.md`);
-		const entry = resolved.trace.layers.find((layer) => layer.path === path);
+		const held = [path, ...dataExtensions.map(({ extension }) => join(dir, `${name.name}${extension}`))];
+		const entry = resolved.trace.layers.find((layer) => held.includes(layer.path));
 		const below = resolveReference(name, source, {
 			display,
 			below: dir
 		});
 		report.places.push({
 			scope,
-			path: scope === "project" ? relative(root, path) : display(path),
+			path: assets ? `${scope === "project" ? relative(root, dir) : display(dir)}/${name.name}.<ext>` : scope === "project" ? relative(root, path) : display(path),
 			reaches: reaches[scope],
 			status: entry?.file ? entry.outcome : "empty",
-			sections: below.status === "found" ? headingPaths(below.content ?? "") : []
+			sections: !assets && below.status === "found" && below.format === "markdown" ? headingPaths(below.content ?? "") : []
 		});
 	}
 	return report;
@@ -13326,7 +13516,7 @@ function parseTemplate(content, label) {
 * A title: the top level is a single heading holding every other one. `patch` matches by heading
 * path, so it would add the whole document under the title instead of patching its sections.
 */
-function titleOf({ body }) {
+function titleOf$1({ body }) {
 	const tree = parseSections(body, () => {});
 	const [only] = tree.children;
 	return tree.children.length === 1 && only?.children.length ? only.heading.trim() : void 0;
@@ -13491,7 +13681,7 @@ function createContribution(layers, args, options = {}) {
 		metadata: {},
 		body: ""
 	} : readTemplate(args.template === void 0 ? void 0 : resolve(args.template));
-	const title = titleOf(template);
+	const title = titleOf$1(template);
 	if (title) throw new ReferenceWriteError("template-title", `the template's top level is the single heading "${title}" holding the others; patch matches by heading path, so make its sections top-level.`);
 	const before = resolveReference(name, layers, options);
 	const hider = hiddenBy(before, target.dir, target.path);
@@ -13556,12 +13746,20 @@ function selectContribution(layers, args, options = {}) {
 		after: resolveReference(name, layers, options)
 	};
 }
+/** The data files that can answer a name in a folder. */
+function dataFiles(dir, name) {
+	return dataExtensions.map(({ extension }) => join(dir, `${name}${extension}`));
+}
 function deleteContribution(layers, args, options = {}) {
 	const name = bareName(args.name);
 	const target = writeTarget(name, args);
 	const shown = options.display ?? ((path) => path);
 	const before = resolveReference(name, layers, options);
-	const path = (target.scope === "project" || target.scope === "user" ? [target.path, join(target.dir, name.name, "README.md")] : [target.path]).find((candidate) => candidate !== options.without && existsSync(candidate));
+	const path = (target.scope === "project" || target.scope === "user" ? [
+		target.path,
+		join(target.dir, name.name, "README.md"),
+		...dataFiles(target.dir, name.name)
+	] : [target.path]).find((candidate) => candidate !== options.without && existsSync(candidate));
 	if (!path) throw new ReferenceWriteError("no-file", `${shown(target.path)} does not exist, so there is no ${target.scope} contribution of "${name.name}" to delete. ${describeAnswer(before, options.display)} An installed plugin's, a managed, or an installed skill's contribution is never deleted.`);
 	const steps = readExtends(parseDocument(tryRead(path) ?? "", () => {}).metadata["extends"], () => {});
 	const dryRun = Boolean(args.dryRun);
@@ -13586,7 +13784,7 @@ function deleteContribution(layers, args, options = {}) {
 }
 //#endregion
 //#region src/references/reference.command.ts
-const rootOption = {
+const rootOption$1 = {
 	description: "Directory the project tier is read from, and each folder above it up to the repository root; a project write goes to its `.agents/references/`. Defaults to the current directory.",
 	type: t.string().optional()
 };
@@ -13598,14 +13796,15 @@ const defaultOption = {
 	description: "The calling skill's folder: its `references/<name>.default.md` joins as the `default` tier.",
 	type: t.string().optional()
 };
-function layerSource(plugin) {
+function layerSource(plugin, folder = "references") {
 	return (args, home) => referenceLayers({
 		root: args.root ?? process.cwd(),
 		home,
 		platform: process.platform,
 		env: process.env,
 		plugin,
-		defaultSkill: args.default
+		defaultSkill: args.default,
+		folder
 	});
 }
 /** A field with nothing to say is left out: `undefined`, an empty string, or an empty list. */
@@ -13613,7 +13812,7 @@ function compact(value) {
 	return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== void 0 && field !== "" && !(Array.isArray(field) && !field.length)));
 }
 /** stderr, not stdout: an agent parses stdout. Rethrows what the cli already reports. */
-function fail(error, fallback) {
+function fail$1(error, fallback) {
 	if (isCliError(error)) throw error;
 	if (error instanceof ReferenceWriteError) {
 		process.stderr.write(`error: ${error.code}: ${error.message}\n`);
@@ -13622,7 +13821,7 @@ function fail(error, fallback) {
 	process.stderr.write(`error: ${error instanceof Error ? error.message : fallback}\n`);
 	throw CliError.reported(exitCodes.error);
 }
-function usage(message) {
+function usage$2(message) {
 	process.stderr.write(`error: usage: ${message}\n`);
 	throw CliError.reported(exitCodes.usage);
 }
@@ -13678,11 +13877,12 @@ function errorText(entry) {
 	return `${entry.name}: ${entry.message}${options}`;
 }
 function showEntry(resolved, home, { metadata, trace }) {
-	if (resolved.status === "found" && !resolved.warnings.length && !metadata && !trace) return resolved.content;
+	if (resolved.status === "found" && !resolved.warnings.length && !metadata && !trace && resolved.format === "markdown") return resolved.content;
 	return compact({
 		name: resolved.name,
 		status: resolved.status,
 		content: resolved.content,
+		format: resolved.format === "markdown" ? void 0 : resolved.format,
 		code: resolved.code,
 		options: resolved.options,
 		metadata: metadata ? resolved.metadata : void 0,
@@ -13702,9 +13902,9 @@ function showText(resolved) {
 	}
 	return document(resolved.map((entry) => entry.content === void 0 ? `<reference name="${entry.name}" status="${entry.status}" />` : `<reference name="${entry.name}">\n${entry.content}</reference>`).join("\n\n"));
 }
-function showCommand(layersFor) {
+function showCommand$1(layersFor, name = "show") {
 	return command({
-		name: "show",
+		name,
 		description: "Print one or more references, each composed from its contributions as their extends and merge declare.",
 		arguments: [{
 			name: "names",
@@ -13712,7 +13912,7 @@ function showCommand(layersFor) {
 			type: t.array(t.string())
 		}],
 		options: {
-			root: rootOption,
+			root: rootOption$1,
 			default: defaultOption,
 			metadata: {
 				description: "Make every entry a record with its status and composed frontmatter.",
@@ -13722,7 +13922,7 @@ function showCommand(layersFor) {
 		},
 		async run(args) {
 			const format = this.format;
-			if (!args.names.length) usage("name at least one reference.");
+			if (!args.names.length) usage$2("name at least one reference.");
 			try {
 				const home = homedir();
 				const layers = await layersFor(args, home);
@@ -13757,14 +13957,14 @@ function showCommand(layersFor) {
 				const answer = result(resolved.map((entry) => showEntry(entry, home, flags)), { render: bareArray });
 				return ok ? answer : answerThenFail(answer, format);
 			} catch (error) {
-				return fail(error, "Reference lookup failed.");
+				return fail$1(error, "Reference lookup failed.");
 			}
 		}
 	});
 }
-function listCommand(layersFor) {
+function listCommand$1(layersFor, name = "list") {
 	return command({
-		name: "list",
+		name,
 		description: "List every reference name, one row each, with its description, and its status when not found. A pattern keeps only the names it matches exactly.",
 		arguments: [{
 			name: "pattern",
@@ -13772,7 +13972,7 @@ function listCommand(layersFor) {
 			type: t.string().optional()
 		}],
 		options: {
-			root: rootOption,
+			root: rootOption$1,
 			trace: {
 				...traceOption,
 				description: "Add one row per name per layer holding it, with its outcome."
@@ -13790,6 +13990,7 @@ function listCommand(layersFor) {
 					references: listing.references.length ? listing.references.map((row) => compact({
 						name: row.name,
 						description: row.description,
+						format: row.format,
 						status: row.status === "found" ? void 0 : row.status,
 						options: row.options
 					})) : args.pattern ? `0 references match "${args.pattern}"` : "0 references — no layer holds one",
@@ -13802,7 +14003,7 @@ function listCommand(layersFor) {
 				if (listing.warnings.length) report.warnings = listing.warnings;
 				return result(report);
 			} catch (error) {
-				return fail(error, "Reference listing failed.");
+				return fail$1(error, "Reference listing failed.");
 			}
 		}
 	});
@@ -13817,7 +14018,7 @@ function searchCommand(layersFor) {
 			type: t.string()
 		}],
 		options: {
-			root: rootOption,
+			root: rootOption$1,
 			trace: {
 				...traceOption,
 				description: "Add the tier and plugin or skill of each match."
@@ -13825,7 +14026,7 @@ function searchCommand(layersFor) {
 		},
 		async run(args) {
 			const query = args.query.trim();
-			if (!query) usage("search needs a query.");
+			if (!query) usage$2("search needs a query.");
 			try {
 				const home = homedir();
 				const { matches, defaults } = searchReferences(query, await layersFor(args, home), { display: (path) => collapseHome(home, path) });
@@ -13847,14 +14048,14 @@ function searchCommand(layersFor) {
 					defaults
 				}));
 			} catch (error) {
-				return fail(error, "Reference search failed.");
+				return fail$1(error, "Reference search failed.");
 			}
 		}
 	});
 }
-function whereCommand(layersFor) {
+function whereCommand(layersFor, assets = false, name = "where") {
 	return command({
-		name: "where",
+		name,
 		description: "Give the project and user files a customization or a selection of a reference is written to, who each reaches, and the heading paths of the document below each.",
 		arguments: [{
 			name: "name",
@@ -13862,7 +14063,7 @@ function whereCommand(layersFor) {
 			type: t.string()
 		}],
 		options: {
-			root: rootOption,
+			root: rootOption$1,
 			default: defaultOption,
 			trace: {
 				...traceOption,
@@ -13876,7 +14077,8 @@ function whereCommand(layersFor) {
 				const display = (path) => collapseHome(home, path);
 				const report = whereReference(args.name, await layersFor(args, home), {
 					root: resolve(args.root ?? process.cwd()),
-					display
+					display,
+					assets
 				});
 				const output = compact({
 					name: report.name,
@@ -13895,7 +14097,7 @@ function whereCommand(layersFor) {
 				process.stderr.write(`error: reference-invalid: ${parseReferenceName(args.name).invalid}\n`);
 				return answerThenFail(answer, format);
 			} catch (error) {
-				return fail(error, "Reference placement lookup failed.");
+				return fail$1(error, "Reference placement lookup failed.");
 			}
 		}
 	});
@@ -13903,7 +14105,7 @@ function whereCommand(layersFor) {
 function parseAccept(value) {
 	if (value === void 0) return void 0;
 	const versions = value.split(",").map((part) => part.trim());
-	if (!versions.length || versions.some((part) => !/^[1-9]\d*$/.test(part))) usage(`--accept is a comma-separated list of versions, such as 1,2; got "${value}".`);
+	if (!versions.length || versions.some((part) => !/^[1-9]\d*$/.test(part))) usage$2(`--accept is a comma-separated list of versions, such as 1,2; got "${value}".`);
 	return versions.map(Number);
 }
 function implementationsCommand(layersFor) {
@@ -13916,7 +14118,7 @@ function implementationsCommand(layersFor) {
 			type: t.string()
 		}],
 		options: {
-			root: rootOption,
+			root: rootOption$1,
 			accept: {
 				description: "Versions the consumer knows, comma-separated, such as 1,2. Defaults to the interface's `versions`.",
 				type: t.string().optional()
@@ -13956,7 +14158,7 @@ function implementationsCommand(layersFor) {
 				}));
 				return result(report);
 			} catch (error) {
-				return fail(error, "Implementation lookup failed.");
+				return fail$1(error, "Implementation lookup failed.");
 			}
 		}
 	});
@@ -13971,7 +14173,7 @@ function checkCommand(layersFor) {
 			type: t.array(t.string()).optional()
 		}],
 		options: {
-			root: rootOption,
+			root: rootOption$1,
 			trace: {
 				...traceOption,
 				description: "Add every entry checked, with its kind and unsupported sections."
@@ -14010,7 +14212,7 @@ function checkCommand(layersFor) {
 				if (format === "text") process.stderr.write(`error: interface-check: ${failing.length} of ${entries.length} references fail their check.\n`);
 				return answerThenFail(answer, format);
 			} catch (error) {
-				return fail(error, "Reference check failed.");
+				return fail$1(error, "Reference check failed.");
 			}
 		}
 	});
@@ -14023,7 +14225,7 @@ const pluginOption = {
 	description: "A plugin's source folder in this repository: acts on its `references/<name>.md`.",
 	type: t.string().optional()
 };
-const skillOption = {
+const skillOption$1 = {
 	description: "A skill's source folder in this repository: acts on its `references/<name>.default.md`.",
 	type: t.string().optional()
 };
@@ -14037,10 +14239,10 @@ function createCommand(layersFor) {
 			type: t.string()
 		}],
 		options: {
-			root: rootOption,
+			root: rootOption$1,
 			scope: scopeOption,
 			plugin: pluginOption,
-			default: skillOption,
+			default: skillOption$1,
 			merge: {
 				description: "How it applies over what is below: replace, patch (default), combine, or remove. remove writes no body.",
 				type: t.string().optional()
@@ -14095,12 +14297,12 @@ function createCommand(layersFor) {
 				if (args.trace && created.after) process.stderr.write(traceText(created.after, home));
 				return document(created.dryRun ? `${report.path}\n\n${created.content}` : `${report.path}\n\n${report.hint}\n`);
 			} catch (error) {
-				return fail(error, "Reference creation failed.");
+				return fail$1(error, "Reference creation failed.");
 			}
 		}
 	});
 }
-function selectCommand(layersFor) {
+function selectCommand$1(layersFor) {
 	return command({
 		name: "select",
 		description: "Choose what a name builds on: write an `extends` listing the options, bottom first, in the project or user file. Its body and other keys are kept.",
@@ -14114,7 +14316,7 @@ function selectCommand(layersFor) {
 			type: t.array(t.string()).optional()
 		}],
 		options: {
-			root: rootOption,
+			root: rootOption$1,
 			scope: scopeOption,
 			clear: {
 				description: "Remove the selection; a file left with nothing in it is deleted.",
@@ -14148,7 +14350,7 @@ function selectCommand(layersFor) {
 				const what = args.clear ? selected.deleted ? "selection cleared; the file was left empty and deleted" : "selection cleared" : `extends: [${selected.extends.join(", ")}]`;
 				return document(`${report.path}\n\n${what}. ${report.answer}\n`);
 			} catch (error) {
-				return fail(error, "Reference selection failed.");
+				return fail$1(error, "Reference selection failed.");
 			}
 		}
 	});
@@ -14165,7 +14367,7 @@ function deleteReport(deleted, home) {
 		options: deleted.after.options
 	});
 }
-function deleteCommand(layersFor) {
+function deleteCommand$1(layersFor) {
 	return command({
 		name: "delete",
 		description: "Delete a project or user contribution, or one in a plugin's or a skill's source folder, and report what answers the name afterwards. Never deletes an installed or managed one.",
@@ -14175,13 +14377,13 @@ function deleteCommand(layersFor) {
 			type: t.string()
 		}],
 		options: {
-			root: rootOption,
+			root: rootOption$1,
 			scope: {
 				...scopeOption,
 				description: "Tier to delete from: project (default) or user."
 			},
 			plugin: pluginOption,
-			default: skillOption,
+			default: skillOption$1,
 			"dry-run": {
 				description: "Print the file that would be deleted and what would answer the name then, and delete nothing.",
 				type: t.boolean().optional()
@@ -14209,7 +14411,7 @@ function deleteCommand(layersFor) {
 				const selection = report.selection ? ` Also, ${report.selection}.` : "";
 				return document(`${report.path}\n\n${deleted.dryRun ? "would delete" : "deleted"}. ${report.answer}${selection}\n`);
 			} catch (error) {
-				return fail(error, "Reference deletion failed.");
+				return fail$1(error, "Reference deletion failed.");
 			}
 		}
 	});
@@ -14218,13 +14420,13 @@ function deleteCommand(layersFor) {
 function createReferenceCommands({ plugin } = {}) {
 	const layersFor = layerSource(plugin);
 	return {
-		show: showCommand(layersFor),
-		list: listCommand(layersFor),
+		show: showCommand$1(layersFor),
+		list: listCommand$1(layersFor),
 		search: searchCommand(layersFor),
 		where: whereCommand(layersFor),
 		create: createCommand(layersFor),
-		select: selectCommand(layersFor),
-		delete: deleteCommand(layersFor),
+		select: selectCommand$1(layersFor),
+		delete: deleteCommand$1(layersFor),
 		check: checkCommand(layersFor),
 		implementations: implementationsCommand(layersFor)
 	};
@@ -14247,6 +14449,1115 @@ function createReferenceCommand(options = {}) {
 		]
 	});
 }
+/**
+* The tiered, by-name commands over `assets/` folders: the reference engine reading `assets/` where it
+* reads `references/`. `load` is `show`, `names` is `list`. `asset`'s own commands act on a path.
+*/
+function createAssetResolveCommands({ plugin } = {}) {
+	const layersFor = layerSource(plugin, "assets");
+	return {
+		load: showCommand$1(layersFor, "load"),
+		names: listCommand$1(layersFor, "names"),
+		where: whereCommand(layersFor, true)
+	};
+}
+//#endregion
+//#region src/assets/skill-assets.ts
+/** A refusal. `usage` marks a wrong invocation (exit 2) rather than a refusal (exit 1). */
+var AssetError = class extends Error {
+	code;
+	usage;
+	constructor(code, message, usage = false) {
+		super(message);
+		this.code = code;
+		this.usage = usage;
+	}
+};
+/** The skill's `assets/` folder, for a skill folder that holds a `SKILL.md`. */
+function assetsDir(skill, root, write) {
+	const folder = resolve(skill);
+	if (skillName(folder) === void 0) throw new AssetError("folder-invalid", `${folder} holds no SKILL.md, so it is not a skill folder.`);
+	if (write && !insideRepository(folder, root)) throw new AssetError("folder-invalid", `${folder} is outside the repository, such as an installed copy; write to the skill's source instead.`);
+	return join(folder, "assets");
+}
+/** An asset path: relative, `/`-separated, with no `..` or empty part. */
+function assetFile(dir, path) {
+	const parts = path.split("/");
+	if (!path || path.includes("\\") || path.startsWith("/") || parts.some((part) => part === "" || part === "." || part === "..")) throw new AssetError("path-invalid", `"${path}" is not an asset path. Use a relative path inside assets/, with "/" separators and no "..".`, true);
+	return join(dir, ...parts);
+}
+/** True when the real location of an existing file or its nearest existing parent stays inside the folder. */
+function contained(dir, file) {
+	if (!existsSync(dir)) return true;
+	const base = realpathSync(dir);
+	let probe = file;
+	while (!existsSync(probe)) probe = dirname(probe);
+	const real = realpathSync(probe);
+	return real === base || real.startsWith(base + sep);
+}
+function guard(dir, file, path) {
+	if (!contained(dir, file)) throw new AssetError("path-invalid", `"${path}" leaves the assets/ folder through a link.`, true);
+}
+function listAssets(skill, root) {
+	const dir = assetsDir(skill, root, false);
+	const entries = [];
+	const walk = (folder, prefix) => {
+		let items;
+		try {
+			items = readdirSync(folder, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const item of items) {
+			const full = join(folder, item.name);
+			const stat = lstatSync(full);
+			if (stat.isSymbolicLink()) continue;
+			if (stat.isDirectory()) walk(full, `${prefix}${item.name}/`);
+			else if (stat.isFile()) entries.push({
+				path: `${prefix}${item.name}`,
+				bytes: stat.size
+			});
+		}
+	};
+	walk(dir, "");
+	return entries.sort((a, b) => a.path.localeCompare(b.path));
+}
+function showAsset(skill, root, path) {
+	const dir = assetsDir(skill, root, false);
+	const file = assetFile(dir, path);
+	guard(dir, file, path);
+	if (!existsSync(file) || !lstatSync(file).isFile()) throw new AssetError("no-file", `${path} does not exist in assets/.`);
+	const bytes = readFileSync(file);
+	if (bytes.includes(0)) throw new AssetError("binary", `${path} is binary (${bytes.length} bytes); point to it by path instead of showing it.`);
+	return bytes.toString("utf8");
+}
+function writeAsset(mode, skill, root, path, content) {
+	const dir = assetsDir(skill, root, true);
+	const file = assetFile(dir, path);
+	guard(dir, file, path);
+	const exists = existsSync(file);
+	if (mode === "create" && exists) throw new AssetError("exists", `${path} already exists in assets/; use update to replace it.`);
+	if (mode === "update" && !exists) throw new AssetError("no-file", `${path} does not exist in assets/; use create to add it.`);
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, content);
+	return file;
+}
+function deleteAsset(skill, root, path) {
+	const dir = assetsDir(skill, root, true);
+	const file = assetFile(dir, path);
+	guard(dir, file, path);
+	if (!existsSync(file) || !lstatSync(file).isFile()) throw new AssetError("no-file", `${path} does not exist in assets/.`);
+	rmSync(file);
+	for (let folder = dirname(file); folder !== dir && folder.startsWith(dir + sep); folder = dirname(folder)) try {
+		rmdirSync(folder);
+	} catch {
+		break;
+	}
+	return file;
+}
+//#endregion
+//#region src/assets/copy-asset.ts
+/**
+* Creates `<name>.<ext>` in the project or user `assets/` folder as a copy of the file another tier or
+* plugin holds, so it can be edited as an override. The managed tier is never a source: it is policy an
+* administrator keeps out of repositories and home folders, and a copy would show stale text as if it
+* were in effect (the managed file would still win).
+*/
+function copyAsset(layers, args) {
+	const name = parseReferenceName(args.name);
+	if (name.invalid || name.plugin !== void 0) throw new AssetError("name-invalid", name.invalid ?? "create takes a bare name.", true);
+	if (args.scope !== "project" && args.scope !== "user") throw new AssetError("options-invalid", "--scope is project or user.", true);
+	if (args.copy === "managed") throw new AssetError("managed-copy-refused", "the managed tier is policy and is never copied into a project or user folder. Ask the administrator, or read it with \"asset load\".");
+	const found = resolveReference(name.name, layers).trace.layers.filter(({ file }) => file);
+	const source = found.find((layer) => args.copy === "default" || args.copy === "project" || args.copy === "user" ? layer.tier === args.copy : layer.tier === "plugin" && layer.plugin === args.copy);
+	if (!source) {
+		const held = found.map((layer) => layer.tier === "plugin" ? layer.plugin : layer.tier);
+		throw new AssetError("no-source", `"${args.copy}" holds no asset "${name.name}". Held by: ${held.filter((tier) => tier !== "managed").join(", ") || "nothing"}.`);
+	}
+	const extension = extname(source.path);
+	if (source.file && ![...dataExtensions.map((item) => item.extension), ".md"].includes(extension)) throw new AssetError("no-source", `${basename(source.path)} is not a file an asset name resolves to.`);
+	const base = args.scope === "user" ? userReferencesDir(args.home) : projectReferencesDir(resolve(args.root));
+	const dir = join(dirname(base), "assets");
+	const taken = [".md", ...dataExtensions.map((item) => item.extension)].map((item) => join(dir, `${name.name}${item}`)).find((path) => existsSync(path));
+	if (taken) throw new AssetError("exists", `${taken} already exists; edit it, or delete it first.`);
+	const path = join(dir, `${name.name}${extension}`);
+	mkdirSync(dir, { recursive: true });
+	copyFileSync(source.path, path);
+	return {
+		path,
+		source: source.path,
+		from: args.copy
+	};
+}
+//#endregion
+//#region src/assets/select-asset.ts
+/** The options a name can be selected between: each plugin holding it, and `default` when the skill's file exists. */
+function options(layers, name) {
+	const found = resolveReference(name, layers).trace.layers;
+	return [...found.filter(({ tier, file }) => tier === "plugin" && file).map(({ plugin }) => plugin), ...found.some(({ tier, file }) => tier === "default" && file) ? ["default"] : []];
+}
+/**
+* Writes `<name>.select` in the project or user `assets/` folder: one line, the plugin or `default` that
+* answers the name. Nothing else is in the file, and nothing extends or merges.
+*/
+function selectAsset(layers, args) {
+	const name = parseReferenceName(args.name);
+	if (name.invalid || name.plugin !== void 0) throw new AssetError("name-invalid", name.invalid ?? "select takes a bare name.", true);
+	if (args.scope !== void 0 && args.scope !== "project" && args.scope !== "user") throw new AssetError("options-invalid", "--scope is project or user.", true);
+	const base = args.scope === "user" ? userReferencesDir(args.home) : projectReferencesDir(resolve(args.root));
+	const path = join(dirname(base), "assets", `${name.name}.select`);
+	if (args.clear) {
+		if (!existsSync(path)) throw new AssetError("no-file", `${path} does not exist, so there is no selection to clear.`);
+		rmSync(path);
+	} else {
+		const held = options(layers, name.name);
+		if (!args.option || !held.includes(args.option)) throw new AssetError("option-invalid", `"${args.option ?? ""}" cannot be selected for "${name.name}". Options: ${held.join(", ") || "none, no plugin or default holds it"}.`, !args.option);
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, `${args.option}\n`);
+	}
+	const result = {
+		path,
+		cleared: Boolean(args.clear),
+		after: resolveReference(name.name, layers, { without: args.clear ? path : void 0 })
+	};
+	return args.clear ? result : {
+		...result,
+		selected: args.option
+	};
+}
+//#endregion
+//#region src/assets/asset.command.ts
+const skillOption = {
+	description: "A skill's source folder in this repository: its `assets/` folder is acted on.",
+	type: t.string()
+};
+const rootOption = {
+	description: "The directory the repository is found from. Defaults to the current directory.",
+	type: t.string().optional()
+};
+function fail(error, fallback) {
+	if (isCliError(error)) throw error;
+	if (error instanceof AssetError) {
+		process.stderr.write(`error: ${error.code}: ${error.message}\n`);
+		throw CliError.reported(error.usage ? exitCodes.usage : exitCodes.error);
+	}
+	process.stderr.write(`error: ${error instanceof Error ? error.message : fallback}\n`);
+	throw CliError.reported(exitCodes.error);
+}
+function usage$1(message) {
+	process.stderr.write(`error: usage: ${message}\n`);
+	throw CliError.reported(exitCodes.usage);
+}
+const pathDescription = "Asset path inside `assets/`, such as `data/rules.json`.";
+function rootOf(args) {
+	return resolve(args.root ?? process.cwd());
+}
+function listCommand() {
+	return command({
+		name: "list",
+		description: "List every file in a skill's assets/ folder with its size.",
+		options: {
+			skill: skillOption,
+			root: rootOption
+		},
+		async run(args) {
+			try {
+				const entries = listAssets(args.skill, rootOf(args));
+				return result({ assets: entries.length ? entries : "0 assets — the skill holds none" });
+			} catch (error) {
+				return fail(error, "Asset listing failed.");
+			}
+		}
+	});
+}
+function showCommand() {
+	return command({
+		name: "show",
+		description: "Print a text asset as written.",
+		arguments: [{
+			name: "path",
+			description: pathDescription,
+			type: t.string()
+		}],
+		options: {
+			skill: skillOption,
+			root: rootOption
+		},
+		async run(args) {
+			try {
+				return document(showAsset(args.skill, rootOf(args), args.path));
+			} catch (error) {
+				return fail(error, "Asset read failed.");
+			}
+		}
+	});
+}
+function writeCommand(mode, host) {
+	const create = mode === "create";
+	return command({
+		name: mode,
+		description: create ? "Add a new asset: by path in a skill from --content or --from, or, with --copy, by name in the project or user assets folder as a copy of what a plugin, the default, or another tier holds (never the managed tier). Never overwrites a file." : "Replace an existing asset from --content or --from.",
+		arguments: [{
+			name: "path",
+			description: `${pathDescription} With --copy, the asset name.`,
+			type: t.string()
+		}],
+		options: {
+			skill: {
+				...skillOption,
+				type: t.string().optional()
+			},
+			root: rootOption,
+			content: {
+				description: "The text to write.",
+				type: t.string().optional()
+			},
+			from: {
+				description: "A local file whose bytes to write.",
+				type: t.string().optional()
+			},
+			...create ? {
+				default: {
+					description: "With --copy, the calling skill's folder: its `assets/<name>.<ext>` is the `default` source.",
+					type: t.string().optional()
+				},
+				copy: {
+					description: "Copy the asset of this source: a plugin's name, `default` (the skill's own file), `project`, or `user`. `managed` is refused.",
+					type: t.string().optional()
+				},
+				scope: {
+					description: "With --copy, where the copy goes: project (default), `.agents/assets/`, or user, `~/.agents/assets/`.",
+					type: t.string().optional()
+				}
+			} : {}
+		},
+		async run(args) {
+			try {
+				if (args.copy !== void 0) {
+					if (args.content !== void 0 || args.from !== void 0) usage$1("--copy takes neither --content nor --from.");
+					const home = homedir();
+					const root = rootOf(args);
+					const done = copyAsset(await referenceLayers({
+						root,
+						home,
+						platform: process.platform,
+						env: process.env,
+						plugin: host.plugin,
+						defaultSkill: args.default ?? args.skill,
+						folder: "assets"
+					}), {
+						root,
+						home,
+						name: args.path,
+						scope: args.scope ?? "project",
+						copy: args.copy
+					});
+					return document(`${done.path}\n\ncopied from ${done.from}. Edit it; it now answers over the plugin tier.\n`);
+				}
+				if (!args.skill) usage$1("pass --skill, or --copy to create an override by name.");
+				if (args.content === void 0 === (args.from === void 0)) usage$1("pass exactly one of --content and --from.");
+				const content = args.content ?? readFileSync(resolve(args.from), "utf8");
+				return document(`${writeAsset(mode, args.skill, rootOf(args), args.path, content)}\n\n${create ? "created" : "updated"}.\n`);
+			} catch (error) {
+				return fail(error, `Asset ${mode} failed.`);
+			}
+		}
+	});
+}
+function deleteCommand() {
+	return command({
+		name: "delete",
+		description: "Delete an asset from a skill's source folder, and any folder it leaves empty.",
+		arguments: [{
+			name: "path",
+			description: pathDescription,
+			type: t.string()
+		}],
+		options: {
+			skill: skillOption,
+			root: rootOption
+		},
+		async run(args) {
+			try {
+				return document(`${deleteAsset(args.skill, rootOf(args), args.path)}\n\ndeleted.\n`);
+			} catch (error) {
+				return fail(error, "Asset deletion failed.");
+			}
+		}
+	});
+}
+function selectCommand(options) {
+	return command({
+		name: "select",
+		description: "Choose which plugin, or the skill itself, answers an asset name that several hold, by writing `<name>.select` in the project or user assets folder.",
+		arguments: [{
+			name: "name",
+			description: "Asset name, without its extension.",
+			type: t.string()
+		}, {
+			name: "option",
+			description: "A plugin name, or `default` for the skill's own file. Not used with --clear.",
+			type: t.string().optional()
+		}],
+		options: {
+			root: rootOption,
+			default: {
+				description: "The calling skill's folder: its `assets/<name>.<ext>` is the `default` option.",
+				type: t.string().optional()
+			},
+			scope: {
+				description: "Where to write: project (default), `.agents/assets/`, or user, `~/.agents/assets/`.",
+				type: t.string().optional()
+			},
+			clear: {
+				description: "Remove the selection.",
+				type: t.boolean().optional()
+			}
+		},
+		async run(args) {
+			try {
+				const home = homedir();
+				const root = resolve(args.root ?? process.cwd());
+				const done = selectAsset(await referenceLayers({
+					root,
+					home,
+					platform: process.platform,
+					env: process.env,
+					plugin: options.plugin,
+					defaultSkill: args.default,
+					folder: "assets"
+				}), {
+					...args,
+					root,
+					home
+				});
+				const answer = done.after.status === "found" ? `${args.name} now answers from ${done.after.trace.stack.join(", ") || "a tier"}.` : `${args.name} is ${done.after.status}: ${done.after.message ?? ""}`;
+				return document(`${done.path}\n\n${done.cleared ? "selection cleared" : `selected ${done.selected}`}. ${answer}\n`);
+			} catch (error) {
+				return fail(error, "Asset selection failed.");
+			}
+		}
+	});
+}
+function createAssetCommand(options = {}) {
+	const { load, names, where } = createAssetResolveCommands(options);
+	return command({
+		name: "asset",
+		description: "Manage a skill's assets/ files by path (list, show, create, update, delete), and load one by name through the tiers (load, names, where, select).",
+		commands: [
+			listCommand(),
+			showCommand(),
+			writeCommand("create", options),
+			writeCommand("update", options),
+			deleteCommand(),
+			load,
+			names,
+			where,
+			selectCommand(options)
+		]
+	});
+}
+//#endregion
+//#region src/prose-update/split-sentences.ts
+const ABBREVIATIONS = [
+	"e.g.",
+	"i.e.",
+	"etc.",
+	"vs."
+];
+const FENCE$2 = /^\s*(`{3,}|~{3,})/;
+const HEADING$2 = /^#{1,6}\s/;
+const ITEM = /^\s*(?:[-*+]|\d+[.)])\s/;
+const ROW = /^\s*\|/;
+const QUOTE = /^\s*>/;
+function endsAbbreviation(before) {
+	return ABBREVIATIONS.some((abbreviation) => {
+		if (!before.endsWith(abbreviation)) return false;
+		const start = before.length - abbreviation.length;
+		return start === 0 || /\s/.test(before[start - 1]);
+	});
+}
+function splitParagraph(paragraph) {
+	const parts = [];
+	let start = 0;
+	for (let i = 0; i < paragraph.length; i++) {
+		if (!".;?!".includes(paragraph[i])) continue;
+		const next = paragraph[i + 1];
+		if (next !== void 0 && !/\s/.test(next)) continue;
+		if (paragraph[i] === "." && endsAbbreviation(paragraph.slice(start, i + 1))) continue;
+		parts.push(paragraph.slice(start, i + 1));
+		start = i + 1;
+	}
+	parts.push(paragraph.slice(start));
+	return parts.map((part) => part.trim()).filter(Boolean);
+}
+/**
+* Splits text into sentences (K4): at `.`, `;`, `?` or `!` before whitespace or the end, except after an
+* abbreviation; at every blank line; a heading line, list item and table row are one sentence each; a fenced
+* code block and a blockquote are each one sentence.
+*/
+function splitSentences(input) {
+	const lines = input.split(/\r?\n/);
+	const out = [];
+	let paragraph = [];
+	let blank = false;
+	const gapBefore = () => out.length === 0 ? "" : blank ? "\n\n" : "\n";
+	const add = (text, kind) => {
+		out.push({
+			text,
+			kind,
+			gap: gapBefore()
+		});
+		blank = false;
+	};
+	const flush = () => {
+		if (!paragraph.length) return;
+		splitParagraph(paragraph.join(" ")).forEach((text, index) => {
+			if (index === 0) add(text, "text");
+			else out.push({
+				text,
+				kind: "text",
+				gap: " "
+			});
+		});
+		paragraph = [];
+	};
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const fence = FENCE$2.exec(line);
+		if (fence) {
+			flush();
+			const marker = fence[1][0];
+			const block = [line.trimEnd()];
+			while (++i < lines.length) {
+				block.push(lines[i].trimEnd());
+				const close = FENCE$2.exec(lines[i]);
+				if (close && close[1][0] === marker && lines[i].trim() === close[1]) break;
+			}
+			add(block.join("\n"), "fence");
+		} else if (!line.trim()) {
+			flush();
+			blank = true;
+		} else if (HEADING$2.test(line)) {
+			flush();
+			add(line.trim(), "heading");
+		} else if (QUOTE.test(line)) {
+			flush();
+			const block = [line.trim()];
+			while (i + 1 < lines.length && QUOTE.test(lines[i + 1])) block.push(lines[++i].trim());
+			add(block.join("\n"), "quote");
+		} else if (ROW.test(line)) {
+			flush();
+			add(line.trim(), "row");
+		} else if (ITEM.test(line)) {
+			flush();
+			add(line.trim(), "item");
+		} else paragraph.push(line.trim());
+	}
+	flush();
+	return out;
+}
+/** Two sentences are equal when they match after each run of whitespace becomes one space (K4). */
+function sameSentence(a, b) {
+	return a.replace(/\s+/g, " ").trim() === b.replace(/\s+/g, " ").trim();
+}
+//#endregion
+//#region src/prose-update/align.ts
+/**
+* Pairs of indexes `[a, b]` of the longest common subsequence of two sentence lists (K10). Equal sentences
+* repeated in both lists are matched in order, earliest first.
+*/
+function matchSentences(a, b) {
+	const table = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+	const at = (i, j) => table[i][j];
+	for (let i = a.length - 1; i >= 0; i--) for (let j = b.length - 1; j >= 0; j--) table[i][j] = sameSentence(a[i].text, b[j].text) ? at(i + 1, j + 1) + 1 : Math.max(at(i + 1, j), at(i, j + 1));
+	const pairs = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length && j < b.length) if (sameSentence(a[i].text, b[j].text) && at(i, j) === at(i + 1, j + 1) + 1) pairs.push([i++, j++]);
+	else if (at(i + 1, j) >= at(i, j + 1)) i++;
+	else j++;
+	return pairs;
+}
+/** The number of sentences two lists share (K10). */
+function shared(a, b) {
+	return matchSentences(a, b).length;
+}
+//#endregion
+//#region src/prose-update/history.ts
+const HEADING$1 = /^## Superseded(?:\s+(.*))?$/;
+const FENCE$1 = /^(`{3,}|~{3,})(.*)$/;
+const SEPARATOR = " — ";
+function linesOf(text) {
+	const lines = [];
+	let start = 0;
+	while (start <= text.length) {
+		const newline = text.indexOf("\n", start);
+		const end = newline === -1 ? text.length : newline;
+		lines.push({
+			text: text.slice(start, end),
+			start,
+			end
+		});
+		if (newline === -1) break;
+		start = newline + 1;
+	}
+	return lines;
+}
+/** Each line index that opens a `## Superseded` entry, outside fences. */
+function entryHeadings(lines) {
+	const found = [];
+	let fence;
+	lines.forEach((line, index) => {
+		const open = FENCE$1.exec(line.text);
+		if (fence) {
+			if (open && open[1] === fence && !open[2]?.trim()) fence = void 0;
+		} else if (open) fence = open[1];
+		else if (HEADING$1.test(line.text)) found.push(index);
+	});
+	return found;
+}
+/**
+* Reads the retired wordings of a history text, newest first. Each entry is a `## Superseded <date> — <reason>`
+* heading followed by the wording in a fence. An entry that does not parse is returned in `invalid`.
+*/
+function parseHistory(text) {
+	const lines = linesOf(text);
+	const headings = entryHeadings(lines);
+	const entries = [];
+	const invalid = [];
+	headings.forEach((headingIndex, position) => {
+		const heading = lines[headingIndex];
+		const limit = headings[position + 1] ?? lines.length;
+		const bad = () => {
+			invalid.push({
+				position,
+				line: headingIndex + 1,
+				heading: heading.text
+			});
+		};
+		const openIndex = lines.findIndex((line, index) => index > headingIndex && index < limit && FENCE$1.test(line.text));
+		if (openIndex === -1) {
+			bad();
+			return;
+		}
+		const open = lines[openIndex];
+		const marker = FENCE$1.exec(open.text)[1];
+		const closeIndex = lines.findIndex((line, index) => index > openIndex && index < limit && line.text.trimEnd() === marker);
+		const close = lines[closeIndex];
+		if (!close) {
+			bad();
+			return;
+		}
+		const rest = HEADING$1.exec(heading.text)[1] ?? "";
+		const split = rest.indexOf(SEPARATOR);
+		const wording = text.slice(open.end + 1, Math.max(open.end + 1, close.start - 1));
+		entries.push({
+			wording,
+			date: split === -1 ? rest.trim() : rest.slice(0, split).trim(),
+			reason: split === -1 ? "" : rest.slice(split + 3).trim()
+		});
+	});
+	return {
+		entries,
+		invalid
+	};
+}
+function fenceFor(wording) {
+	const longest = Math.max(0, ...(wording.match(/^\s*`{3,}/gm) ?? []).map((run) => run.trim().length));
+	return "`".repeat(Math.max(3, longest + 1));
+}
+/**
+* Returns the history text with the outgoing wording added as its newest entry and every other byte unchanged.
+* The wording equal to the newest retired one changes nothing.
+*/
+function retire(history, wording, date, reason) {
+	if (parseHistory(history).entries[0]?.wording === wording) return history;
+	const fence = fenceFor(wording);
+	const entry = `## Superseded ${date} ${SEPARATOR.trim()} ${reason}\n\n${fence}markdown\n${wording}\n${fence}\n`;
+	const lines = linesOf(history);
+	const first = entryHeadings(lines)[0];
+	if (first !== void 0) {
+		const at = lines[first].start;
+		return `${history.slice(0, at)}${entry}\n${history.slice(at)}`;
+	}
+	const body = history.endsWith("\n") || history === "" ? history : `${history}\n`;
+	return `${body}${body ? "\n" : ""}${entry}`;
+}
+//#endregion
+//#region src/prose-update/merge.ts
+function equal(a, b) {
+	return a.length === b.length && a.every((sentence, index) => sameSentence(sentence.text, b[index].text));
+}
+/** The revision kind of an offered part over its base part (K6). */
+function revisionKind(base, offered) {
+	return offered.length >= base.length && equal(base, offered.slice(0, base.length)) ? "append" : "rewrite";
+}
+function appendTo(base, found, added) {
+	const last = matchSentences(base, found).find(([i]) => i === base.length - 1);
+	const out = [...found];
+	let at = last ? last[1] + 1 : out.length;
+	for (const sentence of added) {
+		const had = out.findIndex((x, index) => index >= at && sameSentence(x.text, sentence.text));
+		if (had === -1) out.splice(at++, 0, sentence);
+		else at = had + 1;
+	}
+	return out;
+}
+/**
+* Three-way merge at sentence level of one part (R6 to R9). An append revision puts the new sentences after
+* the base's last sentence as found (R8) and never collides. A rewrite is merged between the sentences both
+* sides left alone; where both changed the same stretch differently the found sentences stay and the stretch
+* is reported as a collision.
+*/
+function mergeSentences(base, found, offered) {
+	const revision = revisionKind(base, offered);
+	if (revision === "append") return {
+		revision,
+		merged: appendTo(base, found, offered.slice(base.length)),
+		collisions: []
+	};
+	const inFound = new Map(matchSentences(base, found));
+	const inOffered = new Map(matchSentences(base, offered));
+	const anchors = [...inFound.keys()].filter((i) => inOffered.has(i)).sort((x, y) => x - y);
+	const merged = [];
+	const collisions = [];
+	let b = 0;
+	let f = 0;
+	let o = 0;
+	for (const anchor of [...anchors, base.length]) {
+		const toB = anchor;
+		const toF = anchor === base.length ? found.length : inFound.get(anchor);
+		const toO = anchor === base.length ? offered.length : inOffered.get(anchor);
+		const segment = {
+			base: base.slice(b, toB),
+			found: found.slice(f, toF),
+			offered: offered.slice(o, toO)
+		};
+		if (equal(segment.found, segment.base)) merged.push(...segment.offered);
+		else if (equal(segment.offered, segment.base) || equal(segment.found, segment.offered)) merged.push(...segment.found);
+		else {
+			merged.push(...segment.found);
+			collisions.push(segment);
+		}
+		if (anchor < base.length) merged.push(found[toF]);
+		b = toB + 1;
+		f = toF + 1;
+		o = toO + 1;
+	}
+	return {
+		revision,
+		merged,
+		collisions
+	};
+}
+//#endregion
+//#region src/prose-update/parts.ts
+const HEADING = /^(#{1,6})[ \t](.*)$/;
+const FENCE = /^\s*(`{3,}|~{3,})/;
+function titleOf(text) {
+	let end = text.trimEnd().length;
+	while (end > 0 && text[end - 1] === "#") end--;
+	return text.slice(0, end).trim();
+}
+/** Divides a document into parts by heading path. A heading inside a fence is not a heading. */
+function parseParts(input) {
+	const lines = input.split(/\r?\n/);
+	const raw = [{
+		level: 0,
+		title: "",
+		body: []
+	}];
+	let fence;
+	for (const line of lines) {
+		const open = FENCE.exec(line);
+		if (fence) {
+			if (open && open[1][0] === fence[0] && line.trim() === open[1]) fence = void 0;
+		} else if (open) fence = open[1];
+		else {
+			const heading = HEADING.exec(line);
+			if (heading) {
+				raw.push({
+					heading: line.trim(),
+					level: heading[1].length,
+					title: titleOf(heading[2]),
+					body: []
+				});
+				continue;
+			}
+		}
+		raw[raw.length - 1]?.body.push(line);
+	}
+	const stack = [];
+	const seen = /* @__PURE__ */ new Map();
+	const parts = [];
+	for (const entry of raw) {
+		const sentences = splitSentences(entry.body.join("\n"));
+		const first = sentences[0];
+		if (entry.heading !== void 0 && first) first.gap = entry.body[0]?.trim() === "" ? "\n\n" : "\n";
+		if (entry.heading === void 0) {
+			if (!sentences.length) continue;
+		} else {
+			while (stack.length && stack[stack.length - 1].level >= entry.level) stack.pop();
+			stack.push({
+				level: entry.level,
+				title: entry.title
+			});
+		}
+		const path = stack.map((item) => item.title);
+		const base = path.join(" > ");
+		const count = (seen.get(base) ?? 0) + 1;
+		seen.set(base, count);
+		parts.push({
+			path,
+			key: count === 1 ? base : `${base} #${count}`,
+			heading: entry.heading,
+			sentences,
+			raw: [entry.heading, ...entry.body].filter((line) => line !== void 0).join("\n").trimEnd().replace(/^\n+/, "")
+		});
+	}
+	return parts;
+}
+/** Writes a part: its heading, then each sentence after the separator it came with. */
+function renderPart(heading, sentences) {
+	let out = heading ?? "";
+	sentences.forEach((sentence, index) => {
+		if (index > 0) out += sentence.gap || " ";
+		else if (heading !== void 0) out += sentence.gap === "\n" ? "\n" : "\n\n";
+		out += sentence.text;
+	});
+	return out;
+}
+/** Lines the parts of several texts up by key. Keys keep the order of their first appearance. */
+function alignParts(texts) {
+	const rows = /* @__PURE__ */ new Map();
+	texts.forEach((parts, column) => {
+		for (const part of parts) {
+			const row = rows.get(part.key) ?? {
+				key: part.key,
+				parts: texts.map(() => void 0)
+			};
+			row.parts[column] = part;
+			rows.set(part.key, row);
+		}
+	});
+	return [...rows.values()];
+}
+//#endregion
+//#region src/prose-update/classify.ts
+/** The offered wording is empty, so nothing can be classified (R33). */
+var ProseUpdateError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "ProseUpdateError";
+	}
+};
+const ORDER = [
+	"conflict",
+	"undetermined",
+	"update",
+	"owners",
+	"up-to-date"
+];
+const norm = (text) => text.replace(/\s+/g, " ").trim();
+const sameList = (a, b) => a.length === b.length && a.every((sentence, index) => sameSentence(sentence.text, b[index].text));
+function retiredOf(history) {
+	const list = typeof history === "string" ? parseHistory(history).entries.map(({ wording, date }) => ({
+		wording,
+		date
+	})) : history.map((wording) => ({
+		wording,
+		date: void 0
+	}));
+	const seen = /* @__PURE__ */ new Set();
+	return list.map(({ wording, date }, index) => ({
+		text: wording,
+		date,
+		sentences: splitSentences(wording),
+		index
+	})).filter((retired) => {
+		const key = retired.sentences.map((sentence) => norm(sentence.text)).join("\0");
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function chooseBase(found, retired) {
+	const counts = retired.map((r) => ({
+		r,
+		count: shared(found, r.sentences)
+	}));
+	const most = Math.max(0, ...counts.map((c) => c.count));
+	if (most < 1) return {};
+	const top = counts.filter((c) => c.count === most).map((c) => c.r);
+	return top.length > 1 ? { tied: top } : { base: top[0] };
+}
+function render(part, heading, sentences) {
+	return renderPart(heading ?? part?.heading, sentences);
+}
+/** Classifies each part of the found text against the offered wording and the history, and merges where it can. */
+function classify(input) {
+	if (!splitSentences(input.offered).length) throw new ProseUpdateError("empty-offered", "The offered wording is empty.");
+	const foundSentences = splitSentences(input.found);
+	const foundParts = parseParts(input.found);
+	const offeredParts = parseParts(input.offered);
+	const retired = retiredOf(input.history);
+	const whole = (reason, extra = {}) => {
+		const keys = alignParts([foundParts, offeredParts]);
+		return {
+			outcome: "undetermined",
+			reason,
+			parts: (keys.length ? keys : [{
+				key: "",
+				parts: []
+			}]).map((row) => ({
+				path: (row.parts[0] ?? row.parts[1])?.path ?? [],
+				key: row.key,
+				outcome: "undetermined",
+				reason,
+				...extra
+			})),
+			text: input.found
+		};
+	};
+	if (!foundSentences.length) return whole("empty-section");
+	if (!retired.length) return whole("no-history");
+	const { base, tied } = chooseBase(foundSentences, retired);
+	if (tied) return whole("tied-base", { tied: tied.map((r) => r.index) });
+	const baseParts = base ? parseParts(base.text) : [];
+	const historySet = new Set(retired.flatMap((r) => r.sentences.map((sentence) => norm(sentence.text))));
+	const baseRef = base && {
+		index: base.index,
+		date: base.date
+	};
+	const rows = alignParts([
+		baseParts,
+		foundParts,
+		offeredParts
+	]);
+	const results = /* @__PURE__ */ new Map();
+	const merged = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const [b, f, o] = row.parts;
+		const result = {
+			path: (f ?? o ?? b)?.path ?? [],
+			key: row.key,
+			outcome: "owners"
+		};
+		results.set(row.key, result);
+		const withBase = (outcome, baseSentences, foundSentencesOfPart, offeredSentencesOfPart) => {
+			result.outcome = outcome;
+			if (baseRef) result.base = baseRef;
+			result.shared = shared(foundSentencesOfPart, baseSentences);
+			result.baseSentences = baseSentences.length;
+			result.revision = revisionKind(baseSentences, offeredSentencesOfPart);
+		};
+		if (!f && o) {
+			if (!b) {
+				result.outcome = "update";
+				result.text = o.raw;
+				merged.set(row.key, o.raw);
+			} else if (sameList(b.sentences, o.sentences)) {
+				result.outcome = "up-to-date";
+				result.text = "";
+			} else {
+				withBase("conflict", b.sentences, [], o.sentences);
+				result.collisions = [{
+					base: b.sentences,
+					found: [],
+					offered: o.sentences
+				}];
+			}
+		} else if (f && !o) {
+			if (!b) result.text = f.raw;
+			else if (sameList(b.sentences, f.sentences)) {
+				result.outcome = "update";
+				result.text = "";
+				merged.set(row.key, "");
+			} else {
+				withBase("conflict", b.sentences, f.sentences, []);
+				result.collisions = [{
+					base: b.sentences,
+					found: f.sentences,
+					offered: []
+				}];
+			}
+		} else if (f && o) {
+			const stale = f.sentences.some((sentence) => historySet.has(norm(sentence.text)) && !o.sentences.some((x) => sameSentence(x.text, sentence.text)));
+			const common = shared(f.sentences, o.sentences);
+			if (!f.sentences.length) {
+				result.outcome = "undetermined";
+				result.reason = "empty-section";
+			} else if (common === o.sentences.length && !stale) {
+				result.outcome = "up-to-date";
+				result.text = f.raw;
+			} else if (!base || !b?.sentences.length) {
+				if (common > 0) {
+					result.outcome = "undetermined";
+					result.reason = "no-base";
+				} else result.text = f.raw;
+			} else if (!shared(f.sentences, b.sentences) && common === 0) result.text = f.raw;
+			else {
+				const merge = mergeSentences(b.sentences, f.sentences, o.sentences);
+				withBase(merge.collisions.length ? "conflict" : "update", b.sentences, f.sentences, o.sentences);
+				result.text = render(f, f.heading ?? o.heading, merge.merged);
+				merged.set(row.key, result.text);
+				if (merge.collisions.length) result.collisions = merge.collisions;
+			}
+		}
+	}
+	const outcome = ORDER.find((o) => [...results.values()].some((r) => r.outcome === o));
+	const changed = [...results.values()].some((r) => r.outcome === "update" || r.outcome === "conflict");
+	const parts = documentOrder(foundParts, offeredParts, results).map((key) => results.get(key));
+	const text = changed ? assemble(input.found, foundParts, offeredParts, merged, results) : input.found;
+	const reason = outcome === "undetermined" ? parts.find((part) => part.outcome === "undetermined")?.reason : void 0;
+	return {
+		outcome,
+		...reason ? { reason } : {},
+		...baseRef ? { base: baseRef } : {},
+		parts,
+		text
+	};
+}
+/** Found parts in order, each added part after the nearest preceding offered part the found text holds (R22). */
+function documentOrder(found, offered, results) {
+	const inFound = new Set(found.map((part) => part.key));
+	const after = /* @__PURE__ */ new Map();
+	offered.forEach((part, index) => {
+		if (inFound.has(part.key)) return;
+		const anchor = offered.slice(0, index).reverse().find((earlier) => inFound.has(earlier.key))?.key;
+		after.set(anchor, [...after.get(anchor) ?? [], part.key]);
+	});
+	const keys = [...after.get(void 0) ?? []];
+	for (const part of found) keys.push(part.key, ...after.get(part.key) ?? []);
+	const rest = [...results.keys()].filter((key) => !keys.includes(key));
+	return [...keys, ...rest];
+}
+function assemble(found, foundParts, offeredParts, merged, results) {
+	const raw = new Map([...offeredParts, ...foundParts].map((part) => [part.key, part.raw]));
+	return documentOrder(foundParts, offeredParts, results).filter((key) => results.get(key).outcome !== "up-to-date" || foundParts.some((p) => p.key === key)).map((key) => merged.get(key) ?? (foundParts.some((p) => p.key === key) ? raw.get(key) : void 0)).filter((piece) => piece !== void 0 && piece !== "").join("\n\n") + (found.endsWith("\n") ? "\n" : "");
+}
+//#endregion
+//#region src/prose-update/prose-update.command.ts
+const text = (what) => ({
+	description: `${what}, as text.`,
+	type: t.string().optional()
+});
+const file = (what) => ({
+	description: `${what}, read from this file.`,
+	type: t.string().optional()
+});
+function usage(message) {
+	process.stderr.write(`error: usage: ${message}\n`);
+	throw CliError.reported(exitCodes.usage);
+}
+/** Exactly one of `--<name>` and `--<name>-from`. */
+function input(name, inline, from) {
+	if (inline === void 0 === (from === void 0)) usage(`pass exactly one of --${name} and --${name}-from.`);
+	return inline ?? readFileSync(resolve(from), "utf8");
+}
+function classifyCommand() {
+	return command({
+		name: "classify",
+		description: "Compare found prose with an offered wording and the retired wordings: the outcome for each part and the merged text, with no judgment involved.",
+		options: {
+			offered: text("The wording offered now"),
+			"offered-from": file("The wording offered now"),
+			found: text("The text found in the file being updated"),
+			"found-from": file("The text found in the file being updated"),
+			history: text("A history text of retired wordings, newest first"),
+			"history-from": file("A history text of retired wordings, newest first"),
+			retired: {
+				description: "A retired wording, as text. Repeat for several, newest first. Used when no history text is given.",
+				type: t.array(t.string()).optional()
+			},
+			"retired-from": {
+				description: "A file holding a retired wording. Repeat for several, newest first.",
+				type: t.array(t.string()).optional()
+			}
+		},
+		async run(args) {
+			const offered = input("offered", args.offered, args["offered-from"]);
+			const found = input("found", args.found, args["found-from"]);
+			const retired = [...args.retired ?? [], ...(args["retired-from"] ?? []).map((path) => readFileSync(resolve(path), "utf8"))];
+			const hasHistory = args.history !== void 0 || args["history-from"] !== void 0;
+			if (hasHistory && retired.length) usage("pass a history text or retired wordings, not both.");
+			const history = hasHistory ? input("history", args.history, args["history-from"]) : retired;
+			if (typeof history === "string") {
+				const { invalid } = parseHistory(history);
+				for (const entry of invalid) process.stderr.write(`warning: history entry ${entry.position + 1} (line ${entry.line}) did not parse: ${entry.heading}\n`);
+			}
+			try {
+				const out = classify({
+					found,
+					offered,
+					history
+				});
+				return result({
+					outcome: out.outcome,
+					...out.reason ? { reason: out.reason } : {},
+					...out.base ? { base: out.base } : {},
+					parts: out.parts.map((part) => ({
+						path: part.path.join(" > "),
+						outcome: part.outcome,
+						...part.reason ? { reason: part.reason } : {},
+						...part.tied ? { tied: part.tied } : {},
+						...part.base ? { base: part.base } : {},
+						...part.shared === void 0 ? {} : {
+							shared: part.shared,
+							baseSentences: part.baseSentences
+						},
+						...part.revision ? { revision: part.revision } : {},
+						...part.text === void 0 ? {} : { text: part.text },
+						...part.collisions ? { collisions: part.collisions.map((c) => ({
+							base: c.base.map((s) => s.text),
+							found: c.found.map((s) => s.text),
+							offered: c.offered.map((s) => s.text)
+						})) } : {}
+					})),
+					text: out.text
+				});
+			} catch (error) {
+				if (!(error instanceof ProseUpdateError)) throw error;
+				process.stderr.write(`error: ${error.code}: ${error.message}\n`);
+				throw CliError.reported(exitCodes.error);
+			}
+		}
+	});
+}
+function retireCommand() {
+	return command({
+		name: "retire",
+		description: "Print the history text with the outgoing wording added as its newest entry. Writes no file: the caller saves the answer.",
+		options: {
+			history: text("The history text"),
+			"history-from": file("The history text"),
+			wording: text("The outgoing wording"),
+			"wording-from": file("The outgoing wording"),
+			date: {
+				description: "The date of the entry, written as given.",
+				type: t.string()
+			},
+			reason: {
+				description: "Why the wording was replaced.",
+				type: t.string()
+			}
+		},
+		async run(args) {
+			return document(retire(input("history", args.history, args["history-from"]), input("wording", args.wording, args["wording-from"]), args.date, args.reason));
+		}
+	});
+}
+/** `classify` and `retire`: the script behind the `prose-update` skill (R26). */
+function createProseUpdateCommand() {
+	return command({
+		name: "prose-update",
+		description: "Bring prose a tool wrote earlier to its offered wording without losing the owner’s edits: classify found prose, and extend the history of retired wordings.",
+		commands: [classifyCommand(), retireCommand()]
+	});
+}
 //#endregion
 //#region src/cli.ts
 function readJson(url) {
@@ -14271,11 +15582,14 @@ function app({ name, version, root }, format) {
 		format,
 		name: "cyber-agentkit",
 		version,
-		description: "Work with the AI agent harness running here: read its layered reference documents."
+		description: "Work with the AI agent harness running here: read its layered reference documents, and update prose a tool wrote earlier."
 	}).command(createReferenceCommand({ plugin: {
 		name,
 		root
-	} }));
+	} })).command(createAssetCommand({ plugin: {
+		name,
+		root
+	} })).command(createProseUpdateCommand());
 }
 /**
 * `show`, `create`, `select`, and `delete` answer in `text` unless `--format` says otherwise; the other
@@ -14285,12 +15599,15 @@ function app({ name, version, root }, format) {
 function defaultFormat(argv) {
 	const args = argv.slice(2);
 	if (args.some((arg) => arg === "--format" || arg.startsWith("--format="))) return "toon";
-	const subcommand = args[0] === "reference" ? args[1] : void 0;
+	const subcommand = args[0] === "reference" || args[0] === "asset" || args[0] === "prose-update" ? args[1] : void 0;
 	return [
 		"show",
+		"load",
 		"create",
+		"update",
 		"select",
-		"delete"
+		"delete",
+		"retire"
 	].includes(subcommand ?? "") ? "text" : "toon";
 }
 /** argv in, exit code out — returned rather than written, so a caller that is not the process can act on it. */