@lmzhen/dsh-evolution-core 0.30.30 → 0.30.32

package/lib/index.js

@@ -4,9 +4,9 @@ import { w as allowRowCollisions } from "./composition-DSesmTvf.js";
 import { n as errorText, t as EVOLUTION_ERRORS } from "./errors-Br2-uUSK.js";
 import { createSubagentChannel, probeChannelState, subagentChannelState } from "./subagent/index.js";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { basename, dirname, join, resolve } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { copyFileSync, existsSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { cp, lstat, mkdir, open, readFile, readdir, rename, rm, stat } from "node:fs/promises";
+import { cp, lstat, mkdir, open, readFile, readdir, realpath, rename, rm, stat } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { parse } from "yaml";
 import { homedir } from "node:os";
@@ -2251,6 +2251,40 @@ function describeReferenceRewrite(plan) {
 	].filter((part) => part.length > 0).join("; ")}`;
 }
 //#endregion
+//#region lib/types/support-refs.js
+/**
+* Support-directory references in a markdown body (009 kernel): references/…,
+* templates/…, scripts/…, assets/… relative links — any extension and nested
+* paths. Pure: who checks them and what the verdict is belongs to the caller.
+* `..` traversal is a different defect class (path validation owns it) and is
+* not a support link.
+*/
+function supportRefs(content) {
+	const refs = [];
+	for (const match of content.matchAll(/(?<![A-Za-z0-9._/-])(?:references|templates|scripts|assets)\/[A-Za-z0-9._/-]+/g)) {
+		const ref = match[0];
+		if (ref.includes("..")) continue;
+		refs.push(ref);
+	}
+	return refs;
+}
+/**
+* References that leave the skill root: parent traversals or absolute support paths.
+* Extract must not silently treat these as relative support files; the caller reports
+* them (bounded external copy is a separate, explicit policy).
+* @param content - markdown body.
+* @returns external-looking support references, de-duplicated in first-seen order.
+*/
+function externalRefs(content) {
+	const refs = [];
+	for (const match of content.matchAll(/(?:^|[\s("'`])((?:\.\.\/)+[A-Za-z0-9._/-]+|\/[A-Za-z0-9._/-]+)/g)) {
+		const ref = match[1]?.replace(/[.,;:]+$/, "");
+		if (ref === void 0 || ref.length === 0 || refs.includes(ref)) continue;
+		refs.push(ref);
+	}
+	return refs;
+}
+//#endregion
 //#region lib/types/constants.js
 /**
 * Shared constants for the dsh-evolution plugin family.
@@ -3047,6 +3081,786 @@ function authoringFeedback(frontmatter) {
 * v28 G2.1 (EVO-IO-05): this is a delegation to the seam's own
 * `isCommittedWarning` — the marker predicate has exactly one definition. */
 //#endregion
