@lmzhen/dsh-evolution-core 0.22.0 → 0.23.0

package/lib/index.js

@@ -1,9 +1,9 @@
 import { parse } from "yaml";
 import { basename, dirname, join, resolve } from "node:path";
-import { cp, lstat, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { copyFileSync, existsSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { cp, lstat, mkdir, open, readFile, readdir, rename, rm, stat } from "node:fs/promises";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
-import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { scopeOf } from "@deepseek-ai/dsh-scope";
 import { z } from "zod";
@@ -1157,6 +1157,34 @@ function bodyCost(content) {
 	};
 }
 //#endregion
+//#region lib/types/guards.js
+/**
+* The family's plain-object predicate, in ONE place (v46 G7.1 / audit A8).
+*
+* The audit found the same guard — "a non-null object that is not an array" — rewritten fifteen
+* times across nine packages, four times inside core itself, and with two byte-identical `asRecord`
+* copies in evolution-policy and evolution-threat. This module is the single definition; callers
+* import it instead of spelling the clause again.
+*
+* @module @lmzhen/dsh-evolution-core
+*/
+/**
+* Is this a non-null, non-array object (what JSON calls an object)?
+* @param value - the value to test.
+* @returns whether it is a plain object.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Read a value as a record, or undefined when it is not one.
+* @param value - the value to read.
+* @returns the value typed as a record, or undefined.
+*/
+function asRecord(value) {
+	return isRecord(value) ? value : void 0;
+}
+//#endregion
 //#region lib/types/probe.js
 function probePresent(value) {
 	return {
@@ -1356,37 +1384,6 @@ function evolutionIoAdapter(provider) {
 		}
 	};
 }
-/**
-* F-367 (②): lock paths whose release (the finally `rm`) failed. The next write
-* to the same file proactively recycles our own leftover lock — the holder is
-* us, so a leftover is stale by definition. Module-level by design: it must
-* survive across `nodeEvolutionIo()` instances for the self-heal to be
-* effective. (Not a pure function — the cross-call state is the intent.)
-* V4-05: this set — not an mtime heuristic — is the ONLY signal that a
-* same-pid lock is a leftover rather than a live in-process task, so it is the
-* sole gate for the self-pid recycle branch. Exported (read-only in practice)
-* so `io.spec.ts` can drive the self-heal path deterministically.
-*/
-const pendingSelfCleanup = /* @__PURE__ */ new Map();
-/** P2-7 (v11)/P3-10 (v14): record a failed release so the next write to this
-* path self-heals it, keeping the map's 64-entry cap — a never-re-touched path
-* must not pin it, while a path whose lock still EXISTS is the last to drop
-* (dropping it disables the self-heal for a lock that is really there). */
-const recordPendingSelfCleanup = async (lock, token) => {
-	if (pendingSelfCleanup.size >= 64) {
-		let droppable;
-		for (const candidate of pendingSelfCleanup.keys()) {
-			if (candidate === lock) continue;
-			if (await readFile(candidate, "utf8").then(() => false, () => true)) {
-				droppable = candidate;
-				break;
-			}
-		}
-		const victim = droppable ?? pendingSelfCleanup.keys().next().value;
-		if (victim !== void 0) pendingSelfCleanup.delete(victim);
-	}
-	pendingSelfCleanup.set(lock, token);
-};
 const RENAME_RETRY_BASE_MS = 50;
 const RENAME_RETRY_MAX_DELAY_MS = 800;
 const RENAME_RETRY_MAX_ATTEMPTS = 6;
@@ -1514,73 +1511,14 @@ function isProcessAlive(pid) {
 		return error?.code === "EPERM";
 	}
 }
-/** F-17 (v18): the write-lock protocol is a cross-module contract — the lock
-* file is `<target>.lock` and its body is `<pid>:<token>`. This module creates
-* them (`withWriteLock`) and `skill-store`'s probes/sweepers parse them, so both
-* consume these two constants instead of repeating the literals. */
-const LOCK_SUFFIX = ".lock";
-/** Writer-lock body shape: a decimal pid, a colon, then the claim token. A
-* torn body (no parsable pid) still matches the `\\d+:` prefix rule only when
-* the pid part is intact, which is what the takeover probe needs. The capture
-* group feeds `parseLockBody` (v20 A-1: skill-store's sweepers consume this
-* helper instead of re-inlining a third regex copy — F-17 single-source). */
-const LOCK_BODY_RE = /^(\d+):[0-9a-f]*$/;
-/** Parse a writer-lock body into its holder pid. `null` when the body does
-* not have the `pid:token` shape at all (e.g. a user support file named
-* `*.lock`) — callers leave such files alone. A shape-matching body always
-* yields a number, possibly `0` (state corruption / hand edit): there is no
-* pid 0, so a `0` holder must be treated as DEAD by the caller —
-* `isProcessAlive(0)` signals the caller's own process group on POSIX and
-* answers true, so probe sites must guard `holder > 0` before probing. */
-function parseLockBody(body) {
-	const match = LOCK_BODY_RE.exec(body.trim());
-	return match === null ? null : Number(match[1]);
-}
-/**
-* V27 G0.2 (EVO-IO-01): the write lock named by this claim is no longer ours
-* at the commit point — a takeover reclaimed it while we were inside the
-* critical section. The lock layer converts this into a retry of the whole
-* read-modify-write; it must never reach a caller as a successful write.
-*/
-var LostWriteLock = class extends Error {
-	constructor() {
-		super("evolution-io: the write lock was reclaimed before the commit");
-		this.name = "LostWriteLock";
-	}
-};
+/** How long an abandoned quarantine copy is kept for operator rescue. G2 S4: hoisted to module scope
+* (it used to live inside `nodeEvolutionIo`, in the region the lock protocol occupied). */
+const CORRUPT_SWEEP_AGE_MS = 168 * 36e5;
 /** V27 G1.4: every quarantine-copy name this family has ever produced —
 * `<file>.corrupt` (current fixed name), `<file>.corrupt.<epoch>`, and the
 * v10-05 legacy `<file>.corrupt-<epoch>-<rand>` series. A user support file
 * keeps a final extension (`.corrupt-backup.md`) and therefore stays. */
 const CORRUPT_COPY_RE = /\.corrupt(\.\d+|-\d+-[0-9a-z]+)?$/;
