cyber-agentkit 1.1.0 → 1.2.0

package/dist/cli.js

@@ -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",
@@ -13516,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;
@@ -13681,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);
@@ -13821,7 +13821,7 @@ function fail$1(error, fallback) {
 	process.stderr.write(`error: ${error instanceof Error ? error.message : fallback}\n`);
 	throw CliError.reported(exitCodes.error);
 }
-function usage$1(message) {
+function usage$2(message) {
 	process.stderr.write(`error: usage: ${message}\n`);
 	throw CliError.reported(exitCodes.usage);
 }
@@ -13922,7 +13922,7 @@ function showCommand$1(layersFor, name = "show") {
 		},
 		async run(args) {
 			const format = this.format;
-			if (!args.names.length) usage$1("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);
@@ -14026,7 +14026,7 @@ function searchCommand(layersFor) {
 		},
 		async run(args) {
 			const query = args.query.trim();
-			if (!query) usage$1("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) });
@@ -14105,7 +14105,7 @@ function whereCommand(layersFor, assets = false, name = "where") {
 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$1(`--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) {
@@ -14644,7 +14644,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$1(message) {
 	process.stderr.write(`error: usage: ${message}\n`);
 	throw CliError.reported(exitCodes.usage);
 }
@@ -14734,7 +14734,7 @@ function writeCommand(mode, host) {
 		async run(args) {
 			try {
 				if (args.copy !== void 0) {
-					if (args.content !== void 0 || args.from !== void 0) usage("--copy takes neither --content nor --from.");
+					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({
@@ -14754,8 +14754,8 @@ function writeCommand(mode, host) {
 					});
 					return document(`${done.path}\n\ncopied from ${done.from}. Edit it; it now answers over the plugin tier.\n`);
 				}
-				if (!args.skill) usage("pass --skill, or --copy to create an override by name.");
-				if (args.content === void 0 === (args.from === void 0)) usage("pass exactly one of --content and --from.");
+				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) {
@@ -14858,6 +14858,707 @@ function createAssetCommand(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) {
 	return JSON.parse(readFileSync(url, "utf8"));
@@ -14881,14 +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
@@ -14898,14 +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[0] === "asset" ? 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. */