cyber-agentkit 1.1.0 → 1.2.0

package/dist/index.js

@@ -587,6 +587,588 @@ function headlessCommand(harness, 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/skills/skill-invocation.ts
 /**
 * How a user invokes a plugin's skill in a harness.
@@ -662,4 +1244,4 @@ function skillInvocation(harness, { plugin, skill }) {
 	}
 }
 //#endregion
-export { adminSkillFolders, checkPluginDependencies, checkReferences, declaredDependencies, declaredPluginDependencies, defaultLayer, detectHarness, enabledPlugins, harnessIds, harnessSkillFolders, headlessCommand, headlessInvocation, installedPlugins, listReferences, loadAsset, loadReference, managedPolicyLocations, packageDir, parseReferenceName, pluginManifestName, pluginManifestPaths, pluginSkillFolders, pluginStorage, projectReferencesDir, readPluginDependencies, referenceImplementations, referenceLayers, referenceNames, resolveReference, searchReferences, skillFoldersVerified, skillInvocation, skillName, skillsDirectories, skillsIn, supportsPluginDependencies, userReferencesDir, whereReference };
+export { ProseUpdateError, adminSkillFolders, checkPluginDependencies, checkReferences, classify, declaredDependencies, declaredPluginDependencies, defaultLayer, detectHarness, enabledPlugins, harnessIds, harnessSkillFolders, headlessCommand, headlessInvocation, installedPlugins, listReferences, loadAsset, loadReference, managedPolicyLocations, packageDir, parseHistory, parseReferenceName, pluginManifestName, pluginManifestPaths, pluginSkillFolders, pluginStorage, projectReferencesDir, readPluginDependencies, referenceImplementations, referenceLayers, referenceNames, resolveReference, retire, searchReferences, skillFoldersVerified, skillInvocation, skillName, skillsDirectories, skillsIn, supportsPluginDependencies, userReferencesDir, whereReference };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyber-agentkit",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "An agent-harness-agnostic toolkit: the fundamental features agent tools need, working the same on every harness. Detect the running harness, check plugin dependencies, resolve layered reference documents, and lease git worktrees.",
   "keywords": [
     "agent-harness",

package/plugin.json

@@ -1,7 +1,7 @@
 {
 	"$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
 	"name": "cyber-agentkit",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"description": "An agent-harness-agnostic toolkit: the fundamental features agent tools need, working the same on every harness. Detect the running harness, check plugin dependencies, resolve layered reference documents, and lease git worktrees.",
 	"author": {
 		"name": "unional"
@@ -21,7 +21,8 @@
 			},
 			"scripts": {
 				"skills/reference/scripts/reference.mjs": "src/references/reference.skill-script.ts",
-				"skills/asset/scripts/asset.mjs": "src/assets/asset.skill-script.ts"
+				"skills/asset/scripts/asset.mjs": "src/assets/asset.skill-script.ts",
+				"skills/prose-update/scripts/prose-update.mjs": "src/prose-update/prose-update.skill-script.ts"
 			}
 		}
 	}