-/** V27 G1.1: the three takeover windows, as protocol constants at ONE place
-* (the inline copies that used to live in the acquisition loop, plus the dead
-* branch's bare `1000`, are gone). */
-/** A named holder that is gone, past this age, is reclaimed. Fits inside the
-* `lockAttempts * 50ms` retry budget so a dead holder's lock is reachable
-* within one budget (v19 gate arithmetic: budget >= 2 x threshold). */
-const DEAD_LOCK_TAKEOVER_MS = 1e3;
-/** No body at all: nothing attributes the lock to a holder, so this is the one
-* branch that cannot probe liveness — it must outlast any plausible stall
-* between create and body write (V27 G0.2: 1s was below what a loaded machine
-* actually took, which let a peer delete a live holder's lock). */
-const EMPTY_LOCK_TAKEOVER_MS = 3e4;
-/** A body with no parseable pid (crash mid-write): 1h, far above any legal hold
-* and far below "forever". */
-const LOCK_TEAR_TAKEOVER_MS = 36e5;
-/** A2 (audit P1-2): even a lock whose holder pid probes ALIVE is reclaimable
-* past this age. Liveness-by-pid cannot distinguish the original holder from
-* an unrelated process the OS later assigned the same pid, so the plain alive
-* probe let one recycled pid brick every writer of one state file forever.
-* No write in this family holds a lock for more than minutes (the longest is
-* the ~120s review window), so a day-old "alive" lock is a recycled pid, not
-* a live writer. */
-const ALIVE_LOCK_TAKEOVER_MS = 864e5;
-/** P2-27 (v37): the commit-point ownership re-read. A transient read failure
-* (EACCES/EMFILE/antivirus hold) must not abort a valid RMW, so the read is
-* retried in place; only a still-unreadable lock fails the attempt. */
-const OWNERSHIP_READ_ATTEMPTS = 3;
-const OWNERSHIP_READ_RETRY_MS = 20;
 /**
 * V27 G1.3: the error `commitTmp` throws when the rename landed but the parent
 * directory fsync failed — the bytes ARE visible, only their durability is
@@ -1593,39 +1531,12 @@ function isCommittedWarning(error) {
 	return error?.committed === true;
 }
 /**
-* V27 G1.1: the lock-takeover decision as ONE pure function, so the protocol is
-* testable and exhaustive instead of being an inline expression inside the
-* acquisition loop:
-*   - `none`    the lock is fresh, or its holder is alive within the alive
-*               window → wait, never steal;
-*   - `dead`    a named holder that is gone past the dead threshold, OR whose
-*               pid still probes alive but whose lock is older than the alive
-*               window (A2: a recycled pid must not hold the file forever);
-*   - `empty`   no body at all: nothing attributes it to a holder, so only the
-*               wide `emptyAfterMs` window may reclaim it;
-*   - `corrupt` a body with no parseable pid (a crash mid-write), past the 1h
-*               tear threshold.
-* The age thresholds compare against `nowMs - mtimeMs` with `>` so a lock whose
-* age EQUALS the threshold is not yet reclaimed (the boundary the v19 gate fix
-* pinned).
-*/
-function decideTakeover(probe) {
-	const age = (probe.nowMs ?? Date.now()) - probe.mtimeMs;
-	const holder = Number(probe.body.split(":")[0] ?? "");
-	const namedHolder = Number.isInteger(holder) && holder > 0;
-	if (probe.body === "") return age > (probe.emptyAfterMs ?? 3e4) ? "empty" : "none";
-	if (!namedHolder) return age > (probe.corruptAfterMs ?? 36e5) ? "corrupt" : "none";
-	if (probe.alive(holder)) return age > (probe.aliveAfterMs ?? 864e5) ? "dead" : "none";
-	return age > (probe.deadAfterMs ?? 1e3) ? "dead" : "none";
-}
-/**
-* Build the Node IO backend. `lockAttempts` scales the write-lock retry budget
-* (attempts × 50ms); the default 40 (~2s, rc.69) covers production contention,
-* while contention TESTS on a loaded runner may raise it (e.g. 240 ≈ 12s) —
-* V10-06 integration: full-suite parallel load made 32-way takeover bursts
-* exceed the default budget and fail loud.
-*/
-function nodeEvolutionIo(lockAttempts = 40) {
+* Build the Node IO backend: plain fs promises, durable tmp + rename commits (crash atomicity) and
+* ONE concurrency guarantee of its own — writes to the same path are serialized in-process (see
+* `inProcessWrite`). G2 S4 removed the cross-process write lock and its takeover protocol; the
+* plugin path gets cross-process safety from the platform provider (`ctx.fs`).
+*/
+function nodeEvolutionIo() {
 	/**
 	* 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
@@ -1640,201 +1551,34 @@ function nodeEvolutionIo(lockAttempts = 40) {
 	/** True when the pid is alive (single source: `isProcessAlive`). */
 	const isAlive = isProcessAlive;
 	/**
-	* V10-06 (P1-1 integration fix): a takeover TICKET must never be reclaimed
-	* while its (live) holder can still be committing — the C-28 rename retry
-	* budget is ~2.35s under AV/indexer pressure, so the former 1s ticket age
-	* threshold let a contender steal an in-flight ticket, double-enter the
-	* critical section and drop one RMW (observed as 5/6 increments under
-	* full-suite load). 5s = retry budget + comfortable margin; a DEAD holder's
-	* ticket is still reclaimed immediately via the pid probe.
-	*/
-	const TICKET_STALE_MS = 5e3;
-	/**
-	* Cross-process write lock (claw `withFileLock` parity): an O_EXCL lock file
-	* guards the atomic write. A >1s-old lock is taken over ONLY after probing
-	* the holder pid it carries (rc.66): a LIVE holder is never stolen, so a
-	* slow writer no longer loses its lock to a peer at the threshold (the
-	* takeover is the only best-effort surface; the retry budget fails loud —
-	* rc.65 — instead of ever proceeding unlocked). Budget = 40 * 50ms (~2s,
-	* rc.69): 8-writer contention bursts on a loaded CI runner exceed 10
-	* attempts (500ms), and a fail-loud throw was observed instead of a clean
-	* serialization.
-	* 0.3.17 (E-8): acquisition and the task are now SEPARATE try blocks — a
-	* task error (win32 rename/EBUSY surfaces as EPERM) used to be mistaken for
-	* lock contention, retried up to 40x and finally reported as
-	* "could not acquire write lock" while the real cause was hidden.
-	* 0.3.17 (E-8a): the takeover threshold (1000ms) now fits INSIDE the ~2s
-	* retry budget (budget >= 2 x threshold), so a dead holder's lock is
-	* actually recoverable within one budget instead of being arithmetically
-	* unreachable.
-	* 0.3.21 (F-101), V4-04: takeover re-reads the lock right before acting and
-	* only proceeds when the content still names the dead pid — a peer that
-	* acquired the lock after our stale probe wrote its own pid, and deleting a
-	* LIVE lock is the double-hold (concurrent task) the probe must prevent. The
-	* re-read is necessary but not sufficient: two peers can both pass it, so the
-	* commit itself is an atomic rename to a unique name (only one peer's rename
-	* can succeed; the loser's source is gone). A naive rm lets the later peer
-	* delete the winner's freshly re-acquired live lock.
-	* 0.3.21 (F-367), V4-05: a self-pid lock is recycled ONLY when the failed
-	* release was recorded in pendingSelfCleanup — never on age alone, because an
-	* mtime over 1s is indistinguishable from a long task still executing in this
-	* process, and recycling that live lock would double-hold it. A failure to
-	* release in finally is recorded so the next write self-heals.
-	* V10-07 (P2-1): a third takeover shape — a TORN body (non-empty, no
-	* parseable pid) — is taken over after a wide 1h threshold with a
-	* console.warn; before this branch such a lock blocked every future writer
-	* forever.
-	* V27 G0.2 (EVO-IO-01): the CONTRACT for `task` is therefore: commit only
-	* after calling the `assertOwned` callback it receives, immediately before the
-	* rename (or delete) that publishes the result. A takeover may reclaim a lock
-	* whose holder is alive — an empty body cannot be attributed to a pid, and a
-	* peer can read a stale stat — and the holder cannot see it from the handle it
-	* opened (on POSIX its write lands on the UNLINKED inode). With the guard, a
-	* reclaimed claim aborts the RMW (`LostWriteLock`, converted into a retry
-	* here) instead of overwriting the current holder's result; without it, two
-	* writers commit and one update is silently lost.
+	* G2 S4: the family write-lock protocol is retired. Concurrency is the PLATFORM’s job now — the
+	* plugin path requires `ctx.fs`, whose writes are versioned — so this backend keeps exactly one
+	* guarantee of its own: writes to the SAME path inside THIS process are serialized (a promise
+	* chain per path: no timers, no lock files, no takeover windows). Cross-process RMW safety comes
+	* from the provider; a standalone caller sharing a directory across processes must not rely on
+	* this backend alone. The durable tmp + rename commit stays — crash atomicity and mutual
+	* exclusion are different concerns.
 	*/
-	const withWriteLock = async (path, task) => {
-		const lock = `${path}${LOCK_SUFFIX}`;
-		let myClaim = "";
-		for (let attempt = 0; attempt < lockAttempts; attempt += 1) {
-			try {
-				myClaim = `${process.pid}:${randomBytes(4).toString("hex")}`;
-				await writeFile(lock, myClaim, { flag: "wx" });
-			} catch (error) {
-				const code = error?.code;
-				if (code === "EEXIST" || code === "EPERM") {} else {
-					await rm(lock, { force: true }).catch(() => {});
-					throw error;
-				}
-				try {
-					const st = await stat(lock);
-					const holderRead = await readFile(lock, "utf8").then((body) => ({
-						ok: true,
-						body
-					}), () => ({
-						ok: false,
-						body: ""
-					}));
-					if (!holderRead.ok) continue;
-					const holderContent = holderRead.body;
-					const holder = Number(holderContent.split(":")[0] ?? "");
-					if (holder === process.pid && pendingSelfCleanup.has(lock)) {
-						const token = pendingSelfCleanup.get(lock);
-						if (await readFile(lock, "utf8").catch(() => "") === token) try {
-							await rm(lock, { force: true });
-							pendingSelfCleanup.delete(lock);
-						} catch {}
-						continue;
-					}
-					const decision = decideTakeover({
-						body: holderContent,
-						mtimeMs: st.mtimeMs,
-						alive: isAlive
-					});
-					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"})`);
-						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(() => "");
-								const ticketMtime = await stat(ticket).then((s) => s.mtimeMs, () => 0);
-								const ticketHolder = Number(ticketBody.split(":")[0] ?? "");
-								if ((!Number.isInteger(ticketHolder) || ticketHolder <= 0 || !isAlive(ticketHolder) || Date.now() - ticketMtime > TICKET_STALE_MS) && (ticketBody !== "" || Date.now() - ticketMtime > TICKET_STALE_MS)) await rm(ticket, { force: true }).catch(() => {});
-							} catch {}
-							try {
-								await writeFile(ticket, `${process.pid}:${randomBytes(4).toString("hex")}`, { flag: "wx" });
-							} catch {
-								continue;
-							}
-							const verifyRead = await readFile(lock, "utf8").then((body) => ({
-								ok: true,
-								body
-							}), () => ({
-								ok: false,
-								body: ""
-							}));
-							if (!verifyRead.ok) {
-								await rm(ticket, { force: true }).catch(() => {});
-								continue;
-							}
-							const verify = verifyRead.body;
-							if (verify === holderContent) {
-								const verifyHolder = Number(verify.split(":")[0] ?? "");
-								if (!(Number.isInteger(verifyHolder) && verifyHolder > 0 && isAlive(verifyHolder))) await rm(lock, { force: true }).catch(() => {});
-							}
-							await rm(ticket, { force: true }).catch(() => {});
-							continue;
-						}
-					}
-				} catch {
-					continue;
-				}
-				await new Promise((resolve) => setTimeout(resolve, 50));
-				continue;
-			}
-			const assertOwned = async () => {
-				let body = "";
-				let readable = false;
-				for (let read = 0; read < OWNERSHIP_READ_ATTEMPTS && !readable; read += 1) {
-					if (read > 0) await new Promise((resolve) => setTimeout(resolve, OWNERSHIP_READ_RETRY_MS));
-					const attempt = await readFile(lock, "utf8").then((value) => ({
-						ok: true,
-						value
-					}), () => ({
-						ok: false,
-						value: ""
-					}));
-					if (attempt.ok) {
-						body = attempt.value;
-						readable = true;
-					}
-				}
-				if (!readable) {
-					console.warn(`evolution-io: write lock ${lock} could not be read at the commit point (ownership unverified, ours: ${JSON.stringify(myClaim)}) — aborting this read-modify-write and retrying under a fresh acquisition`);
-					throw new LostWriteLock();
-				}
-				if (body !== myClaim) {
-					console.warn(`evolution-io: write lock ${lock} was reclaimed by another writer before the commit (on disk now: ${JSON.stringify(body)}, ours: ${JSON.stringify(myClaim)}) — aborting this read-modify-write and retrying under a fresh acquisition`);
-					throw new LostWriteLock();
-				}
-			};
-			try {
-				return await task(assertOwned);
-			} catch (error) {
-				if (error instanceof LostWriteLock) continue;
-				throw error;
-			} finally {
-				const mine = await readFile(lock, "utf8").then((body) => ({
-					ok: true,
-					body
-				}), (error) => ({
-					ok: false,
-					missing: isMissing(error)
-				}));
-				if (!mine.ok) {
-					if (!mine.missing) await recordPendingSelfCleanup(lock, myClaim);
-				} else if (mine.body === myClaim) await rm(lock, {
-					force: true,
-					maxRetries: 20,
-					retryDelay: 100
-				}).catch(() => recordPendingSelfCleanup(lock, myClaim));
-			}
+	const queues = /* @__PURE__ */ new Map();
+	const inProcessWrite = async (path, run) => {
+		const result = (queues.get(path) ?? Promise.resolve()).then(run, run);
+		const settled = result.then(() => {}, () => {});
+		queues.set(path, settled);
+		try {
+			return await result;
+		} finally {
+			if (queues.get(path) === settled) queues.delete(path);
 		}
-		throw new Error(`could not acquire write lock for ${path} after ${lockAttempts} attempts`);
 	};
-	/** 0.3.17 (E-8b): sweep tmp files a crashed writer left behind — same
-	* `<target>.<pid>.<rand>.tmp` shape, older than 1h AND held by a dead pid.
-	* Lazy: only the directory a write is about to touch gets swept, once per
-	* write, inside the write lock. */
+	/**
+	* Sweep transient files a crashed writer left behind, lazily: once per write, for the directory
+	* that write is about to touch.
+	* `<target>.<pid>.<rand>.tmp` — the durable-write tmp. This process's own leftover is recycled
+	* immediately (a live writer's tmp is a current write, not a crash artifact); a foreign tmp
+	* needs an age past an hour AND a dead holder.
+	* `.corrupt*` — quarantine copies past their rescue window.
+	* G2 S4: the lock and takeover-ticket branches are gone with the write-lock protocol.
+	*/
 	const sweepStaleTmps = async (path) => {
 		const dir = dirname(path);
 		const base = basename(path);
@@ -1844,12 +1588,7 @@ function nodeEvolutionIo(lockAttempts = 40) {
 		} catch {
 			return;
 		}
-		const prefix = `${base}.`;
-		const lockName = `${base}${LOCK_SUFFIX}`;
-		const ticketName = `${lockName}.next`;
-		const CORRUPT_SWEEP_AGE_MS = 168 * 36e5;
 		for (const name of entries) {
-			if (!name.startsWith(prefix) || name === lockName) continue;
 			const tmpMatch = /^(.*)\.(\d+)\.([0-9a-f]+)\.tmp$/.exec(name);
 			if (tmpMatch !== null && tmpMatch[1] === base) {
 				const tmpPath = join(dir, name);
@@ -1861,19 +1600,7 @@ function nodeEvolutionIo(lockAttempts = 40) {
 				} catch {}
 				continue;
 			}
-			if (name === ticketName) {
-				const ticketPath = join(dir, name);
-				try {
-					const body = await readFile(ticketPath, "utf8").catch(() => "");
-					const holder = Number(body.split(":")[0] ?? "");
-					const st = await stat(ticketPath);
-					const dead = !Number.isInteger(holder) || holder <= 0 || !isAlive(holder);
-					const old = Date.now() - st.mtimeMs > TICKET_STALE_MS;
-					if (dead || old) await rm(ticketPath, { force: true });
-				} catch {}
-				continue;
-			}
-			if (CORRUPT_COPY_RE.test(name)) {
+			if (name.startsWith(base + ".") && CORRUPT_COPY_RE.test(name)) {
 				const corruptPath = join(dir, name);
 				try {
 					const st = await stat(corruptPath);
@@ -1893,16 +1620,14 @@ function nodeEvolutionIo(lockAttempts = 40) {
 		},
 		async writeText(path, content) {
 			await mkdir(dirname(path), { recursive: true });
-			await withWriteLock(path, async (assertOwned) => {
+			await inProcessWrite(path, async () => {
 				await sweepStaleTmps(path);
-				const tmp = await writeDurableTmp(path, content);
-				await assertOwned();
-				await commitTmp(tmp, path);
+				await commitTmp(await writeDurableTmp(path, content), path);
 			});
 		},
 		async transact(path, task) {
 			await mkdir(dirname(path), { recursive: true });
-			await withWriteLock(path, async (assertOwned) => {
+			await inProcessWrite(path, async () => {
 				await sweepStaleTmps(path);
 				let current;
 				try {
@@ -1913,14 +1638,11 @@ function nodeEvolutionIo(lockAttempts = 40) {
 				}
 				const next = await task(current);
 				if (next === null) {
-					await assertOwned();
 					await rm(path, { force: true });
 					return;
 				}
 				if (next === current) return;
-				const tmp = await writeDurableTmp(path, next);
-				await assertOwned();
-				await commitTmp(tmp, path);
+				await commitTmp(await writeDurableTmp(path, next), path);
 			});
 		},
 		async remove(path) {
@@ -1983,6 +1705,121 @@ function nodeEvolutionIo(lockAttempts = 40) {
 		}
 	};
 }
+const defaultFs = {
+	writeFileSync: (path, data) => {
+		writeFileSync(path, data);
+	},
+	existsSync: (path) => existsSync(path),
+	copyFileSync: (from, to) => {
+		copyFileSync(from, to);
+	},
+	renameSync: (from, to) => {
+		renameSync(from, to);
+	},
+	rmSync: (path, options) => {
+		rmSync(path, options);
+	},
+	mtime: (path) => {
+		try {
+			return statSync(path).mtimeMs;
+		} catch (error) {
+			if (isMissingPath(error)) return null;
+			throw error;
+		}
+	}
+};
+/**
+* S6.3 (E-40): atomically replace a set of files within one directory.
+* Each file is staged to a sibling `<name>.tmp`, then renamed into place
+* (atomic on the same filesystem); a pre-existing file keeps a single
+* `<name>.bak`. A failure at ANY staging step removes the staged temps and
+* leaves the previous files untouched — a half-written target is impossible
+* up to the staging and backup phases.
+*
+* F-211: the rename COMMIT phase does not carry the same guarantee. When a
+* filesystem refuses to overwrite the destination, the code removes it and
+* retries the rename; if the retry ALSO fails the destination is gone. The
+* single `.bak` created above still holds the previous content, so the target
+* is restored from it (best-effort) before the original rename error is
+* rethrown, so a failed commit never leaves the file missing.
+*
+* V4-17: the `.bak` is refreshed to the committed content after every
+* successful commit, so a later failed commit always recovers to the most
+* recent good generation (a once-at-first-install `.bak` could otherwise
+* restore content several installs old). The recovery error names the `.bak`
+* source (and mtime when available) so the caller knows the generation it
+* restored from.
+*/
+function atomicWriteFiles(targetDir, writes, fs = defaultFs, logger = console.warn) {
+	const stage = (name) => join(targetDir, `${name}.tmp`);
+	const dupes = [...new Set(writes.map((write) => write.name).filter((name, index, all) => all.indexOf(name) !== index))];
+	if (dupes.length > 0) throw new Error(`atomicWriteFiles: duplicate input names: ${dupes.join(", ")}`);
+	try {
+		for (const { name, content } of writes) fs.writeFileSync(stage(name), content);
+		for (const { name } of writes) {
+			const finalPath = join(targetDir, name);
+			const bakPath = join(targetDir, `${name}.bak`);
+			if (fs.existsSync(finalPath) && !fs.existsSync(bakPath)) fs.copyFileSync(finalPath, bakPath);
+		}
+		const committed = [];
+		for (const { name } of writes) {
+			const finalPath = join(targetDir, name);
+			const bakPath = join(targetDir, `${name}.bak`);
+			const tmp = stage(name);
+			try {
+				fs.renameSync(tmp, finalPath);
+				committed.push(name);
+			} catch {
+				try {
+					fs.rmSync(finalPath, { force: true });
+				} catch (removeError) {
+					const already = committed.length > 0 ? `; already committed: ${committed.join(", ")}` : "";
+					throw new Error(`atomicWriteFiles: could not remove "${name}" to replace it (${removeError instanceof Error ? removeError.message : String(removeError)})${already}`);
+				}
+				try {
+					fs.renameSync(tmp, finalPath);
+					committed.push(name);
+				} catch (renameError) {
+					const already = committed.length > 0 ? `; already committed: ${committed.join(", ")}` : "";
+					if (fs.existsSync(bakPath)) {
+						try {
+							fs.copyFileSync(bakPath, finalPath);
+						} catch {
+							throw new Error(`atomicWriteFiles: "${name}" was removed but recovery from ${bakPath} failed (${renameError instanceof Error ? renameError.message : String(renameError)}); verify the file manually${already}`);
+						}
+						const bakMtime = fs.mtime?.(bakPath);
+						const when = bakMtime !== null && bakMtime !== void 0 && Number.isFinite(bakMtime) ? ` (bak mtime ${new Date(bakMtime).toISOString()})` : "";
+						throw new Error(`atomicWriteFiles: "${name}" was removed during commit and restored from the last good generation ${bakPath}${when}; original error: ${renameError instanceof Error ? renameError.message : String(renameError)}${already}`);
+					}
+					throw new Error(`${renameError instanceof Error ? renameError.message : String(renameError)}${already}`);
+				}
+			}
+		}
+		for (const { name } of writes) {
+			const finalPath = join(targetDir, name);
+			try {
+				if (fs.existsSync(finalPath)) fs.copyFileSync(finalPath, join(targetDir, `${name}.bak`));
+			} catch (refreshError) {
+				logger(`atomicWriteFiles: committed "${name}" but failed to refresh its .bak (${refreshError instanceof Error ? refreshError.message : String(refreshError)}); a later failed commit will recover to an OLDER generation`);
+			}
+		}
+	} catch (error) {
+		const cleanupFailures = [];
+		for (const { name } of writes) try {
+			fs.rmSync(stage(name), {
+				force: true,
+				recursive: true
+			});
+		} catch (cleanupError) {
+			cleanupFailures.push(`${name}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+		}
+		if (cleanupFailures.length > 0) {
+			const original = error instanceof Error ? error.message : String(error);
+			throw new Error(`${original} (staged-temp cleanup also failed: ${cleanupFailures.join("; ")})`);
+		}
+		throw error;
+	}
+}
 //#endregion
 //#region lib/types/usage.js
 /**
@@ -2093,7 +1930,7 @@ async function mutateUsage(root, io, task, options = {}) {
 			let parsed = null;
 			try {
 				const probe = JSON.parse(current);
-				if (probe !== null && typeof probe === "object" && !Array.isArray(probe)) parsed = probe;
+				if (isRecord(probe)) parsed = probe;
 			} catch {
 				parsed = null;
 			}
@@ -3221,7 +3058,7 @@ async function readJsonBody(req) {
 */
 async function readJsonObject(req) {
 	const body = await readJsonBody(req);
-	return body !== null && typeof body === "object" && !Array.isArray(body) ? body : null;
+	return isRecord(body) ? body : null;
 }
 //#endregion
 //#region lib/types/env.js
@@ -3252,7 +3089,7 @@ function allowRowCollisions(env = process.env) {
 //#endregion
 //#region lib/types/errors.js
 /**
-* THE error-code table: E-301…E-319 with the exact text each one emits (E-317…E-319 are the
+* THE error-code table: E-301…E-322 with the exact text each one emits (E-317…E-319 are the
 * write-admission gates' own refusals).
 *
 * The codes used to be spelled out at 33 call sites across two packages, so one
@@ -3289,6 +3126,7 @@ const EVOLUTION_ERRORS = Object.freeze({
 	"e-317-skill-write-not-confirmed": "E-317: skill \"%a1%\" was not %a2% — the confirmation prompt was declined or dismissed, so nothing was written. The prompt appears on every create and bare delete; repeat the call only if the operator asks for it.",
 	"e-318-skill-write-without-a-read": "E-318: skill \"%a1%\" was not read in this session, so this write is refused. Read it with the `skill` tool first (a read that failed does not count), then repeat the write.",
 	"e-320-the-profile-home-is-not": "E-320: the profile home is not reported by this host, so the legacy settings document cannot be located. /evolution migrate reads `<profile home>/settings.yaml.imported`; run it from a profile-launched session.",
+	"e-322-a-parameter-would-break-a": "E-322: %a1% must be at least %a2%, but this write sets it to %a3%. Nothing was written.",
 	"e-321-no-io-provider-is": "E-321: no evolution-io provider is mounted, so the legacy settings document cannot be read. Mount the evolution-io row (evolution-host/evolution-all) and retry.",
 	"e-319-skill-write-confirm-timed-out": "E-319: skill \"%a1%\" was not %a2% — the confirmation prompt went unanswered for %a3% second(s), so the write was cancelled. Nobody was there to decide: set `skillWriteConfirm` to `auto` to write without a prompt, keep `ask` to wait until someone answers, or raise `skillWriteConfirmTimeoutSeconds`."
 });
@@ -4532,7 +4370,7 @@ async function recordMutation(root, io, record, cap = 500) {
 			console.warn(`mutation audit record dropped: ${mutationsFile(root)} is malformed and was not overwritten`);
 			return current;
 		}
-		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+		if (isRecord(parsed)) {
 			const version = parsed.version;
 			if (typeof version === "number" && version > 1) {
 				console.warn(`mutation audit record dropped: ${mutationsFile(root)} declares version ${version} (newer than 1); not overwritten`);
@@ -4596,16 +4434,23 @@ function composePresetComposition(standardComposition, deltaComposition) {
 * test can keep — the entries are now data, and a divergence is impossible.
 */
 const ROW_OVERRIDES_URL = new URL("../row-overrides.json", import.meta.url);
-let cachedOverrides;
+/** One cache per PATH: the installer reads the same file through its own root, and a single-slot
+* cache would hand the second caller the first caller's bytes. */
+const overridesCache = /* @__PURE__ */ new Map();
 /**
 * Read and validate the shared override table.
+* G6.1/M1: the path is a PARAMETER (default: the table beside this module). The source installer
+* runs the generated port from `scripts/`, so its own root has to be passed in — a module-relative
+* read would look for `scripts/../row-overrides.json` and fail.
+* @param path - the table to read.
 * @returns the entries, in file order. A malformed table fails LOUD: a composer
 * that silently skipped an entry would ship a preset running the platform
 * default while nothing downstream reported it.
 */
-function loadRowOverrides() {
-	if (cachedOverrides !== void 0) return cachedOverrides;
-	const parsed = JSON.parse(readFileSync(fileURLToPath(ROW_OVERRIDES_URL), "utf8"));
+function loadRowOverrides(path = fileURLToPath(ROW_OVERRIDES_URL)) {
+	const cached = overridesCache.get(path);
+	if (cached !== void 0) return cached;
+	const parsed = JSON.parse(readFileSync(path, "utf8"));
 	if (!Array.isArray(parsed)) throw new Error("evolution-core: row-overrides.json must be an array of override entries");
 	const entries = [];
 	for (const [index, entry] of parsed.entries()) {
@@ -4618,7 +4463,7 @@ function loadRowOverrides() {
 			missingReason: candidate.missingReason
 		});
 	}
-	cachedOverrides = entries;
+	overridesCache.set(path, entries);
 	return entries;
 }
 /**
@@ -4737,7 +4582,7 @@ function composePresetRow(baseComposition, deltaComposition, identity) {
 }
 /** The patch-entry key that ADDS a row: a plain entry overrides the row with the same id, so a
 * preset the platform does not ship has to arrive inside an `insert` entry
-* (`packages/boot/app-boot/tests/user-patches.spec.ts:47-64`). */
+* (the platform's own `user-patches.spec.ts` proves the override-vs-insert split). */
 const PATCH_INSERT_KEY = "insert";
 /**
 * Wrap a composed row as the patch entry a profile patch needs.
@@ -6411,7 +6256,7 @@ function renderLongRunTable() {
 /**
 * Every platform service the family reaches for with `ctx.get`, and what degrades without it.
 *
-* O-2 (v46 audit): the family probes 26 platform services optionally — the platform has no
+* O-2 (v46 audit): the family probes 28 platform services optionally — the platform has no
 * formalized "optional dependency", so an ABSENT service is a silent downgrade and the diagnostic
 * surface is the only place a reader can learn about it. `/evolution doctor` used to judge six of
 * them; this table is the single source it judges the rest from, and the arch guard cross-checks it
@@ -6421,7 +6266,7 @@ function renderLongRunTable() {
 * `client` probes run in the browser half, where the host has no view of the seats.
 * @module @lmzhen/dsh-evolution-core
 */
-/** The 26 probes, in service-name order (the guard checks this list against the tree). */
+/** The 28 probes, in service-name order (the guard checks this list against the tree). */
 const PLATFORM_SERVICE_PROBES = Object.freeze([
 	{
 		service: "agents",
@@ -6458,6 +6303,16 @@ const PLATFORM_SERVICE_PROBES = Object.freeze([
 		feature: "every durable read and write (the IO seam)",
 		side: "host"
 	},
+	{
+		service: "fs",
+		feature: "the platform filesystem the evolution-io-fs backend maps the seam onto (locks + writeText(expected) version CAS)",
+		side: "host"
+	},
+	{
+		service: "hmr",
+		feature: "the preset install read-merge-write commit (the platform HMR lock serializes it)",
+		side: "host"
+	},
 	{
 		service: "evolutionMemoryBudget",
 		feature: "the memory-budget divergence section of this report",
@@ -8007,6 +7862,13 @@ function versionRowCells(row) {
 		tone: "tertiary",
 		slot: "meta"
 	});
+	if (row.hash !== void 0 && row.hash !== "") title.push({
+		key: "hash",
+		literal: row.hash.slice(0, 7),
+		tone: "tertiary",
+		slot: "meta",
+		note: row.hash
+	});
 	const meta = [];
 	if (row.summary !== void 0 && row.summary !== "") meta.push({
 		key: "summary",
@@ -8055,6 +7917,13 @@ function skillRowCells(skill) {
 		tone: "tertiary",
 		slot: "meta"
 	}];
+	if (skill.protectedBy !== null) meta.push({
+		key: "protectedBy",
+		literal: skill.protectedBy,
+		tone: "tertiary",
+		slot: "meta",
+		note: skill.protectedBy
+	});
 	if (skill.age !== null) meta.push({
 		key: "age",
 		copy: ageCopyKey(skill.age),
@@ -9002,7 +8871,7 @@ function elapsedSince(at, nowMs) {
 *    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/
+*    with `supportDirsUnlistable` 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
@@ -9239,15 +9108,6 @@ function skillDir(root, name) {
 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) {
@@ -9326,7 +9186,6 @@ function validateSupportPath(filePath) {
 	if (parts.length < 2) return "Provide a file name, not just a directory.";
 	for (const part of parts.slice(1)) {
 		if (!SUPPORT_FILE_NAME_RE.test(part)) return `Unsupported file name "${part}" — use lowercase letters, digits, dots, hyphens, and underscores (leading letter or digit).`;
-		if (part.toLowerCase().endsWith(".lock")) return `Unsupported file name "${part}" — the .lock suffix is reserved for the writer-lock protocol.`;
 		if (part.toLowerCase().endsWith(".corrupt") || part.toLowerCase().endsWith(".tmp")) return `Unsupported file name "${part}" — the .corrupt/.tmp suffixes are reserved for the state/IO protocols.`;
 		const stem = part.split(".")[0]?.toLowerCase() ?? "";
 		if (WIN32_RESERVED_DEVICE_NAMES.has(stem)) return `Unsupported file name "${part}" — a Windows reserved device name.`;
@@ -9506,16 +9365,14 @@ var SkillLibrary = class {
 	* found no SKILL.md — remove the possibly-resurrected directory ONLY when it
 	* holds nothing but this path's own write-lock file. The BR-5 rule from
 	* setPinnedCore/createCore applies unchanged: a concurrent mover can land a
-	* full directory between the list probe and the remove, so anything beyond
-	* the lock file (support files, a fresh restore) must never be recursed
-	* away. Best-effort: a failed cleanup leaves the "not found" result
+	* full directory between the list probe and the remove, so ANY content at all (support files, a
+	* fresh restore) must never be recursed away. Best-effort: a failed cleanup leaves the "not found" result
 	* unchanged (the operator-facing ghost-dir refusal is fail-loud already).
 	*/
 	async cleanupGhostDir(skillFilePath) {
 		const dir = dirname(skillFilePath);
-		const lockName = `${basename(skillFilePath)}${LOCK_SUFFIX}`;
 		try {
-			if ((await this.io.list(dir)).some((entry) => entry !== lockName)) return;
+			if ((await this.io.list(dir)).length > 0) return;
 			await this.io.remove(dir);
 		} catch {}
 	}
@@ -10380,110 +10237,19 @@ var SkillLibrary = class {
 	* P2 (v16): the write-lock probe for the DESTRUCTIVE MOVERS (archive /
 	* restoreFromArchive). A byte-writer mid-flight is the ghost-generator —
 	* after the move its transact commit re-creates `<dir>/…` (mkdir
-	* recursive) and the tree ends half-archived. The signal is the writer's
-	* own lock file, and its PLACEMENT (inside the moved directory) is why the
-	* mover must PROBE-and-REFUSE instead of acquiring it: an acquired lock
-	* would be renamed into `.archive` with the tree, stranding a phantom live
-	* lock (the v16 audit proved the probe→rename TOCTOU does exactly that,
-	* and restore would later move the residue back into the live root).
-	* Coverage: `SKILL.md.lock` (update/patch of the body) plus one level of
-	* each support dir (write_file's lock sits next to its file). Residual:
-	* NESTED support-subdir locks and the probe→rename TOCTOU itself remain
-	* fail-safe (renameWithRetry rides the write out; the writer's locked
-	* re-read refuses on the moved-away file). v37 (P2-8): a residue `.lock` whose
-	* holder is GONE is not a writer — `decideTakeover` owns that verdict.
+	* recursive) and the tree ends half-archived.
+	* G2 S4: the writer-lock probe that used to answer this question is retired — writes go through
+	* the provider's versioned writes, so a writer that raced the move fails its own write loudly
+	* instead of landing on a moved-away path. What REMAINS load-bearing here is the fail-closed
+	* listing rule, which is about the filesystem misbehaving rather than about writers.
 	*/
-	async hasWriteLock(dir) {
-		const markerLocks = MARKER_LOCK_NAMES.map((name) => join(dir, name));
-		for (const lock of markerLocks) if (await this.isWriterLock(lock)) return true;
-		for (const supportDir of SUPPORT_DIRS) {
-			let entries;
-			try {
-				entries = await this.io.list(join(dir, supportDir));
-			} catch {
-				return true;
-			}
-			for (const entry of entries) {
-				if (!entry.endsWith(".lock")) continue;
-				if (await this.isWriterLock(join(dir, supportDir, entry))) return true;
-			}
-		}
-		return false;
-	}
-	/** P2 (v17): a `*.lock` file counts as a writer lock only when its body
-	* carries the io layer's protocol — `pid:token`, a bare pid, or an empty body
-	* (a creator between create and body write); anything else is user content
-	* (suffix-only matching refused archiving and deleted user files on restore).
-	* v37 (P2-8): the verdict is `decideTakeover`'s, so the mover refuses exactly
-	* the lock the io layer refuses to reclaim, the 30s empty window included. */
-	async isWriterLock(lockPath) {
-		let body;
-		try {
-			body = await this.io.readText(lockPath);
+	async supportDirsUnlistable(dir) {
+		for (const supportDir of SUPPORT_DIRS) try {
+			await this.io.list(join(dir, supportDir));
 		} catch {
 			return true;
 		}
-		if (body === null) return false;
-		const trimmed = body.trim();
-		if (trimmed !== "" && !/^\d+$/.test(trimmed) && !LOCK_BODY_RE.test(trimmed)) return false;
-		let mtimeMs = null;
-		try {
-			mtimeMs = await this.io.mtime?.(lockPath) ?? null;
-		} catch {
-			mtimeMs = null;
-		}
-		return decideTakeover({
-			body,
-			mtimeMs: mtimeMs ?? Date.now(),
-			alive: isProcessAlive
-		}) === "none";
-	}
-	/** P2 (v16): best-effort removal of lock residue inside a RESTORED tree.
-	* A1-2/A1-7 (v18): the sweep now covers the marker locks the probe checks
-	* (`SKILL.md.lock`/`.pinned.lock`/`.hermes-managed.lock`) and only removes
-	* a lock whose holder pid is NOT alive — a live writer's lock is never
-	* stolen by the sweep. A dead-pid residue would otherwise permanently
-	* refuse archive/restore. */
-	async deleteStrandedLocks(dir) {
-		for (const markerLock of MARKER_LOCK_NAMES) await this.sweepLockIfStranded(join(dir, markerLock));
-		for (const supportDir of SUPPORT_DIRS) {
-			let entries = [];
-			try {
-				entries = await this.io.list(join(dir, supportDir));
-			} catch {
-				continue;
-			}
-			for (const entry of entries) if (entry.endsWith(".lock")) await this.sweepLockIfStranded(join(dir, supportDir, entry));
-		}
-	}
-	/** R2 follow-up (audit of A2): the recycled-pid window from io's
-	* `ALIVE_LOCK_TAKEOVER_MS`, applied to the stranded-lock sweepers. A lock
-	* whose holder pid probes alive but whose mtime is older than the alive
-	* window is a recycled pid, not a live writer (no write in this family
-	* holds a lock for more than minutes) — without this, one recycled pid
-	* blocked whole-tree snapshot recovery forever with a "retry once the
-	* write completes" message that could never become true. A backend without
-	* `mtime` keeps the conservative refuse-on-alive posture. */
-	async lockHolderAgedOut(lockPath) {
-		const mtime = await this.io.mtime?.(lockPath).catch(() => null);
-		return typeof mtime === "number" && Date.now() - mtime > 864e5;
-	}
-	/** Remove `lockPath` only when its body has the writer-lock `pid:token`
-	* shape AND the holder pid is not alive (or is an aged-out recycled pid —
-	* R2 follow-up); anything else (a user support file or a live writer's
-	* lock) is left untouched. */
-	async sweepLockIfStranded(lockPath) {
-		const lockProbe = await probeText(this.io, lockPath);
-		if (isUnknown(lockProbe)) {
-			console.warn(`skill-store: could not read ${lockPath} to check whether its holder is alive (${lockProbe.reason}); leaving the lock in place`);
-			return;
-		}
-		if (!isPresent(lockProbe)) return;
-		const body = lockProbe.value;
-		const pid = parseLockBody(body);
-		if (pid === null) return;
-		if (Number.isInteger(pid) && pid > 0 && isProcessAlive(pid) && !await this.lockHolderAgedOut(lockPath)) return;
-		await this.io.remove(lockPath).catch(() => {});
+		return false;
 	}
 	/** A1-4 (v18): a manifest-declared name is copied with `join(root, name)`;
 	* only a single, non-traversing path component is safe. Dotfiles
@@ -10494,22 +10260,6 @@ var SkillLibrary = class {
 		if (typeof name !== "string") return false;
 		return name !== "" && name !== "." && name !== ".." && !name.includes("/") && !name.includes("\\") && basename(name) === name;
 	}
-	/** A1-7 (v18): a root-level lock whose holder is alive must refuse the
-	* restore; a dead residue is swept so a crashed writer cannot block
-	* recovery. A non-lock body shape is left alone (user file). */
-	async refuseLiveLockOrSweep(lockPath, label) {
-		let body;
-		try {
-			body = await this.io.readText(lockPath);
-		} catch (error) {
-			throw new Error(`snapshot restore refused: cannot verify ${label} (${error instanceof Error ? error.message : String(error)}); a live writer may hold it`);
-		}
-		if (body === null) return;
-		const pid = parseLockBody(body);
-		if (pid === null) return;
-		if (Number.isInteger(pid) && pid > 0 && isProcessAlive(pid) && !await this.lockHolderAgedOut(lockPath)) throw new Error(`snapshot restore refused: ${label} is being written (write lock present); retry once the write completes`);
-		await this.io.remove(lockPath).catch(() => {});
-	}
 	async archive(rawName, options = {}) {
 		const name = rawName.trim();
 		const badName = this.badName(name, { allowReserved: true });
@@ -10556,9 +10306,9 @@ var SkillLibrary = class {
 				message: `Skill "${name}" is a symlink; refusing to archive it.`
 			};
 		}
-		if (await this.hasWriteLock(dir)) return {
+		if (await this.supportDirsUnlistable(dir)) return {
 			ok: false,
-			message: `Skill "${name}" is being written (write lock present); retry archiving once the write completes.`
+			message: `Skill "${name}" could not be checked for writers (a support directory could not be listed); retry archiving.`
 		};
 		const commitProtection = await this.deleteProtection(name, options);
 		if (commitProtection) return {
@@ -11188,16 +10938,15 @@ var SkillLibrary = class {
 				message: `Archived entry "${chosen}" is a symlink; refusing to restore it.`
 			};
 		}
-		if (await this.hasWriteLock(dest)) return {
+		if (await this.supportDirsUnlistable(dest)) return {
 			ok: false,
-			message: `Skill "${name}" is being written (write lock present); retry restoring once the write completes.`
+			message: `Skill "${name}" could not be checked for writers (a support directory could not be listed); retry restoring.`
 		};
 		const moveFailure = await this.moveDir(source, dest);
 		if (moveFailure !== void 0) return {
 			ok: false,
 			message: `Restore of "${name}" from .archive failed: ${moveFailure}`
 		};
-		await this.deleteStrandedLocks(dest);
 		for (const marker of [".archive-reason", ".archive-name"]) if (await this.io.exists(join(dest, marker))) await this.io.remove(join(dest, marker));
 		const restoredProbe = await probeText(this.io, join(dest, "SKILL.md"));
 		if (isUnknown(restoredProbe)) console.warn(`evolution-skill-store: the restored SKILL.md of "${name}" could not be read back (${restoredProbe.reason}); the restore is recorded without after-bytes`);
@@ -11445,8 +11194,8 @@ var SkillLibrary = class {
 			const names = await listNames(this.root, this.io);
 			const skipped = [];
 			const copyable = [];
-			for (const name of names) if (await this.hasWriteLock(this.dirOf(name))) {
-				console.warn(`skill-store: snapshot skipped "${name}" — a byte-writer holds its write lock; the skill is recorded as skipped in the manifest`);
+			for (const name of names) if (await this.supportDirsUnlistable(this.dirOf(name))) {
+				console.warn(`skill-store: snapshot skipped "${name}" — its support directory could not be listed; the skill is recorded as skipped in the manifest`);
 				skipped.push(name);
 			} else copyable.push(name);
 			const copyFailure = (await Promise.allSettled(copyable.map(async (name) => {
@@ -11454,7 +11203,7 @@ var SkillLibrary = class {
 			}))).find((result) => result.status === "rejected");
 			if (copyFailure) throw copyFailure.reason;
 			const suspect = [];
-			for (const name of copyable) if (await this.hasWriteLock(this.dirOf(name))) suspect.push(name);
+			for (const name of copyable) if (await this.supportDirsUnlistable(this.dirOf(name))) suspect.push(name);
 			if (suspect.length > 0) {
 				for (const name of suspect) console.warn(`skill-store: snapshot demoted "${name}" to skipped — a write lock appeared while its copy ran; the copied bytes are suspect`);
 				for (const name of suspect) copyable.splice(copyable.indexOf(name), 1);
@@ -11713,14 +11462,9 @@ var SkillLibrary = class {
 		}
 		for (const entry of rootEntries) {
 			if (entry === ".archive" || entry === ".backups" || entry === ".mutations.json" || entry === ".curator-suppressed.json" || entry === ".history") continue;
-			if (entry.endsWith(".lock") || entry.endsWith(`.lock.next`)) {
-				await this.refuseLiveLockOrSweep(join(this.root, entry), entry);
-				continue;
-			}
 			const dir = join(this.root, entry);
 			if (await this.io.exists(join(dir, "SKILL.md"))) {
-				await this.deleteStrandedLocks(dir);
-				if (await this.hasWriteLock(dir)) throw new Error(`snapshot restore refused: skill "${entry}" is being written (write lock present); retry once the write completes`);
+				if (await this.supportDirsUnlistable(dir)) throw new Error(`snapshot restore refused: skill "${entry}" is being written (write lock present); retry once the write completes`);
 			}
 		}
 		const restoresSuppressed = manifest.sidecars.includes(".curator-suppressed.json");
@@ -11728,7 +11472,6 @@ var SkillLibrary = class {
 			if (entry === ".archive" || entry === ".backups" || entry === ".mutations.json") continue;
 			if (entry === ".history") continue;
 			if (entry === ".curator-suppressed.json" && restoresSuppressed) continue;
-			if (entry.endsWith(".lock") || entry.endsWith(`.lock.next`)) continue;
 			await this.io.remove(join(this.root, entry));
 		}
 		for (const name of manifest.skills) await this.io.copy(join(snapshotPath, name), join(this.root, name));
@@ -11740,10 +11483,7 @@ var SkillLibrary = class {
 				await this.io.copy(join(snapshotPath, ".archive"), archiveRoot);
 			} else if (manifest.hasArchive === false) await this.io.remove(archiveRoot);
 		}
-		for (const entry of await this.io.list(this.root)) {
-			if (entry.startsWith(".")) continue;
-			await this.deleteStrandedLocks(join(this.root, entry));
-		}
+		for (const entry of await this.io.list(this.root)) if (entry.startsWith(".")) continue;
 	}
 };
 function newSkillLibrary(options) {
@@ -12358,6 +12098,7 @@ const PARAM_EXPOSURE = Object.freeze([
 		control: "number",
 		unit: "天",
 		values: "",
+		relation: { atLeast: "staleAfterDays" },
 		card: "evolution-curator"
 	},
 	{
@@ -12999,6 +12740,23 @@ const PARAM_EXPOSURE = Object.freeze([
 		values: "",
 		card: "evolution-approval"
 	},
+	{
+		id: "approvalConfirm",
+		group: "write-caps",
+		tier: "E3",
+		authority: "cordis",
+		owner: "evolution-approval",
+		applies: "live",
+		docAnchor: "PARAMETERS.md#write-caps",
+		summary: "What the confirmation before an APPROVE does: write straight through, ask first, or treat an unanswered prompt as a cancel. The same three words skillWriteConfirm uses for a skill write.",
+		label: "批准前先确认",
+		hint: "点「批准」时要不要再确认一次：直接执行 / 先确认 / 等待超时即取消。默认直接执行（不打断批量批准）。",
+		control: "select",
+		unit: "",
+		values: "auto|ask|timeout",
+		valueLabels: "直接执行|先确认|等待超时即取消",
+		card: "evolution-approval"
+	},
 	{
 		id: "qualityWarnThreshold",
 		group: "deployment",
@@ -13269,14 +13027,6 @@ function readNumberParam(carrier, id) {
 * @module @lmzhen/dsh-evolution-core
 */
 /**
-* Whether a parsed value is a plain mapping (a settings section).
-* @param value - the parsed value.
-* @returns true for a non-null, non-array object.
-*/
-function isSection(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
 * The key names one row may be written with: its own E3 rows, plus the deprecated
 * spellings that still resolve to them. An unknown key is refused instead of written —
 * the platform validates a write against the row's schema, so writing it would fail the
@@ -13307,7 +13057,7 @@ function planNamespaceMigration(documentText) {
 		foreign: [],
 		skipped: []
 	};
-	if (!isSection(parsed)) throw new Error("the settings document is not a mapping; refusing to migrate it");
+	if (!isRecord(parsed)) throw new Error("the settings document is not a mapping; refusing to migrate it");
 	const legacy = new Map(NAMESPACE_MIGRATIONS.map((entry) => [entry.namespace, entry.rowId]));
 	const entries = [];
 	const empty = [];
@@ -13315,7 +13065,7 @@ function planNamespaceMigration(documentText) {
 	for (const [namespace, section] of Object.entries(parsed)) {
 		const rowId = legacy.get(namespace);
 		if (rowId === void 0) continue;
-		if (!isSection(section)) throw new Error("settings section `" + namespace + "` is not a mapping; refusing to migrate it");
+		if (!isRecord(section)) throw new Error("settings section `" + namespace + "` is not a mapping; refusing to migrate it");
 		const allowed = writableKeys(rowId);
 		const values = [];
 		for (const [key, value] of Object.entries(section)) {
@@ -13689,4 +13439,4 @@ function foldUntrustedLines(text, limit) {
 	return limit > 0 ? marked.slice(0, limit) : marked;
 }
 //#endregion
-export { AGENT_PRESET_PACKAGE, AGENT_PRESET_ROOT_HINT, ALIVE_LOCK_TAKEOVER_MS, 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, DEAD_LOCK_TAKEOVER_MS, DEDUP_MAX_PAIR_COMPARISONS, DEDUP_SIMILARITY_THRESHOLD, 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, DISPATCH_EVENT_TYPES, DRIFT_MAX_LINE_CHARS, DRIFT_SIGNALS_VERSION, DRIFT_SIGNAL_NOUNS, DSH_AUTHORING_STANDARDS, EMPTY_LOCK_TAKEOVER_MS, EMPTY_PATCH_SEED, ENTRY_DELIMITER, EVENT_ARCHIVE_PREFIX, EVENT_LOG_RETAIN_ARCHIVES, EVENT_LOG_ROTATE_AT, EVENT_LOG_VERSION, EVOLUTION_ERRORS, 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, INSTANCE_KEYS, KEEP_LINE_RE, LOCK_BODY_RE, LOCK_SUFFIX, LOCK_TEAR_TAKEOVER_MS, LONG_RUNS, LOW_QUALITY_THRESHOLD, LostWriteLock, 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, 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_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, RESTRUCTURE_TARGET_RE, RETENTION_FEEDBACK_KEEP_RATIO, RETENTION_FEEDBACK_MIN_CHARS, 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, SUMMARY_DUPLICATE_HINT_THRESHOLD, SUPPORT_DIRS, SUPPRESSED_FILE_VERSION, SkillLibrary, TEXT_DIFF_MAX_CHARS, TEXT_DIFF_MAX_LINES, THREAT_EXEMPTION_HINT, TOKEN_ASCII_WEIGHT, TOKEN_CJK_WEIGHT, ToolDispatchNormalizer, ToolDispatchPayloadError, UNTRUSTED_LINE_BREAK, UNTRUSTED_LINE_MARK, UPSTREAM_LIMIT_CHARS_PER_TOKEN, VERSION_SUMMARY_MAX_CHARS, absentHostServices, advanceReview, affinity, ageCopyKey, allowRowCollisions, anchorVerdict, appendEvolutionEvent, applyCuratorLifecycleFields, applyCuratorMetaFields, applyNamespaceMigration, applyReferenceRewrite, assertDispatchPayload, assertSkillsRootAliasRetired, assessStructureHealth, authoringFeedback, basePresetPlugins, blobPath, bodyCost, buildCuratorRunReport, buildLearnPrompt, bumpPatch, bumpSupportRead, bumpUse, bumpView, callingScope, canonicalWriteId, claimInstance, clampOnce, clampedNumber, classifyNamespaceMigration, clearReviewChannel, collectReadSkillNames, composePresetComposition, composePresetEntry, composePresetInsert, composePresetRow, computeDedupGroups, computeDriftSignals, computeLifecycleTransitions, computePrefixClusters, computeQualityScores, computeScopeView, contentHash, contentRetentionFeedback, countDispatches, createGateSet, daysSinceIso, decideTakeover, declaredReportStamp, describeReferenceRewrite, dispatchKeyOf, dispatchStepOf, displayBodyOf, duplicateHeadings, elapsedSince, emptyRecord, entryTarget, errorText, evaluateThreat, eventsFile, evidenceKindIndex, evolutionActivityProjection, evolutionEventPayloadIssue, evolutionEvidenceProjection, evolutionHome, evolutionIoAdapter, evolutionReadsProjection, evolutionRoot, evolutionSignalsProjection, filterUnreadSkillOps, findDriftSignal, foldCuratorFields, foldToolDispatches, foldTurnEvent, foldTurnEvents, foldUntrustedLines, frontmatterBlock, frontmatterCatalogInvalid, fuzzyPatch, getRecord, historyIndexFile, historyRoot, identity, idleDays, initialTurnFold, installEvolutionProjections, instanceClaimKey, instanceClaimedWriteSites, instanceHolder, isAbsent, isBookkeepingFrame, isCommittedWarning, isDeprecatedParamId, isFileShapedPath, isLoopbackRequest, isMissingPath, isPresent, isProcessAlive, isProgramToolName, isReviewChannelSession, isSkillReadToolName, isSkillToolName, isUnknown, isUnreadWrite, latestActivityAt, latestVersionAt, lifecycleCandidate, listEventArchives, liveBool, liveEnum, liveNumber, liveString, loadMutations, loadRowOverrides, loadSuppressedNames, loadUsage, loadVersionContent, loadVersions, makeSerialQueue, mapProbe, markAgentCreated, markReviewChannel, markerEntryName, memoryRoot, mergePresetRow, missingSupportPointers, mutateUsage, mutationsFile, narrowNameMatches, nearDuplicateSummaries, neutralizePromptVariables, newRunRegistry, newSkillLibrary, nextHistoryIndex, nodeEvolutionIo, normalizeFrontmatter, normalizeUsageRecord, normalizeVersionSummary, observeEvent, orderVersions, overlongLines, paramNamespace, paramRowId, paramSettingsId, parseCuratorNominations, parseEvolutionEvents, parseFrontmatter, parseHistoryIndex, parseLockBody, partitionVersions, payloadText, pendingSelfCleanup, persistedWriteSite, persistedWriteSites, pickWithPolicy, planNamespaceMigration, planReferenceRewrite, planRehoming, policyStageLimits, presetPatchText, presetRowBlock, presetRowBody, presetRowId, probeAbsent, probeList, probeMtime, probePresent, probeReason, probeText, probeUnknown, projectionText, readDispatchSignal, readEvolutionEvents, readEvolutionTimeline, readHistoryIndex, readJsonBody, readJsonObject, readNumberParam, readParam, readingStats, recordMutation, recordVersions, redactSecrets, relatedSkillNames, releaseInstance, removePresetRow, renameWithRetry, renderCuratorReportMarkdown, renderLongRunTable, reportTime, reportsSweepLockTarget, resolveBasePresetPatch, resolveCitations, resolveExecOrigins, resolveOrigins, resolveParamId, resolveRootConfig, resolveSkillsRoot, retainEventArchives, retirementReport, reviewPrompt, runsFile, saveSuppressedNames, saveUsage, scanBodyHooks, scanContentThreats, scanMemoryThreats, scanThreats, scopedProbeReport, sessionAudited, sessionEvidenceIndex, sessionLastEventTime, sessionReadNames, sessionReadSkillNames, sessionSeesFamilyTools, sessionTurnSignals, skillReadNameOf, skillRowCells, skillStateKey, skillsRoot, supportFileReadOf, suppressedFile, sweepReports, sweepReviewChannelSessions, textDiffFacts, tokenLineFor, transactIo, transactTaskGuard, trimPatternBoundaries, unhookedSupportPointers, unwrapLive, updateSuppressedNames, usageFile, usageObserved, userSetKeys, validateFrontmatter, validateRestructureTarget, valueOr, verifyPromptBundle, versionActionKind, versionRowCells, versionSummaryPrompt, versionTarget, vocabulary, writeDurableTmp, writeJson, writePathSymbols, yamlPlainScalarNeedsQuotes };
+export { AGENT_PRESET_PACKAGE, AGENT_PRESET_ROOT_HINT, 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_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, DISPATCH_EVENT_TYPES, DRIFT_MAX_LINE_CHARS, DRIFT_SIGNALS_VERSION, DRIFT_SIGNAL_NOUNS, DSH_AUTHORING_STANDARDS, EMPTY_PATCH_SEED, ENTRY_DELIMITER, EVENT_ARCHIVE_PREFIX, EVENT_LOG_RETAIN_ARCHIVES, EVENT_LOG_ROTATE_AT, EVENT_LOG_VERSION, EVOLUTION_ERRORS, 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, INSTANCE_KEYS, KEEP_LINE_RE, LONG_RUNS, LOW_QUALITY_THRESHOLD, 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, 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_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, RESTRUCTURE_TARGET_RE, RETENTION_FEEDBACK_KEEP_RATIO, RETENTION_FEEDBACK_MIN_CHARS, 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, SUMMARY_DUPLICATE_HINT_THRESHOLD, SUPPORT_DIRS, SUPPRESSED_FILE_VERSION, SkillLibrary, TEXT_DIFF_MAX_CHARS, TEXT_DIFF_MAX_LINES, THREAT_EXEMPTION_HINT, TOKEN_ASCII_WEIGHT, TOKEN_CJK_WEIGHT, ToolDispatchNormalizer, ToolDispatchPayloadError, UNTRUSTED_LINE_BREAK, UNTRUSTED_LINE_MARK, UPSTREAM_LIMIT_CHARS_PER_TOKEN, VERSION_SUMMARY_MAX_CHARS, absentHostServices, advanceReview, affinity, ageCopyKey, allowRowCollisions, anchorVerdict, appendEvolutionEvent, applyCuratorLifecycleFields, applyCuratorMetaFields, applyNamespaceMigration, applyReferenceRewrite, asRecord, assertDispatchPayload, assertSkillsRootAliasRetired, assessStructureHealth, atomicWriteFiles, authoringFeedback, basePresetPlugins, blobPath, bodyCost, buildCuratorRunReport, buildLearnPrompt, bumpPatch, bumpSupportRead, bumpUse, bumpView, callingScope, canonicalWriteId, claimInstance, clampOnce, clampedNumber, classifyNamespaceMigration, clearReviewChannel, collectReadSkillNames, composePresetComposition, composePresetEntry, composePresetInsert, composePresetRow, compositionRowIds, computeDedupGroups, computeDriftSignals, computeLifecycleTransitions, computePrefixClusters, computeQualityScores, computeScopeView, contentHash, contentRetentionFeedback, countDispatches, createGateSet, daysSinceIso, declaredReportStamp, denseBlockSequence, describeReferenceRewrite, dispatchKeyOf, dispatchStepOf, displayBodyOf, duplicateHeadings, elapsedSince, emptyRecord, entryTarget, errorText, evaluateThreat, eventsFile, evidenceKindIndex, evolutionActivityProjection, evolutionEventPayloadIssue, evolutionEvidenceProjection, evolutionHome, evolutionIoAdapter, evolutionReadsProjection, evolutionRoot, evolutionSignalsProjection, filterUnreadSkillOps, findDriftSignal, foldCuratorFields, foldToolDispatches, foldTurnEvent, foldTurnEvents, foldUntrustedLines, frontmatterBlock, frontmatterCatalogInvalid, fuzzyPatch, getRecord, historyIndexFile, historyRoot, identity, idleDays, initialTurnFold, installEvolutionProjections, instanceClaimKey, instanceClaimedWriteSites, instanceHolder, isAbsent, isBookkeepingFrame, isCommittedWarning, isDeprecatedParamId, isFileShapedPath, isLoopbackRequest, isMissingPath, isPresent, isProcessAlive, isProgramToolName, isRecord, isReviewChannelSession, isSkillReadToolName, isSkillToolName, isUnknown, isUnreadWrite, latestActivityAt, latestVersionAt, lifecycleCandidate, listDirectories, listEventArchives, liveBool, liveEnum, liveNumber, liveString, loadMutations, loadRowOverrides, loadSuppressedNames, loadUsage, loadVersionContent, loadVersions, makeSerialQueue, mapProbe, markAgentCreated, markReviewChannel, markerEntryName, memoryRoot, mergePresetRow, missingSupportPointers, mutateUsage, mutationsFile, narrowNameMatches, nearDuplicateSummaries, neutralizePromptVariables, 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, policyStageLimits, presetPatchText, presetRowBlock, presetRowBody, presetRowId, probeAbsent, probeDesktopScope, probeList, probeMtime, probePresent, probeReason, probeText, probeUnknown, projectionText, readDispatchSignal, readEvolutionEvents, readEvolutionTimeline, readHistoryIndex, readJsonBody, readJsonObject, readNumberParam, readParam, readingStats, recordMutation, recordVersions, redactSecrets, relatedSkillNames, releaseInstance, removePresetRow, renameWithRetry, renderCuratorReportMarkdown, renderLongRunTable, reportTime, reportsSweepLockTarget, resolveBasePresetPatch, resolveCitations, resolveExecOrigins, resolveOrigins, resolveParamId, resolveRootConfig, resolveSkillsRoot, retainEventArchives, retirementReport, reviewPrompt, rowBlockSpan, rowSiblingEnd, runsFile, saveSuppressedNames, saveUsage, scanBodyHooks, scanContentThreats, scanMemoryThreats, scanThreats, scopedProbeReport, sessionAudited, sessionEvidenceIndex, sessionLastEventTime, sessionReadNames, sessionReadSkillNames, sessionSeesFamilyTools, sessionTurnSignals, skillReadNameOf, skillRowCells, skillStateKey, skillsRoot, supportFileReadOf, suppressedFile, sweepReports, sweepReviewChannelSessions, textDiffFacts, tokenLineFor, transactIo, transactTaskGuard, trimPatternBoundaries, trimTrailingBlankLines, unhookedSupportPointers, unwrapLive, updateSuppressedNames, usageFile, usageObserved, userSetKeys, validateFrontmatter, validateRestructureTarget, valueOr, verifyPromptBundle, versionActionKind, versionRowCells, versionSummaryPrompt, versionTarget, vocabulary, writeDurableTmp, writeJson, writePathSymbols, yamlPlainScalarNeedsQuotes };