+//#region lib/types/document-body.js
+/**
+* What the panel shows when it renders one version as a document.
+*
+* Two decisions, both made here so the preview and the rendered diff cannot drift apart:
+*
+*  - FRONTMATTER IS NOT DOCUMENT TEXT. A SKILL.md opens with a YAML block; the renderer read its
+*    closing `---` as a setext underline, so the metadata line became the document's biggest heading
+*    and the real title sat below it (measured on the installed panel 2026-09-28). The block is
+*    stripped for DISPLAY only: the raw view and the body route still carry every byte, and the
+*    panel already shows the name and description on the row and in the left column.
+*  - STRIPPING FAILS OPEN. Only a block that the family's own reader accepts is removed. A document
+*    whose text merely starts with a thematic break, a block with no closing line, or a frontmatter
+*    whose body is empty is returned UNCHANGED — showing a document's first line is always better
+*    than showing nothing.
+*
+* `readingStats` exists for the other half of the reader's honesty: a preview that stops early has
+* to be able to say HOW much it is not showing.
+* @module @lmzhen/dsh-evolution-core/document-body
+*/
+/**
+* The document a reader sees: the body without its leading frontmatter block.
+* @param content - the stored bytes of one version.
+* @returns the text to render; unchanged when there is no frontmatter the reader accepts.
+*/
+function displayBodyOf(content) {
+	const block = frontmatterBlock(content);
+	if (block === null) return content;
+	if (parseFrontmatter(content) === null) return content;
+	return block.lines.slice(block.end + 1).join("\n").replace(/^\s*\n/, "");
+}
+/**
+* How much of a version the panel is showing.
+* @param full - the whole stored text.
+* @param shown - the part the route handed over.
+* @returns the counts, so the panel can say what it is not showing.
+*/
+function readingStats(full, shown) {
+	return {
+		totalChars: full.length,
+		shownChars: shown.length,
+		truncated: shown.length < full.length
+	};
+}
+/**
+* The H2 sections of a body, in document order — the ONE scan (G3).
+*
+* Both the restructure candidate list and the store anchor validation call this function, so a
+* candidate can only name a heading that exists EXACTLY ONCE and has content: the two rejections a
+* hand-written anchor used to hit ("no such heading", "ambiguous anchor") stop being reachable.
+* H2 is the section boundary (a section spans to the next H2 or EOF), matching the store.
+* @param body - the markdown after the frontmatter block.
+* @returns one row per H2 heading, with `count` filled in a second pass.
+*/
+function h2Sections(body) {
+	const lines = body.split(String.fromCharCode(10));
+	const rows = [];
+	for (let i = 0; i < lines.length; i += 1) {
+		const match = /^#{2}\s+(.+?)\s*$/.exec(lines[i] ?? "");
+		if (match === null) continue;
+		const title = (match[1] ?? "").trim();
+		let end = lines.length;
+		for (let j = i + 1; j < lines.length; j += 1) if (/^#{2}\s/.test(lines[j] ?? "")) {
+			end = j;
+			break;
+		}
+		rows.push({
+			title,
+			start: i,
+			end,
+			count: 0
+		});
+	}
+	for (const row of rows) row.count = rows.filter((other) => other.title === row.title).length;
+	return rows;
+}
+/**
+* The sections a restructure proposal may name: heading unique, section non-empty. Derived from
+* `h2Sections`, i.e. from the SAME scan the store validates against.
+* @param body - the markdown after the frontmatter block.
+* @returns move-ready pairs in document order; empty when nothing qualifies.
+*/
+function restructureCandidates(body) {
+	return h2Sections(body).filter((section) => section.count === 1 && section.end > section.start + 1).map((section) => ({
+		heading: section.title,
+		toFile: "references/" + section.title.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "-").replace(/^-+|-+$/g, "") + ".md"
+	}));
+}
+//#endregion
+//#region lib/types/section-selection.js
+const LF$1 = String.fromCharCode(10);
+/**
+* Select whole H2 sections or exact content sub-blocks from one body.
+*
+* The H2 scan is document-body's h2Sections, so restructure and extract share
+* one boundary rule. A start/end pair selects an inclusive, contiguous run of
+* exact lines inside that heading; it cannot select the heading itself, overlap
+* another request, or leave a selected range empty.
+* @param body - markdown after frontmatter.
+* @param requests - exact heading plus optional start/end line pairs.
+* @returns selected ranges in request order, or the first refusal.
+*/
+function selectSections(body, requests) {
+	const lines = body.split(LF$1);
+	const sections = h2Sections(body);
+	const selected = [];
+	for (let requestIndex = 0; requestIndex < requests.length; requestIndex += 1) {
+		const request = requests[requestIndex];
+		if (request === void 0) continue;
+		const wanted = request.heading.trim();
+		const matching = sections.filter((section) => section.title === wanted);
+		if (matching.length === 0) return {
+			ok: false,
+			code: "heading-missing",
+			message: "no \"## " + wanted + "\" heading in the body"
+		};
+		if (matching.length > 1) return {
+			ok: false,
+			code: "heading-ambiguous",
+			message: "heading \"## " + wanted + "\" appears " + matching.length + " times (ambiguous anchor)"
+		};
+		const section = matching[0];
+		if (section === void 0) return {
+			ok: false,
+			code: "heading-missing",
+			message: "no \"## " + wanted + "\" heading in the body"
+		};
+		if (selected.some((entry) => entry.start === section.start)) return {
+			ok: false,
+			code: "heading-duplicate",
+			message: "heading \"## " + wanted + "\" is moved twice"
+		};
+		if (!(request.start !== void 0 || request.end !== void 0)) {
+			if (section.end === section.start + 1) return {
+				ok: false,
+				code: "heading-empty",
+				message: "heading \"## " + wanted + "\" has an empty section"
+			};
+			selected.push({
+				heading: wanted,
+				start: section.start,
+				end: section.end,
+				text: lines.slice(section.start, section.end).join(LF$1),
+				requestIndex
+			});
+			continue;
+		}
+		if (request.start === void 0 || request.end === void 0) return {
+			ok: false,
+			code: "part-anchor-incomplete",
+			message: "heading \"## " + wanted + "\" needs both start and end anchors"
+		};
+		const startMatches = [];
+		const endMatches = [];
+		for (let index = 0; index < lines.length; index += 1) {
+			if (index <= section.start || index >= section.end) continue;
+			if (lines[index] === request.start) startMatches.push(index);
+			if (lines[index] === request.end) endMatches.push(index);
+		}
+		if (startMatches.length !== 1) return {
+			ok: false,
+			code: "part-anchor-not-found",
+			message: "heading \"## " + wanted + "\" start anchor must match exactly one content line"
+		};
+		if (endMatches.length !== 1) return {
+			ok: false,
+			code: "part-anchor-not-found",
+			message: "heading \"## " + wanted + "\" end anchor must match exactly one content line"
+		};
+		const start = startMatches[0];
+		const end = endMatches[0];
+		if (start === void 0 || end === void 0 || start > end) return {
+			ok: false,
+			code: "part-anchor-order",
+			message: "heading \"## " + wanted + "\" start anchor is after end anchor"
+		};
+		if (selected.some((entry) => start < entry.end && end + 1 > entry.start)) return {
+			ok: false,
+			code: "part-anchor-overlaps",
+			message: "heading \"## " + wanted + "\" selection overlaps another selected block"
+		};
+		selected.push({
+			heading: wanted,
+			start,
+			end: end + 1,
+			text: lines.slice(start, end + 1).join(LF$1),
+			requestIndex,
+			anchorStart: request.start,
+			anchorEnd: request.end
+		});
+	}
+	return {
+		ok: true,
+		sections: selected
+	};
+}
+//#endregion
+//#region lib/types/extract-plan.js
+const LF = String.fromCharCode(10);
+function sha256$1(text) {
+	return createHash("sha256").update(text).digest("hex");
+}
+function unique(values) {
+	return [...new Set(values)];
+}
+function computeSupport(parts, residual, sourceName, sourceFiles, targetFiles, externalFiles) {
+	const selectedText = parts.map((part) => part.sourceText).join("\n\n");
+	const selectedRefs = unique(supportRefs(selectedText));
+	const residualRefs = new Set(supportRefs(residual));
+	const unresolved = selectedRefs.filter((ref) => !sourceFiles.includes(ref));
+	if (unresolved.length > 0) return { error: "support-unresolved: " + unresolved.join(", ") };
+	const candidates = selectedRefs.filter((ref) => sourceFiles.includes(ref));
+	const moves = planRehoming(candidates, targetFiles, sourceName).moves;
+	const byFrom = new Map(moves.map((move) => [move.from, move.to]));
+	const exclusive = [];
+	const shared = [];
+	for (const from of candidates) {
+		const to = byFrom.get(from);
+		if (to === void 0) continue;
+		if (residualRefs.has(from)) shared.push({
+			from,
+			to,
+			provenance: sourceName + ":" + from
+		});
+		else exclusive.push({
+			from,
+			to
+		});
+	}
+	const targetFilesWithMoves = unique([...targetFiles, ...moves.map((move) => move.to)]);
+	const external = unique(externalRefs(selectedText));
+	const suppliedRefs = new Set(externalFiles.map((file) => file.ref));
+	const missingExternal = external.filter((ref) => !suppliedRefs.has(ref));
+	const warnings = [];
+	if (missingExternal.length > 0) warnings.push("external-support-not-copied: " + missingExternal.join(", "));
+	const externalClosure = [];
+	for (const file of externalFiles) {
+		if (!external.includes(file.ref)) return { error: "external-ref-not-selected: " + file.ref };
+		if (file.targetPath.startsWith("/") || file.targetPath.includes("..") || !/^(?:references|templates|scripts|assets)\//.test(file.targetPath)) return { error: "external-target-unsafe: " + file.targetPath };
+		if (targetFilesWithMoves.includes(file.targetPath)) return { error: "external-collision: " + file.targetPath };
+		externalClosure.push({
+			from: file.ref,
+			to: file.targetPath,
+			provenance: file.provenance,
+			originalPath: file.originalPath,
+			content: file.content,
+			sha256: file.sha256
+		});
+	}
+	const rewritten = /* @__PURE__ */ new Map();
+	for (const part of parts) {
+		const partRefs = supportRefs(part.sourceText);
+		const rewrite = planReferenceRewrite({
+			content: part.sourceText,
+			files: sourceFiles,
+			moves: moves.filter((move) => partRefs.includes(move.from)),
+			targetFiles: targetFilesWithMoves
+		});
+		rewritten.set(part.heading, applyReferenceRewrite(part.sourceText, rewrite.edits));
+		warnings.push(...rewrite.unresolved.map((ref) => "support-unresolved: " + ref));
+		warnings.push(...rewrite.residualDangling.map((ref) => "support-dangling: " + ref));
+	}
+	for (const part of parts) {
+		let text = rewritten.get(part.heading) ?? part.sourceText;
+		for (const file of externalClosure) text = text.split(file.from).join(file.to);
+		part.movedText = text;
+	}
+	const exclusiveSet = new Set(exclusive.map((entry) => entry.from));
+	const parentExclusive = supportRefs(residual).filter((ref) => exclusiveSet.has(ref));
+	if (parentExclusive.length > 0) return { error: "support-exclusive-referenced-by-parent: " + parentExclusive.join(", ") };
+	const dangling = unique(warnings.filter((item) => item.startsWith("support-dangling: ")).map((item) => item.slice(18)));
+	return {
+		support: {
+			exclusive,
+			shared,
+			external: externalClosure,
+			unresolved: warnings.filter((item) => item.startsWith("support-unresolved: ")),
+			dangling
+		},
+		warnings
+	};
+}
+/**
+* Build a pure extract plan. No IO, no writes: selection, residual, support
+* closure and the moved text are computed from the supplied bodies/file lists.
+* @param input - source body, target identity, owner decision and support lists.
+* @returns a plan, or a refusal with a stable code.
+*/
+function planExtract(input) {
+	if (input.outcome === "owner-gap") {
+		if (input.owner.mode !== "owner-gap") return {
+			ok: false,
+			code: "owner-gap-mismatch",
+			message: "outcome owner-gap requires an owner-gap decision"
+		};
+		if (input.owner.neededOwner === void 0 || input.owner.neededOwner.trim() === "") return {
+			ok: false,
+			code: "owner-gap-needed-owner",
+			message: "owner-gap requires neededOwner"
+		};
+	} else {
+		if (input.owner.mode !== "covered" || !input.owner.triggerCovers || !input.owner.outcomeCovers) return {
+			ok: false,
+			code: "owner-not-covered",
+			message: "extract/mixed requires a covering owner"
+		};
+		if (!input.targetExists) return {
+			ok: false,
+			code: "target-missing",
+			message: "covered owner target does not exist"
+		};
+	}
+	const selection = selectSections(input.body, input.requests);
+	if (!selection.ok) return {
+		ok: false,
+		code: selection.code,
+		message: selection.message
+	};
+	if (selection.sections.length === 0) return {
+		ok: false,
+		code: "part-empty",
+		message: "at least one part is required"
+	};
+	const parts = selection.sections.map((section) => ({
+		heading: section.heading,
+		anchor: {
+			heading: section.heading,
+			...section.anchorStart === void 0 ? {} : { start: section.anchorStart },
+			...section.anchorEnd === void 0 ? {} : { end: section.anchorEnd }
+		},
+		sourceText: section.text,
+		movedText: section.text,
+		bytes: Buffer.byteLength(section.text, "utf8"),
+		sha256: sha256$1(section.text)
+	}));
+	const pointer = "This capability now lives in " + (input.owner.mode === "covered" ? input.owner.name ?? input.targetName : input.owner.neededOwner ?? input.targetName) + "; project-specific facts stay here.";
+	const ordered = [...selection.sections].sort((a, b) => a.start - b.start);
+	const first = ordered[0];
+	if (first === void 0) return {
+		ok: false,
+		code: "part-empty",
+		message: "at least one part is required"
+	};
+	const byStart = new Map(ordered.map((section) => [section.start, section]));
+	const lines = input.body.split(LF);
+	const rebuilt = [];
+	for (let index = 0; index < lines.length; index += 1) {
+		const section = byStart.get(index);
+		if (section !== void 0) {
+			if (index === first.start) rebuilt.push(pointer);
+			index = section.end - 1;
+		} else rebuilt.push(lines[index] ?? "");
+	}
+	const residual = rebuilt.join(LF);
+	if (residual.trim().length === 0) return {
+		ok: false,
+		code: "parent-empty",
+		message: "parent residual is empty"
+	};
+	if (residual.split(LF).filter((line) => line.trim() !== "" && line !== pointer && !line.trimStart().startsWith("#")).length === 0) return {
+		ok: false,
+		code: "parent-hollow-heading",
+		message: "parent residual has no substantive content"
+	};
+	if (input.outcome === "owner-gap") return {
+		ok: true,
+		plan: {
+			source: input.sourceName,
+			target: {
+				name: input.targetName,
+				exists: input.targetExists
+			},
+			outcome: input.outcome,
+			parts,
+			residual,
+			pointer,
+			owner: input.owner,
+			support: {
+				exclusive: [],
+				shared: [],
+				external: [],
+				unresolved: [],
+				dangling: []
+			},
+			warnings: [],
+			...input.anchors === void 0 ? {} : { anchors: input.anchors }
+		}
+	};
+	const supportResult = computeSupport(parts, residual, input.sourceName, input.sourceFiles, input.targetFiles, input.external ?? []);
+	if ("error" in supportResult) return {
+		ok: false,
+		code: supportResult.error.split(":")[0] ?? "support-invalid",
+		message: supportResult.error
+	};
+	if (supportResult.support.dangling.length > 0) return {
+		ok: false,
+		code: "support-dangling",
+		message: "support-dangling: " + supportResult.support.dangling.join(", ")
+	};
+	return {
+		ok: true,
+		plan: {
+			source: input.sourceName,
+			target: {
+				name: input.targetName,
+				exists: input.targetExists
+			},
+			outcome: input.outcome,
+			parts,
+			residual,
+			pointer,
+			owner: input.owner,
+			support: supportResult.support,
+			warnings: unique(supportResult.warnings),
+			...input.anchors === void 0 ? {} : { anchors: input.anchors }
+		}
+	};
+}
+/**
+* Project one plan onto the current source/target SKILL.md bytes.
+*
+* This is the one place that composes frontmatter + residual + target additions;
+* preview and the write adapter both call it so they cannot advertise different
+* bytes. Pure: no IO.
+* @param plan - plan from planExtract.
+* @param sourceMd - current source SKILL.md.
+* @param targetMd - current target SKILL.md.
+* @returns both next documents, or the refusal that makes projection impossible.
+*/
+function projectExtractBodies(plan, sourceMd, targetMd) {
+	const sourceBlock = frontmatterBlock(sourceMd);
+	const targetBlock = frontmatterBlock(targetMd);
+	if (!sourceBlock) return {
+		ok: false,
+		message: "source 没有有效 frontmatter"
+	};
+	if (!targetBlock) return {
+		ok: false,
+		message: "target 没有有效 frontmatter"
+	};
+	const sourceHeader = sourceBlock.lines.slice(0, sourceBlock.end + 1).join(LF);
+	const targetNormalized = targetMd.replace(/\r\n/g, LF);
+	const targetLines = targetNormalized.split(LF);
+	for (const part of plan.parts) if (targetLines.some((line) => line.trim() === "## " + part.heading)) return {
+		ok: false,
+		message: "target 已有同名 heading「" + part.heading + "」。"
+	};
+	const additions = plan.parts.map((part) => part.movedText).join("\n\n");
+	const targetRaw = targetNormalized.trimEnd() + "\n\n" + additions + LF;
+	const targetAfter = targetBlock.nl === "\r\n" ? targetRaw.replace(/\n/g, "\r\n") : targetRaw;
+	const sourceRaw = (sourceHeader + plan.residual).replace(/\r\n/g, LF);
+	return {
+		ok: true,
+		projection: {
+			sourceAfter: sourceBlock.nl === "\r\n" ? sourceRaw.replace(/\n/g, "\r\n") : sourceRaw,
+			targetAfter
+		}
+	};
+}
+//#endregion
+//#region lib/types/owner-resolver.js
+/**
+* Project the current library listing into owner candidates.
+*
+* The source is excluded; a skill with an empty description is named in
+* excluded rather than silently dropped. Protected candidates remain visible
+* (so a caller can explain why it refused), but are marked for the writer's
+* protection gate. Headings reuse h2Sections; no second heading scanner.
+* @param source - skill being extracted from.
+* @param summaries - SkillLibrary.list({ withContent: true, withFrontmatter: true }).
+* @returns stable-name-ordered candidates plus explicit exclusions.
+*/
+function ownerCandidatesFromSummaries(source, summaries) {
+	const normalized = source.trim();
+	const candidates = [];
+	const excluded = [];
+	for (const summary of summaries) {
+		if (summary.name === normalized) {
+			excluded.push({
+				name: summary.name,
+				reason: "source"
+			});
+			continue;
+		}
+		if (summary.description.trim() === "") {
+			excluded.push({
+				name: summary.name,
+				reason: "unreadable"
+			});
+			continue;
+		}
+		candidates.push({
+			name: summary.name,
+			description: summary.description,
+			...summary.whenToUse === void 0 ? {} : { whenToUse: summary.whenToUse },
+			headings: h2Sections(summary.content ?? "").map((section) => section.title),
+			protectedBy: summary.protectedBy,
+			protectionUnknown: summary.protectionUnknown,
+			managed: summary.managed
+		});
+	}
+	candidates.sort((left, right) => left.name.localeCompare(right.name));
+	excluded.sort((left, right) => left.name.localeCompare(right.name));
+	return {
+		source: normalized,
+		candidates,
+		excluded
+	};
+}
+/**
+* Find one named candidate in a lookup.
+* @param lookup - projection from ownerCandidatesFromSummaries.
+* @param name - exact skill name.
+* @returns the candidate, or undefined when absent.
+*/
+function findOwnerCandidate(lookup, name) {
+	return lookup.candidates.find((candidate) => candidate.name === name);
+}
+//#endregion
+//#region lib/types/proposal-view.js
+/**
+* Project a pure ExtractPlan into the proposal record every read-only surface consumes.
+*
+* This is a projection, not a second evaluator: it keeps the plan's owner decision,
+* support closure and warnings. It never writes and never invents coverage.
+* @param plan - plan produced by planExtract.
+* @param provenance - run id and timestamp for the proposing pass.
+* @returns a proposal with status proposed.
+*/
+function proposalFromPlan(plan, provenance) {
+	return {
+		version: 1,
+		id: "extract-" + provenance.runId + "-" + plan.source,
+		source: plan.source,
+		outcome: plan.outcome,
+		parts: plan.parts.map((part) => ({
+			heading: part.heading,
+			anchor: part.anchor,
+			reason: part.sourceText.slice(0, 160)
+		})),
+		owner: plan.owner,
+		support: plan.support,
+		warnings: plan.warnings,
+		provenance: {
+			promptVersion: "v1",
+			runId: provenance.runId,
+			at: provenance.at ?? Date.now()
+		},
+		status: "proposed"
+	};
+}
+//#endregion
+//#region lib/types/state-store.js
+/**
+* Evolution home path helpers: the DSH root and `$DSH_HOME/evolution` for
+* plugin-owned sidecar state (reports, activity store, feedback file,
+* state-domain data).
+*
+* C-10: PATH HELPERS ONLY — despite the file name there is no store
+* here. Durable evolution state lives in the state stack (evolution-state over
+* evolution-state-json / -domain); skills and memories live in skill-store.ts
+* / memory-store.ts. The file name is kept deliberately: renaming it would
+* touch every family import for zero behavior change, and the audit records
+* the mismatch as known naming debt.
+*/
+/**
+* DSH home root: `$DSH_HOME` or `~/.dsh`. Single source of the empty-string
+* fallback — an EMPTY or WHITESPACE-ONLY DSH_HOME resolves to the default
+* home, never to a CWD-relative path (0.3.19 W1.3, 0.3.22 F-207);
+* V8-06 (0.3.47) extends the guard to whitespace.
+* C-11 correction (S2.2, PLAN 2026-09-16): upstream `resolveDshHome`
+* (util/home-paths) uses `trim()` ONLY as the ADOPTION test and then uses the
+* RAW env value — the earlier "same trimmed source" form returned the trimmed
+* text, so `DSH_HOME=" /x "` produced `/x` where upstream produced the literal
+* padded path. The value semantics now match upstream line for line:
+* `const selected = configured ?? (fromEnv !== undefined &&
+* fromEnv.trim().length > 0 ? fromEnv : defaultDshHome())`.
+* OPT-27 (2026-09, plan D5 — accepted): the v10-era "no `~` expansion, no
+* resolve" divergence from upstream `resolveDshHome` is RETIRED. It became
+* load-bearing when the skill-catalog shadow made "same tree as the upstream
+* `USER_DSH_RANK` provider" a hard contract: upstream watches the EXPANDED
+* absolute `<home>/skills` while this value fed a literal `~/x` (a directory
+* named `~` under the host CWD) or a CWD-relative path — split-brain skill
+* trees, preset installs the platform never reads, doctor probes of a
+* directory nothing serves.
+* S2.2 (PLAN 2026-09-16), final correction: the result is ALWAYS
+* `resolve(expandHomePath(selected))` — the earlier form returned an
+* already-absolute value VERBATIM, so a trailing slash or `..` segment
+* landed unnormalized while upstream normalizes every value. Relative
+* `DSH_HOME` values change landing spot; a CLEAN absolute home stays
+* byte-identical (resolve is a no-op on it).
+*/
+function evolutionRoot(env = process.env) {
+	const fromEnv = env.DSH_HOME;
+	const selected = fromEnv !== void 0 && fromEnv.trim().length > 0 ? fromEnv : join(homedir(), ".dsh");
+	return resolve(selected === "~" ? homedir() : selected.startsWith("~/") || selected.startsWith("~\\") ? join(homedir(), selected.slice(2)) : selected);
+}
+/** Evolution home path helper: `$DSH_HOME/evolution` for plugin-owned sidecar
+* state (reports, activity store, feedback file, state-domain data). */
+function evolutionHome(env = process.env) {
+	return join(evolutionRoot(env), "evolution");
+}
+//#endregion
+//#region lib/types/proposal-report.js
+/** Directory for the one proposal lane; reports are retention-swept with the other run reports. */
+function proposalReportDir() {
+	return join(evolutionHome(), "reports");
+}
+/** Stable report filename for one proposal; the id may carry path separators. */
+function proposalReportName(proposal) {
+	return "extract-proposal-" + encodeURIComponent(proposal.id) + ".json";
+}
+/**
+* Persist one proposal as a report. Best-effort: a failed write never blocks the extract.
+* @param io - evolution IO seam.
+* @param proposal - proposal to persist.
+* @param dir - reports directory (tests pass a temp dir).
+* @returns the written path.
+*/
+async function writeProposalReport(io, proposal, dir = proposalReportDir()) {
+	const path = join(dir, proposalReportName(proposal));
+	await io.writeText(path, JSON.stringify(proposal));
+	return path;
+}
+function isProposal(value) {
+	if (value === null || typeof value !== "object") return false;
+	const candidate = value;
+	return candidate.version === 1 && typeof candidate.id === "string" && typeof candidate.source === "string" && (candidate.outcome === "keep" || candidate.outcome === "extract" || candidate.outcome === "mixed" || candidate.outcome === "owner-gap");
+}
+/**
+* Read the newest proposals. Missing/unreadable reports are skipped, never guessed.
+* @param io - evolution IO seam.
+* @param dir - reports directory.
+* @param limit - newest rows to return.
+* @returns valid proposals, newest filename first.
+*/
+async function readProposalReports(io, dir = proposalReportDir(), limit = 10) {
+	const listed = await probeList(io, dir);
+	if (isUnknown(listed) || !isPresent(listed)) return [];
+	const names = listed.value.filter((name) => name.startsWith("extract-proposal-") && name.endsWith(".json"));
+	names.sort((a, b) => b.localeCompare(a));
+	const proposals = [];
+	for (const name of names.slice(0, limit)) {
+		const raw = await probeText(io, join(dir, name));
+		if (!isPresent(raw)) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(raw.value);
+		} catch {
+			continue;
+		}
+		if (isProposal(parsed)) proposals.push(parsed);
+	}
+	return proposals;
+}
+//#endregion
+//#region lib/types/external-support.js
+const MAX_FILE_BYTES = 1024 * 1024;
+const MAX_TOTAL_BYTES = 4 * 1024 * 1024;
+function targetPathFor(ref) {
+	let value = ref.replace(/^\/+/, "");
+	while (value.startsWith("../")) value = value.slice(3);
+	const support = value.match(/(?:^|\/)(references|templates|scripts|assets)\/(.+)$/);
+	if (support !== null) return support[1] + "/" + support[2];
+	return "references/" + basename(value);
+}
+function annotate(content, originalPath) {
+	const note = "external source: " + originalPath;
+	const extension = originalPath.slice(originalPath.lastIndexOf(".")).toLowerCase();
+	if (extension === ".md") return "<!-- " + note + " -->\n\n" + content;
+	const prefix = extension === ".py" || extension === ".sh" || extension === ".rb" ? "# " : "// ";
+	if (extension === ".js" || extension === ".mjs" || extension === ".cjs" || extension === ".ts" || extension === ".tsx" || extension === ".py" || extension === ".sh" || extension === ".rb") {
+		if (content.startsWith("#!")) {
+			const end = content.indexOf(String.fromCharCode(10));
+			if (end >= 0) return content.slice(0, end + 1) + prefix + note + String.fromCharCode(10) + content.slice(end + 1);
+		}
+		return prefix + note + String.fromCharCode(10) + content;
+	}
+	return content;
+}
+function inside(root, candidate) {
+	const rel = relative(root, candidate);
+	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+/**
+* Read and annotate external support files under one explicit root. The caller owns
+* the root choice; this module only enforces containment, target-path safety, size
+* limits and determinism.
+* @param body - selected source markdown body.
+* @param sourceDir - source skill directory.
+* @param allowedRoot - canonical root external files must stay under.
+* @param targetFiles - existing target support paths.
+* @returns resolved external entries, or a refusal.
+*/
+async function readExternalSupport(body, sourceDir, allowedRoot, targetFiles) {
+	const refs = externalRefs(body);
+	if (refs.length === 0) return {
+		ok: true,
+		files: []
+	};
+	let root;
+	try {
+		root = await realpath(allowedRoot);
+	} catch {
+		return {
+			ok: false,
+			message: "external support 根目录不可读：" + allowedRoot
+		};
+	}
+	const files = [];
+	const targets = new Set(targetFiles);
+	let total = 0;
+	for (const ref of refs) {
+		const candidate = isAbsolute(ref) ? resolve(ref) : resolve(sourceDir, ref);
+		let canonical;
+		try {
+			canonical = await realpath(candidate);
+		} catch {
+			return {
+				ok: false,
+				message: "external support 文件不存在：" + ref
+			};
+		}
+		if (!inside(root, canonical)) return {
+			ok: false,
+			message: "external support 越界：" + ref
+		};
+		const info = await stat(canonical);
+		if (!info.isFile()) return {
+			ok: false,
+			message: "external support 不是普通文件：" + ref
+		};
+		if (info.size > MAX_FILE_BYTES) return {
+			ok: false,
+			message: "external support 超过单文件上限：" + ref
+		};
+		total += info.size;
+		if (total > MAX_TOTAL_BYTES) return {
+			ok: false,
+			message: "external support 超过总上限：" + ref
+		};
+		const targetPath = targetPathFor(ref);
+		if (targets.has(targetPath)) return {
+			ok: false,
+			message: "external support 目标冲突：" + targetPath
+		};
+		targets.add(targetPath);
+		const annotated = annotate(await readFile(canonical, "utf8"), canonical);
+		files.push({
+			ref,
+			originalPath: canonical,
+			targetPath,
+			content: annotated,
+			sha256: createHash("sha256").update(annotated).digest("hex"),
+			provenance: "external:" + canonical
+		});
+	}
+	return {
+		ok: true,
+		files
+	};
+}
+//#endregion
+//#region lib/types/extract-prompt.js
+/**
+* The frozen semantic prompt for skill extraction. One constant, consumed by
+* explicit extract agents and tests; it is deliberately not part of the review
+* prompt bundle, and no review path injects it.
+*/
+const EXTRACT_PROMPT_VERSION = "v1";
+const EXTRACT_PROMPT_V1 = `Inspect the source skill, its linked support files, and the candidate owners
+in the library. A part of the skill (one or more sections) is a separate
+capability when it has its own trigger and outcome, can be used without the
+parent context, and leaves the parent coherent. If it is separate and a
+class-level owner covers it, extract that part. If no owner covers it, report
+the owner gap and name the class-level owner that would be needed. If it mixes
+a reusable capability with parent-specific facts, return mixed and name only
+the reusable part. Otherwise keep it. Keep, extract, mixed, and owner-gap are
+all valid outcomes; no split is required.`;
+//#endregion
 //#region lib/types/cost.js
 /**
 * Context-cost accounting for skill bodies (design §5.2).
@@ -4469,78 +5283,27 @@ function fuzzyPatch(content, oldString, newString, replaceAll = false) {
 * Build the agent prompt for an open-ended `/evolution learn` request.
 *
 * @param userRequest free-text the user gave after `/evolution learn`; an
-*   empty string falls back to "the workflow we just went through".
-* @returns a complete instruction the agent runs as a normal turn.
-*/
-function buildLearnPrompt(userRequest) {
-	return [
-		"[/learn] The user wants you to learn a reusable skill from the request below, and save it.",
-		"",
-		"THE REQUEST:",
-		userRequest.trim() || "the workflow we just went through in this conversation — review the steps taken and distill them into a reusable skill",
-		"",
-		"The request is open-ended and may mix two kinds of content, in any order: SOURCES to gather (directories, file paths, URLs, \"what we just did\", pasted notes) AND REQUIREMENTS that shape the skill (what to focus on, what to leave out, scope, naming, the angle to take). Treat EVERY part of the request as load-bearing. In particular, prose that comes after a path or link is NOT incidental — it is the user telling you what they want from that source. A request like `<url> focus on the auth flow, skip the deprecated endpoints` means: gather the URL AND honor \"focus on auth, skip deprecated\" as authoring requirements. Never fetch the first source and ignore the rest.",
-		"",
-		"Do this:",
-		"1. Gather every source the user named, using the tools you already have — reads and searches for local files or directories, web access for URLs, this conversation history if they referred to something you just did, and the text they pasted as-is. If the request is ambiguous about scope, make a reasonable choice and note it; do not stall.",
-		"2. Author ONE SKILL.md, applying every requirement, focus, and constraint in the request — these govern what the SKILL.md covers and emphasizes, not just which sources you read.",
-		"3. Save it with the `skill_manage` tool (action=\"create\"). Pick a sensible category. If the procedure needs a non-trivial script, add it under the skill's `scripts/` with `skill_manage` write_file and reference it by relative path.",
-		"",
-		"Apply the skill-authoring standards (frontmatter, prose, file layout) carried by the `skill_manage` tool description — that is the single copy; do not restate them here.",
-		"",
-		"When done, tell the user the skill name, its category, and a one-line summary of what it captured."
-	].join("\n");
-}
-//#endregion
-//#region lib/types/state-store.js
-/**
-* Evolution home path helpers: the DSH root and `$DSH_HOME/evolution` for
-* plugin-owned sidecar state (reports, activity store, feedback file,
-* state-domain data).
-*
-* C-10: PATH HELPERS ONLY — despite the file name there is no store
-* here. Durable evolution state lives in the state stack (evolution-state over
-* evolution-state-json / -domain); skills and memories live in skill-store.ts
-* / memory-store.ts. The file name is kept deliberately: renaming it would
-* touch every family import for zero behavior change, and the audit records
-* the mismatch as known naming debt.
-*/
-/**
-* DSH home root: `$DSH_HOME` or `~/.dsh`. Single source of the empty-string
-* fallback — an EMPTY or WHITESPACE-ONLY DSH_HOME resolves to the default
-* home, never to a CWD-relative path (0.3.19 W1.3, 0.3.22 F-207);
-* V8-06 (0.3.47) extends the guard to whitespace.
-* C-11 correction (S2.2, PLAN 2026-09-16): upstream `resolveDshHome`
-* (util/home-paths) uses `trim()` ONLY as the ADOPTION test and then uses the
-* RAW env value — the earlier "same trimmed source" form returned the trimmed
-* text, so `DSH_HOME=" /x "` produced `/x` where upstream produced the literal
-* padded path. The value semantics now match upstream line for line:
-* `const selected = configured ?? (fromEnv !== undefined &&
-* fromEnv.trim().length > 0 ? fromEnv : defaultDshHome())`.
-* OPT-27 (2026-09, plan D5 — accepted): the v10-era "no `~` expansion, no
-* resolve" divergence from upstream `resolveDshHome` is RETIRED. It became
-* load-bearing when the skill-catalog shadow made "same tree as the upstream
-* `USER_DSH_RANK` provider" a hard contract: upstream watches the EXPANDED
-* absolute `<home>/skills` while this value fed a literal `~/x` (a directory
-* named `~` under the host CWD) or a CWD-relative path — split-brain skill
-* trees, preset installs the platform never reads, doctor probes of a
-* directory nothing serves.
-* S2.2 (PLAN 2026-09-16), final correction: the result is ALWAYS
-* `resolve(expandHomePath(selected))` — the earlier form returned an
-* already-absolute value VERBATIM, so a trailing slash or `..` segment
-* landed unnormalized while upstream normalizes every value. Relative
-* `DSH_HOME` values change landing spot; a CLEAN absolute home stays
-* byte-identical (resolve is a no-op on it).
+*   empty string falls back to "the workflow we just went through".
+* @returns a complete instruction the agent runs as a normal turn.
 */
-function evolutionRoot(env = process.env) {
-	const fromEnv = env.DSH_HOME;
-	const selected = fromEnv !== void 0 && fromEnv.trim().length > 0 ? fromEnv : join(homedir(), ".dsh");
-	return resolve(selected === "~" ? homedir() : selected.startsWith("~/") || selected.startsWith("~\\") ? join(homedir(), selected.slice(2)) : selected);
-}
-/** Evolution home path helper: `$DSH_HOME/evolution` for plugin-owned sidecar
-* state (reports, activity store, feedback file, state-domain data). */
-function evolutionHome(env = process.env) {
-	return join(evolutionRoot(env), "evolution");
+function buildLearnPrompt(userRequest) {
+	return [
+		"[/learn] The user wants you to learn a reusable skill from the request below, and save it.",
+		"",
+		"THE REQUEST:",
+		userRequest.trim() || "the workflow we just went through in this conversation — review the steps taken and distill them into a reusable skill",
+		"",
+		"The request is open-ended and may mix two kinds of content, in any order: SOURCES to gather (directories, file paths, URLs, \"what we just did\", pasted notes) AND REQUIREMENTS that shape the skill (what to focus on, what to leave out, scope, naming, the angle to take). Treat EVERY part of the request as load-bearing. In particular, prose that comes after a path or link is NOT incidental — it is the user telling you what they want from that source. A request like `<url> focus on the auth flow, skip the deprecated endpoints` means: gather the URL AND honor \"focus on auth, skip deprecated\" as authoring requirements. Never fetch the first source and ignore the rest.",
+		"",
+		"Do this:",
+		"1. Gather every source the user named, using the tools you already have — reads and searches for local files or directories, web access for URLs, this conversation history if they referred to something you just did, and the text they pasted as-is. If the request is ambiguous about scope, make a reasonable choice and note it; do not stall.",
+		"2. Author ONE SKILL.md, applying every requirement, focus, and constraint in the request — these govern what the SKILL.md covers and emphasizes, not just which sources you read.",
+		"3. Save it with the `skill_manage` tool (action=\"create\"). Pick a sensible category. If the procedure needs a non-trivial script, add it under the skill's `scripts/` with `skill_manage` write_file and reference it by relative path.",
+		"",
+		"Apply the skill-authoring standards (frontmatter, prose, file layout) carried by the `skill_manage` tool description — that is the single copy; do not restate them here.",
+		"",
+		"When done, tell the user the skill name, its category, and a one-line summary of what it captured."
+	].join("\n");
 }
 //#endregion
 //#region lib/types/serial.js
@@ -5710,8 +6473,8 @@ async function recordMutation(root, io, record, cap = 500) {
 * changes semantically: the bundle digest is the fail-closed signal for
 * review workers, so a stale id across deployments must be distinguishable.
 */
-const PROMPT_BUNDLE_VERSION = 21;
-const PROMPT_BUNDLE_ID = `dsh-evolution@21`;
+const PROMPT_BUNDLE_VERSION = 22;
+const PROMPT_BUNDLE_ID = `dsh-evolution@22`;
 const MEMORY_REVIEW_PROMPT = `[Auto-review — Memory]
 Review the conversation above and consider saving to memory if appropriate.
 
@@ -5722,10 +6485,12 @@ Focus on:
 If something stands out, save it using the memory tool.
 If nothing is worth saving, just say "Nothing to save." and stop.`;
 const SKILL_REVIEW_PROMPT = `[Auto-review — Skills]
-Review the conversation above and update the skill library. Be ACTIVE — most sessions produce at least one skill update, even if small. A pass that does nothing is a missed learning opportunity, not a neutral outcome.
+Review the conversation above and update the skill library. Be ACTIVE — inspect the session and the existing library thoroughly, and prefer a small, precise update when the session teaches something durable. Activity is not a quota: a precise no-op after checking is better than a vague or forced entry.
 
 Target shape of the library: CLASS-LEVEL skills, each with a rich SKILL.md and a references/ directory for session-specific detail. Not a long flat list of narrow one-session-one-skill entries. This shapes HOW you update, not WHETHER you update.
 
+A skill body is a reusable decision rule (when / do / check); dates, versions, incident narratives, and one-off evidence belong in references when they would otherwise dominate the body.
+
 Signals to look for (any one of these warrants action):
   • User corrected your style, tone, format, legibility, or verbosity. Frustration signals like 'stop doing X', 'this is too verbose', 'don't format like this', 'why are you explaining', 'just give me the answer', 'you always do Y and I hate it', or an explicit 'remember this' are FIRST-CLASS skill signals, not just memory signals. Update the relevant skill(s) to embed the preference so the next session starts already knowing.
   • User corrected your workflow, approach, or sequence of steps. Encode the correction as a pitfall or explicit step in the skill that governs that class of task.
@@ -5743,7 +6508,7 @@ Preference order — prefer the earliest action that fits, but do pick one when
      • scripts/<name>.<ext> — statically re-runnable actions the skill can invoke directly (verification scripts, fixture generators, deterministic probes, anything the agent should run rather than hand-type each time).
      Add support files via skill_manage action=write_file with file_path starting 'references/', 'templates/', or 'scripts/'. The umbrella's SKILL.md should gain a one-line pointer to any new support file so future agents know it exists.
   4. RESTRUCTURE a loaded skill whose body grew log-like — rc/sha/date-dense sections, session-detail spirals, or a fat body with no support files. Use skill_manage action=restructure with restructure: [{"heading": "<the exact ## heading text>", "to_file": "references/<topic>.md"}] — the ENTIRE ## section (from that heading to the next heading) moves into the support file and its position becomes a pointer line. The skill's name and directory never change. Only propose headings that exist verbatim in the body; never invent one, and never restructure a healthy small skill.
-  5. CREATE A NEW CLASS-LEVEL UMBRELLA SKILL when no existing skill covers the class. The name MUST be at the class level. The name MUST NOT be a specific PR number, error string, feature codename, library-alone name, or 'fix-X / debug-Y / audit-Z-today' session artifact. If the proposed name only makes sense for today's task, it's wrong — fall back to (1), (2), or (3).
+  5. CREATE A NEW CLASS-LEVEL UMBRELLA SKILL only when no existing class-level skill covers the class and no existing umbrella can absorb the learning. The name MUST be at the class level. The name MUST NOT be a specific PR number, error string, feature codename, library-alone name, or 'fix-X / debug-Y / audit-Z-today' session artifact. If the proposed name only makes sense for today's task, it's wrong — fall back to (1), (2), or (3).
 
 User-preference embedding (important): when the user expressed a style/format/workflow preference, the update belongs in the SKILL.md body, not just in memory. Memory captures 'who the user is and what the current situation and state of your operations are'; skills capture 'how to do this class of task for this user'. When they complain about how you handled a task, the skill that governs that task needs to carry the lesson.
 
@@ -5767,16 +6532,18 @@ Do NOT capture (these become persistent self-imposed constraints that bite you l
 
 If a tool failed because of setup state, capture the FIX (install command, config step, env var to set) under an existing setup or troubleshooting skill — never 'this tool does not work' as a standalone constraint.
 
-'Nothing to save.' is a real option but should NOT be the default. If the session ran smoothly with no corrections and produced no new technique, just say 'Nothing to save.' and stop. Otherwise, act.`;
+'Nothing to save.' is a real option but should NOT be the default. If the session ran smoothly with no corrections and produced no new technique, state what you checked and stop. Otherwise, act.`;
 const COMBINED_REVIEW_PROMPT = `[Auto-review]
 Review the conversation above and update two things:
 
 **Memory**: who the user is. Did the user reveal persona, desires, preferences, personal details, or expectations about how you should behave? Save facts about the user and durable preferences with the memory tool.
 
-**Skills**: how to do this class of task. Be ACTIVE — most sessions produce at least one skill update. A pass that does nothing is a missed learning opportunity, not a neutral outcome.
+**Skills**: how to do this class of task. Be ACTIVE — inspect the session and the existing library thoroughly, and prefer a small, precise update when the session teaches something durable. Activity is not a quota: a precise no-op after checking is better than a vague or forced entry.
 
 Target shape of the skill library: CLASS-LEVEL skills with a rich SKILL.md and a references/ directory for session-specific detail. Not a long flat list of narrow one-session-one-skill entries.
 
+A skill body is a reusable decision rule (when / do / check); dates, versions, incident narratives, and one-off evidence belong in references when they would otherwise dominate the body.
+
 Signals that warrant a skill update (any one is enough):
   • User corrected your style, tone, format, legibility, verbosity, or approach. Frustration is a FIRST-CLASS skill signal, not just a memory signal. 'stop doing X', 'don't format like this', 'I hate when you Y' — embed the lesson in the skill that governs that task so the next session starts fixed.
   • Non-trivial technique, fix, workaround, or debugging path emerged.
@@ -5789,7 +6556,7 @@ Preference order for skills — pick the earliest that fits:
   2. UPDATE AN EXISTING UMBRELLA. Patch it.
   3. ADD A SUPPORT FILE under an existing umbrella via skill_manage action=write_file. Three kinds: references/<topic>.md for session-specific detail OR condensed knowledge banks (quoted research, API docs excerpts, domain notes) written concise and task-focused; templates/<name>.<ext> for starter files meant to be copied and modified; scripts/<name>.<ext> for statically re-runnable actions (verification, fixture generators, probes). Add a one-line pointer in SKILL.md so future agents find them.
   4. RESTRUCTURE a loaded skill whose body grew log-like (rc/sha/date-dense sections, session-detail spirals, fat body with no support files) via skill_manage action=restructure with restructure: [{"heading": "<the exact ## heading text>", "to_file": "references/<topic>.md"}] — the ENTIRE ## section moves into the support file and its position becomes a pointer line; the skill's name and directory never change. Only propose headings that exist verbatim in the body.
-  5. CREATE A NEW CLASS-LEVEL UMBRELLA when nothing exists. Name at the class level — NOT a PR number, error string, codename, library-alone name, or 'fix-X / debug-Y' session artifact. If the name only fits today's task, fall back to (1), (2), or (3).
+  5. CREATE A NEW CLASS-LEVEL UMBRELLA only when no existing class-level skill covers the class and no existing umbrella can absorb the learning. Name at the class level — NOT a PR number, error string, codename, library-alone name, or 'fix-X / debug-Y' session artifact. If the name only fits today's task, fall back to (1), (2), or (3).
 
 Two-tier deposition discipline (DSH addition): classify before writing — PATTERN (symptom → mechanism → fix → verification) goes in the SKILL.md body; LOG (commit SHAs, npm/profile states, this release's change list, this session's narrative) goes in a references/ file. Body density IS reuse rate; a pattern fits in 2-8 physical lines.
 
@@ -5876,11 +6643,48 @@ Your output IS the deliverable: produce the exact same human-readable summary an
 
 If you accidentally take a mutating action, say so explicitly in the summary.`;
 const COMPLETION_SKILL_REVIEW_PROMPT = `[Auto-review — Skills · task complete]
-Your current task now appears complete. Before wrapping up, review the approach and update the skill library via skill_manage.
+Review the conversation above and update the skill library. Be ACTIVE — inspect the session and the existing library thoroughly, and prefer a small, precise update when the session teaches something durable. Activity is not a quota: a precise no-op after checking is better than a vague or forced entry.
+
+Target shape of the library: CLASS-LEVEL skills, each with a rich SKILL.md and a \`references/\` directory for session-specific detail. Not a long flat list of narrow one-session-one-skill entries. This shapes HOW you update, not WHETHER you update.
 
-Follow the skills review policy: be ACTIVE, prefer class-level umbrellas, patch ONLY skills loaded or read this session, and capture non-trivial techniques and user corrections. Do NOT capture environment-dependent failures, negative claims about tools, or one-off task narratives.
+A skill body is a reusable decision rule (when / do / check); dates, versions, incident narratives, and one-off evidence belong in references when they would otherwise dominate the body.
 
-Do NOT modify output files or re-run the task. If you are still mid-task, ignore this.`;
+Signals to look for (any one of these warrants action):
+  • User corrected your style, tone, format, legibility, or verbosity. Frustration signals like 'stop doing X', 'this is too verbose', 'don't format like this', 'why are you explaining', 'just give me the answer', 'you always do Y and I hate it', or an explicit 'remember this' are FIRST-CLASS skill signals, not just memory signals. Update the relevant skill(s) to embed the preference so the next session starts already knowing.
+  • User corrected your workflow, approach, or sequence of steps. Encode the correction as a pitfall or explicit step in the skill that governs that class of task.
+  • Non-trivial technique, fix, workaround, debugging path, or tool-usage pattern emerged that a future session would benefit from. Capture it.
+  • A skill that got loaded or consulted this session turned out to be wrong, missing a step, or outdated. Patch it NOW.
+
+Preference order — prefer the earliest action that fits, but do pick one when a signal above fired:
+  1. UPDATE A CURRENTLY-LOADED SKILL. Look back through the conversation for skills the user loaded via /skill-name or you read via skill. If any of them covers the territory of the new learning, PATCH that one first. It is the skill that was in play, so it's the right one to extend.
+  2. UPDATE AN EXISTING UMBRELLA (via the skill catalog + skill). If no loaded skill fits but an existing class-level skill does, patch it. Add a subsection, a pitfall, or broaden a trigger.
+  3. ADD A SUPPORT FILE under an existing umbrella. Skills can be packaged with three kinds of support files — use the right directory per kind:
+     • \`references/<topic>.md\` — session-specific detail (error transcripts, reproduction recipes, provider quirks) AND condensed knowledge banks: quoted research, API docs, external authoritative excerpts, or domain notes you found while working on the problem. Write it concise and for the value of the task, not as a full mirror of upstream docs.
+     • \`templates/<name>.<ext>\` — starter files meant to be copied and modified (boilerplate configs, scaffolding, a known-good example the agent can \`reproduce with modifications\`).
+     • \`scripts/<name>.<ext>\` — statically re-runnable actions the skill can invoke directly (verification scripts, fixture generators, deterministic probes, anything the agent should run rather than hand-type each time).
+     Add support files via skill_manage action=write_file with file_path starting 'references/', 'templates/', or 'scripts/'. The umbrella's SKILL.md should gain a one-line pointer to any new support file so future agents know it exists.
+  4. CREATE A NEW CLASS-LEVEL UMBRELLA SKILL only when no existing class-level skill covers the class and no existing umbrella can absorb the learning. The name MUST be at the class level. The name MUST NOT be a specific PR number, error string, feature codename, library-alone name, or 'fix-X / debug-Y / audit-Z-today' session artifact. If the proposed name only makes sense for today's task, it's wrong — fall back to (1), (2), or (3).
+
+User-preference embedding (important): when the user expressed a style/format/workflow preference, the update belongs in the SKILL.md body, not just in memory. Memory captures 'who the user is and what the current situation and state of your operations are'; skills capture 'how to do this class of task for this user'. When they complain about how you handled a task, the skill that governs that task needs to carry the lesson.
+
+If you notice two existing skills that overlap, note it in your reply — the background curator handles consolidation at scale.
+
+Protected skills (DO NOT edit these):
+  • Bundled skills (shipped with the platform).
+  • Hub-installed skills (installed via the platform hub).
+Pinned skills (marked via skill_manage pin) are read-only to THIS background review pass — the pinned write guard refuses background changes, so this pass may not update them. They also cannot be archived by any writer (the foreground included): remove the .pinned marker first. Foreground and delegated-subagent update/patch writes to pinned skills remain allowed.
+If the only skills that need updating are protected, say
+'Nothing to save.' and stop.
+
+Do NOT capture (these become persistent self-imposed constraints that bite you later when the environment changes):
+  • Environment-dependent failures: missing binaries, fresh-install errors, post-migration path mismatches, 'command not found', unconfigured credentials, uninstalled packages. The user can fix these — they are not durable rules.
+  • Negative claims about tools or features ('browser tools do not work', 'X tool is broken', 'cannot use Y from execute_code'). These harden into refusals the agent cites against itself for months after the actual problem was fixed.
+  • Session-specific transient errors that resolved before the conversation ended. If retrying worked, the lesson is the retry pattern, not the original failure.
+  • One-off task narratives. A user asking 'summarize today's market' or 'analyze this PR' is not a class of work that warrants a skill.
+
+If a tool failed because of setup state, capture the FIX (install command, config step, env var to set) under an existing setup or troubleshooting skill — never 'this tool does not work' as a standalone constraint.
+
+'Nothing to save.' is a real option but should NOT be the default. If the session ran smoothly with no corrections and produced no new technique, state what you checked and stop. Otherwise, act.`;
 /**
 * Maintenance-subagent persona (design 011 §6). Constants pin the persona
 * with `{signal:id}` placeholders; the renderer substitutes names from the
@@ -6002,12 +6806,12 @@ function sha256(text) {
 function createPromptBundle(prompts) {
 	const canonical = JSON.stringify({
 		id: PROMPT_BUNDLE_ID,
-		version: 21,
+		version: 22,
 		prompts: Object.fromEntries(Object.entries(prompts).sort())
 	});
 	return Object.freeze({
 		id: PROMPT_BUNDLE_ID,
-		version: 21,
+		version: 22,
 		prompts: Object.freeze({ ...prompts }),
 		sha256: sha256(canonical)
 	});
@@ -6026,10 +6830,10 @@ const PROMPT_BUNDLE = createPromptBundle({
 	skillsGuidance: SKILLS_GUIDANCE
 });
 function verifyPromptBundle(bundle = PROMPT_BUNDLE) {
-	if (bundle.id !== PROMPT_BUNDLE_ID || bundle.version !== 21) return false;
+	if (bundle.id !== PROMPT_BUNDLE_ID || bundle.version !== 22) return false;
 	const canonical = JSON.stringify({
 		id: PROMPT_BUNDLE_ID,
-		version: 21,
+		version: 22,
 		prompts: Object.fromEntries(Object.entries(bundle.prompts).sort())
 	});
 	return bundle.sha256 === sha256(canonical);
@@ -7012,6 +7816,7 @@ const CONTENT_ACTIONS = [
 	"patch",
 	"consolidate",
 	"restructure",
+	"extract",
 	"restore",
 	"merge"
 ];
@@ -7419,6 +8224,7 @@ function versionActionKind(action) {
 		case "archive": return "archive";
 		case "consolidate": return "consolidate";
 		case "restructure": return "restructure";
+		case "extract": return "extract";
 		case "merge": return "merge";
 		case "write_file": return "support-write";
 		case "remove_file": return "support-remove";
@@ -9483,7 +10289,8 @@ const READ_REQUIRED_ACTIONS = Object.freeze([
 	"delete",
 	"write_file",
 	"remove_file",
-	"restructure"
+	"restructure",
+	"extract"
 ]);
 /**
 * Does this one op write a skill the caller never read?
@@ -9694,95 +10501,6 @@ function skillRowCells(skill) {
 	};
 }
 //#endregion
-//#region lib/types/document-body.js
-/**
-* What the panel shows when it renders one version as a document.
-*
-* Two decisions, both made here so the preview and the rendered diff cannot drift apart:
-*
-*  - FRONTMATTER IS NOT DOCUMENT TEXT. A SKILL.md opens with a YAML block; the renderer read its
-*    closing `---` as a setext underline, so the metadata line became the document's biggest heading
-*    and the real title sat below it (measured on the installed panel 2026-09-28). The block is
-*    stripped for DISPLAY only: the raw view and the body route still carry every byte, and the
-*    panel already shows the name and description on the row and in the left column.
-*  - STRIPPING FAILS OPEN. Only a block that the family's own reader accepts is removed. A document
-*    whose text merely starts with a thematic break, a block with no closing line, or a frontmatter
-*    whose body is empty is returned UNCHANGED — showing a document's first line is always better
-*    than showing nothing.
-*
-* `readingStats` exists for the other half of the reader's honesty: a preview that stops early has
-* to be able to say HOW much it is not showing.
-* @module @lmzhen/dsh-evolution-core/document-body
-*/
-/**
-* The document a reader sees: the body without its leading frontmatter block.
-* @param content - the stored bytes of one version.
-* @returns the text to render; unchanged when there is no frontmatter the reader accepts.
-*/
-function displayBodyOf(content) {
-	const block = frontmatterBlock(content);
-	if (block === null) return content;
-	if (parseFrontmatter(content) === null) return content;
-	return block.lines.slice(block.end + 1).join("\n").replace(/^\s*\n/, "");
-}
-/**
-* How much of a version the panel is showing.
-* @param full - the whole stored text.
-* @param shown - the part the route handed over.
-* @returns the counts, so the panel can say what it is not showing.
-*/
-function readingStats(full, shown) {
-	return {
-		totalChars: full.length,
-		shownChars: shown.length,
-		truncated: shown.length < full.length
-	};
-}
-/**
-* The H2 sections of a body, in document order — the ONE scan (G3).
-*
-* Both the restructure candidate list and the store anchor validation call this function, so a
-* candidate can only name a heading that exists EXACTLY ONCE and has content: the two rejections a
-* hand-written anchor used to hit ("no such heading", "ambiguous anchor") stop being reachable.
-* H2 is the section boundary (a section spans to the next H2 or EOF), matching the store.
-* @param body - the markdown after the frontmatter block.
-* @returns one row per H2 heading, with `count` filled in a second pass.
-*/
-function h2Sections(body) {
-	const lines = body.split(String.fromCharCode(10));
-	const rows = [];
-	for (let i = 0; i < lines.length; i += 1) {
-		const match = /^#{2}\s+(.+?)\s*$/.exec(lines[i] ?? "");
-		if (match === null) continue;
-		const title = (match[1] ?? "").trim();
-		let end = lines.length;
-		for (let j = i + 1; j < lines.length; j += 1) if (/^#{2}\s/.test(lines[j] ?? "")) {
-			end = j;
-			break;
-		}
-		rows.push({
-			title,
-			start: i,
-			end,
-			count: 0
-		});
-	}
-	for (const row of rows) row.count = rows.filter((other) => other.title === row.title).length;
-	return rows;
-}
-/**
-* The sections a restructure proposal may name: heading unique, section non-empty. Derived from
-* `h2Sections`, i.e. from the SAME scan the store validates against.
-* @param body - the markdown after the frontmatter block.
-* @returns move-ready pairs in document order; empty when nothing qualifies.
-*/
-function restructureCandidates(body) {
-	return h2Sections(body).filter((section) => section.count === 1 && section.end > section.start + 1).map((section) => ({
-		heading: section.title,
-		toFile: "references/" + section.title.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "-").replace(/^-+|-+$/g, "") + ".md"
-	}));
-}
-//#endregion
 //#region lib/types/drift-signals.js
 /**
 * Library-level drift signals for the maintenance subagent (design 011).
@@ -10585,48 +11303,20 @@ function validateSupportPath(filePath) {
 	}
 	return null;
 }
-/**
-* Support-directory references in a markdown body (009 kernel): `references/…`,
-* `templates/…`, `scripts/…`, `assets/…` relative links — any extension and
-* nested paths (v7 audit P3-1: `.md`-only matching missed `scripts/run.sh` and
-* `references/sub/x.md`, both of which dangle just like a `.md` link once the
-* source package is archived). Pure — who checks them and what the verdict is
-* belongs to the caller's context (a moved/appended body whose references
-* travel with an archived source is a dangling link; a restructure pointer is
-* a fresh link to a file written in the same plan). `..` traversal is a
-* different defect class (path validation owns it) and is not a support link.
-*/
-function supportRefs(content) {
-	const refs = [];
-	for (const match of content.matchAll(/\b(?:references|templates|scripts|assets)\/[A-Za-z0-9._/-]+/g)) {
-		const ref = match[0];
-		if (ref.includes("..")) continue;
-		refs.push(ref);
-	}
-	return refs;
-}
 function planRestructureSections(body, moves) {
+	const selection = selectSections(body, moves.map((move) => ({ heading: move.heading })));
+	if (!selection.ok) return { error: selection.message };
 	const lines = body.split("\n");
-	const sections = h2Sections(body);
-	const spans = [];
-	for (const move of moves) {
-		const wanted = move.heading.trim();
-		const matching = sections.filter((section) => section.title === wanted);
-		if (matching.length === 0) return { error: `no "## ${wanted}" heading in the body` };
-		if (matching.length > 1) return { error: `heading "## ${wanted}" appears ${matching.length} times (ambiguous anchor)` };
-		const section = matching[0];
-		if (section === void 0) return { error: `no "## ${wanted}" heading in the body` };
-		const { start, end } = section;
-		if (end === start + 1) return { error: `heading "## ${wanted}" has an empty section` };
-		if (spans.some((span) => start === span.start)) return { error: `heading "## ${wanted}" is moved twice` };
-		spans.push({
-			start,
-			end,
-			rel: move.toFile,
-			heading: wanted,
-			text: lines.slice(start, end).join("\n")
-		});
-	}
+	const spans = selection.sections.map((section) => {
+		const move = moves[section.requestIndex];
+		return {
+			start: section.start,
+			end: section.end,
+			rel: move?.toFile ?? "",
+			heading: section.heading,
+			text: section.text
+		};
+	});
 	const byStart = new Map(spans.map((span) => [span.start, span]));
 	const rebuilt = [];
 	for (let i = 0; i < lines.length; i += 1) {
@@ -12721,48 +13411,245 @@ var SkillLibrary = class {
 	* restructure (and future reference-mode consolidations) never implement
 	* two-phase commit themselves.
 	*/
-	async applyTreeChange(plan) {
-		const name = plan.name.trim();
-		const badName = this.badName(name, { allowReserved: true });
-		if (badName) return {
+	/**
+	* Apply one G1 ExtractPlan as one cross-skill unit. This is a thin adapter:
+	* selection, residual, pointer and support closure were already decided by
+	* planExtract; this method only projects them into ordered kernel operations.
+	* @param plan - pure plan from extract-plan.ts.
+	* @param origin - write face recorded in the audit ledger.
+	* @returns the kernel result; a refusal writes nothing.
+	*/
+	async extract(plan, origin = this.authority.origin) {
+		if (plan.outcome === "owner-gap" || plan.owner.mode !== "covered") return {
 			ok: false,
-			message: badName
+			message: "提取被拒绝：owner-gap 不是写操作。"
 		};
-		const dir = this.dirOf(name);
-		if (!await this.io.readText(join(dir, "SKILL.md"))) return {
+		if (plan.support.unresolved.length > 0 || plan.support.dangling.length > 0) return {
 			ok: false,
-			message: `技能「${name}」不存在。`
+			message: "提取被拒绝：support closure 存在 unresolved/dangling。"
 		};
-		const protection = plan.protection === "write" ? await this.writeProtection(name, plan.origin) : plan.protection === "delete" ? await this.deleteProtection(name) : null;
-		if (protection) return {
+		if (plan.parts.length === 0) return {
 			ok: false,
-			message: `技能「${name}」受保护（${protection}）。`
+			message: "提取被拒绝：没有 part。"
+		};
+		const source = plan.source.trim();
+		const target = plan.target.name.trim();
+		if (source === target) return {
+			ok: false,
+			message: "提取被拒绝：source 与 target 相同。"
+		};
+		if (plan.target.exists !== true) return {
+			ok: false,
+			message: "提取被拒绝：target 不存在；owner-gap 不自动 create。"
+		};
+		const sourceDir = this.dirOf(source);
+		const targetDir = this.dirOf(target);
+		const sourceMd = await this.io.readText(join(sourceDir, "SKILL.md"));
+		const targetMd = await this.io.readText(join(targetDir, "SKILL.md"));
+		if (sourceMd === null) return {
+			ok: false,
+			message: "技能「" + source + "」不存在。"
+		};
+		if (targetMd === null) return {
+			ok: false,
+			message: "技能「" + target + "」不存在。"
+		};
+		if (plan.anchors !== void 0) {
+			const sourceHash = contentHash(sourceMd);
+			const targetHash = contentHash(targetMd);
+			if (sourceHash !== plan.anchors.sourceMdSha256 || targetHash !== plan.anchors.targetMdSha256) return {
+				ok: false,
+				message: "提取被拒绝：source/target 在计划之后发生了变化；请重新计划。"
+			};
+		}
+		const projected = projectExtractBodies(plan, sourceMd, targetMd);
+		if (!projected.ok) return {
+			ok: false,
+			message: "提取被拒绝：" + projected.message
+		};
+		const sourceNew = projected.projection.sourceAfter;
+		const targetNew = projected.projection.targetAfter;
+		const ops = [];
+		for (const move of [...plan.support.shared, ...plan.support.exclusive]) {
+			const fromPath = join(sourceDir, ...move.from.split("/"));
+			const toPath = join(targetDir, ...move.to.split("/"));
+			const content = await this.io.readText(fromPath);
+			if (content === null) return {
+				ok: false,
+				message: "提取被拒绝：support 文件不存在 " + move.from
+			};
+			const previous = await this.readForCas(toPath);
+			ops.push({
+				kind: "write",
+				target: toPath,
+				content,
+				expected: previous,
+				skill: target
+			});
+		}
+		for (const file of plan.support.external) {
+			if (file.content === void 0) return {
+				ok: false,
+				message: "提取被拒绝：external support 缺少已验证的内容 " + file.from
+			};
+			if (file.to.startsWith("/") || file.to.includes("..") || !/^(?:references|templates|scripts|assets)\//.test(file.to)) return {
+				ok: false,
+				message: "提取被拒绝：external target 不安全 " + file.to
+			};
+			const toPath = join(targetDir, ...file.to.split("/"));
+			const previous = await this.readForCas(toPath);
+			ops.push({
+				kind: "write",
+				target: toPath,
+				content: file.content,
+				expected: previous,
+				skill: target
+			});
+		}
+		ops.push({
+			kind: "write",
+			target: join(targetDir, "SKILL.md"),
+			content: targetNew,
+			expected: targetMd,
+			skill: target
+		});
+		for (const move of plan.support.exclusive) {
+			const sourcePath = join(sourceDir, ...move.from.split("/"));
+			const previous = await this.readForCas(sourcePath);
+			if (previous === null) return {
+				ok: false,
+				message: "提取被拒绝：待删除 support 不存在 " + move.from
+			};
+			ops.push({
+				kind: "delete",
+				target: sourcePath,
+				expected: previous,
+				skill: source
+			});
+		}
+		ops.push({
+			kind: "write",
+			target: join(sourceDir, "SKILL.md"),
+			content: sourceNew,
+			expected: sourceMd,
+			skill: source
+		});
+		return this.applyTreeChange({
+			name: source,
+			origin,
+			protection: "write",
+			roots: [{
+				name: source,
+				protection: "write"
+			}, {
+				name: target,
+				protection: "write"
+			}],
+			writes: [],
+			ops,
+			auditAction: "extract",
+			auditSummary: "extract " + plan.parts.map((part) => part.heading).join(", ") + " from " + source + " to " + target,
+			eventAction: "extract"
+		});
+	}
+	async applyTreeChange(plan) {
+		const primaryName = plan.name.trim();
+		const declared = plan.roots ?? [{
+			name: primaryName,
+			protection: plan.protection
+		}];
+		const roots = [];
+		for (const root of declared) {
+			const name = root.name.trim();
+			if (roots.some((entry) => entry.name === name)) return {
+				ok: false,
+				message: "目录树变更声明了重复的根「" + name + "」。"
+			};
+			const badName = this.badName(name, { allowReserved: true });
+			if (badName) return {
+				ok: false,
+				message: badName
+			};
+			const dir = this.dirOf(name);
+			if (!await this.io.readText(join(dir, "SKILL.md"))) return {
+				ok: false,
+				message: "技能「" + name + "」不存在。"
+			};
+			const protection = root.protection === "write" ? await this.writeProtection(name, plan.origin) : root.protection === "delete" ? await this.deleteProtection(name) : null;
+			if (protection) return {
+				ok: false,
+				message: "技能「" + name + "」受保护（" + protection + "）。"
+			};
+			roots.push({
+				name,
+				protection: root.protection,
+				dir
+			});
+		}
+		if (!roots.some((root) => root.name === primaryName)) return {
+			ok: false,
+			message: "目录树变更的 primary skill「" + primaryName + "」不在 roots 中。"
+		};
+		const provided = plan.ops ?? [...plan.writes.map((write) => ({
+			kind: "write",
+			...write
+		})), ...(plan.deletes ?? []).map((del) => ({
+			kind: "delete",
+			...del
+		}))];
+		if (provided.length === 0) return {
+			ok: false,
+			message: "目录树变更为空。"
 		};
 		const landing = [];
-		for (const write of plan.writes) {
+		for (const op of provided) {
+			const owner = roots.find((root) => {
+				const rel = relative(root.dir, op.target);
+				return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+			});
+			if (owner === void 0) return {
+				ok: false,
+				message: "目标不属于任何声明的技能根：" + op.target
+			};
+			const skill = op.skill ?? owner.name;
+			if (!roots.some((root) => root.name === skill)) return {
+				ok: false,
+				message: "目标声明的技能「" + skill + "」不在 roots 中：" + op.target
+			};
 			let previous;
 			try {
-				previous = await this.io.readText(write.target);
+				previous = await this.io.readText(op.target);
 			} catch (error) {
 				return {
 					ok: false,
-					message: `拒绝目录树变更：无法安全预读 ${write.target}（${error instanceof Error ? error.message : String(error)}）；未执行任何写入`
+					message: "拒绝目录树变更：无法安全预读 " + op.target + "（" + (error instanceof Error ? error.message : String(error)) + "）；未执行任何写入"
 				};
 			}
-			if (Buffer.byteLength(write.content, "utf8") > this.limits.maxSkillFileBytes) return {
-				ok: false,
-				message: `写入超过 ${this.limits.maxSkillFileBytes} 字节：${write.target}`
-			};
-			const threat = this.contentThreatBlock(write.content);
-			if (threat) return {
+			if (op.kind === "delete" && previous === null) return {
 				ok: false,
-				message: threat
+				message: "拒绝目录树变更：删除目标不存在 " + op.target
 			};
+			if (op.kind === "write") {
+				if (Buffer.byteLength(op.content, "utf8") > this.limits.maxSkillFileBytes) return {
+					ok: false,
+					message: "写入超过 " + this.limits.maxSkillFileBytes + " 字节：" + op.target
+				};
+				const threat = this.contentThreatBlock(op.content);
+				if (threat) return {
+					ok: false,
+					message: threat
+				};
+			}
+			const rel = relative(owner.dir, op.target).split(String.fromCharCode(92)).join("/");
 			landing.push({
-				target: write.target,
-				content: write.content,
+				kind: op.kind,
+				target: op.target,
+				content: op.kind === "write" ? op.content : null,
 				previous,
-				expected: write.expected
+				expected: op.expected,
+				skill,
+				dir: owner.dir,
+				rel
 			});
 		}
 		const written = [];
@@ -12781,11 +13668,12 @@ var SkillLibrary = class {
 								drift.seen = true;
 								return current;
 							}
-							return entry.content;
+							return entry.kind === "delete" ? null : entry.content;
 						});
-						if (!ran.done) throw new Error(`internal error: the write transaction for ${entry.target} did not invoke the task; nothing was written`);
-						if (drift.seen) throw new Error(`concurrent modification detected: ${entry.target} changed after the plan was computed (a concurrent writer won the race); no further writes were performed`);
-					} else await this.io.writeText(entry.target, entry.content);
+						if (!ran.done) throw new Error("internal error: the write transaction for " + entry.target + " did not invoke the task; nothing was written");
+						if (drift.seen) throw new Error("concurrent modification detected: " + entry.target + " changed after the plan was computed (a concurrent writer won the race); no further writes were performed");
+					} else if (entry.kind === "delete") await this.io.remove(entry.target);
+					else await this.io.writeText(entry.target, entry.content ?? "");
 				} catch (error) {
 					if (!isCommittedOnly(error)) throw error;
 					durabilityWarning = error instanceof Error ? error.message : String(error);
@@ -12806,42 +13694,43 @@ var SkillLibrary = class {
 			const reason = error instanceof Error ? error.message : String(error);
 			if (stuck.length === 0) return {
 				ok: false,
-				message: `目录树变更失败，已回滚：${reason}`
+				message: "目录树变更失败，已回滚：" + reason
 			};
 			return {
 				ok: false,
-				message: `目录树变更失败：${reason}。回滚无法恢复 ${stuck.join(", ")}：可恢复性由当前快照决定：${await this.snapshotRecoveryAvailability()} —— 若上面不是「最新快照」，请重新应用这次变更。`
+				message: "目录树变更失败：" + reason + "。回滚无法恢复 " + stuck.join(", ") + "：可恢复性由当前快照决定：" + await this.snapshotRecoveryAvailability() + " —— 若上面不是「最新快照」，请重新应用这次变更。"
 			};
 		}
 		const unitId = plan.unitId ?? "u-" + Date.now().toString(36) + "-" + (nextUnitSeq += 1).toString(36);
-		for (const land of landing) {
-			const rel = land.target.split(/[\\/]/).pop() === "SKILL.md" ? void 0 : land.target.slice(dir.length + 1).split("\\").join("/");
-			const unitHead = land === landing[0] ? plan.unitHead ?? {
-				moves: landing.filter((l) => l.target.split(/[\\/]/).pop() !== "SKILL.md").map((l) => {
-					const p = l.target.slice(dir.length + 1).split(String.fromCharCode(92)).join(String.fromCharCode(47));
-					return {
-						path: p,
-						kind: l.previous === null ? "created" : "moved",
-						to: p,
-						...l.previous === null ? {} : { beforeRef: contentHash(l.previous) },
-						afterRef: contentHash(l.content)
-					};
-				}).filter((m, idx, all) => all.map((x) => x.path).lastIndexOf(m.path) === idx),
-				sources: [{ skill: name }]
-			} : void 0;
-			const auditedBefore = land.previous;
-			const auditedAfter = land.content;
-			await this.audit(name, plan.auditAction, auditedBefore, auditedAfter, plan.auditSummary, rel, unitId, unitHead, plan.origin);
+		const defaultHead = {
+			moves: landing.filter((entry) => basename(entry.target) !== "SKILL.md").map((entry) => ({
+				path: entry.rel,
+				kind: entry.kind === "delete" ? "removed" : entry.previous === null ? "created" : "moved",
+				...entry.previous === null ? {} : { beforeRef: contentHash(entry.previous) },
+				...entry.kind === "delete" || entry.content === null ? {} : { afterRef: contentHash(entry.content) }
+			})),
+			sources: roots.map((root) => ({ skill: root.name }))
+		};
+		const affected = /* @__PURE__ */ new Set();
+		for (let index = 0; index < landing.length; index += 1) {
+			const entry = landing[index];
+			if (entry === void 0) continue;
+			await this.audit(entry.skill, plan.auditAction, entry.previous, entry.kind === "delete" ? null : entry.content, plan.auditSummary, entry.rel === "SKILL.md" ? void 0 : entry.rel, unitId, index === 0 ? plan.unitHead ?? defaultHead : void 0, plan.origin);
+			affected.add(entry.skill);
 		}
-		this.notifyMutation({
-			action: plan.eventAction,
-			name,
-			skillDir: dir
-		});
+		for (const skill of affected) {
+			const dir = roots.find((root) => root.name === skill)?.dir;
+			if (dir !== void 0) this.notifyMutation({
+				action: plan.eventAction,
+				name: skill,
+				skillDir: dir
+			});
+		}
+		const primaryDir = roots.find((root) => root.name === primaryName)?.dir ?? roots[0]?.dir ?? "";
 		return {
 			ok: true,
-			message: durabilityWarning === "" ? `${plan.eventAction} "${name}" succeeded.` : `${plan.eventAction} "${name}" succeeded （警告：写入已落盘，但目录 fsync 失败 —— 持久性未确认：${durabilityWarning})`,
-			path: dir
+			message: durabilityWarning === "" ? plan.eventAction + " \"" + primaryName + "\" succeeded." : plan.eventAction + " \"" + primaryName + "\" succeeded （警告：写入已落盘，但目录 fsync 失败 —— 持久性未确认：" + durabilityWarning + ")",
+			path: primaryDir
 		};
 	}
 	/**
@@ -15892,4 +16781,4 @@ function isIgnorableEvent(event) {
 	return classifySessionEvent(event) !== "model";
 }
 //#endregion
-export { AUTHORING_DESCRIPTION_BAR, AUTHORING_SPLIT_LINE_CHARS, BASELINE_ACTION, CITATION_SUPPORT_DIRS, COMBINED_REVIEW_PLAN_PROMPT, COMBINED_REVIEW_PROMPT, COMPLETION_SKILL_REVIEW_PROMPT, CONTENT_SPLIT_HINT, COST_ASCII_TOKEN_HIGH, COST_ASCII_TOKEN_LOW, COST_CJK_TOKEN_HIGH, COST_CJK_TOKEN_LOW, CURATOR_DRY_RUN_BANNER, CURATOR_PROMPT, DEDUP_MAX_PAIR_COMPARISONS, DEDUP_SIMILARITY_THRESHOLD, DEFAULT_ADMISSION, DEFAULT_ARCHIVE_AFTER_DAYS, DEFAULT_ARCHIVE_RETENTION_POLICY, DEFAULT_CITATION_POLICY, DEFAULT_CITATION_REF_BUDGET, DEFAULT_CONSOLIDATION_FAILURES, DEFAULT_CURATOR_BOOT_GRACE_SECONDS, DEFAULT_CURATOR_INTERVAL_HOURS, DEFAULT_CURATOR_MODEL, DEFAULT_CURATOR_REVIEW_MAX_TOKENS, DEFAULT_HEALTH_THRESHOLDS, DEFAULT_MAX_OPS_PER_PLAN, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_MEMORY_REVIEW_MODEL, DEFAULT_MIN_IDLE_HOURS, DEFAULT_MUTATION_CAP, DEFAULT_PROBE_TIMEOUT_MS, DEFAULT_REFERENCE_REWRITE_POLICY, DEFAULT_REVIEW_CONTEXT_MESSAGES, DEFAULT_REVIEW_MEMORY_INTERVAL, DEFAULT_REVIEW_MESSAGE_CHARS, DEFAULT_REVIEW_SKILL_INTERVAL, DEFAULT_REVIEW_TIMEOUT_MS, DEFAULT_RUN_RECORDS, DEFAULT_SKILL_CONTENT_CHARS, DEFAULT_SKILL_LIMITS, DEFAULT_SKILL_REVIEW_COMPLETION_MIN_TOOL_CALLS, DEFAULT_SKILL_REVIEW_MODEL, DEFAULT_SKILL_REVIEW_TRIGGER, DEFAULT_SKILL_VERSION_KEEP, DEFAULT_STALE_AFTER_DAYS, DEFAULT_SUBSTANTIVE_MIN_AGENT_CHARS, DEFAULT_SUBSTANTIVE_MIN_TOOL_CALLS, DEFAULT_SUBSTANTIVE_MIN_USER_CHARS, DEFAULT_SUPPORT_FILE_CHAR_POLICY, DEFAULT_SUPPORT_READ_TOOL_NAMES, DEFAULT_THREAT_MAX_SCAN_CHARS, DEFAULT_USER_CHAR_LIMIT, DEFAULT_WRITE_CONFIRM_MODE, DEFAULT_WRITE_CONFIRM_TIMEOUT_SECONDS, DIAGNOSTICS_FACT_KEYS, DIAGNOSTICS_RUNTIME_KEYS, DIAGNOSTICS_VIEW_SCHEMA_VERSION, DISPATCH_EVENT_TYPES, DRIFT_MAX_LINE_CHARS, DRIFT_SIGNALS_VERSION, DRIFT_SIGNAL_NOUNS, DSH_AUTHORING_STANDARDS, ENTRY_DELIMITER, EVENT_ARCHIVE_PREFIX, EVENT_LOG_RETAIN_ARCHIVES, EVENT_LOG_ROTATE_AT, EVENT_LOG_VERSION, EVOLUTION_ERRORS, EVOLUTION_PRESET_IDS, EVOLUTION_WRITE_TOOLS, EvolutionGateSet, FAMILY_SESSION_TOOL_NAMES, FORBIDDEN_CONTROL_KEYS, FUZZY_MAX_PATTERN_CHARS, FUZZY_MAX_WORK, HEALTH_STAMP_RE, HISTORY_DIR, HISTORY_INDEX_VERSION, HOOK_LINE_RE, HOST_ROUTES, INSTANCE_KEYS, KEEP_LINE_RE, LONG_RUNS, LOW_QUALITY_THRESHOLD, MAINTAINER_PRESET_ID, MAINTAIN_OUTPUT_INSTRUCTION, MAINTAIN_PROMPT, MAX_DESCRIPTION_LENGTH, MAX_REQUEST_BODY_BYTES, MAX_RESTRUCTURE_MOVES, MAX_SKILL_CONTENT_CHARS, MAX_SKILL_FILE_BYTES, MAX_SKILL_NAME_LENGTH, MAX_SUPPORT_READ_PATHS, MAX_TIMER_DELAY_MS, MEMORY_GUIDANCE_SECTION_ORDER, MEMORY_REVIEW_PROMPT, MIN_STAMP_BODY_CHARS, MODEL_SESSION_EVENT_TYPES as MODEL_SESSION_EVENTS, MODEL_SESSION_EVENT_TYPES, MUTATIONS_FILE_VERSION, MemoryStore, NAMESPACE_MIGRATIONS, NATIVE_CALL_EVENT, NATIVE_RESULT_EVENT, PARAM_ALIASES, PARAM_EXPOSURE, PARAM_GROUP_LABELS, PARAM_NAMESPACES, PATTERN_OVERLAP, PLATFORM_CATALOG_DESCRIPTION_DEFAULT, PLATFORM_ESTIMATE_CHARS_PER_TOKEN, PLATFORM_LINE, PLATFORM_SERVICE_PROBES, POLICY_STAGE_DEFAULTS, PROMPT_BUNDLE, PROMPT_BUNDLE_ID, PROMPT_BUNDLE_VERSION, PROTECTED_BUILTIN_SKILLS, PTC_DISPATCH_EVENT, PTC_DISPATCH_START_EVENT, QUALITY_WEIGHTS, READ_REQUIRED_ACTIONS, RESTRICTED_PRESET_DISPLAY, RESTRICTED_TOOLS_ROW_ID, RESTRICTOR_MODULE, RESTRUCTURE_TARGET_RE, RETENTION_FEEDBACK_KEEP_RATIO, RETENTION_FEEDBACK_MIN_CHARS, REVIEWER_PRESET_ID, RULES, RUNS_SCHEMA_VERSION, SKILLS_GUIDANCE, SKILLS_GUIDANCE_SECTION_ORDER, SKILL_ACTION_REQUIRED_FIELDS, SKILL_NAME_RE, SKILL_REVIEW_PLAN_PROMPT, SKILL_REVIEW_PROMPT, SNAPSHOT_EXTRA_NAME_RE, STORE_LEDGER, SUMMARY_DUPLICATE_HINT_THRESHOLD, SUPPORT_DIRS, SUPPORT_SPRAWL_FILES, SUPPRESSED_FILE_VERSION, SkillLibrary, TEXT_DIFF_MAX_CHARS, TEXT_DIFF_MAX_LINES, THREAT_EXEMPTION_HINT, TOKEN_ASCII_WEIGHT, TOKEN_CJK_WEIGHT, ToolDispatchNormalizer, ToolDispatchPayloadError, UNIT_JOURNAL_PHASES, UNIT_JOURNAL_SCHEMA_VERSION, UNIT_STORAGE_SCHEMA_VERSION, UNTRUSTED_LINE_BREAK, UNTRUSTED_LINE_MARK, UPSTREAM_LIMIT_CHARS_PER_TOKEN, UnitTransactions, VERSION_SUMMARY_MAX_CHARS, absentHostServices, acquireTreeWriteLock, admissionVerdict, advanceReview, affinity, ageCopyKey, allowRowCollisions, anchorVerdict, appendEvolutionEvent, applyCuratorLifecycleFields, applyCuratorMetaFields, applyNamespaceMigration, applyReferenceRewrite, asRecord, assertDispatchPayload, assertSkillsRootAliasRetired, assertUnitJournalTransition, assessStructureHealth, atomicWriteFiles, authoringFeedback, authorityFrom, backupsReachability, blobPath, bodyCost, buildCuratorRunReport, buildHealthBaseline, buildLearnPrompt, bumpPatch, bumpSupportRead, bumpUse, bumpView, callingScope, candidateSkills, canonicalWriteId, claimInstance, clampOnce, clampedNumber, classifyNamespaceMigration, classifySessionEvent, clearReviewChannel, collectReadSkillNames, computeDedupGroups, computeDriftSignals, computeLifecycleTransitions, computePrefixClusters, computeQualityScores, computeScopeView, contentHash, contentRetentionFeedback, countDispatches, countReferenceFiles, createGateSet, createSubagentChannel, daysSinceIso, declaredReportStamp, describeReferenceRewrite, diffFindings, dispatchKeyOf, dispatchStepOf, displayBodyOf, duplicateHeadings, elapsedSince, emptyRecord, ensureSkillFrontmatter, entryTarget, errorText, evaluateThreat, eventsFile, evidenceKindIndex, evolutionActivityProjection, evolutionEventPayloadIssue, evolutionEvidenceProjection, evolutionHome, evolutionIoAdapter, evolutionReadsProjection, evolutionRoot, evolutionSignalsProjection, executeUnitUndo, filterUnreadSkillOps, findDriftSignal, foldCuratorFields, foldToolDispatches, foldTurnEvent, foldTurnEvents, foldUntrustedLines, frontmatterBlock, frontmatterCatalogInvalid, fuzzyPatch, getRecord, h2Sections, historyIndexFile, historyReachability, historyRoot, hostSurface, identity, idleDays, initialTurnFold, installEvolutionProjections, instanceClaimKey, instanceClaimedWriteSites, instanceHolder, isAbsent, isBookkeepingFrame, isCommittedWarning, isDeprecatedParamId, isFileShapedPath, isIgnorableEvent, isLandmark, isMissingPath, isPresent, isProcessAlive, isProgramToolName, isRecord, isReviewChannelSession, isSkillReadToolName, isSkillToolName, isUnknown, isUnreadWrite, json, landmarkVerdict, latestActivityAt, latestVersionAt, lifecycleCandidate, lintBody, lintSkill, listEventArchives, liveBool, liveEnum, liveNumber, liveString, loadMutations, loadSuppressedNames, loadUsage, loadVersionContent, loadVersions, makeSerialQueue, mapProbe, markAgentCreated, markReviewChannel, markerEntryName, memoryRoot, methodNotAllowed, missingSupportPointers, mutateUsage, mutationsFile, narrowNameMatches, nearDuplicateSummaries, newRunRegistry, newSkillLibrary, nextHistoryIndex, nodeEvolutionIo, normalizeFrontmatter, normalizeUsageRecord, normalizeVersionSummary, observeEvent, orderVersions, overlongLines, paramNamespace, paramRowId, paramSettingsId, parseCuratorNominations, parseEvolutionEvents, parseFrontmatter, parseHistoryIndex, partitionVersions, payloadText, persistedWriteSite, persistedWriteSites, pickWithPolicy, planNamespaceMigration, planReferenceRewrite, planRehoming, planUnitUndoAcross, policyStageLimits, probeAbsent, probeChannelState, probeList, probeMtime, probePresent, probeReason, probeText, probeUnknown, projectionText, protectedSkillNamesOf, readDispatchSignal, readEvolutionEvents, readEvolutionTimeline, readHistoryIndex, readJsonObject, readNumberParam, readParam, readTreeLock, readUnitEvidence, readUnitIndex, readUnitJournal, readUnitReceipt, readUnitSnapshot, readingStats, recordMutation, recordVersions, redactSecrets, referencedBlobs, registerHostRoutes, relatedSkillNames, releaseInstance, renameWithRetry, renderCuratorReportMarkdown, renderLongRunTable, reportTime, reportsReachability, reportsSweepLockTarget, resolveCitations, resolveExecOrigins, resolveOrigins, resolveParamId, resolveRootConfig, resolveSkillsRoot, resolveUnitMembers, resolveUnitMembersFromIndexes, restructureCandidates, retainEventArchives, retirementReport, reviewPrompt, revisionAnchor, revisionAnchorOf, revisionFingerprint, revisionSupportDigest, runWriteGates, runsFile, saveSuppressedNames, saveUsage, scanBodyHooks, scanContentThreats, scanMemoryThreats, scanThreats, scopeOfNearestManifest, scopedPackageName, scopedProbeReport, sessionAudited, sessionEvidenceIndex, sessionLastEventTime, sessionReadNames, sessionReadSkillNames, sessionSeesFamilyTools, sessionTurnSignals, skillLibraryUnitBackend, skillReadNameOf, skillRowCells, skillStateKey, skillWriteGateContext, skillsRoot, staleRouteStubs, subagentChannelState, supportFileReadOf, supportRefs, suppressedFile, sweepReports, sweepReviewChannelSessions, textDiffFacts, tokenLineFor, transactIo, transactTaskGuard, treeLockFile, trimPatternBoundaries, unhookedSupportPointers, unitEvidenceDigest, unitEvidencePath, unitIndexPath, unitJournalPath, unitJournalPhaseRank, unitMembersAreComplete, unitReceiptPath, unitSnapshotPath, unitSnapshotsDir, unitStorageKey, unwrapLive, updateSuppressedNames, upsertUnitIndex, usageFile, usageObserved, userSetKeys, validateFrontmatter, validateRestructureTarget, validateSupportPath, valueOr, verifyPromptBundle, versionActionKind, versionRowCells, versionSummaryPrompt, versionTarget, vocabulary, withTreeWrite, withTreeWriteLock, writeDurableTmp, writePathSymbols, writeUnitEvidence, writeUnitJournal, writeUnitReceipt, writeUnitSnapshot, yamlPlainScalarNeedsQuotes };
+export { AUTHORING_DESCRIPTION_BAR, AUTHORING_SPLIT_LINE_CHARS, BASELINE_ACTION, CITATION_SUPPORT_DIRS, COMBINED_REVIEW_PLAN_PROMPT, COMBINED_REVIEW_PROMPT, COMPLETION_SKILL_REVIEW_PROMPT, CONTENT_SPLIT_HINT, COST_ASCII_TOKEN_HIGH, COST_ASCII_TOKEN_LOW, COST_CJK_TOKEN_HIGH, COST_CJK_TOKEN_LOW, CURATOR_DRY_RUN_BANNER, CURATOR_PROMPT, DEDUP_MAX_PAIR_COMPARISONS, DEDUP_SIMILARITY_THRESHOLD, DEFAULT_ADMISSION, DEFAULT_ARCHIVE_AFTER_DAYS, DEFAULT_ARCHIVE_RETENTION_POLICY, DEFAULT_CITATION_POLICY, DEFAULT_CITATION_REF_BUDGET, DEFAULT_CONSOLIDATION_FAILURES, DEFAULT_CURATOR_BOOT_GRACE_SECONDS, DEFAULT_CURATOR_INTERVAL_HOURS, DEFAULT_CURATOR_MODEL, DEFAULT_CURATOR_REVIEW_MAX_TOKENS, DEFAULT_HEALTH_THRESHOLDS, DEFAULT_MAX_OPS_PER_PLAN, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_MEMORY_REVIEW_MODEL, DEFAULT_MIN_IDLE_HOURS, DEFAULT_MUTATION_CAP, DEFAULT_PROBE_TIMEOUT_MS, DEFAULT_REFERENCE_REWRITE_POLICY, DEFAULT_REVIEW_CONTEXT_MESSAGES, DEFAULT_REVIEW_MEMORY_INTERVAL, DEFAULT_REVIEW_MESSAGE_CHARS, DEFAULT_REVIEW_SKILL_INTERVAL, DEFAULT_REVIEW_TIMEOUT_MS, DEFAULT_RUN_RECORDS, DEFAULT_SKILL_CONTENT_CHARS, DEFAULT_SKILL_LIMITS, DEFAULT_SKILL_REVIEW_COMPLETION_MIN_TOOL_CALLS, DEFAULT_SKILL_REVIEW_MODEL, DEFAULT_SKILL_REVIEW_TRIGGER, DEFAULT_SKILL_VERSION_KEEP, DEFAULT_STALE_AFTER_DAYS, DEFAULT_SUBSTANTIVE_MIN_AGENT_CHARS, DEFAULT_SUBSTANTIVE_MIN_TOOL_CALLS, DEFAULT_SUBSTANTIVE_MIN_USER_CHARS, DEFAULT_SUPPORT_FILE_CHAR_POLICY, DEFAULT_SUPPORT_READ_TOOL_NAMES, DEFAULT_THREAT_MAX_SCAN_CHARS, DEFAULT_USER_CHAR_LIMIT, DEFAULT_WRITE_CONFIRM_MODE, DEFAULT_WRITE_CONFIRM_TIMEOUT_SECONDS, DIAGNOSTICS_FACT_KEYS, DIAGNOSTICS_RUNTIME_KEYS, DIAGNOSTICS_VIEW_SCHEMA_VERSION, DISPATCH_EVENT_TYPES, DRIFT_MAX_LINE_CHARS, DRIFT_SIGNALS_VERSION, DRIFT_SIGNAL_NOUNS, DSH_AUTHORING_STANDARDS, ENTRY_DELIMITER, EVENT_ARCHIVE_PREFIX, EVENT_LOG_RETAIN_ARCHIVES, EVENT_LOG_ROTATE_AT, EVENT_LOG_VERSION, EVOLUTION_ERRORS, EVOLUTION_PRESET_IDS, EVOLUTION_WRITE_TOOLS, EXTRACT_PROMPT_V1, EXTRACT_PROMPT_VERSION, EvolutionGateSet, FAMILY_SESSION_TOOL_NAMES, FORBIDDEN_CONTROL_KEYS, FUZZY_MAX_PATTERN_CHARS, FUZZY_MAX_WORK, HEALTH_STAMP_RE, HISTORY_DIR, HISTORY_INDEX_VERSION, HOOK_LINE_RE, HOST_ROUTES, INSTANCE_KEYS, KEEP_LINE_RE, LONG_RUNS, LOW_QUALITY_THRESHOLD, MAINTAINER_PRESET_ID, MAINTAIN_OUTPUT_INSTRUCTION, MAINTAIN_PROMPT, MAX_DESCRIPTION_LENGTH, MAX_REQUEST_BODY_BYTES, MAX_RESTRUCTURE_MOVES, MAX_SKILL_CONTENT_CHARS, MAX_SKILL_FILE_BYTES, MAX_SKILL_NAME_LENGTH, MAX_SUPPORT_READ_PATHS, MAX_TIMER_DELAY_MS, MEMORY_GUIDANCE_SECTION_ORDER, MEMORY_REVIEW_PROMPT, MIN_STAMP_BODY_CHARS, MODEL_SESSION_EVENT_TYPES as MODEL_SESSION_EVENTS, MODEL_SESSION_EVENT_TYPES, MUTATIONS_FILE_VERSION, MemoryStore, NAMESPACE_MIGRATIONS, NATIVE_CALL_EVENT, NATIVE_RESULT_EVENT, PARAM_ALIASES, PARAM_EXPOSURE, PARAM_GROUP_LABELS, PARAM_NAMESPACES, PATTERN_OVERLAP, PLATFORM_CATALOG_DESCRIPTION_DEFAULT, PLATFORM_ESTIMATE_CHARS_PER_TOKEN, PLATFORM_LINE, PLATFORM_SERVICE_PROBES, POLICY_STAGE_DEFAULTS, PROMPT_BUNDLE, PROMPT_BUNDLE_ID, PROMPT_BUNDLE_VERSION, PROTECTED_BUILTIN_SKILLS, PTC_DISPATCH_EVENT, PTC_DISPATCH_START_EVENT, QUALITY_WEIGHTS, READ_REQUIRED_ACTIONS, RESTRICTED_PRESET_DISPLAY, RESTRICTED_TOOLS_ROW_ID, RESTRICTOR_MODULE, RESTRUCTURE_TARGET_RE, RETENTION_FEEDBACK_KEEP_RATIO, RETENTION_FEEDBACK_MIN_CHARS, REVIEWER_PRESET_ID, RULES, RUNS_SCHEMA_VERSION, SKILLS_GUIDANCE, SKILLS_GUIDANCE_SECTION_ORDER, SKILL_ACTION_REQUIRED_FIELDS, SKILL_NAME_RE, SKILL_REVIEW_PLAN_PROMPT, SKILL_REVIEW_PROMPT, SNAPSHOT_EXTRA_NAME_RE, STORE_LEDGER, SUMMARY_DUPLICATE_HINT_THRESHOLD, SUPPORT_DIRS, SUPPORT_SPRAWL_FILES, SUPPRESSED_FILE_VERSION, SkillLibrary, TEXT_DIFF_MAX_CHARS, TEXT_DIFF_MAX_LINES, THREAT_EXEMPTION_HINT, TOKEN_ASCII_WEIGHT, TOKEN_CJK_WEIGHT, ToolDispatchNormalizer, ToolDispatchPayloadError, UNIT_JOURNAL_PHASES, UNIT_JOURNAL_SCHEMA_VERSION, UNIT_STORAGE_SCHEMA_VERSION, UNTRUSTED_LINE_BREAK, UNTRUSTED_LINE_MARK, UPSTREAM_LIMIT_CHARS_PER_TOKEN, UnitTransactions, VERSION_SUMMARY_MAX_CHARS, absentHostServices, acquireTreeWriteLock, admissionVerdict, advanceReview, affinity, ageCopyKey, allowRowCollisions, anchorVerdict, appendEvolutionEvent, applyCuratorLifecycleFields, applyCuratorMetaFields, applyNamespaceMigration, applyReferenceRewrite, asRecord, assertDispatchPayload, assertSkillsRootAliasRetired, assertUnitJournalTransition, assessStructureHealth, atomicWriteFiles, authoringFeedback, authorityFrom, backupsReachability, blobPath, bodyCost, buildCuratorRunReport, buildHealthBaseline, buildLearnPrompt, bumpPatch, bumpSupportRead, bumpUse, bumpView, callingScope, candidateSkills, canonicalWriteId, claimInstance, clampOnce, clampedNumber, classifyNamespaceMigration, classifySessionEvent, clearReviewChannel, collectReadSkillNames, computeDedupGroups, computeDriftSignals, computeLifecycleTransitions, computePrefixClusters, computeQualityScores, computeScopeView, contentHash, contentRetentionFeedback, countDispatches, countReferenceFiles, createGateSet, createSubagentChannel, daysSinceIso, declaredReportStamp, describeReferenceRewrite, diffFindings, dispatchKeyOf, dispatchStepOf, displayBodyOf, duplicateHeadings, elapsedSince, emptyRecord, ensureSkillFrontmatter, entryTarget, errorText, evaluateThreat, eventsFile, evidenceKindIndex, evolutionActivityProjection, evolutionEventPayloadIssue, evolutionEvidenceProjection, evolutionHome, evolutionIoAdapter, evolutionReadsProjection, evolutionRoot, evolutionSignalsProjection, executeUnitUndo, externalRefs, filterUnreadSkillOps, findDriftSignal, findOwnerCandidate, foldCuratorFields, foldToolDispatches, foldTurnEvent, foldTurnEvents, foldUntrustedLines, frontmatterBlock, frontmatterCatalogInvalid, fuzzyPatch, getRecord, h2Sections, historyIndexFile, historyReachability, historyRoot, hostSurface, identity, idleDays, initialTurnFold, installEvolutionProjections, instanceClaimKey, instanceClaimedWriteSites, instanceHolder, isAbsent, isBookkeepingFrame, isCommittedWarning, isDeprecatedParamId, isFileShapedPath, isIgnorableEvent, isLandmark, isMissingPath, isPresent, isProcessAlive, isProgramToolName, isRecord, isReviewChannelSession, isSkillReadToolName, isSkillToolName, isUnknown, isUnreadWrite, json, landmarkVerdict, latestActivityAt, latestVersionAt, lifecycleCandidate, lintBody, lintSkill, listEventArchives, liveBool, liveEnum, liveNumber, liveString, loadMutations, loadSuppressedNames, loadUsage, loadVersionContent, loadVersions, makeSerialQueue, mapProbe, markAgentCreated, markReviewChannel, markerEntryName, memoryRoot, methodNotAllowed, missingSupportPointers, mutateUsage, mutationsFile, narrowNameMatches, nearDuplicateSummaries, newRunRegistry, newSkillLibrary, nextHistoryIndex, nodeEvolutionIo, normalizeFrontmatter, normalizeUsageRecord, normalizeVersionSummary, observeEvent, orderVersions, overlongLines, ownerCandidatesFromSummaries, paramNamespace, paramRowId, paramSettingsId, parseCuratorNominations, parseEvolutionEvents, parseFrontmatter, parseHistoryIndex, partitionVersions, payloadText, persistedWriteSite, persistedWriteSites, pickWithPolicy, planExtract, planNamespaceMigration, planReferenceRewrite, planRehoming, planUnitUndoAcross, policyStageLimits, probeAbsent, probeChannelState, probeList, probeMtime, probePresent, probeReason, probeText, probeUnknown, projectExtractBodies, projectionText, proposalFromPlan, proposalReportDir, proposalReportName, protectedSkillNamesOf, readDispatchSignal, readEvolutionEvents, readEvolutionTimeline, readExternalSupport, readHistoryIndex, readJsonObject, readNumberParam, readParam, readProposalReports, readTreeLock, readUnitEvidence, readUnitIndex, readUnitJournal, readUnitReceipt, readUnitSnapshot, readingStats, recordMutation, recordVersions, redactSecrets, referencedBlobs, registerHostRoutes, relatedSkillNames, releaseInstance, renameWithRetry, renderCuratorReportMarkdown, renderLongRunTable, reportTime, reportsReachability, reportsSweepLockTarget, resolveCitations, resolveExecOrigins, resolveOrigins, resolveParamId, resolveRootConfig, resolveSkillsRoot, resolveUnitMembers, resolveUnitMembersFromIndexes, restructureCandidates, retainEventArchives, retirementReport, reviewPrompt, revisionAnchor, revisionAnchorOf, revisionFingerprint, revisionSupportDigest, runWriteGates, runsFile, saveSuppressedNames, saveUsage, scanBodyHooks, scanContentThreats, scanMemoryThreats, scanThreats, scopeOfNearestManifest, scopedPackageName, scopedProbeReport, selectSections, sessionAudited, sessionEvidenceIndex, sessionLastEventTime, sessionReadNames, sessionReadSkillNames, sessionSeesFamilyTools, sessionTurnSignals, skillLibraryUnitBackend, skillReadNameOf, skillRowCells, skillStateKey, skillWriteGateContext, skillsRoot, staleRouteStubs, subagentChannelState, supportFileReadOf, supportRefs, suppressedFile, sweepReports, sweepReviewChannelSessions, textDiffFacts, tokenLineFor, transactIo, transactTaskGuard, treeLockFile, trimPatternBoundaries, unhookedSupportPointers, unitEvidenceDigest, unitEvidencePath, unitIndexPath, unitJournalPath, unitJournalPhaseRank, unitMembersAreComplete, unitReceiptPath, unitSnapshotPath, unitSnapshotsDir, unitStorageKey, unwrapLive, updateSuppressedNames, upsertUnitIndex, usageFile, usageObserved, userSetKeys, validateFrontmatter, validateRestructureTarget, validateSupportPath, valueOr, verifyPromptBundle, versionActionKind, versionRowCells, versionSummaryPrompt, versionTarget, vocabulary, withTreeWrite, withTreeWriteLock, writeDurableTmp, writePathSymbols, writeProposalReport, writeUnitEvidence, writeUnitJournal, writeUnitReceipt, writeUnitSnapshot, yamlPlainScalarNeedsQuotes };