@lmzhen/dsh-evolution-core 0.3.81 → 0.3.82

package/lib/index.js

@@ -6,6 +6,79 @@ import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { scopeOf } from "@deepseek-ai/dsh-scope";
 import { load } from "js-yaml";
+//#region lib/types/probe.js
+function probePresent(value) {
+	return {
+		kind: "present",
+		value
+	};
+}
+function probeAbsent() {
+	return { kind: "absent" };
+}
+function probeUnknown(reason) {
+	return {
+		kind: "unknown",
+		reason
+	};
+}
+function isPresent(probe) {
+	return probe.kind === "present";
+}
+function isAbsent(probe) {
+	return probe.kind === "absent";
+}
+function isUnknown(probe) {
+	return probe.kind === "unknown";
+}
+/** Only a PRESENT probe yields a value; absent and unknown both fall back. */
+function valueOr(probe, fallback) {
+	return probe.kind === "present" ? probe.value : fallback;
+}
+function mapProbe(probe, transform) {
+	return probe.kind === "present" ? probePresent(transform(probe.value)) : probe;
+}
+/** The reason an `unknown` probe carries (message, never a bare String(object)). */
+function probeReason(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* ENOENT/ENOTDIR are the ONE read failure that means "it is not there"; every
+* other failure is an IO error and stays unknown (same split as the node
+* backend's own isMissing, V8-23⑨ for the size probe).
+*/
+function isMissingPath(error) {
+	const code = error?.code;
+	return code === "ENOENT" || code === "ENOTDIR";
+}
+/**
+* Three-state directory listing. The node backend already answers `[]` for a
+* MISSING directory (its own rc.50 P2-4 contract) and THROWS for an unreadable
+* one, so the value this adds is the second half: a backend that throws ENOENT
+* reads as absent, an EACCES/EIO reads as unknown — where a bare
+* `catch { return [] }` served a broken store as an empty one (the N14 class).
+*/
+async function probeList(io, dir) {
+	try {
+		return probePresent(await io.list(dir));
+	} catch (error) {
+		return isMissingPath(error) ? probeAbsent() : probeUnknown(probeReason(error));
+	}
+}
+/**
+* Three-state mtime read. Absent covers both "the path is missing" and "this
+* backend has no mtime probe" — the seam cannot tell those apart, so consumers
+* that must know say so in their own log line. A stat that FAILS is unknown.
+*/
+async function probeMtime(io, path) {
+	try {
+		const value = await io.mtime?.(path) ?? null;
+		return value === null ? probeAbsent() : probePresent(value);
+	} catch (error) {
+		return probeUnknown(probeReason(error));
+	}
+}
+//#endregion
 //#region lib/types/io.js
 /**
 * Structural IO seam for the evolution plugin family.
@@ -40,6 +113,21 @@ async function transactIo(io, path, task) {
 		console.warn(`evolution-io: ${path} was written but its directory fsync failed — the bytes are visible, durability is unconfirmed: ${error instanceof Error ? error.message : String(error)}`);
 	}
 }
+/** Build a {@link TransactTaskGuard} for one write path. See its doc. */
+function transactTaskGuard(what) {
+	let invoked = false;
+	return {
+		wrap: (task) => (current) => {
+			invoked = true;
+			return task(current);
+		},
+		invoked: () => invoked,
+		assertInvoked: () => {
+			if (invoked) return;
+			throw new Error(`internal error: the write transaction for ${what} did not invoke the task; no write was performed`);
+		}
+	};
+}
 /** Lazy adapter over an IO provider registry, shared by every evolution consumer. */
 function evolutionIoAdapter(provider) {
 	return {
@@ -324,10 +412,17 @@ function decideTakeover(probe) {
 * exceed the default budget and fail loud.
 */
 function nodeEvolutionIo(lockAttempts = 40) {
-	const isMissing = (error) => {
-		const code = error?.code;
-		return code === "ENOENT" || code === "ENOTDIR";
-	};
+	/**
+	* v43 S1-4: delegates to the canonical `isMissingPath` (probe.ts) — one
+	* definition for the whole family instead of a second copy of the same two
+	* codes. EISDIR deliberately stays OUT of that predicate: a directory
+	* squatting on a file path is not "absent" — rotation and event reads must
+	* still see it as malformed (rc.72 G-2), while the SkillLibrary.read boundary
+	* absorbs EISDIR into "absent" for its own surface (E-43).
+	* @param error - the caught read failure.
+	* @returns true only for ENOENT/ENOTDIR.
+	*/
+	const isMissing = (error) => isMissingPath(error);
 	/** True when the pid is alive (single source: `isProcessAlive`). */
 	const isAlive = isProcessAlive;
 	/**
@@ -425,7 +520,15 @@ function nodeEvolutionIo(lockAttempts = 40) {
 					});
 					if (decision !== "none") {
 						console.warn(`evolution-io: taking over write lock ${lock} (branch=stale${decision[0]?.toUpperCase()}${decision.slice(1)}, body=${JSON.stringify(holderContent)}, ageMs=${Date.now() - st.mtimeMs}, holderPid=${Number.isInteger(holder) && holder > 0 ? holder : "none"})`);
-						if (await readFile(lock, "utf8").catch(() => "") === holderContent) {
+						const currentRead = await readFile(lock, "utf8").then((body) => ({
+							ok: true,
+							body
+						}), () => ({
+							ok: false,
+							body: ""
+						}));
+						if (!currentRead.ok) continue;
+						if (currentRead.body === holderContent) {
 							const ticket = `${lock}.next`;
 							try {
 								const ticketBody = await readFile(ticket, "utf8").catch(() => "");
@@ -509,9 +612,7 @@ function nodeEvolutionIo(lockAttempts = 40) {
 					force: true,
 					maxRetries: 20,
 					retryDelay: 100
-				}).catch(async () => {
-					await recordPendingSelfCleanup(lock, await readFile(lock, "utf8").catch(() => ""));
-				});
+				}).catch(() => recordPendingSelfCleanup(lock, myClaim));
 			}
 		}
 		throw new Error(`could not acquire write lock for ${path} after ${lockAttempts} attempts`);
@@ -773,7 +874,9 @@ async function mutateUsage(root, io, task, options = {}) {
 				const record = parsed;
 				const isMalformed = (value) => value === null || typeof value !== "object" || Array.isArray(value);
 				if (typeof record.version === "number" && record.version > 1) {
-					options.onQuarantine?.(`usage sidecar ${usageFile(root)} carries schema version ${String(record.version)} (> this runtime) — writes stay frozen and the bytes preserved until the runtime is upgraded`);
+					const message = `usage sidecar ${usageFile(root)} carries schema version ${String(record.version)} (> this runtime) — writes stay frozen and the bytes preserved until the runtime is upgraded`;
+					if (options.onQuarantine !== void 0) options.onQuarantine(message);
+					else console.warn(message);
 					shapePreserved = true;
 				} else if (Object.values(record).some(isMalformed)) {
 					const bad = Object.keys(record).filter((key) => isMalformed(record[key]));
@@ -928,7 +1031,7 @@ function parseSuppressed(raw) {
 	}
 }
 async function saveSuppressedNames(root, names, io = nodeEvolutionIo()) {
-	const current = await io.readText(suppressedFile(root)).catch(() => null);
+	const current = await io.readText(suppressedFile(root));
 	if (current !== null) try {
 		const parsed = JSON.parse(current);
 		if (parsed !== null && typeof parsed.version === "number" && parsed.version > 1) {
@@ -1641,7 +1744,15 @@ async function rotateIfDue(io, path, events, rotateAt) {
 	const anchor = tail[0]?.seq ?? 0;
 	const archivePath = join(dirname(path), `${EVENT_ARCHIVE_PREFIX}${anchor - 1}.json`);
 	let archived = head;
-	const existing = await io.readText(archivePath).catch(() => null);
+	let existing;
+	try {
+		existing = await io.readText(archivePath);
+	} catch (error) {
+		return {
+			ok: false,
+			reason: `evolution event archive collision at ${archivePath} could not be read (${error instanceof Error ? error.message : String(error)}) and was not touched`
+		};
+	}
 	if (existing !== null) {
 		let parsed = null;
 		try {
@@ -1716,18 +1827,20 @@ async function pruneCollideArchives(io, path) {
 		if (stamp && now - Number(stamp[1]) < COLLIDE_AGE_MS) continue;
 		if (!stamp) try {
 			const mtime = await io.mtime?.(full);
-			if (typeof mtime === "number" && now - mtime < COLLIDE_AGE_MS) continue;
+			if (typeof mtime !== "number" || now - mtime < COLLIDE_AGE_MS) continue;
 		} catch {
 			continue;
 		}
 		await io.remove(full).catch(() => {});
 	}
 }
-/** Read the event log; a missing/whitespace-only file reads as empty,
-* corrupt content is flagged (and refused on append). A well-formed future-
-* version body is v1-incompatible and reads as empty, NOT malformed (F-338:
-* the reader must never mis-shape a newer format; the append path refuses it
-* up front so the original bytes survive). */
+/** Read the event log; a missing/whitespace-only file reads as empty, corrupt
+* content is flagged (and refused on append). A well-formed future-version body
+* is v1-incompatible: it reads as EMPTY and is now flagged malformed as well
+* (C-events-dispatch-1, v43). F-338's own guarantees are untouched — the reader
+* never mis-shapes a newer format and the append path refuses it up front, so
+* the original bytes survive — while the flag reports what the old reader hid:
+* every record that body holds is dropped from this read. */
 async function readEvolutionEvents(io, path) {
 	let raw;
 	try {
@@ -1746,7 +1859,7 @@ async function readEvolutionEvents(io, path) {
 		const parsed = JSON.parse(raw);
 		if (parsed.version !== void 0 && parsed.version !== 1) return {
 			events: [],
-			malformed: false
+			malformed: true
 		};
 		if (!Array.isArray(parsed.events)) return {
 			events: [],
@@ -1767,8 +1880,11 @@ async function readEvolutionEvents(io, path) {
 * Read the full timeline (rc.71): active log + all archives, merged by seq
 * (active copy wins, duplicates only arise from the rotation crash window),
 * sorted ascending. Per-file malformed flag as in `readEvolutionEvents`; a
-* malformed (or unreadable) ARCHIVE is skipped — it never bricks the boot and
-* it is still flagged.
+* flagged ARCHIVE (unreadable, damaged, or a future-version body this reader
+* cannot interpret) is SKIPPED — it never bricks the boot, the returned events
+* simply LACK that seq band, and `malformed` is the only signal that they do
+* (C-events-dispatch-1, v43: the flag is the consumer's contract; a truncated
+* timeline must never be folded back as if it were complete).
 */
 async function readEvolutionTimeline(io, path, archives) {
 	const dir = dirname(path);
@@ -3811,79 +3927,6 @@ function sweepReviewChannelSessions(isAlive) {
 	return removed;
 }
 //#endregion
-//#region lib/types/probe.js
-function probePresent(value) {
-	return {
-		kind: "present",
-		value
-	};
-}
-function probeAbsent() {
-	return { kind: "absent" };
-}
-function probeUnknown(reason) {
-	return {
-		kind: "unknown",
-		reason
-	};
-}
-function isPresent(probe) {
-	return probe.kind === "present";
-}
-function isAbsent(probe) {
-	return probe.kind === "absent";
-}
-function isUnknown(probe) {
-	return probe.kind === "unknown";
-}
-/** Only a PRESENT probe yields a value; absent and unknown both fall back. */
-function valueOr(probe, fallback) {
-	return probe.kind === "present" ? probe.value : fallback;
-}
-function mapProbe(probe, transform) {
-	return probe.kind === "present" ? probePresent(transform(probe.value)) : probe;
-}
-/** The reason an `unknown` probe carries (message, never a bare String(object)). */
-function probeReason(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-/**
-* ENOENT/ENOTDIR are the ONE read failure that means "it is not there"; every
-* other failure is an IO error and stays unknown (same split as the node
-* backend's own isMissing, V8-23⑨ for the size probe).
-*/
-function isMissingPath(error) {
-	const code = error?.code;
-	return code === "ENOENT" || code === "ENOTDIR";
-}
-/**
-* Three-state directory listing. The node backend already answers `[]` for a
-* MISSING directory (its own rc.50 P2-4 contract) and THROWS for an unreadable
-* one, so the value this adds is the second half: a backend that throws ENOENT
-* reads as absent, an EACCES/EIO reads as unknown — where a bare
-* `catch { return [] }` served a broken store as an empty one (the N14 class).
-*/
-async function probeList(io, dir) {
-	try {
-		return probePresent(await io.list(dir));
-	} catch (error) {
-		return isMissingPath(error) ? probeAbsent() : probeUnknown(probeReason(error));
-	}
-}
-/**
-* Three-state mtime read. Absent covers both "the path is missing" and "this
-* backend has no mtime probe" — the seam cannot tell those apart, so consumers
-* that must know say so in their own log line. A stat that FAILS is unknown.
-*/
-async function probeMtime(io, path) {
-	try {
-		const value = await io.mtime?.(path) ?? null;
-		return value === null ? probeAbsent() : probePresent(value);
-	} catch (error) {
-		return probeUnknown(probeReason(error));
-	}
-}
-//#endregion
 //#region lib/types/instance-scope.js
 /**
 * B3 / G4 (0.3.78): the family's single-instance contract, made explicit.
@@ -3901,11 +3944,30 @@ async function probeMtime(io, path) {
 * the sidecar directory, so two instances resolving different homes (an
 * isolated test fixture, a second DSH_HOME) do not contend, while two rows on
 * one profile do.
+*
+* ## Scope (v43 FLOW2-1) — this registry is PER PROCESS
+*
+* `claims` below is a module-scope Map: two ROWS over one home in ONE process
+* contend, while the SAME home in another process gets its own Map and is
+* granted the key. That is by construction, not a gap to close here — the
+* cross-process half of the contract is the IO backend's write lock
+* (`transactIo`, core/io.ts), which serializes a per-target read-modify-write.
+* The FLOW2-1 finding was three call sites reading a GRANTED claim as "no other
+* process can be doing this work", so the caller contract is stated here:
+* - granted means "no other row OF THIS PROCESS owns the key";
+* - `instanceHolder()` answers "who holds it HERE"; `undefined` also covers
+*   "held by another process";
+* - a foreign holder's LIVENESS cannot be decided from a claim at all (no pid
+*   is recorded here): a consumer that needs that decision must carry a pid in
+*   its own credential and probe it (`isProcessAlive`, core/io.ts), or state
+*   that its action is destructive.
 * @module @lmzhen/dsh-evolution-core/src/instance-scope
 */
-/** home+key -> holder. Single-process by construction: a claim can only
-* serialize instances inside this process, which is the whole point (the
-* cross-process half is the write lock, see persisted-write-inventory.json). */
+/** home+key -> holder, IN THIS PROCESS ONLY. The Map is module-scope, so two
+* processes never share it: this half cannot exclude another process (v43
+* FLOW2-1) — the cross-process half is the write lock, see
+* persisted-write-inventory.json. It is still the whole point for the case it
+* was written for: two ROWS of one process writing one home. */
 const claims = /* @__PURE__ */ new Map();
 /** `<home> :: <key>` — the registry key, exported so diagnostics name the
 * same unit the claim does. */
@@ -3936,7 +3998,8 @@ function releaseInstance(home, key, owner) {
 	const id = instanceClaimKey(home, key);
 	if (claims.get(id) === owner) claims.delete(id);
 }
-/** The current holder of `key` at `home`, or undefined. */
+/** The current holder of `key` at `home`, IN THIS PROCESS, or undefined
+* (which also covers "another process holds it" — v43 FLOW2-1). */
 function instanceHolder(home, key) {
 	return claims.get(instanceClaimKey(home, key));
 }
@@ -4001,16 +4064,39 @@ function parseSites(raw) {
 const INSTANCE_KEYS = { 
 /** The per-home curator: report writing + the retention sweep. */
 curator: "evolution-curator" };
-/** The declared persisted write sites, in file order. */
-const PERSISTED_WRITE_SITES = parseSites(JSON.parse(readFileSync(fileURLToPath(SITES_URL), "utf8")));
+let cachedSites;
+/**
+* The declared persisted write sites, in file order.
+*
+* v43 audit (S2-3 / P1-10): this used to be a module-scope readFileSync plus
+* parse, so an unshipped asset threw AT IMPORT — one absent file took the whole
+* family's load down (0.3.79 shipped a tarball without this asset and every
+* package failed to load). The read is lazy now: importing the package never
+* fails on this asset, while the first caller still gets a loud, descriptive
+* failure instead of an empty table ("no declared write sites" would silently
+* disable rule N20).
+* @returns the sites, in file order.
+*/
+function persistedWriteSites() {
+	if (cachedSites !== void 0) return cachedSites;
+	let raw;
+	try {
+		raw = readFileSync(fileURLToPath(SITES_URL), "utf8");
+	} catch (error) {
+		const cause = error instanceof Error ? error.message : String(error);
+		throw new Error(`evolution-core: persisted-write-inventory.json is unreadable (${cause}) — the package asset is missing or was not shipped; the write-inventory rules cannot be evaluated without it`);
+	}
+	cachedSites = parseSites(JSON.parse(raw));
+	return cachedSites;
+}
 /** Sites serialized by the per-home instance claim, with their instance keys. */
 function instanceClaimedWriteSites() {
-	return PERSISTED_WRITE_SITES.filter((site) => site.serializedBy === "instance-claim");
+	return persistedWriteSites().filter((site) => site.serializedBy === "instance-claim");
 }
 /** One declared site by id. An undeclared id throws — a stale caller must fail
 * loud rather than read "nothing is declared". */
 function persistedWriteSite(id) {
-	const site = PERSISTED_WRITE_SITES.find((candidate) => candidate.id === id);
+	const site = persistedWriteSites().find((candidate) => candidate.id === id);
 	if (site === void 0) throw new Error(`evolution-core: no persisted write site "${id}" in persisted-write-inventory.json`);
 	return site;
 }
@@ -4238,21 +4324,34 @@ var ToolDispatchNormalizer = class {
 		this.maxTracked = options.maxTracked ?? Number.POSITIVE_INFINITY;
 	}
 	/**
+	* v43 audit (FLOW4-4): the ledger key. A normalizer shared by every session
+	* (skill-usage's live listener holds ONE process-wide instance) used the bare
+	* call id, so two sessions that produced the same id — PTC sub-call ids are
+	* short, and an id-less payload falls back to a type+payload key that is not
+	* unique by construction — collided: the second session's read was absorbed as
+	* "already seen" and never counted, and a settle in one session flipped the
+	* other's `ok`. Callers that span sessions pass the session id as `scope`.
+	*/
+	keyOf(callId, scope) {
+		return scope === "" ? callId : `${scope}:${callId}`;
+	}
+	/**
 	* Absorb one session event.
 	* @param event - the event to absorb; any non-dispatch event is ignored.
 	* @returns the dispatch's signal when this event FIRST reveals the dispatch,
 	* otherwise \`null\` (the paired event of an already-emitted dispatch, or a
 	* non-dispatch event). A \`null\` return is never a dispatch to count again.
 	*/
-	advance(event) {
+	advance(event, scope = "") {
 		const record = readDispatchRecord(event);
 		if (record === null) return null;
+		const key = this.keyOf(record.callId, scope);
 		if (record.name === "") {
-			const existing = this.records.get(record.callId);
+			const existing = this.records.get(key);
 			if (existing !== void 0 && record.outcome !== void 0) existing.ok = record.outcome.ok;
 			return null;
 		}
-		const existing = this.records.get(record.callId);
+		const existing = this.records.get(key);
 		if (existing !== void 0) {
 			if (record.outcome !== void 0) existing.ok = record.outcome.ok;
 			return null;
@@ -4265,7 +4364,7 @@ var ToolDispatchNormalizer = class {
 			arguments: record.arguments,
 			ok: record.outcome?.ok
 		};
-		this.records.set(record.callId, signal);
+		this.records.set(key, signal);
 		this.evict();
 		return signal;
 	}
@@ -4279,13 +4378,14 @@ var ToolDispatchNormalizer = class {
 	* @param event - the event already absorbed by \`advance\`.
 	* @returns the dispatch this event settled, or \`null\`.
 	*/
-	settledSignalOf(event) {
+	settledSignalOf(event, scope = "") {
 		const record = readDispatchRecord(event);
 		if (record === null || record.outcome === void 0) return null;
-		if (this.settledIds.has(record.callId)) return null;
-		const signal = this.records.get(record.callId);
+		const key = this.keyOf(record.callId, scope);
+		if (this.settledIds.has(key)) return null;
+		const signal = this.records.get(key);
 		if (signal === void 0) return null;
-		this.settledIds.add(record.callId);
+		this.settledIds.add(key);
 		this.evict();
 		return signal;
 	}
@@ -4738,236 +4838,42 @@ function findDriftSignal(signals, id) {
 	return signals.find((signal) => signal.id === id);
 }
 //#endregion
-//#region lib/types/skill-store.js
+//#region lib/types/limits.js
 /**
-* Skill library management for the self-evolution plugin.
-*
-* Skills live under `$DSH_HOME/skills` (`~/.dsh/skills` by default), matching
-* the default dsh skill-filesystem user root. The plugin only manages skills
-* it created unless a `.hermes-managed` marker opts a skill in. Archival is a
-* move to `.archive/` — never a hard delete.
-*
-* ## Concurrency discipline (OPT-09, 2026-09) — read before adding a mutator
-*
-* Three primitives, three distinct jobs (they compose, they do not replace
-* each other):
-*
-* 1. **In-process serial queue** (`this.serial`, makeSerialQueue) — orders the
-*    read→plan→commit phases of one skill's mutation against OTHER mutators
-*    in this process. Used by: create/update/patch/setPinned/restructure/
-*    writeSupportFile/removeSupportFile and (whole-mutation) consolidate.
-*    NON-reentrant: a callback must never call a public method that wraps
-*    itself in `this.serial` (archive/restoreFromArchive deliberately do not).
-* 2. **Per-directory write lock** (io.ts LOCK_*) — cross-process mutual
-*    exclusion plus in-process crash ownership (tickets, takeover). Checked
-*    with `hasWriteLock` before any destructive move (archive/restore/
-*    snapshot); held inside transactIo by byte writers.
-* 3. **CAS baseline (`expected:`)** — any read whose bytes feed a later write
-*    must either live inside the serial section that commits the write, or
-*    carry its plan-time bytes as `expected` so the commit fails closed on
-*    drift (V8-11 / V24-01). A read outside the serial section WITHOUT a
-*    baseline is a lost-update bug; this file's history is the test suite.
+* Skill content limits: the byte/char budgets every write path validates against.
 *
-* Known residuals (deliberate, documented at their sites): the archive commit
-* re-check narrows but does not close the pin race (OPT-06); snapshotAll
-* re-probes after its copies so a mid-copy writer demotes to `skipped`
-* (OPT-07); the movers' probe→rename window is owned by the io.ts protocol.
+* Split out of skill-store.ts (S2-1) so the frontmatter validators and the
+* store share one declaration site. Re-exported by skill-store.ts: the package
+* export surface is unchanged.
 */
-/** 0.3.16 (S1.13, T-6): the pointer-line prefix written into a body when a
-* section is moved to references/ — single literal, both restructure and
-* append-mode consolidation emit the same discoverability line. */
-const POINTER_LINE_PREFIX = "> 详见 references/";
 const DEFAULT_SKILL_LIMITS = {
 	maxNameLength: 64,
 	maxDescriptionLength: MAX_DESCRIPTION_LENGTH,
 	maxSkillContentChars: MAX_SKILL_CONTENT_CHARS,
 	maxSkillFileBytes: MAX_SKILL_FILE_BYTES
 };
+//#endregion
+//#region lib/types/frontmatter.js
 /**
-* Evaluate a stage-time anchor against the bytes a locked read observed.
-* @param anchor - the caller's anchor, or `undefined` for an unanchored write.
-* @param current - the bytes the write lock read (`null` = the target is absent).
-* @returns `match` when the write may proceed, otherwise the refusal verdict.
+* Frontmatter parsing, normalization and validation for skill Markdown files.
+*
+* Split out of skill-store.ts (S2-1): pure functions over file text, no store
+* state. skill-store.ts re-exports the same names it exported before the split,
+* so the package export surface is unchanged.
 */
-function anchorVerdict(anchor, current) {
-	if (anchor === void 0) return "match";
-	if ("absent" in anchor) return current === null ? "match" : "drift";
-	if (current === null) return "missing";
-	return contentHash(current) === anchor.sha256 ? "match" : "drift";
-}
 /**
-* Build the refusal for a skill write whose anchor did not hold. The wording is
-* the library's own; a caller with staged-replay wording (the skill tool, the
-* review plan) re-words it from {@link SkillActionResult.anchor}.
-* @param name - the skill name the refusal names.
-* @param verdict - the non-matching verdict.
-* @returns the refusal result (nothing was written).
-*/
-function anchorRefusal(name, verdict) {
-	return {
-		ok: false,
-		stale: true,
-		anchor: verdict,
-		message: verdict === "missing" ? `Skill "${name}" not found.` : `Skill "${name}" changed since it was read; the write was refused to avoid overwriting newer content.`
-	};
-}
-/**
-* Build the refusal for a support-file write/remove whose anchor did not hold.
-* @param name - the owning skill name.
-* @param filePath - the support-file path inside the skill.
-* @param verdict - the non-matching verdict.
-* @returns the refusal result (nothing was written or removed).
-*/
-/**
-* Refusal for a target the locked read could not verify at all (EISDIR, an
-* unreadable file). A staged replay reports "could not be verified" instead of
-* propagating an exception: nothing was read, so nothing can have been written.
-* @param name - the owning skill name.
-* @param filePath - the support-file path, or `null` for the skill body.
-* @returns the refusal result.
-*/
-function anchorUnverifiable(name, filePath) {
-	return {
-		ok: false,
-		stale: true,
-		anchor: "drift",
-		message: filePath === null ? `Skill "${name}" could not be read to verify the staged content.` : `Support file "${filePath}" of "${name}" could not be read to verify the staged content.`
-	};
-}
-function anchorRefusalFile(name, filePath, verdict) {
-	return {
-		ok: false,
-		stale: true,
-		anchor: verdict,
-		message: verdict === "missing" ? `File "${filePath}" not found in skill "${name}".` : `Support file "${filePath}" of "${name}" changed since it was read; the write was refused to avoid overwriting newer content.`
-	};
-}
-/** Upper bound of moves per restructure proposal (validator and core agree). */
-const MAX_RESTRUCTURE_MOVES = 5;
-/** Restructure targets are plain markdown files under references/ — no
-* subdirectories, no other support kind. V8-10 (0.3.47): the regex-level
-* `(?!.*\.\.)` keeps the restructure-created set EXACTLY the set
-* validateSupportPath can reopen — a `references/my..notes.md` target (double
-* dots) used to pass here while every later patch/write/remove on it was
-* refused as traversal (an orphan file the user could not touch). */
-const RESTRUCTURE_TARGET_RE = /^references\/[a-z0-9](?!.*\.\.)[a-z0-9._-]*\.md$/;
-/** F-20 (v18): the character rule shared by support-file names and snapshot
-* `extras/` entry names. The two exported names used to carry the same literal
-* independently; both now derive from this one. */
-const SUPPORT_ENTRY_NAME_RE = /^[a-z0-9][a-z0-9._-]*$/;
-/** Extra file name carried inside a snapshot's `extras/` directory. */
-const SNAPSHOT_EXTRA_NAME_RE = SUPPORT_ENTRY_NAME_RE;
-function skillsRoot(env = process.env) {
-	return join(evolutionRoot(env), "skills");
-}
-/** 0.3.18 (S4.1, E-30): the ONE root resolution for every member that reads
-* the skills tree — tool-skill-manage / evolution-skill-catalog / skill-usage
-* / evolution-learning-graph used to each resolve `config.root || skillsRoot()`
-* (and the graph ignored config entirely). Empty/whitespace config falls
-* through to the default; callers pass their raw Config. The optional field is
-* declared `| undefined` so a config object whose root field is explicitly
-* `string | undefined` still assignable under exactOptionalPropertyTypes. */
-function resolveSkillsRoot(config = {}) {
-	return (config.root ?? "").trim() || skillsRoot();
-}
-/** E-7 (v18) → V27 G2.4 (M-08): every family row reads ONE root key. `root` is
-* canonical; the `skillsRoot` alias was honoured for one minor version and its
-* window closed at 0.3.65 — it is now two releases past expiry, so this
-* resolver no longer reads it at all. A deployment that still sets the alias
-* must fail LOUDLY at load (see {@link assertSkillsRootAliasRetired}): silently
-* ignoring a config key leaves the deployment pointing at a root nobody reads,
-* which is the worst form of compatibility.
-* @param config - the raw plugin config.
-* @returns the effective root (empty when the key is unset or blank).
-*/
-function resolveRootConfig(config = {}) {
-	return { root: (config.root ?? "").trim() };
-}
-/** V27 G2.4 (M-08): the retirement gate for the expired `skillsRoot` alias.
-* Called at each plugin's load boundary (before the root is resolved), it turns
-* a stale key into an explicit load error naming the replacement — the
-* fail-loud form the plan requires instead of a silent no-op.
-* @param config - the raw plugin config (the alias field stays DECLARED in each
-* schema so the loader can hand it here instead of dropping it).
-*/
-function assertSkillsRootAliasRetired(config = {}) {
-	if ((config.skillsRoot ?? "").trim() !== "") throw new Error("evolution: config \"skillsRoot\" was removed after 0.3.65 — rename the key to \"root\" (the alias is no longer honoured)");
-}
-/**
-* Map a requesting session onto the two origin surfaces (rc.44 plan M2-2.3):
-* the APPROVAL surface treats every delegated subagent as the autonomous
-* review channel, while the LIBRARY surface keeps the Hermes distinction -
-* the review fork is 'background_review' (the pinned guard blocks its
-* writes) and any other subagent is 'subagent' (agent-authored, not
-* review-channel). `isReview` marks the caller as the background review
-* pipeline itself. Single source: the two tools and the review executor all
-* read this table instead of re-deriving it.
-*/
-function resolveOrigins(headerOrigin, isReview = false) {
-	if (isReview) return {
-		approval: "background_review",
-		library: "background_review"
-	};
-	if (headerOrigin === "subagent") return {
-		approval: "background_review",
-		library: "subagent"
-	};
-	return {
-		approval: "foreground",
-		library: "foreground"
-	};
-}
-/**
-* S1-E8 (0.3.80): ONE exec→origins resolution for the two write tools — reads
-* the session header origin AND the v37 S2.2 review-channel session mark, so a
-* tool cannot forget the mark half (tool-memory shipped without it, which
-* mislabeled every inject-mode review memory write as `foreground` and let it
-* bypass staging under `stageForeground: false`).
-* Single source: both tools call this instead of re-deriving the pair.
-*/
-function resolveExecOrigins(exec) {
-	const session = exec?.agent?.session;
-	return resolveOrigins(session?.header?.origin, isReviewChannelSession(typeof session?.id === "string" ? session.id : void 0));
-}
-function skillDir(root, name) {
-	return join(root, name);
-}
-/** Dot-prefixed on-disk marker name. SINGLE source: `list()` matches directory
-* entries against this name, and path builders must never hardcode a marker
-* literal (N-1: the rc.49 exists()-probe convergence dropped the dot,
-* poisoning every protectedBy/managed report). Exported for cross-package
-* consumers that must probe markers without re-deriving the name (curator's
-* archive-copy bundled probe, 0.3.26 V4-02). */
-function markerEntryName(marker) {
-	return `.${marker}`;
-}
-/** F-17 (v18): the root-level lock files a DESTRUCTIVE MOVER must treat as an
-* active writer (skill body + the two marker writers). Single source with
-* `markerEntryName`/`LOCK_SUFFIX` so a renamed marker cannot silently drop out
-* of the ghost-writer probe. */
-const MARKER_LOCK_NAMES = [
-	`SKILL.md${LOCK_SUFFIX}`,
-	`.pinned${LOCK_SUFFIX}`,
-	`.hermes-managed${LOCK_SUFFIX}`
-];
-/** v23 (ML-1): `.archive` retention window (see pruneExpiredArchives). */
-const ARCHIVE_RETENTION_DAYS = 365;
-function markerPath(dir, marker) {
-	return join(dir, markerEntryName(marker));
-}
-/**
-* Shared frontmatter block detection (P3-3 single owner): opening line `---`
-* and closing line exactly `---`. Used by `parseFrontmatter`,
-* `frontmatterCatalogInvalid` and `normalizeFrontmatter` so the three can
-* never disagree about where the block ends (the loose `indexOf('\n---')`
-* form matched `\n----` and was replaced by this strict line rule).
-*
-* V27 G2.1: both fence lines are matched EXACTLY, tolerating only a trailing
-* `\r` — the same rule the upstream filesystem catalog uses
-* (`skill-filesystem.parseFrontmatter`). The former `.trim()` comparison
-* accepted ` --- `, so an indented fence loaded in the family while the
-* platform ignored the file: family visibility split from platform visibility,
-* which is exactly what a strict-YAML frontmatter is supposed to prevent.
+* Shared frontmatter block detection (P3-3 single owner): opening line `---`
+* and closing line exactly `---`. Used by `parseFrontmatter`,
+* `frontmatterCatalogInvalid` and `normalizeFrontmatter` so the three can
+* never disagree about where the block ends (the loose `indexOf('\n---')`
+* form matched `\n----` and was replaced by this strict line rule).
+*
+* V27 G2.1: both fence lines are matched EXACTLY, tolerating only a trailing
+* `\r` — the same rule the upstream filesystem catalog uses
+* (`skill-filesystem.parseFrontmatter`). The former `.trim()` comparison
+* accepted ` --- `, so an indented fence loaded in the family while the
+* platform ignored the file: family visibility split from platform visibility,
+* which is exactly what a strict-YAML frontmatter is supposed to prevent.
 */
 /**
 * S1.1 (v37 P1-4): the frontmatter block is split on LF and every line keeps its
@@ -5341,65 +5247,381 @@ function relatedSkillNames(content, exclude) {
 	}
 	return [...names];
 }
-/** S1.2 (v37 P2-1): the content limit applies to the bytes that LAND ON DISK.
-* Every write normalizes with `trimEnd() + '\n'`, so judging the raw argument let
-* a 100_000-character body with no trailing newline land as 100_001 bytes — and
-* every later patch/update of that skill was then refused, which made it
-* unmaintainable through `skill_manage` with no repair path at all. */
-function skillMdOnDisk(content) {
-	return content.trimEnd() + "\n";
+/** S1.2 (v37 P2-1): the content limit applies to the bytes that LAND ON DISK.
+* Every write normalizes with `trimEnd() + '\n'`, so judging the raw argument let
+* a 100_000-character body with no trailing newline land as 100_001 bytes — and
+* every later patch/update of that skill was then refused, which made it
+* unmaintainable through `skill_manage` with no repair path at all. */
+function skillMdOnDisk(content) {
+	return content.trimEnd() + "\n";
+}
+/** Whether `content` would exceed `limit` once written. */
+function exceedsContentLimit(content, limit) {
+	return skillMdOnDisk(content).length > limit;
+}
+/** S1.2: the repair path — a write that makes an already-over-limit file smaller.
+* Only a NET SHRINK is exempt; an equal or larger write stays refused. */
+function shrinksOverLimit(next, current, limit) {
+	if (current === null || current === void 0 || !exceedsContentLimit(current, limit)) return false;
+	return skillMdOnDisk(next).length < skillMdOnDisk(current).length;
+}
+function validateFrontmatter(content, expectedName, limits = DEFAULT_SKILL_LIMITS, current) {
+	const parsed = parseFrontmatter(content);
+	if (!parsed) return "SKILL.md must start with a `---` line, close the frontmatter with another exact `---` line (only a trailing `\\r` is tolerated), and include a body below it.";
+	const unreadable = parsed.platformStringSplit.filter((entry) => entry.kind === "sequence" || entry.kind === "mapping");
+	if (unreadable.length > 0) return `Frontmatter field ${unreadable.map((entry) => `"${entry.key}" (a YAML ${entry.kind})`).join(", ")} must be a string: the platform skill catalog reads such a field as absent and ignores the whole file. Write plain text, or wrap the value in double quotes to keep it literally.`;
+	if (!parsed.frontmatter.name) return "Frontmatter must include a name field.";
+	if (!SKILL_NAME_RE.test(parsed.frontmatter.name)) return `Invalid skill name "${parsed.frontmatter.name}" — use lowercase letters, digits, and hyphens.`;
+	if (parsed.frontmatter.name.length > limits.maxNameLength) return `Skill name exceeds ${limits.maxNameLength} characters.`;
+	if (expectedName && parsed.frontmatter.name !== expectedName) return `Frontmatter name "${parsed.frontmatter.name}" does not match target skill "${expectedName}".`;
+	if (!parsed.frontmatter.description) return "Frontmatter must include a description field.";
+	if (parsed.frontmatter.description.length > limits.maxDescriptionLength) return `Description exceeds ${limits.maxDescriptionLength} characters.`;
+	if (exceedsContentLimit(content, limits.maxSkillContentChars) && !shrinksOverLimit(content, current, limits.maxSkillContentChars)) return `SKILL.md content exceeds ${limits.maxSkillContentChars} characters. Consider splitting into a smaller SKILL.md with supporting files.`;
+	return null;
+}
+/**
+* Advisory authoring feedback (P0): evaluate frontmatter against the
+* authoring bar WITHOUT changing platform validation semantics. The bar is
+* the quality target, `validateFrontmatter`'s limits are the compatibility
+* floor, and this bridge layer tells the model when its text would be
+* truncated or route-poor instead of silently shipping it.
+*/
+function authoringFeedback(frontmatter) {
+	const description = frontmatter.description ?? "";
+	const over60 = description.length > 60;
+	const hasColon = description.includes(":");
+	const lines = [];
+	lines.push(over60 ? `Description is ${description.length}/60 characters — exceeds the 60-char authoring bar (Hermes standard; the catalog truncates at the configured platform cap).` : `Description ${description.length}/60 characters — within the authoring bar.`);
+	if (hasColon) lines.push("Description contains a colon — wrap the whole value in double quotes.");
+	return {
+		descriptionChars: description.length,
+		over60,
+		hasColon,
+		lines
+	};
+}
+/** A1-15 (v18) / P2-2 (v19): the io layer marks an error `committed: true` when
+* the rename landed and only the directory fsync failed. Every single-file
+* writer must treat that as "written, durability unconfirmed" — never as a
+* plain failure (which a caller would retry, or a two-phase caller roll back).
+* 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/fuzzy-match.js
+/**
+* Fuzzy string matching and replacement for patch/restructure edits of skill files.
+*
+* Split out of skill-store.ts (S2-1): pure text functions with no store state.
+* The store imports the scan, the budgets and the replace entry points directly;
+* none of them is re-exported, so the package export surface is unchanged.
+*/
+function fuzzyIndexOf(content, pattern, from = 0) {
+	const isSpace = (char) => char !== void 0 && /[ \t]/.test(char);
+	const escaped = (char) => {
+		if (char === "n") return "\n";
+		if (char === "t") return "	";
+		if (char === "r") return "\r";
+		return null;
+	};
+	for (let start = from; start < content.length; start += 1) {
+		let contentIndex = start;
+		let patternIndex = 0;
+		while (patternIndex < pattern.length && contentIndex < content.length) {
+			const patternChar = pattern[patternIndex];
+			const contentChar = content[contentIndex];
+			if (isSpace(patternChar)) {
+				while (patternIndex < pattern.length && isSpace(pattern[patternIndex])) patternIndex += 1;
+				while (contentIndex < content.length && isSpace(content[contentIndex])) contentIndex += 1;
+				continue;
+			}
+			const escapedChar = patternChar === "\\" ? escaped(pattern[patternIndex + 1]) : null;
+			if (escapedChar !== null && contentChar === escapedChar) {
+				patternIndex += 2;
+				contentIndex += 1;
+				continue;
+			}
+			if (patternChar === contentChar) {
+				contentIndex += 1;
+				patternIndex += 1;
+				continue;
+			}
+			break;
+		}
+		if (patternIndex === pattern.length) return [start, contentIndex];
+	}
+	return null;
+}
+/** Trim leading whitespace of the first line and trailing whitespace of the last line. */
+function trimPatternBoundaries(pattern) {
+	const from = pattern.search(/\S/);
+	const trimmed = from < 0 ? pattern : pattern.slice(from);
+	const trailing = trimmed.search(/\s+$/);
+	return trailing < 0 ? trimmed : trimmed.slice(0, trailing);
+}
+/** Replace only the fuzzy-matched span, preserving all surrounding bytes.
+* V7-11 (0.3.44): the replaceAll loop accumulates the per-scan cost — the
+* single-scan budget at the caller only bounded ONE fuzzyIndexOf, while an
+* unbounded number of matches × O(n·m) each could still stall the loop.
+* When the accumulated cost exceeds the budget the whole replace fails
+* (null) instead of partially applying an arbitrary prefix. */
+function fuzzyReplace(content, oldString, newString, replaceAll) {
+	let current = content;
+	let scanFrom = 0;
+	let totalWork = 0;
+	for (;;) {
+		totalWork += current.length * oldString.length;
+		if (totalWork > 8e6) return null;
+		const match = fuzzyIndexOf(current, oldString, scanFrom);
+		if (match === null) return current;
+		const [start, end] = match;
+		const next = current.slice(0, start) + newString + current.slice(end);
+		if (!replaceAll) return next;
+		current = next;
+		scanFrom = start + newString.length;
+	}
+}
+function fuzzyPatch(content, oldString, newString, replaceAll = false) {
+	if (oldString === "") return null;
+	if (content.includes(oldString)) return replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, () => newString);
+	const boundary = trimPatternBoundaries(oldString);
+	if (boundary === "") return null;
+	if (boundary !== oldString) {
+		if (fuzzyIndexOf(content, boundary) !== null) return fuzzyReplace(content, boundary, newString, replaceAll);
+	}
+	if (fuzzyIndexOf(content, oldString) !== null) return fuzzyReplace(content, oldString, newString, replaceAll);
+	return null;
+}
+/** Deterministic section-extraction plan facts; the caller owns the IO and the append semantics. */
+//#endregion
+//#region lib/types/skill-store.js
+/**
+* Skill library management for the self-evolution plugin.
+*
+* Skills live under `$DSH_HOME/skills` (`~/.dsh/skills` by default), matching
+* the default dsh skill-filesystem user root. The plugin only manages skills
+* it created unless a `.hermes-managed` marker opts a skill in. Archival is a
+* move to `.archive/` — never a hard delete.
+*
+* ## Concurrency discipline (OPT-09, 2026-09) — read before adding a mutator
+*
+* Three primitives, three distinct jobs (they compose, they do not replace
+* each other):
+*
+* 1. **In-process serial queue** (`this.serial`, makeSerialQueue) — orders the
+*    read→plan→commit phases of one skill's mutation against OTHER mutators
+*    in this process. Used by: create/update/patch/setPinned/restructure/
+*    writeSupportFile/removeSupportFile and (whole-mutation) consolidate.
+*    NON-reentrant: a callback must never call a public method that wraps
+*    itself in `this.serial` (archive/restoreFromArchive deliberately do not).
+* 2. **Per-directory write lock** (io.ts LOCK_*) — cross-process mutual
+*    exclusion plus in-process crash ownership (tickets, takeover). Checked
+*    with `hasWriteLock` before any destructive move (archive/restore/
+*    snapshot); held inside transactIo by byte writers.
+* 3. **CAS baseline (`expected:`)** — any read whose bytes feed a later write
+*    must either live inside the serial section that commits the write, or
+*    carry its plan-time bytes as `expected` so the commit fails closed on
+*    drift (V8-11 / V24-01). A read outside the serial section WITHOUT a
+*    baseline is a lost-update bug; this file's history is the test suite.
+*
+* Known residuals (deliberate, documented at their sites): the archive commit
+* re-check narrows but does not close the pin race (OPT-06); snapshotAll
+* re-probes after its copies so a mid-copy writer demotes to `skipped`
+* (OPT-07); the movers' probe→rename window is owned by the io.ts protocol.
+*/
+/** 0.3.16 (S1.13, T-6): the pointer-line prefix written into a body when a
+* section is moved to references/ — single literal, both restructure and
+* append-mode consolidation emit the same discoverability line. */
+const POINTER_LINE_PREFIX = "> 详见 references/";
+/**
+* Evaluate a stage-time anchor against the bytes a locked read observed.
+* @param anchor - the caller's anchor, or `undefined` for an unanchored write.
+* @param current - the bytes the write lock read (`null` = the target is absent).
+* @returns `match` when the write may proceed, otherwise the refusal verdict.
+*/
+function anchorVerdict(anchor, current) {
+	if (anchor === void 0) return "match";
+	if ("absent" in anchor) return current === null ? "match" : "drift";
+	if (current === null) return "missing";
+	return contentHash(current) === anchor.sha256 ? "match" : "drift";
+}
+/**
+* Build the refusal for a skill write whose anchor did not hold. The wording is
+* the library's own; a caller with staged-replay wording (the skill tool, the
+* review plan) re-words it from {@link SkillActionResult.anchor}.
+* @param name - the skill name the refusal names.
+* @param verdict - the non-matching verdict.
+* @returns the refusal result (nothing was written).
+*/
+function anchorRefusal(name, verdict) {
+	return {
+		ok: false,
+		stale: true,
+		anchor: verdict,
+		message: verdict === "missing" ? `Skill "${name}" not found.` : `Skill "${name}" changed since it was read; the write was refused to avoid overwriting newer content.`
+	};
+}
+/**
+* Build the refusal for a support-file write/remove whose anchor did not hold.
+* @param name - the owning skill name.
+* @param filePath - the support-file path inside the skill.
+* @param verdict - the non-matching verdict.
+* @returns the refusal result (nothing was written or removed).
+*/
+/**
+* Refusal for a target the locked read could not verify at all (EISDIR, an
+* unreadable file). A staged replay reports "could not be verified" instead of
+* propagating an exception: nothing was read, so nothing can have been written.
+* @param name - the owning skill name.
+* @param filePath - the support-file path, or `null` for the skill body.
+* @returns the refusal result.
+*/
+function anchorUnverifiable(name, filePath) {
+	return {
+		ok: false,
+		stale: true,
+		anchor: "drift",
+		message: filePath === null ? `Skill "${name}" could not be read to verify the staged content.` : `Support file "${filePath}" of "${name}" could not be read to verify the staged content.`
+	};
+}
+function anchorRefusalFile(name, filePath, verdict) {
+	return {
+		ok: false,
+		stale: true,
+		anchor: verdict,
+		message: verdict === "missing" ? `File "${filePath}" not found in skill "${name}".` : `Support file "${filePath}" of "${name}" changed since it was read; the write was refused to avoid overwriting newer content.`
+	};
+}
+/**
+* v43 S2-14 (FLOW2-1/flow-3): the target could not be READ at all — EISDIR, an
+* unreadable file, a failing backend. `io.readText` returns null only for a
+* genuinely missing path and throws for everything else, so a raw errno used to
+* escape `update` / `patch` / `write_file` to the model while the remove path had
+* classified the same condition since A-5 (v15). Structured refusal, nothing
+* written.
+*
+* @param label - `name` or `name/filePath`, as the caller's surface names it.
+* @param error - the read failure.
+* @returns the refusal result.
+*/
+function unreadableTarget(label, error) {
+	return {
+		ok: false,
+		message: `Could not read "${label}": ${error?.code === "EISDIR" ? "the path is a DIRECTORY, not a file" : error instanceof Error ? error.message : String(error)}. Nothing was written.`
+	};
+}
+/** Upper bound of moves per restructure proposal (validator and core agree). */
+const MAX_RESTRUCTURE_MOVES = 5;
+/** Restructure targets are plain markdown files under references/ — no
+* subdirectories, no other support kind. V8-10 (0.3.47): the regex-level
+* `(?!.*\.\.)` keeps the restructure-created set EXACTLY the set
+* validateSupportPath can reopen — a `references/my..notes.md` target (double
+* dots) used to pass here while every later patch/write/remove on it was
+* refused as traversal (an orphan file the user could not touch). */
+const RESTRUCTURE_TARGET_RE = /^references\/[a-z0-9](?!.*\.\.)[a-z0-9._-]*\.md$/;
+/** F-20 (v18): the character rule shared by support-file names and snapshot
+* `extras/` entry names. The two exported names used to carry the same literal
+* independently; both now derive from this one. */
+const SUPPORT_ENTRY_NAME_RE = /^[a-z0-9][a-z0-9._-]*$/;
+/** Extra file name carried inside a snapshot's `extras/` directory. */
+const SNAPSHOT_EXTRA_NAME_RE = SUPPORT_ENTRY_NAME_RE;
+function skillsRoot(env = process.env) {
+	return join(evolutionRoot(env), "skills");
 }
-/** Whether `content` would exceed `limit` once written. */
-function exceedsContentLimit(content, limit) {
-	return skillMdOnDisk(content).length > limit;
+/** 0.3.18 (S4.1, E-30): the ONE root resolution for every member that reads
+* the skills tree — tool-skill-manage / evolution-skill-catalog / skill-usage
+* / evolution-learning-graph used to each resolve `config.root || skillsRoot()`
+* (and the graph ignored config entirely). Empty/whitespace config falls
+* through to the default; callers pass their raw Config. The optional field is
+* declared `| undefined` so a config object whose root field is explicitly
+* `string | undefined` still assignable under exactOptionalPropertyTypes. */
+function resolveSkillsRoot(config = {}) {
+	return (config.root ?? "").trim() || skillsRoot();
 }
-/** S1.2: the repair path — a write that makes an already-over-limit file smaller.
-* Only a NET SHRINK is exempt; an equal or larger write stays refused. */
-function shrinksOverLimit(next, current, limit) {
-	if (current === null || current === void 0 || !exceedsContentLimit(current, limit)) return false;
-	return skillMdOnDisk(next).length < skillMdOnDisk(current).length;
+/** E-7 (v18) → V27 G2.4 (M-08): every family row reads ONE root key. `root` is
+* canonical; the `skillsRoot` alias was honoured for one minor version and its
+* window closed at 0.3.65 — it is now two releases past expiry, so this
+* resolver no longer reads it at all. A deployment that still sets the alias
+* must fail LOUDLY at load (see {@link assertSkillsRootAliasRetired}): silently
+* ignoring a config key leaves the deployment pointing at a root nobody reads,
+* which is the worst form of compatibility.
+* @param config - the raw plugin config.
+* @returns the effective root (empty when the key is unset or blank).
+*/
+function resolveRootConfig(config = {}) {
+	return { root: (config.root ?? "").trim() };
 }
-function validateFrontmatter(content, expectedName, limits = DEFAULT_SKILL_LIMITS, current) {
-	const parsed = parseFrontmatter(content);
-	if (!parsed) return "SKILL.md must start with a `---` line, close the frontmatter with another exact `---` line (only a trailing `\\r` is tolerated), and include a body below it.";
-	const unreadable = parsed.platformStringSplit.filter((entry) => entry.kind === "sequence" || entry.kind === "mapping");
-	if (unreadable.length > 0) return `Frontmatter field ${unreadable.map((entry) => `"${entry.key}" (a YAML ${entry.kind})`).join(", ")} must be a string: the platform skill catalog reads such a field as absent and ignores the whole file. Write plain text, or wrap the value in double quotes to keep it literally.`;
-	if (!parsed.frontmatter.name) return "Frontmatter must include a name field.";
-	if (!SKILL_NAME_RE.test(parsed.frontmatter.name)) return `Invalid skill name "${parsed.frontmatter.name}" — use lowercase letters, digits, and hyphens.`;
-	if (parsed.frontmatter.name.length > limits.maxNameLength) return `Skill name exceeds ${limits.maxNameLength} characters.`;
-	if (expectedName && parsed.frontmatter.name !== expectedName) return `Frontmatter name "${parsed.frontmatter.name}" does not match target skill "${expectedName}".`;
-	if (!parsed.frontmatter.description) return "Frontmatter must include a description field.";
-	if (parsed.frontmatter.description.length > limits.maxDescriptionLength) return `Description exceeds ${limits.maxDescriptionLength} characters.`;
-	if (exceedsContentLimit(content, limits.maxSkillContentChars) && !shrinksOverLimit(content, current, limits.maxSkillContentChars)) return `SKILL.md content exceeds ${limits.maxSkillContentChars} characters. Consider splitting into a smaller SKILL.md with supporting files.`;
-	return null;
+/** V27 G2.4 (M-08): the retirement gate for the expired `skillsRoot` alias.
+* Called at each plugin's load boundary (before the root is resolved), it turns
+* a stale key into an explicit load error naming the replacement — the
+* fail-loud form the plan requires instead of a silent no-op.
+* @param config - the raw plugin config (the alias field stays DECLARED in each
+* schema so the loader can hand it here instead of dropping it).
+*/
+function assertSkillsRootAliasRetired(config = {}) {
+	if ((config.skillsRoot ?? "").trim() !== "") throw new Error("evolution: config \"skillsRoot\" was removed after 0.3.65 — rename the key to \"root\" (the alias is no longer honoured)");
 }
 /**
-* Advisory authoring feedback (P0): evaluate frontmatter against the
-* authoring bar WITHOUT changing platform validation semantics. The bar is
-* the quality target, `validateFrontmatter`'s limits are the compatibility
-* floor, and this bridge layer tells the model when its text would be
-* truncated or route-poor instead of silently shipping it.
+* Map a requesting session onto the two origin surfaces (rc.44 plan M2-2.3):
+* the APPROVAL surface treats every delegated subagent as the autonomous
+* review channel, while the LIBRARY surface keeps the Hermes distinction -
+* the review fork is 'background_review' (the pinned guard blocks its
+* writes) and any other subagent is 'subagent' (agent-authored, not
+* review-channel). `isReview` marks the caller as the background review
+* pipeline itself. Single source: the two tools and the review executor all
+* read this table instead of re-deriving it.
 */
-function authoringFeedback(frontmatter) {
-	const description = frontmatter.description ?? "";
-	const over60 = description.length > 60;
-	const hasColon = description.includes(":");
-	const lines = [];
-	lines.push(over60 ? `Description is ${description.length}/60 characters — exceeds the 60-char authoring bar (Hermes standard; the catalog truncates at the configured platform cap).` : `Description ${description.length}/60 characters — within the authoring bar.`);
-	if (hasColon) lines.push("Description contains a colon — wrap the whole value in double quotes.");
+function resolveOrigins(headerOrigin, isReview = false) {
+	if (isReview) return {
+		approval: "background_review",
+		library: "background_review"
+	};
+	if (headerOrigin === "subagent") return {
+		approval: "background_review",
+		library: "subagent"
+	};
 	return {
-		descriptionChars: description.length,
-		over60,
-		hasColon,
-		lines
+		approval: "foreground",
+		library: "foreground"
 	};
 }
-/** A1-15 (v18) / P2-2 (v19): the io layer marks an error `committed: true` when
-* the rename landed and only the directory fsync failed. Every single-file
-* writer must treat that as "written, durability unconfirmed" — never as a
-* plain failure (which a caller would retry, or a two-phase caller roll back).
-* v28 G2.1 (EVO-IO-05): this is a delegation to the seam's own
-* `isCommittedWarning` — the marker predicate has exactly one definition. */
+/**
+* S1-E8 (0.3.80): ONE exec→origins resolution for the two write tools — reads
+* the session header origin AND the v37 S2.2 review-channel session mark, so a
+* tool cannot forget the mark half (tool-memory shipped without it, which
+* mislabeled every inject-mode review memory write as `foreground` and let it
+* bypass staging under `stageForeground: false`).
+* Single source: both tools call this instead of re-deriving the pair.
+*/
+function resolveExecOrigins(exec) {
+	const session = exec?.agent?.session;
+	return resolveOrigins(session?.header?.origin, isReviewChannelSession(typeof session?.id === "string" ? session.id : void 0));
+}
+function skillDir(root, name) {
+	return join(root, name);
+}
+/** Dot-prefixed on-disk marker name. SINGLE source: `list()` matches directory
+* entries against this name, and path builders must never hardcode a marker
+* literal (N-1: the rc.49 exists()-probe convergence dropped the dot,
+* poisoning every protectedBy/managed report). Exported for cross-package
+* consumers that must probe markers without re-deriving the name (curator's
+* archive-copy bundled probe, 0.3.26 V4-02). */
+function markerEntryName(marker) {
+	return `.${marker}`;
+}
+/** F-17 (v18): the root-level lock files a DESTRUCTIVE MOVER must treat as an
+* active writer (skill body + the two marker writers). Single source with
+* `markerEntryName`/`LOCK_SUFFIX` so a renamed marker cannot silently drop out
+* of the ghost-writer probe. */
+const MARKER_LOCK_NAMES = [
+	`SKILL.md${LOCK_SUFFIX}`,
+	`.pinned${LOCK_SUFFIX}`,
+	`.hermes-managed${LOCK_SUFFIX}`
+];
+/** v23 (ML-1): `.archive` retention window (see pruneExpiredArchives). */
+const ARCHIVE_RETENTION_DAYS = 365;
+function markerPath(dir, marker) {
+	return join(dir, markerEntryName(marker));
+}
 function isCommittedOnly(error) {
 	return isCommittedWarning(error);
 }
@@ -5481,99 +5703,6 @@ function validateSupportPath(filePath) {
 	return null;
 }
 /**
-* Index of `pattern` inside `content`, treating whitespace runs (spaces/tabs)
-* as flexible and literal escape sequences (`\n`, `\t`, `\r`) as their real
-* characters: a PATTERN whitespace run matches any content run of any length
-* (even empty), while extra whitespace that only exists in the content is not
-* skipped — the flexibility is one-sided on the pattern, and a backslash-
-* escaped char in the pattern matches the real char in the content
-* (model-copy drift). Returns the [start, end) range in the ORIGINAL content
-* so a patch can replace exactly the matched span and keep every other byte
-* intact. Returns null when no fuzzy match exists.
-*/
-function fuzzyIndexOf(content, pattern, from = 0) {
-	const isSpace = (char) => char !== void 0 && /[ \t]/.test(char);
-	const escaped = (char) => {
-		if (char === "n") return "\n";
-		if (char === "t") return "	";
-		if (char === "r") return "\r";
-		return null;
-	};
-	for (let start = from; start < content.length; start += 1) {
-		let contentIndex = start;
-		let patternIndex = 0;
-		while (patternIndex < pattern.length && contentIndex < content.length) {
-			const patternChar = pattern[patternIndex];
-			const contentChar = content[contentIndex];
-			if (isSpace(patternChar)) {
-				while (patternIndex < pattern.length && isSpace(pattern[patternIndex])) patternIndex += 1;
-				while (contentIndex < content.length && isSpace(content[contentIndex])) contentIndex += 1;
-				continue;
-			}
-			const escapedChar = patternChar === "\\" ? escaped(pattern[patternIndex + 1]) : null;
-			if (escapedChar !== null && contentChar === escapedChar) {
-				patternIndex += 2;
-				contentIndex += 1;
-				continue;
-			}
-			if (patternChar === contentChar) {
-				contentIndex += 1;
-				patternIndex += 1;
-				continue;
-			}
-			break;
-		}
-		if (patternIndex === pattern.length) return [start, contentIndex];
-	}
-	return null;
-}
-/** V6-17 (0.3.37): the fuzzy-patch scan is O(n·m) with no input bound; a
-* non-exact anchor past these budgets would block the event loop (measured
-* ~6s at 20k×20k). Exact matches go through the fast `includes` path and stay
-* allowed regardless of size. */
-const FUZZY_MAX_PATTERN_CHARS = 4096;
-const FUZZY_MAX_WORK = 8e6;
-/** Trim leading whitespace of the first line and trailing whitespace of the last line. */
-function trimPatternBoundaries(pattern) {
-	const from = pattern.search(/\S/);
-	const trimmed = from < 0 ? pattern : pattern.slice(from);
-	const trailing = trimmed.search(/\s+$/);
-	return trailing < 0 ? trimmed : trimmed.slice(0, trailing);
-}
-/** Replace only the fuzzy-matched span, preserving all surrounding bytes.
-* V7-11 (0.3.44): the replaceAll loop accumulates the per-scan cost — the
-* single-scan budget at the caller only bounded ONE fuzzyIndexOf, while an
-* unbounded number of matches × O(n·m) each could still stall the loop.
-* When the accumulated cost exceeds the budget the whole replace fails
-* (null) instead of partially applying an arbitrary prefix. */
-function fuzzyReplace(content, oldString, newString, replaceAll) {
-	let current = content;
-	let scanFrom = 0;
-	let totalWork = 0;
-	for (;;) {
-		totalWork += current.length * oldString.length;
-		if (totalWork > FUZZY_MAX_WORK) return null;
-		const match = fuzzyIndexOf(current, oldString, scanFrom);
-		if (match === null) return current;
-		const [start, end] = match;
-		const next = current.slice(0, start) + newString + current.slice(end);
-		if (!replaceAll) return next;
-		current = next;
-		scanFrom = start + newString.length;
-	}
-}
-function fuzzyPatch(content, oldString, newString, replaceAll = false) {
-	if (oldString === "") return null;
-	if (content.includes(oldString)) return replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, () => newString);
-	const boundary = trimPatternBoundaries(oldString);
-	if (boundary === "") return null;
-	if (boundary !== oldString) {
-		if (fuzzyIndexOf(content, boundary) !== null) return fuzzyReplace(content, boundary, newString, replaceAll);
-	}
-	if (fuzzyIndexOf(content, oldString) !== null) return fuzzyReplace(content, oldString, newString, replaceAll);
-	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
@@ -5692,7 +5821,7 @@ var SkillLibrary = class {
 		if (this.transact) try {
 			await this.transact(this.io, path, run);
 		} catch (error) {
-			if (!progress.entered && readFailure !== void 0) return readFailure;
+			if (!progress.entered && readFailure !== void 0) return readFailure(error);
 			if (!committedOnly(error)) throw error;
 			durabilityWarning = error instanceof Error ? error.message : String(error);
 		}
@@ -5701,7 +5830,7 @@ var SkillLibrary = class {
 			try {
 				current = await this.io.readText(path);
 			} catch (error) {
-				if (readFailure !== void 0) return readFailure;
+				if (readFailure !== void 0) return readFailure(error);
 				throw error;
 			}
 			const next = await run(current);
@@ -6104,7 +6233,17 @@ var SkillLibrary = class {
 			ok: false,
 			message: `Skill "${normalized}" already exists.`
 		};
-		for (const entry of await this.io.list(this.root).catch(() => [])) if (typeof entry === "string" && entry !== normalized && entry.toLowerCase() === normalized.toLowerCase()) return {
+		let rootEntries;
+		try {
+			rootEntries = await this.io.list(this.root);
+		} catch (error) {
+			const cause = error instanceof Error ? error.message : String(error);
+			return {
+				ok: false,
+				message: `Skill "${normalized}" could not be checked for a case-variant collision: listing ${this.root} failed (${cause}). Refusing the create — a second directory differing only in case cannot be undone across platforms.`
+			};
+		}
+		for (const entry of rootEntries) if (typeof entry === "string" && entry !== normalized && entry.toLowerCase() === normalized.toLowerCase()) return {
 			ok: false,
 			message: `Skill "${normalized}" collides with the existing case-variant directory "${entry}" (skill names are lowercase-only); rename one of them.`
 		};
@@ -6120,6 +6259,7 @@ var SkillLibrary = class {
 		let createDurabilityWarning = "";
 		if (this.transact) try {
 			await this.transact(this.io, createPath, (current) => {
+				existsAtCommit = false;
 				taskRan = true;
 				if (current !== null) {
 					existsAtCommit = true;
@@ -6267,7 +6407,7 @@ var SkillLibrary = class {
 					skillDir: dir
 				}
 			};
-		}, anchor !== void 0 ? anchorUnverifiable(name, null) : void 0);
+		}, anchor !== void 0 ? () => anchorUnverifiable(name, null) : (error) => unreadableTarget(name, error));
 	}
 	async patch(rawName, oldString, newString, filePath = "", replaceAll = false, origin = "foreground") {
 		const name = rawName.trim();
@@ -6310,7 +6450,7 @@ var SkillLibrary = class {
 				},
 				write: null
 			};
-			if (!md.includes(oldString) && (oldString.length > FUZZY_MAX_PATTERN_CHARS || md.length * oldString.length > FUZZY_MAX_WORK)) return {
+			if (!md.includes(oldString) && (oldString.length > 4096 || md.length * oldString.length > 8e6)) return {
 				result: {
 					ok: false,
 					message: `old_string too large for fuzzy match (${oldString.length} chars in ${patchLabel}); use update for a full rewrite or a narrower anchor.`
@@ -6421,7 +6561,7 @@ var SkillLibrary = class {
 					skillDir: dir
 				}
 			};
-		});
+		}, (error) => unreadableTarget(name + "/" + patchLabel, error));
 	}
 	/**
 	* P2-9 (v15): the destructive directory move shared by archive and
@@ -7009,6 +7149,7 @@ var SkillLibrary = class {
 						const drift = { seen: false };
 						const ran = { done: false };
 						await this.transact(this.io, entry.target, (current) => {
+							drift.seen = false;
 							ran.done = true;
 							if (current !== baseline) {
 								drift.seen = true;
@@ -7223,7 +7364,7 @@ var SkillLibrary = class {
 					file: target
 				}
 			};
-		}, anchor !== void 0 ? anchorUnverifiable(name, filePath) : void 0);
+		}, anchor !== void 0 ? () => anchorUnverifiable(name, filePath) : (error) => unreadableTarget(name + "/" + filePath, error));
 	}
 	async removeSupportFile(rawName, filePath, origin = "foreground", anchor) {
 		const name = rawName.trim();
@@ -7651,6 +7792,35 @@ function newSkillLibrary(options) {
 */
 const FAMILY_SESSION_TOOL_NAMES = ["skill_manage", "memory"];
 /**
+* S0-4 (v43 J-1 / G-1): the process-wide witness behind the deployment
+* diagnostic. A scoped false is the CORRECT answer for a session that did not
+* opt in, so the miss alone proves nothing — "no session in this process ever
+* matched" is the shape both real faults share, and only a witness that outlives
+* one session can tell it from a healthy per-session skip.
+*
+* Module scope on purpose: the claim spans every session and every row of this
+* process, so no single row's fiber owns it. Monotone scalars with no per-key
+* lifecycle — the N12 registry covers module-scope Set/Map/WeakMap stores, which
+* carry entries that do need one.
+*/
+let scopedProbeHits = 0;
+let scopedProbeMisses = 0;
+let scopedProbeWarned = false;
+/**
+* Read the witness for a diagnostic surface (`/evolution doctor`). Read-only: it
+* neither evaluates the probe nor consumes the one-time warn, so a report run
+* cannot change what the next miss would have logged.
+* @returns the verdict with both counts, zeroed in a process where the gate has
+* not run.
+*/
+function scopedProbeReport() {
+	return {
+		verdict: scopedProbeHits > 0 ? "hit" : scopedProbeMisses > 0 ? "never-hit" : "idle",
+		hits: scopedProbeHits,
+		misses: scopedProbeMisses
+	};
+}
+/**
 * Does this session's scope see the family's model tools?
 *
 * The scope is the live agent's — the platform's own addressing for "what does
@@ -7671,6 +7841,23 @@ function sessionSeesFamilyTools(ctx, sessionId) {
 	return FAMILY_SESSION_TOOL_NAMES.some((name) => tools.get(name, scope) !== void 0);
 }
 /**
+* S0-4 (v43 J-1 / G-1): record a scoped rejection and leave the one-time
+* deployment diagnostic.
+*
+* Fires at most once per process, on the first miss, and only while nothing has
+* ever matched. The message names the check rather than guessing the deployment
+* form: a host-only install and a disabled model row are the two shapes that can
+* never match, while the layered variant form legitimately waits for a session
+* that selected the Evolution preset.
+* @param ctx - the asking row's context; the warn rides that row's own logger.
+*/
+function noteScopedProbeMiss(ctx) {
+	scopedProbeMisses += 1;
+	if (scopedProbeHits > 0 || scopedProbeWarned) return;
+	scopedProbeWarned = true;
+	ctx.logger.warn("dsh-evolution: sessionScoped is on but the family-tool probe has never matched a session in this process — review injection and skill-usage telemetry are inert for every session seen so far. Check whether the family's model rows are mounted at all: tool-memory / tool-skill-manage are devDependencies of @lmzhen/dsh-evolution-host, so a HOST-ONLY install can never match, and a profile overlay that disables either row has the same effect. Under the layered VARIANT form only a session on the Evolution preset matches, so a miss there just means none has run yet. Next: /evolution doctor reports the scoped rows and this verdict (see INSTALL.md).");
+}
+/**
 * The one decision every cross-session consumer calls before it acts.
 * @param ctx - a context of the runtime.
 * @param sessionId - the session the event belongs to.
@@ -7678,11 +7865,17 @@ function sessionSeesFamilyTools(ctx, sessionId) {
 * @returns true when the consumer may act on this session. A deployment that did
 * not declare session scoping always answers true (the historical behavior);
 * a scoped one answers true only for a session that carries the family's model
-* tools.
+* tools. Each scoped answer updates the process witness, and the first miss with
+* no match ever leaves one warn (see {@link noteScopedProbeMiss}).
 */
 function sessionAudited(ctx, sessionId, sessionScoped) {
 	if (sessionScoped !== true) return true;
-	return sessionSeesFamilyTools(ctx, sessionId);
+	if (sessionSeesFamilyTools(ctx, sessionId)) {
+		scopedProbeHits += 1;
+		return true;
+	}
+	noteScopedProbeMiss(ctx);
+	return false;
 }
 //#endregion
-export { AUTHORING_DESCRIPTION_BAR, COMBINED_REVIEW_PLAN_PROMPT, COMBINED_REVIEW_PROMPT, COMPLETION_SKILL_REVIEW_PROMPT, CURATOR_DRY_RUN_BANNER, CURATOR_PROMPT, DEAD_LOCK_TAKEOVER_MS, DEFAULT_ARCHIVE_AFTER_DAYS, 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_REVIEW_CONTEXT_MESSAGES, DEFAULT_REVIEW_MEMORY_INTERVAL, DEFAULT_REVIEW_MESSAGE_CHARS, DEFAULT_REVIEW_SKILL_INTERVAL, DEFAULT_REVIEW_TIMEOUT_MS, DEFAULT_SKILL_CONTENT_CHARS, DEFAULT_SKILL_LIMITS, DEFAULT_SKILL_REVIEW_COMPLETION_MIN_TOOL_CALLS, DEFAULT_SKILL_REVIEW_MODEL, DEFAULT_SKILL_REVIEW_TRIGGER, DEFAULT_STALE_AFTER_DAYS, DEFAULT_SUBSTANTIVE_MIN_AGENT_CHARS, DEFAULT_SUBSTANTIVE_MIN_TOOL_CALLS, DEFAULT_SUBSTANTIVE_MIN_USER_CHARS, DEFAULT_USER_CHAR_LIMIT, DISPATCH_EVENT_TYPES, DRIFT_MAX_LINE_CHARS, DRIFT_SIGNALS_VERSION, DRIFT_SIGNAL_NOUNS, DSH_AUTHORING_STANDARDS, EMPTY_LOCK_TAKEOVER_MS, ENTRY_DELIMITER, EVENT_ARCHIVE_PREFIX, EVENT_LOG_RETAIN_ARCHIVES, EVENT_LOG_ROTATE_AT, EVENT_LOG_VERSION, EVOLUTION_WRITE_TOOLS, EvolutionGateSet, FAMILY_SESSION_TOOL_NAMES, FORBIDDEN_CONTROL_KEYS, HEALTH_STAMP_RE, INSTANCE_KEYS, LOCK_BODY_RE, LOCK_SUFFIX, LOCK_TEAR_TAKEOVER_MS, LOW_QUALITY_THRESHOLD, LostWriteLock, MAINTAIN_OUTPUT_INSTRUCTION, MAINTAIN_PROMPT, MAX_DESCRIPTION_LENGTH, MAX_RESTRUCTURE_MOVES, MAX_SKILL_CONTENT_CHARS, MAX_SKILL_FILE_BYTES, MAX_SKILL_NAME_LENGTH, MAX_TIMER_DELAY_MS, MEMORY_GUIDANCE_SECTION_ORDER, MEMORY_REVIEW_PROMPT, MIN_STAMP_BODY_CHARS, MUTATIONS_FILE_VERSION, MemoryStore, NATIVE_CALL_EVENT, NATIVE_RESULT_EVENT, PATTERN_OVERLAP, PERSISTED_WRITE_SITES, PROMPT_BUNDLE, PROMPT_BUNDLE_ID, PROMPT_BUNDLE_VERSION, PROTECTED_BUILTIN_SKILLS, PTC_DISPATCH_EVENT, PTC_DISPATCH_START_EVENT, QUALITY_WEIGHTS, RESTRUCTURE_TARGET_RE, SKILLS_GUIDANCE, SKILLS_GUIDANCE_SECTION_ORDER, SKILL_ACTION_REQUIRED_FIELDS, SKILL_NAME_RE, SKILL_REVIEW_PLAN_PROMPT, SKILL_REVIEW_PROMPT, SNAPSHOT_EXTRA_NAME_RE, SUPPORT_DIRS, SUPPRESSED_FILE_VERSION, SkillLibrary, THREAT_EXEMPTION_HINT, ToolDispatchNormalizer, ToolDispatchPayloadError, advanceReview, allowRowCollisions, appendEvolutionEvent, applyCuratorLifecycleFields, applyCuratorMetaFields, assertDispatchPayload, assertSkillsRootAliasRetired, assessStructureHealth, authoringFeedback, buildCuratorRunReport, buildLearnPrompt, bumpPatch, bumpUse, bumpView, callingScope, claimInstance, clampedNumber, clearReviewChannel, collectReadSkillNames, composePresetComposition, computeDedupGroups, computeDriftSignals, computeLifecycleTransitions, computePrefixClusters, computeQualityScores, computeScopeView, contentHash, countDispatches, createGateSet, decideTakeover, duplicateHeadings, emptyRecord, evaluateThreat, eventsFile, evolutionEventPayloadIssue, evolutionHome, evolutionIoAdapter, evolutionRoot, findDriftSignal, foldCuratorFields, foldToolDispatches, foldTurn, frontmatterBlock, frontmatterCatalogInvalid, getRecord, instanceClaimKey, instanceClaimedWriteSites, instanceHolder, isAbsent, isCommittedWarning, isGlobalRead, isMissingPath, isPresent, isProcessAlive, isProgramToolName, isReviewChannelSession, isSkillReadToolName, isSkillToolName, isUnknown, latestActivityAt, lifecycleCandidate, listEventArchives, loadMutations, loadRowOverrides, loadSuppressedNames, loadUsage, makeSerialQueue, mapProbe, markAgentCreated, markReviewChannel, markerEntryName, memoryRoot, missingSupportPointers, mutateUsage, mutationsFile, narrowNameMatches, neutralizePromptVariables, newSkillLibrary, nodeEvolutionIo, normalizeFrontmatter, normalizeUsageRecord, observeEvent, overlongLines, parseCuratorNominations, parseEvolutionEvents, parseFrontmatter, parseLockBody, pendingSelfCleanup, persistedWriteSite, probeAbsent, probeList, probeMtime, probePresent, probeReason, probeUnknown, readDispatchSignal, readEvolutionEvents, readEvolutionTimeline, recordMutation, redactSecrets, relatedSkillNames, releaseInstance, renameWithRetry, renderCuratorReportMarkdown, resolveExecOrigins, resolveOrigins, resolveRootConfig, resolveSkillsRoot, retainEventArchives, reviewPrompt, saveSuppressedNames, saveUsage, scanContentThreats, scanMemoryThreats, scanThreats, sessionAudited, sessionSeesFamilyTools, skillReadNameOf, skillsRoot, suppressedFile, sweepReviewChannelSessions, transactIo, updateSuppressedNames, usageFile, usageObserved, validateFrontmatter, validateRestructureTarget, valueOr, verifyPromptBundle, writeDurableTmp, yamlPlainScalarNeedsQuotes };
+export { AUTHORING_DESCRIPTION_BAR, COMBINED_REVIEW_PLAN_PROMPT, COMBINED_REVIEW_PROMPT, COMPLETION_SKILL_REVIEW_PROMPT, CURATOR_DRY_RUN_BANNER, CURATOR_PROMPT, DEAD_LOCK_TAKEOVER_MS, DEFAULT_ARCHIVE_AFTER_DAYS, 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_REVIEW_CONTEXT_MESSAGES, DEFAULT_REVIEW_MEMORY_INTERVAL, DEFAULT_REVIEW_MESSAGE_CHARS, DEFAULT_REVIEW_SKILL_INTERVAL, DEFAULT_REVIEW_TIMEOUT_MS, DEFAULT_SKILL_CONTENT_CHARS, DEFAULT_SKILL_LIMITS, DEFAULT_SKILL_REVIEW_COMPLETION_MIN_TOOL_CALLS, DEFAULT_SKILL_REVIEW_MODEL, DEFAULT_SKILL_REVIEW_TRIGGER, DEFAULT_STALE_AFTER_DAYS, DEFAULT_SUBSTANTIVE_MIN_AGENT_CHARS, DEFAULT_SUBSTANTIVE_MIN_TOOL_CALLS, DEFAULT_SUBSTANTIVE_MIN_USER_CHARS, DEFAULT_USER_CHAR_LIMIT, DISPATCH_EVENT_TYPES, DRIFT_MAX_LINE_CHARS, DRIFT_SIGNALS_VERSION, DRIFT_SIGNAL_NOUNS, DSH_AUTHORING_STANDARDS, EMPTY_LOCK_TAKEOVER_MS, ENTRY_DELIMITER, EVENT_ARCHIVE_PREFIX, EVENT_LOG_RETAIN_ARCHIVES, EVENT_LOG_ROTATE_AT, EVENT_LOG_VERSION, EVOLUTION_WRITE_TOOLS, EvolutionGateSet, FAMILY_SESSION_TOOL_NAMES, FORBIDDEN_CONTROL_KEYS, HEALTH_STAMP_RE, INSTANCE_KEYS, LOCK_BODY_RE, LOCK_SUFFIX, LOCK_TEAR_TAKEOVER_MS, LOW_QUALITY_THRESHOLD, LostWriteLock, MAINTAIN_OUTPUT_INSTRUCTION, MAINTAIN_PROMPT, MAX_DESCRIPTION_LENGTH, MAX_RESTRUCTURE_MOVES, MAX_SKILL_CONTENT_CHARS, MAX_SKILL_FILE_BYTES, MAX_SKILL_NAME_LENGTH, MAX_TIMER_DELAY_MS, MEMORY_GUIDANCE_SECTION_ORDER, MEMORY_REVIEW_PROMPT, MIN_STAMP_BODY_CHARS, MUTATIONS_FILE_VERSION, MemoryStore, NATIVE_CALL_EVENT, NATIVE_RESULT_EVENT, PATTERN_OVERLAP, PROMPT_BUNDLE, PROMPT_BUNDLE_ID, PROMPT_BUNDLE_VERSION, PROTECTED_BUILTIN_SKILLS, PTC_DISPATCH_EVENT, PTC_DISPATCH_START_EVENT, QUALITY_WEIGHTS, RESTRUCTURE_TARGET_RE, SKILLS_GUIDANCE, SKILLS_GUIDANCE_SECTION_ORDER, SKILL_ACTION_REQUIRED_FIELDS, SKILL_NAME_RE, SKILL_REVIEW_PLAN_PROMPT, SKILL_REVIEW_PROMPT, SNAPSHOT_EXTRA_NAME_RE, SUPPORT_DIRS, SUPPRESSED_FILE_VERSION, SkillLibrary, THREAT_EXEMPTION_HINT, ToolDispatchNormalizer, ToolDispatchPayloadError, advanceReview, allowRowCollisions, appendEvolutionEvent, applyCuratorLifecycleFields, applyCuratorMetaFields, assertDispatchPayload, assertSkillsRootAliasRetired, assessStructureHealth, authoringFeedback, buildCuratorRunReport, buildLearnPrompt, bumpPatch, bumpUse, bumpView, callingScope, claimInstance, clampedNumber, clearReviewChannel, collectReadSkillNames, composePresetComposition, computeDedupGroups, computeDriftSignals, computeLifecycleTransitions, computePrefixClusters, computeQualityScores, computeScopeView, contentHash, countDispatches, createGateSet, decideTakeover, duplicateHeadings, emptyRecord, evaluateThreat, eventsFile, evolutionEventPayloadIssue, evolutionHome, evolutionIoAdapter, evolutionRoot, findDriftSignal, foldCuratorFields, foldToolDispatches, foldTurn, frontmatterBlock, frontmatterCatalogInvalid, getRecord, instanceClaimKey, instanceClaimedWriteSites, instanceHolder, isAbsent, isCommittedWarning, isGlobalRead, isMissingPath, isPresent, isProcessAlive, isProgramToolName, isReviewChannelSession, isSkillReadToolName, isSkillToolName, isUnknown, latestActivityAt, lifecycleCandidate, listEventArchives, loadMutations, loadRowOverrides, loadSuppressedNames, loadUsage, makeSerialQueue, mapProbe, markAgentCreated, markReviewChannel, markerEntryName, memoryRoot, missingSupportPointers, mutateUsage, mutationsFile, narrowNameMatches, neutralizePromptVariables, newSkillLibrary, nodeEvolutionIo, normalizeFrontmatter, normalizeUsageRecord, observeEvent, overlongLines, parseCuratorNominations, parseEvolutionEvents, parseFrontmatter, parseLockBody, pendingSelfCleanup, persistedWriteSite, persistedWriteSites, probeAbsent, probeList, probeMtime, probePresent, probeReason, probeUnknown, readDispatchSignal, readEvolutionEvents, readEvolutionTimeline, recordMutation, redactSecrets, relatedSkillNames, releaseInstance, renameWithRetry, renderCuratorReportMarkdown, resolveExecOrigins, resolveOrigins, resolveRootConfig, resolveSkillsRoot, retainEventArchives, reviewPrompt, saveSuppressedNames, saveUsage, scanContentThreats, scanMemoryThreats, scanThreats, scopedProbeReport, sessionAudited, sessionSeesFamilyTools, skillReadNameOf, skillsRoot, suppressedFile, sweepReviewChannelSessions, transactIo, transactTaskGuard, updateSuppressedNames, usageFile, usageObserved, validateFrontmatter, validateRestructureTarget, valueOr, verifyPromptBundle, writeDurableTmp, yamlPlainScalarNeedsQuotes };