@lmzhen/dsh-evolution-core 0.22.0 → 0.24.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";
@@ -531,7 +531,7 @@ const PLATFORM_CATALOG_DESCRIPTION_DEFAULT = 500;
 * be copied into validateFrontmatter AND the patch path, and neither copy named
 * where the content should go — the upstream cap message names the destination
 * directories, and that is the part a model actually acts on. */
-const CONTENT_SPLIT_HINT = "Consider splitting into a smaller SKILL.md with supporting files in references/ or templates.";
+const CONTENT_SPLIT_HINT = "建议拆成更小的 SKILL.md，把支撑文件放进 references/ 或 templates/。";
 /** V27 G2.4: the largest millisecond delay a timer accepts. `AbortSignal.timeout`
 * (and `setTimeout`) coerce anything larger to 1ms after a Node warning, so a
 * timeout configured above this ceiling silently collapses to "immediately
@@ -1052,16 +1052,16 @@ function shrinksOverLimit(next, current, limit) {
 }
 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.";
+	if (!parsed) return "SKILL.md 必须以 `---` 行开头，用另一个完全相同的 `---` 行结束 frontmatter（只容忍结尾的 `\\r`），并在其下包含正文。";
 	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. ${CONTENT_SPLIT_HINT}`;
+	if (unreadable.length > 0) return `Frontmatter 字段 ${unreadable.map((entry) => `"${entry.key}" (a YAML ${entry.kind})`).join(", ")} 必须是字符串：平台技能目录会把这种字段当作缺失，并忽略整个文件。请写成纯文本，或用双引号包住取值以保持字面内容。`;
+	if (!parsed.frontmatter.name) return "Frontmatter 必须包含 name 字段。";
+	if (!SKILL_NAME_RE.test(parsed.frontmatter.name)) return `技能名「${parsed.frontmatter.name}」不合法：请只用小写字母、数字和连字符。`;
+	if (parsed.frontmatter.name.length > limits.maxNameLength) return `技能名超过 ${limits.maxNameLength} 个字符。`;
+	if (expectedName && parsed.frontmatter.name !== expectedName) return `Frontmatter 里的 name「${parsed.frontmatter.name}」与目标技能「${expectedName}」不一致。`;
+	if (!parsed.frontmatter.description) return "Frontmatter 必须包含 description 字段。";
+	if (parsed.frontmatter.description.length > limits.maxDescriptionLength) return `description 超过 ${limits.maxDescriptionLength} 个字符。`;
+	if (exceedsContentLimit(content, limits.maxSkillContentChars) && !shrinksOverLimit(content, current, limits.maxSkillContentChars)) return `SKILL.md 内容超过 ${limits.maxSkillContentChars} 个字符。${CONTENT_SPLIT_HINT}`;
 	return null;
 }
 /**
@@ -1076,8 +1076,8 @@ function authoringFeedback(frontmatter) {
 	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.");
+	lines.push(over60 ? `描述为 ${description.length}/60 个字符 —— 超过 60 字符的作者规范上限（Hermes 标准；技能目录会按平台配置的上限截断）。` : `描述为 ${description.length}/60 个字符 —— 在作者规范上限之内。`);
+	if (hasColon) lines.push("描述里含冒号 —— 请用双引号把整个取值包起来。");
 	return {
 		descriptionChars: description.length,
 		over60,
@@ -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
@@ -3265,32 +3102,33 @@ function allowRowCollisions(env = process.env) {
 * @module @lmzhen/dsh-evolution-core
 */
 const EVOLUTION_ERRORS = Object.freeze({
-	"e-305-this-invocation-carries-no": "E-305: this invocation carries no agent — `%a1%` needs a session-backed call (run it from a session in the GUI or the CLI).",
-	"e-306-this-deployment-stages-foreground": "E-306: this deployment stages foreground writes, but `/evolution %a1%` is not replayable through the skill runner — there is nothing to stage. Run it from a session whose approval policy is 'never', or set `stageForeground: false` on the evolution-approval row, then repeat the command.",
-	"e-301-approval-service-not-mounted": "E-301: approval service not mounted — pending writes cannot be listed or replayed. Next: the evolution-approval row ships with evolution-host/evolution-all — run /evolution doctor to see which services are mounted.",
-	"e-301-approval-service-not-mounted-2": "E-301: approval service not mounted. Next: the evolution-approval row ships with evolution-host/evolution-all — run /evolution doctor to see which services are mounted.",
-	"e-304-the-mounted-approval-service": "E-304: the mounted approval service predates the release capability — reject the record instead.",
-	"e-302-curator-service-not-mounted": "E-302: curator service not mounted. Next: mount the evolution-curator row (evolution-host/evolution-all) and run /evolution doctor.",
-	"e-305-the-invocation-agent-exposes": "E-305: the invocation agent exposes neither `followup` nor `inject` — %a1% has no delivery channel.",
-	"e-306-this-deployment-stages-foreground-2": "E-306: this deployment stages foreground writes, but this invocation carries no agent session — `/evolution restructure` would stage a record with no session attribution. Run it from a session in the GUI or the CLI, or set `stageForeground: false` on the evolution-approval row, then repeat the command.",
-	"e-303-replay-service-not-mounted": "E-303: replay service not mounted. Next: mount the evolution-replay row (evolution-host/evolution-all) and run /evolution doctor.",
-	"e-307-the-settings-service-could": "E-307: the settings service could not report its sections (%a1%). /evolution params needs the user layer to tell an override from a deployment value; run /evolution doctor to see which services are mounted.",
-	"e-308-unknown-parameter-group-group": "E-308: unknown parameter group \"%a1%\" — known groups: %a2%.",
-	"e-311-no-settings-service-is": "E-311: no settings service is mounted, so there is no user layer to write. Mount the settings row (packages/settings/settings-file) and retry; this command never edits cordis.yml — a deployment value belongs to the deployment. /evolution doctor lists the mounted services.",
-	"e-312-error-instanceof-Error-error": "E-312: %a1% — /evolution params lists the canonical ids.",
-	"e-313-unknown-parameter-id-evolution": "E-313: unknown parameter \"%a1%\" — /evolution params lists every registered id with its tier and user layer.",
-	"e-314-id-is-a-deployment": "E-314: \"%a1%\" is a deployment parameter (tier %a2%, owner %a3%) — it is written in cordis.yml on its plugin or policy row, not from a session. /evolution params shows who may write each row.",
-	"e-315-id-has-no-user": "E-315: \"%a1%\" has no user layer — owner %a2% publishes no settings namespace, so the value stays with the deployment.",
-	"e-307-the-settings-service-could-2": "E-307: the settings service could not report its sections (%a1%). /evolution policy set needs the current revision to write safely; run /evolution doctor to see which services are mounted.",
-	"e-316-namespace-namespace-is-not": "E-316: namespace \"%a1%\" is not registered — owner %a2% is not mounted in this composition, so its parameters cannot be written from here. /evolution params marks those rows 'unregistered'.",
-	"e-309-revision-conflict-you-sent": "E-309: revision conflict — you sent %a1%, the document stands at %a2%. Re-read with /evolution params --json and retry.",
-	"e-309-revision-conflict-message-Re": "E-309: revision conflict — %a1%. Re-read with /evolution params --json and retry.",
-	"e-310-the-settings-service-refused": "E-310: the settings service refused the write: %a1% — the owning plugin's rule stands (a cross-field pair, or a cap that may only be tightened). /evolution params shows the current value.",
-	"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-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`."
+	"e-305-this-invocation-carries-no": "E-305: 本次调用没有携带 agent —— `%a1%` 需要由会话支撑的调用（请在 GUI 或 CLI 的会话里运行）。",
+	"e-306-this-deployment-stages-foreground": "E-306: 本部署会暂存前台写入，但 `/evolution %a1%` 无法通过技能运行器回放 —— 没有可暂存的内容。请在批准策略为 'never' 的会话里运行，或在 evolution-approval 行上设置 `stageForeground: false`，然后重试该命令。",
+	"e-301-approval-service-not-mounted": "E-301: 批准服务未挂载：待批准写入无法列出或回放。挂载 evolution-approval 行（随 evolution-host/evolution-all 提供）后，运行 /evolution doctor 可查看已挂载的服务。",
+	"e-301-approval-service-not-mounted-2": "E-301: 批准服务未挂载。下一步：evolution-approval 行随 evolution-host/evolution-all 一起提供 —— 运行 /evolution doctor 查看已挂载的服务。",
+	"e-304-the-mounted-approval-service": "E-304: 已挂载的批准服务早于本能力发布 —— 请改为驳回该记录。",
+	"e-302-curator-service-not-mounted": "E-302: 策展服务未挂载。下一步：挂载 evolution-curator 行（evolution-host/evolution-all），并运行 /evolution doctor。",
+	"e-305-the-invocation-agent-exposes": "E-305: 调用 agent 既没有暴露 `followup` 也没有 `inject` —— %a1% 没有投递通道。",
+	"e-306-this-deployment-stages-foreground-2": "E-306: 本部署会暂存前台写入，但本次调用没有 agent 会话 —— `/evolution restructure` 会暂存一条没有会话归属的记录。请在 GUI 或 CLI 的会话里运行，或在 `stageForeground: false` 行上设置，然后重试该命令。",
+	"e-303-replay-service-not-mounted": "E-303: 回放服务未挂载。下一步：挂载 evolution-replay 行（evolution-host/evolution-all），并运行 /evolution doctor。",
+	"e-307-the-settings-service-could": "E-307: 设置服务无法报告它的分区（%a1%）。/evolution params 需要用户层来区分覆盖值与部署值；运行 /evolution doctor 查看已挂载的服务。",
+	"e-308-unknown-parameter-group-group": "E-308: 未知的参数分组「%a1%」—— 已知分组：%a2%。",
+	"e-311-no-settings-service-is": "E-311: 没有挂载设置服务，因此没有可写入的用户层。请挂载 settings 行（packages/settings/settings-file）后重试；本命令从不修改 cordis.yml —— 部署值属于部署。/evolution doctor 会列出已挂载的服务。",
+	"e-312-error-instanceof-Error-error": "E-312: %a1% —— /evolution params 会列出规范 id。",
+	"e-313-unknown-parameter-id-evolution": "E-313: 未知参数「%a1%」—— /evolution params 会列出每个已注册 id 及其层级与用户层。",
+	"e-314-id-is-a-deployment": "E-314: 「%a1%」是部署参数（层级 %a2%，归属 %a3%）—— 它写在 cordis.yml 的插件行或策略行上，而不是从会话写入。/evolution params 会显示每一行由谁可写。",
+	"e-315-id-has-no-user": "E-315: 「%a1%」没有用户层 —— 归属 %a2% 没有发布设置命名空间，因此该值留在部署层。",
+	"e-307-the-settings-service-could-2": "E-307: 设置服务无法报告它的分区（%a1%）。/evolution policy set 需要当前修订号才能安全写入；运行 /evolution doctor 查看已挂载的服务。",
+	"e-316-namespace-namespace-is-not": "E-316: namespace \"%a1%\" 未注册 —— 归属 %a2% 在本组合中未挂载，因此无法从这里写入它的参数。 /evolution params 会把那些行标为 'unregistered'.",
+	"e-309-revision-conflict-you-sent": "E-309: 修订冲突 —— 你提交的是 %a1%，文档当前为 %a2%。请用 /evolution params --json 重新读取后重试。",
+	"e-309-revision-conflict-message-Re": "E-309: 修订冲突 —— %a1%。请用 /evolution params --json 重新读取后重试。",
+	"e-310-the-settings-service-refused": "E-310: 设置服务拒绝了这次写入：%a1% —— 归属插件的规则优先（跨字段成对约束，或只能收紧的上限）。/evolution params 会显示当前值。",
+	"e-317-skill-write-not-confirmed": "E-317: 技能 \"%a1%\" 未被%a2% —— 确认提示被拒绝或关闭，因此没有写入任何内容。每次创建与裸删除都会出现该提示；只有操作者要求时才重复调用。",
+	"e-318-skill-write-without-a-read": "E-318: 本会话没有读取技能 \"%a1%\"，因此拒绝这次写入。请先用 `skill` 工具读取它（失败的读取不算），然后重复该写入。",
+	"e-320-the-profile-home-is-not": "E-320: 本宿主没有报告 profile home，因此无法定位旧设置文档。/evolution migrate 读取 `<profile home>/settings.yaml.imported`；请在由 profile 启动的会话里运行。",
+	"e-322-a-parameter-would-break-a": "E-322: %a1% 至少应为 %a2%，但这次写入把它设成 %a3%。未写入任何内容。",
+	"e-321-no-io-provider-is": "E-321: 没有挂载 evolution-io 提供方，因此无法读取旧设置文档。请挂载 evolution-io 行（evolution-host/evolution-all）后重试。",
+	"e-319-skill-write-confirm-timed-out": "E-319: 技能 \"%a1%\" 未被%a2% —— 确认提示在 %a3% 秒内无人应答，因此该写入被取消。没有人在场决定：把 `skillWriteConfirm` 设为 `auto` 可免提示直接写入，保留 `ask` 则一直等到有人应答，或提高 `skillWriteConfirmTimeoutSeconds`。"
 });
 /**
 * Render one table entry, substituting its interpolation slots.
@@ -3983,7 +3821,7 @@ var MemoryStore = class {
 		const chars = entries.join(ENTRY_DELIMITER).length;
 		if (this.failureCount > this.maxFailures) return {
 			ok: false,
-			message: `Memory consolidation failed ${this.failureCount} times this turn. Stop retrying memory calls and continue with the user's task.${previewEntries(entries)}`,
+			message: `本轮记忆整理已失败 ${this.failureCount} 次。请停止重试记忆调用，继续处理用户的任务。${previewEntries(entries)}`,
 			entries,
 			chars,
 			limit: this.limitFor(target)
@@ -4046,10 +3884,10 @@ var MemoryStore = class {
 		const oversized = await this.oversizedFile(target);
 		if (!oversized) return null;
 		const backup = await this.backupFile(target);
-		const suffix = backup ? ` A backup was saved to ${basename(backup)}.` : "";
+		const suffix = backup ? ` 已把备份保存到 ${basename(backup)}。` : "";
 		return {
 			ok: false,
-			message: `Memory file is ${oversized.size} bytes (limit ${oversized.limit * READ_GUARD_FACTOR}) — skipping read.${suffix} Fix the file manually, then retry.`,
+			message: `记忆文件为 ${oversized.size} 字节（上限 ${oversized.limit * READ_GUARD_FACTOR}）—— 跳过读取。${suffix} 请手动修复该文件后重试。`,
 			entries: [],
 			chars: 0,
 			limit: this.limitFor(target)
@@ -4082,7 +3920,7 @@ var MemoryStore = class {
 			const size = await this.io.size?.(fileFor(this.root, target));
 			if (typeof size === "number" && size > SHRINK_LOAD_CEILING) return {
 				ok: false,
-				message: `Memory file is ${size} bytes - too large to load even for a remove-only batch. Fix the file manually, then retry.`,
+				message: `记忆文件为 ${size} 字节 —— 即使只做删除批处理也过大、无法加载。请手动修复该文件后重试。`,
 				entries: [],
 				chars: 0,
 				limit: this.limitFor(target)
@@ -4096,7 +3934,7 @@ var MemoryStore = class {
 		});
 		return outcome ?? {
 			ok: false,
-			message: "internal error: the memory transaction did not invoke the task; no write was performed",
+			message: "内部错误：记忆写事务没有调用任务；未执行任何写入",
 			entries: [],
 			chars: 0,
 			limit: this.limitFor(target)
@@ -4108,7 +3946,7 @@ var MemoryStore = class {
 	async addChained(target, facts) {
 		if (!facts.trim()) return {
 			ok: false,
-			message: "Content cannot be empty.",
+			message: "内容不能为空。",
 			entries: [],
 			chars: 0,
 			limit: this.limitFor(target)
@@ -4125,7 +3963,7 @@ var MemoryStore = class {
 		if (!content) return {
 			result: {
 				ok: false,
-				message: "Content cannot be empty.",
+				message: "内容不能为空。",
 				entries: [],
 				chars: 0,
 				limit: this.limitFor(target)
@@ -4152,7 +3990,7 @@ var MemoryStore = class {
 		if (hasEntryDelimiter(prefixed)) return {
 			result: {
 				ok: false,
-				message: "Fact contains the entry delimiter (§) and would split into multiple entries; rewrite it as separate facts.",
+				message: "该条目含有分隔符（§），会被拆成多条；请改写为多条独立的事实。",
 				entries: [],
 				chars: 0,
 				limit: this.limitFor(target)
@@ -4165,7 +4003,7 @@ var MemoryStore = class {
 			return {
 				result: {
 					ok: true,
-					message: `Entry already exists (no duplicate added).${this.storageHint(target, entries.join(ENTRY_DELIMITER).length)}`,
+					message: `该条目已存在（未重复添加）。${this.storageHint(target, entries.join(ENTRY_DELIMITER).length)}`,
 					entries,
 					chars: entries.join(ENTRY_DELIMITER).length,
 					limit: this.limitFor(target)
@@ -4177,14 +4015,14 @@ var MemoryStore = class {
 		const total = next.join(ENTRY_DELIMITER).length;
 		const addLimit = this.limitFor(target);
 		if (addLimit > 0 && total > addLimit) return {
-			result: this.failure(target, `Adding this entry would exceed the ${addLimit} char limit. Consolidate or remove stale entries, then retry.`, entries),
+			result: this.failure(target, `添加该条目会超过 ${addLimit} 字符上限。请先合并或删除过期条目，再重试。`, entries),
 			write: null
 		};
 		this.resetFailures();
 		return {
 			result: {
 				ok: true,
-				message: `Entry added.${this.storageHint(target, total)}`,
+				message: `已添加条目。${this.storageHint(target, total)}`,
 				entries: next,
 				chars: total,
 				limit: this.limitFor(target)
@@ -4261,10 +4099,9 @@ var MemoryStore = class {
 			if (shrinkOnly) return null;
 			const limit = this.limitFor(target);
 			const entries = normalizeEntries(raw);
-			const over = entries.filter((entry) => entry.length > limit).length;
 			return {
 				ok: false,
-				message: `${over} memory ${over === 1 ? "entry exceeds" : "entries exceed"} the configured ${target}CharLimit (${limit}); they were written under a higher limit. Raise the limit or remove entries — remove operations stay available.`,
+				message: `${entries.filter((entry) => entry.length > limit).length} 条记忆超过了配置的 ${target}CharLimit（${limit}）；它们是在更高上限下写入的。请提高上限或删除条目 —— 删除类操作仍然可用。`,
 				entries,
 				chars: entries.join(ENTRY_DELIMITER).length,
 				limit
@@ -4273,7 +4110,7 @@ var MemoryStore = class {
 		const backup = await this.backupFile(target);
 		return {
 			ok: false,
-			message: `External drift detected in memory file.${backup ? ` A backup was saved to ${basename(backup)}.` : ""} Resolve the drift before retrying.`,
+			message: `检测到记忆文件被外部改动。${backup ? ` 已把备份保存到 ${basename(backup)}。` : ""} 请先处理该漂移再重试。`,
 			entries: [],
 			chars: 0,
 			limit: this.limitFor(target)
@@ -4285,7 +4122,7 @@ var MemoryStore = class {
 	async applyBatchChained(target, operations) {
 		if (operations.length === 0) return {
 			ok: false,
-			message: "operations list is empty.",
+			message: "operations 列表为空。",
 			entries: [],
 			chars: 0,
 			limit: this.limitFor(target)
@@ -4310,7 +4147,7 @@ var MemoryStore = class {
 				if (!body) return {
 					result: {
 						ok: false,
-						message: `Operation ${position} (add): facts is required. No operations were applied.${previewEntries(entries)}`,
+						message: `第 ${position} 个操作（add）：必须提供 facts。未应用任何操作。${previewEntries(entries)}`,
 						entries,
 						chars: entries.join(ENTRY_DELIMITER).length,
 						limit: this.limitFor(target)
@@ -4321,7 +4158,7 @@ var MemoryStore = class {
 				if (threat) return {
 					result: {
 						ok: false,
-						message: `Operation ${position}: ${threat}${previewEntries(entries)}`,
+						message: `第 ${position} 个操作：${threat}${previewEntries(entries)}`,
 						entries,
 						chars: entries.join(ENTRY_DELIMITER).length,
 						limit: this.limitFor(target)
@@ -4332,7 +4169,7 @@ var MemoryStore = class {
 				if (hasEntryDelimiter(entryBody)) return {
 					result: {
 						ok: false,
-						message: `Operation ${position} (add): Fact contains the entry delimiter (§) and would split into multiple entries; rewrite it as separate facts.${previewEntries(entries)}`,
+						message: `第 ${position} 个操作（add）：该条目含有分隔符（§），会被拆成多条；请改写为多条独立的事实。${previewEntries(entries)}`,
 						entries,
 						chars: entries.join(ENTRY_DELIMITER).length,
 						limit: this.limitFor(target)
@@ -4346,7 +4183,7 @@ var MemoryStore = class {
 			if (rawAction !== "remove" && rawAction !== "replace") return {
 				result: {
 					ok: false,
-					message: `Operation ${position}: unknown action "${String(rawAction)}" (expected add/remove/replace). No operations were applied.${previewEntries(entries)}`,
+					message: `第 ${position} 个操作：未知动作「${String(rawAction)}」（应为 add/remove/replace）。未应用任何操作。${previewEntries(entries)}`,
 					entries,
 					chars: entries.join(ENTRY_DELIMITER).length,
 					limit: this.limitFor(target)
@@ -4357,7 +4194,7 @@ var MemoryStore = class {
 			if (!needle) return {
 				result: {
 					ok: false,
-					message: `Operation ${position} (${op.action}): old_text is required. No operations were applied.${previewEntries(entries)}`,
+					message: `第 ${position} 个操作（${op.action}）：必须提供 old_text。未应用任何操作。${previewEntries(entries)}`,
 					entries,
 					chars: entries.join(ENTRY_DELIMITER).length,
 					limit: this.limitFor(target)
@@ -4369,13 +4206,13 @@ var MemoryStore = class {
 				matchIndex
 			})).filter(({ entry }) => entry.includes(needle));
 			if (matches.length === 0) return {
-				result: this.failure(target, `Operation ${position}: no entry matching "${needle}" found. No operations were applied.`, entries),
+				result: this.failure(target, `第 ${position} 个操作：找不到匹配 "${needle}" 的条目。未应用任何操作。`, entries),
 				write: null
 			};
 			if (new Set(matches.map((m) => m.entry)).size > 1) return {
 				result: {
 					ok: false,
-					message: `Operation ${position}: "${needle}" matched multiple distinct entries. No operations were applied.${previewEntries(entries)}`,
+					message: `第 ${position} 个操作：「${needle}」匹配到多条不同条目。未应用任何操作。${previewEntries(entries)}`,
 					entries,
 					chars: entries.join(ENTRY_DELIMITER).length,
 					limit: this.limitFor(target)
@@ -4389,7 +4226,7 @@ var MemoryStore = class {
 				if (!body) return {
 					result: {
 						ok: false,
-						message: `Operation ${position} (replace): facts is required.${previewEntries(entries)}`,
+						message: `第 ${position} 个操作（replace）：必须提供 facts。${previewEntries(entries)}`,
 						entries,
 						chars: entries.join(ENTRY_DELIMITER).length,
 						limit: this.limitFor(target)
@@ -4400,7 +4237,7 @@ var MemoryStore = class {
 				if (threat) return {
 					result: {
 						ok: false,
-						message: `Operation ${position}: ${threat}${previewEntries(entries)}`,
+						message: `第 ${position} 个操作：${threat}${previewEntries(entries)}`,
 						entries,
 						chars: entries.join(ENTRY_DELIMITER).length,
 						limit: this.limitFor(target)
@@ -4411,7 +4248,7 @@ var MemoryStore = class {
 				if (hasEntryDelimiter(entryBody)) return {
 					result: {
 						ok: false,
-						message: `Operation ${position} (replace): Fact contains the entry delimiter (§) and would split into multiple entries; rewrite it as separate facts.${previewEntries(entries)}`,
+						message: `第 ${position} 个操作（replace）：该条目含有分隔符（§），会被拆成多条；请改写为多条独立的事实。${previewEntries(entries)}`,
 						entries,
 						chars: entries.join(ENTRY_DELIMITER).length,
 						limit: this.limitFor(target)
@@ -4424,14 +4261,14 @@ var MemoryStore = class {
 		const total = working.join(ENTRY_DELIMITER).length;
 		const batchLimit = this.limitFor(target);
 		if (batchLimit > 0 && total > batchLimit) return {
-			result: this.failure(target, `Batch result (${total} chars) exceeds the ${batchLimit} limit. Remove or shorten more entries in the same batch.`, entries),
+			result: this.failure(target, `批处理结果（${total} 字符）超过 ${batchLimit} 上限。请在同一个批里再删除或缩短一些条目。`, entries),
 			write: null
 		};
 		this.resetFailures();
 		return {
 			result: {
 				ok: true,
-				message: `Applied ${operations.length} operation(s).${this.storageHint(target, total)}`,
+				message: `已应用 ${operations.length} 个操作。${this.storageHint(target, total)}`,
 				entries: working,
 				chars: total,
 				limit: this.limitFor(target)
@@ -4532,7 +4369,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 +4433,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 +4462,7 @@ function loadRowOverrides() {
 			missingReason: candidate.missingReason
 		});
 	}
-	cachedOverrides = entries;
+	overridesCache.set(path, entries);
 	return entries;
 }
 /**
@@ -4737,7 +4581,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.
@@ -6116,7 +5960,7 @@ function newRunRegistry(options) {
 			const parsed = parseIndex(raw);
 			if (!parsed.ok) return {
 				ok: false,
-				note: "run index could not be read as an index (not JSON, or no runs array) — the previous run history is unknown (the reports are unaffected)"
+				note: "运行索引读不出来（不是 JSON，或没有 runs 数组）—— 上一次的运行历史未知（报告不受影响）"
 			};
 			const wasRunning = new Set([...foreign.values()].filter((row) => row.state === "running").map((row) => row.id));
 			const seen = /* @__PURE__ */ new Set();
@@ -6411,7 +6255,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 +6265,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 +6302,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 +7861,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 +7916,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),
@@ -8710,7 +8578,7 @@ function contentRetentionFeedback(input) {
 	if (before === null || after === null) return null;
 	if (before.length < 200) return null;
 	if (after.length >= before.length * .5) return null;
-	return `Content kept ${Math.round(after.length / before.length * 100)}% of the previous body (${after.length} of ${before.length} characters); the replaced version is preserved in this skill's history.`;
+	return `新内容保留了上一版正文的 ${Math.round(after.length / before.length * 100)}%（${after.length}／${before.length} 字符）；被替换的版本已保留在该技能的历史里。`;
 }
 /**
 * Read one skill's versions, oldest first.
@@ -9002,7 +8870,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
@@ -9078,7 +8946,7 @@ function anchorRefusal(name, verdict) {
 		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.`
+		message: verdict === "missing" ? `技能「${name}」不存在。` : `技能 "${name}" 在读取之后被改动过；为避免覆盖更新的内容，本次写入被拒绝。`
 	};
 }
 /**
@@ -9101,7 +8969,7 @@ function anchorUnverifiable(name, filePath) {
 		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.`
+		message: filePath === null ? `无法读取技能 "${name}" 以校验暂存内容。` : `无法读取技能 "${name}" 的支撑文件 "${filePath}" 以校验暂存内容。`
 	};
 }
 function anchorRefusalFile(name, filePath, verdict) {
@@ -9109,7 +8977,7 @@ function anchorRefusalFile(name, filePath, verdict) {
 		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.`
+		message: verdict === "missing" ? `文件「${filePath}」不在技能「${name}」里。` : `技能 "${name}" 的支撑文件 "${filePath}" 在读取之后被改动过；为避免覆盖更新的内容，本次写入被拒绝。`
 	};
 }
 /**
@@ -9127,7 +8995,7 @@ function anchorRefusalFile(name, filePath, verdict) {
 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.`
+		message: `读不出「${label}」：${error?.code === "EISDIR" ? "the path is a DIRECTORY, not a file" : error instanceof Error ? error.message : String(error)}。没有写入任何内容。`
 	};
 }
 /** Upper bound of moves per restructure proposal (validator and core agree). */
@@ -9239,15 +9107,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) {
@@ -9320,16 +9179,15 @@ function validateRestructureTarget(filePath) {
 }
 function validateSupportPath(filePath) {
 	const normalized = filePath.replace(/\\/g, "/");
-	if (normalized.includes("..")) return "Path traversal is not allowed.";
+	if (normalized.includes("..")) return "不允许路径穿越。";
 	const parts = normalized.split("/").filter(Boolean);
 	if (parts.length === 0 || !SUPPORT_DIRS.includes(parts[0])) return `file_path must be under one of: ${SUPPORT_DIRS.join(", ")}.`;
-	if (parts.length < 2) return "Provide a file name, not just a directory.";
+	if (parts.length < 2) return "请给出文件名，不能只给目录。";
 	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.`;
+		if (!SUPPORT_FILE_NAME_RE.test(part)) return `不支持的文件名「${part}」：请只用小写字母、数字、点、连字符和下划线（首字符须为字母或数字）。`;
+		if (part.toLowerCase().endsWith(".corrupt") || part.toLowerCase().endsWith(".tmp")) return `不支持的文件名「${part}」：.corrupt/.tmp 后缀由状态与 IO 协议保留。`;
 		const stem = part.split(".")[0]?.toLowerCase() ?? "";
-		if (WIN32_RESERVED_DEVICE_NAMES.has(stem)) return `Unsupported file name "${part}" — a Windows reserved device name.`;
+		if (WIN32_RESERVED_DEVICE_NAMES.has(stem)) return `不支持的文件名「${part}」：这是 Windows 保留设备名。`;
 	}
 	return null;
 }
@@ -9478,7 +9336,7 @@ var SkillLibrary = class {
 		const o = outcome;
 		if (o === void 0 || typeof o !== "object" || !Object.prototype.hasOwnProperty.call(o, "write")) return {
 			ok: false,
-			message: "internal error: the write transaction did not invoke the task; no write was performed"
+			message: "内部错误：写事务没有调用任务；未执行任何写入"
 		};
 		if (o.ghostDir === true) await this.cleanupGhostDir(path);
 		let result = o.result;
@@ -9498,7 +9356,7 @@ var SkillLibrary = class {
 		if (o.write !== null && o.event) this.notifyMutation(o.event);
 		return durabilityWarning === "" || !result.ok ? result : {
 			...result,
-			message: `${result.message} (warning: the write landed but the directory fsync failed — durability unconfirmed: ${durabilityWarning})`
+			message: `${result.message} （警告：写入已落盘，但目录 fsync 失败 —— 持久性未确认：${durabilityWarning})`
 		};
 	}
 	/**
@@ -9506,16 +9364,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 {}
 	}
@@ -9663,7 +9519,7 @@ var SkillLibrary = class {
 	*/
 	badName(name, opts = {}) {
 		const normalized = name.trim();
-		if (!SKILL_NAME_RE.test(normalized) || normalized.length > this.limits.maxNameLength) return `Invalid skill name "${normalized}". Use lowercase letters, digits, and hyphens (<= ${this.limits.maxNameLength}).`;
+		if (!SKILL_NAME_RE.test(normalized) || normalized.length > this.limits.maxNameLength) return `技能名「${normalized}」不合法：请只用小写字母、数字和连字符（不超过 ${this.limits.maxNameLength} 个）。`;
 		if (!opts.allowReserved && WIN32_RESERVED_DEVICE_NAMES.has(normalized)) return `"${normalized}" is a Windows reserved device name and cannot be used as a skill name.`;
 		return null;
 	}
@@ -9922,7 +9778,7 @@ var SkillLibrary = class {
 		};
 		if (origin === "background_review") return {
 			ok: false,
-			message: "Only the foreground (user or the main agent) may pin or unpin skills."
+			message: "只有前台（用户或主智能体）可以固定或取消固定技能。"
 		};
 		let durabilityWarning = "";
 		const dir = this.dirOf(normalized);
@@ -9930,17 +9786,17 @@ var SkillLibrary = class {
 		const existing = await this.io.exists(marker);
 		if (pinned && existing) return {
 			ok: true,
-			message: `Skill "${normalized}" is already pinned.`,
+			message: `技能「${normalized}」已被固定。`,
 			path: dir
 		};
 		if (!pinned && !existing) return {
 			ok: true,
-			message: `Skill "${normalized}" is not pinned; nothing to do.`,
+			message: `技能「${normalized}」未被固定，无需处理。`,
 			path: dir
 		};
 		if (!await this.io.exists(join(dir, "SKILL.md"))) return {
 			ok: false,
-			message: `Skill "${normalized}" not found.`
+			message: `技能「${normalized}」不存在。`
 		};
 		if (pinned) {
 			try {
@@ -9954,14 +9810,14 @@ var SkillLibrary = class {
 				await this.cleanupGhostDir(join(dir, "SKILL.md"));
 				return {
 					ok: false,
-					message: `Skill "${normalized}" was archived concurrently while pinning; the partial marker was removed — retry after the mover settles.`
+					message: `固定过程中技能「${normalized}」被并发归档；残留标记已移除：等搬运完成后重试。`
 				};
 			}
 		} else await this.io.remove(marker);
 		await this.audit(normalized, pinned ? "pin" : "unpin", null, null, pinned ? "pinned" : "unpinned");
 		return {
 			ok: true,
-			message: `${pinned ? `Skill "${normalized}" pinned: protected from deletion, background review, and the lifecycle.` : `Skill "${normalized}" unpinned.`}${durabilityWarning === "" ? "" : ` (warning: the write landed but the directory fsync failed — durability unconfirmed: ${durabilityWarning})`}`,
+			message: `${pinned ? `技能 "${normalized}" 已固定：免受删除、后台复核与生命周期影响。` : `技能 "${normalized}" 已取消固定。`}${durabilityWarning === "" ? "" : ` （警告：写入已落盘，但目录 fsync 失败 —— 持久性未确认：${durabilityWarning})`}`,
 			path: dir
 		};
 	}
@@ -9983,7 +9839,7 @@ var SkillLibrary = class {
 		const norm = normalizeFrontmatter(content);
 		if (norm.issues.length > 0) return {
 			ok: false,
-			message: `Skill "${normalized}" frontmatter cannot be auto-fixed: ${norm.issues[0]} — wrap the value in double quotes and retry.`
+			message: `技能「${normalized}」的 frontmatter 无法自动修复：${norm.issues[0]}：请用双引号包住取值后重试。`
 		};
 		const finalContent = norm.changed ? norm.content : content;
 		if (norm.changed) {
@@ -10001,7 +9857,7 @@ var SkillLibrary = class {
 		const dir = this.dirOf(normalized);
 		if (await this.io.exists(join(dir, "SKILL.md"))) return {
 			ok: false,
-			message: `Skill "${normalized}" already exists.`
+			message: `技能「${normalized}」已存在。`
 		};
 		let rootEntries;
 		try {
@@ -10010,17 +9866,17 @@ var SkillLibrary = class {
 			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.`
+				message: `无法检查技能「${normalized}」是否与大小写变体冲突：列出 ${this.root} 失败（${cause}）。拒绝创建 —— 仅大小写不同的第二个目录在跨平台时无法撤销。`
 			};
 		}
 		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.`
+			message: `技能「${normalized}」与已存在的大小写变体目录「${entry}」冲突（技能名只允许小写）：请重命名其中一个。`
 		};
 		const protection = await this.writeProtection(normalized, origin);
 		if (protection) return {
 			ok: false,
-			message: `Skill "${normalized}" is protected (${protection}).`
+			message: `技能「${normalized}」受保护（${protection}）。`
 		};
 		const onDisk = finalContent.trimEnd() + "\n";
 		const createPath = join(dir, "SKILL.md");
@@ -10055,18 +9911,18 @@ var SkillLibrary = class {
 		}
 		if (!taskRan) return {
 			ok: false,
-			message: "internal error: the create transaction did not invoke the task; no file was written"
+			message: "内部错误：创建事务没有调用任务；未写入任何文件"
 		};
 		if (existsAtCommit) return {
 			ok: false,
-			message: `Skill "${normalized}" already exists.`
+			message: `技能「${normalized}」已存在。`
 		};
 		let markerWarning = "";
 		if (origin !== "foreground") {
 			try {
 				await this.io.writeText(markerPath(dir, "hermes-managed"), "");
 			} catch (error) {
-				if (isCommittedOnly(error)) markerWarning = `the hermes-managed marker landed but its directory fsync failed — durability unconfirmed: ${error instanceof Error ? error.message : String(error)}`;
+				if (isCommittedOnly(error)) markerWarning = `hermes-managed 标记已落盘，但其目录 fsync 失败 —— 持久性未确认：${error instanceof Error ? error.message : String(error)}`;
 				else markerWarning = `hermes-managed marker write failed (${error instanceof Error ? error.message : String(error)}); the skill landed but is NOT lifecycle-managed — recreate or pin it manually`;
 			}
 			if (!await this.io.exists(createPath)) {
@@ -10074,7 +9930,7 @@ var SkillLibrary = class {
 				await this.cleanupGhostDir(createPath);
 				return {
 					ok: false,
-					message: `Skill "${normalized}" was archived concurrently while being created; the partial marker was removed — retry once the mover settles.`
+					message: `创建过程中技能「${normalized}」被并发归档；残留标记已移除：等搬运完成后重试一次。`
 				};
 			}
 		}
@@ -10084,10 +9940,10 @@ var SkillLibrary = class {
 			name: normalized,
 			skillDir: dir
 		});
-		const warnings = [createDurabilityWarning !== "" ? `the write landed but the directory fsync failed — durability unconfirmed: ${createDurabilityWarning}` : "", markerWarning].filter((warning) => warning !== "");
+		const warnings = [createDurabilityWarning !== "" ? `写入已落盘，但目录 fsync 失败 —— 持久性未确认：${createDurabilityWarning}` : "", markerWarning].filter((warning) => warning !== "");
 		return {
 			ok: true,
-			message: `Skill "${normalized}" created.${warnings.length === 0 ? "" : ` (warning: ${warnings.join("; ")})`}`,
+			message: `已创建技能「${normalized}」。${warnings.length === 0 ? "" : ` （警告：${warnings.join("；")}）`}`,
 			path: dir,
 			...norm.changed ? { normalizedFrontmatterFields: norm.fields } : {}
 		};
@@ -10107,7 +9963,7 @@ var SkillLibrary = class {
 		const protection = await this.writeProtection(name, origin);
 		if (protection) return {
 			ok: false,
-			message: `Skill "${name}" is protected (${protection}).`
+			message: `技能「${name}」受保护（${protection}）。`
 		};
 		const limitProbe = await probeText(this.io, path);
 		if (isUnknown(limitProbe)) console.warn(`skill-store: could not re-read ${path} for the shrink exemption (${limitProbe.reason}); validating without it — an over-limit repair is refused, not accepted`);
@@ -10120,7 +9976,7 @@ var SkillLibrary = class {
 		const norm = normalizeFrontmatter(content);
 		if (norm.issues.length > 0) return {
 			ok: false,
-			message: `Skill "${name}" frontmatter cannot be auto-fixed: ${norm.issues[0]} — wrap the value in double quotes and retry.`
+			message: `技能「${name}」的 frontmatter 无法自动修复：${norm.issues[0]}：请用双引号包住取值后重试。`
 		};
 		const finalContent = norm.changed ? norm.content : content;
 		if (norm.changed) {
@@ -10144,14 +10000,14 @@ var SkillLibrary = class {
 			if (current === null) return {
 				result: {
 					ok: false,
-					message: `Skill "${name}" not found.`
+					message: `技能「${name}」不存在。`
 				},
 				write: null
 			};
 			if (finalContent.trimEnd() === current.trimEnd()) return {
 				result: {
 					ok: true,
-					message: `Skill "${name}" unchanged: the supplied content already matches the current file; nothing written.`,
+					message: `技能「${name}」未变更：提供的内容与当前文件一致，未写入。`,
 					noop: true,
 					path: dir
 				},
@@ -10161,7 +10017,7 @@ var SkillLibrary = class {
 			return {
 				result: {
 					ok: true,
-					message: `Skill "${name}" updated.`,
+					message: `技能「${name}」已更新。`,
 					path: dir,
 					...norm.changed ? { normalizedFrontmatterFields: norm.fields } : {}
 				},
@@ -10195,12 +10051,12 @@ var SkillLibrary = class {
 		const skillMd = join(dir, "SKILL.md");
 		if (!await this.io.exists(skillMd)) return {
 			ok: false,
-			message: `Skill "${name}" not found.`
+			message: `技能「${name}」不存在。`
 		};
 		const protection = await this.writeProtection(name, origin);
 		if (protection) return {
 			ok: false,
-			message: `Skill "${name}" is protected (${protection}).`
+			message: `技能「${name}」受保护（${protection}）。`
 		};
 		let target = skillMd;
 		let patchLabel = "SKILL.md";
@@ -10218,7 +10074,7 @@ var SkillLibrary = class {
 			if (md === null) return {
 				result: {
 					ok: false,
-					message: `File not found: ${patchLabel}`
+					message: `文件不存在：${patchLabel}`
 				},
 				write: null
 			};
@@ -10240,7 +10096,7 @@ var SkillLibrary = class {
 			if (patched === null) return {
 				result: {
 					ok: false,
-					message: `Could not find old_string in "${name}/${patchLabel}" (or the replaceAll fuzzy budget was exceeded). Use update for a full rewrite.`
+					message: `在「${name}/${patchLabel}」里找不到 old_string（或 replaceAll 的模糊匹配预算已用尽）。整篇重写请改用 update。`
 				},
 				write: null
 			};
@@ -10253,7 +10109,7 @@ var SkillLibrary = class {
 				if (validation) return {
 					result: {
 						ok: false,
-						message: `Patch rejected: ${validation}`
+						message: `补丁被拒绝：${validation}`
 					},
 					write: null
 				};
@@ -10261,7 +10117,7 @@ var SkillLibrary = class {
 				if (norm.issues.length > 0) return {
 					result: {
 						ok: false,
-						message: `Patch rejected: frontmatter cannot be auto-fixed (${norm.issues[0]}).`
+						message: `补丁被拒绝：frontmatter 无法自动修复（${norm.issues[0]}）。`
 					},
 					write: null
 				};
@@ -10272,7 +10128,7 @@ var SkillLibrary = class {
 					if (revalidated) return {
 						result: {
 							ok: false,
-							message: `Patch rejected: ${revalidated}`
+							message: `补丁被拒绝：${revalidated}`
 						},
 						write: null
 					};
@@ -10281,7 +10137,7 @@ var SkillLibrary = class {
 			if (Buffer.byteLength(writeContent, "utf8") > this.limits.maxSkillFileBytes && target !== skillMd) return {
 				result: {
 					ok: false,
-					message: `Patched file exceeds ${this.limits.maxSkillFileBytes} bytes.`
+					message: `修补后的文件超过 ${this.limits.maxSkillFileBytes} 字节。`
 				},
 				write: null
 			};
@@ -10290,7 +10146,7 @@ var SkillLibrary = class {
 			if (overLimit && target === skillMd && !repairing) return {
 				result: {
 					ok: false,
-					message: `Patched content exceeds ${this.limits.maxSkillContentChars} characters. ${CONTENT_SPLIT_HINT}`
+					message: `修补后的内容超过 ${this.limits.maxSkillContentChars} 个字符。${CONTENT_SPLIT_HINT}`
 				},
 				write: null
 			};
@@ -10299,7 +10155,7 @@ var SkillLibrary = class {
 			if (supportOverCap && this.supportFileCharPolicy() === "enforce") return {
 				result: {
 					ok: false,
-					message: `Patched file content exceeds ${this.limits.maxSkillContentChars} characters. ${CONTENT_SPLIT_HINT}`
+					message: `修补后的文件内容超过 ${this.limits.maxSkillContentChars} 个字符。${CONTENT_SPLIT_HINT}`
 				},
 				write: null
 			};
@@ -10314,7 +10170,7 @@ var SkillLibrary = class {
 			if (writeContent.trimEnd() === md.trimEnd()) return {
 				result: {
 					ok: true,
-					message: `Skill "${name}" unchanged: old_string already equals the replacement (${patchLabel}); nothing written.`,
+					message: `技能「${name}」未变更：old_string 与替换内容相同（${patchLabel}），未写入。`,
 					noop: true,
 					path: dir
 				},
@@ -10324,7 +10180,7 @@ var SkillLibrary = class {
 			return {
 				result: {
 					ok: true,
-					message: `Skill "${name}" patched (${patchLabel}).${patchNote}${capAdvisory}`,
+					message: `技能「${name}」已修补（${patchLabel}）。${patchNote}${capAdvisory}`,
 					path: dir,
 					...normalizedFields ? { normalizedFrontmatterFields: normalizedFields } : {}
 				},
@@ -10369,9 +10225,9 @@ var SkillLibrary = class {
 				const reason = error instanceof Error ? error.message : String(error);
 				try {
 					await this.io.remove(dest);
-					return `the copy succeeded but the source could not be removed (${reason}); the copied tree was rolled back`;
+					return `复制成功，但源目录删不掉（${reason}）；已回滚复制出的目录树`;
 				} catch {
-					return `the copy succeeded but the source could not be removed (${reason}) and the copied tree could not be rolled back — the tree now exists in BOTH locations; clean up manually`;
+					return `复制成功，但源目录删不掉（${reason}），且复制出的目录树也无法回滚 —— 该目录树现在同时存在于两处；请手动清理`;
 				}
 			}
 		}
@@ -10380,110 +10236,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 +10259,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 });
@@ -10521,17 +10270,17 @@ var SkillLibrary = class {
 		const md = await this.io.readText(join(dir, "SKILL.md"));
 		if (md === null) return {
 			ok: false,
-			message: `Skill "${name}" not found.`
+			message: `技能「${name}」不存在。`
 		};
 		const protection = await this.deleteProtection(name, options);
 		if (protection) return {
 			ok: false,
-			message: protection === "pinned" ? `Skill "${name}" is pinned and cannot be archived. Remove the \`.pinned\` marker in its directory, then retry.` : `Skill "${name}" is protected (${protection}).`
+			message: protection === "pinned" ? `Skill "${name}" is pinned and cannot be archived. Remove the \`.pinned\` marker in its directory, then retry.` : `技能「${name}」受保护（${protection}）。`
 		};
 		if (options.absorbedInto) {
 			if (options.absorbedInto.trim() === name) return {
 				ok: false,
-				message: "absorbed_into cannot be the skill being archived (cannot absorb into itself)."
+				message: "absorbed_into 不能是正在归档的技能本身（不能吸收到自己）。"
 			};
 			const intoBad = this.badName(options.absorbedInto.trim());
 			if (intoBad) return {
@@ -10553,22 +10302,22 @@ var SkillLibrary = class {
 		if (this.io.isSymlink) {
 			if (await this.io.isSymlink(dir) === true) return {
 				ok: false,
-				message: `Skill "${name}" is a symlink; refusing to archive it.`
+				message: `技能「${name}」是符号链接；拒绝归档。`
 			};
 		}
-		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: `无法检查技能「${name}」是否有写入方（有一个支撑目录列不出来）：请重试归档。`
 		};
 		const commitProtection = await this.deleteProtection(name, options);
 		if (commitProtection) return {
 			ok: false,
-			message: commitProtection === "pinned" ? `Skill "${name}" is pinned and cannot be archived. Remove the \`.pinned\` marker in its directory, then retry.` : `Skill "${name}" is protected (${commitProtection}).`
+			message: commitProtection === "pinned" ? `Skill "${name}" is pinned and cannot be archived. Remove the \`.pinned\` marker in its directory, then retry.` : `技能「${name}」受保护（${commitProtection}）。`
 		};
 		const moveFailure = await this.moveDir(dir, dest);
 		if (moveFailure !== void 0) return {
 			ok: false,
-			message: `Skill "${name}" archive failed: ${moveFailure}.`
+			message: `技能「${name}」归档失败：${moveFailure}。`
 		};
 		const reason = options.reason ?? (options.absorbedInto ? `Consolidated into ${options.absorbedInto}` : "Archived by self-evolution curator");
 		try {
@@ -10585,7 +10334,7 @@ var SkillLibrary = class {
 		});
 		return {
 			ok: true,
-			message: `Skill "${name}" archived to .archive.`,
+			message: `技能「${name}」已归档到 .archive。`,
 			path: dest
 		};
 	}
@@ -10683,7 +10432,7 @@ var SkillLibrary = class {
 		const mode = options.mode ?? "append";
 		if (normalizedSources.length === 0) return {
 			ok: false,
-			message: "Consolidation requires at least one distinct source skill."
+			message: "合并至少需要一个互不相同的来源技能。"
 		};
 		for (const name of [targetName, ...normalizedSources]) {
 			const bad = this.badName(name);
@@ -10696,7 +10445,7 @@ var SkillLibrary = class {
 		const targetProtection = await this.writeProtection(targetName, origin);
 		if (targetProtection) return {
 			ok: false,
-			message: `Skill "${targetName}" is protected (${targetProtection}).`
+			message: `技能「${targetName}」受保护（${targetProtection}）。`
 		};
 		return await this.serial(async () => {
 			const referenceWrites = [];
@@ -10708,17 +10457,17 @@ var SkillLibrary = class {
 				const protection = await this.deleteProtection(source);
 				if (protection) return {
 					ok: false,
-					message: `Skill "${source}" is protected (${protection}).`
+					message: `技能「${source}」受保护（${protection}）。`
 				};
 				const sourceMd = await this.io.readText(join(this.dirOf(source), "SKILL.md"));
 				if (!sourceMd) return {
 					ok: false,
-					message: `Skill "${source}" not found.`
+					message: `技能「${source}」不存在。`
 				};
 				const parsed = parseFrontmatter(sourceMd);
 				if (!parsed) return {
 					ok: false,
-					message: `Skill "${source}" has no valid frontmatter; refusing to merge.`
+					message: `技能「${source}」没有有效的 frontmatter；拒绝合并。`
 				};
 				const carriesSupport = await this.countSupportDirs(source) > 0;
 				const refs = supportRefs(parsed.body);
@@ -10727,7 +10476,7 @@ var SkillLibrary = class {
 					const decision = await this.planSourceRehoming(source, targetName, parsed.body, rehomed.map((file) => file.to));
 					if (decision.kind === "blocked") return {
 						ok: false,
-						message: `Consolidation rejected: ${carriesSupport ? `source "${source}" carries support files` : `source "${source}" body references support files (${refs.join(", ")})`} that would be left behind — use mode:'reference' or archive the whole package instead.${decision.note}`
+						message: `合并被拒绝：${carriesSupport ? `source "${source}" carries support files` : `source "${source}" body references support files (${refs.join(", ")})`} 会被落下。请改用 mode:'reference'，或直接归档整个包。${decision.note}`
 					};
 					rehomed.push(...decision.files);
 					appendedBody = decision.rewritten;
@@ -10739,17 +10488,17 @@ var SkillLibrary = class {
 				const protection = await this.deleteProtection(source);
 				if (protection) return {
 					ok: false,
-					message: `Skill "${source}" is protected (${protection}).`
+					message: `技能「${source}」受保护（${protection}）。`
 				};
 				const sourceMd = await this.io.readText(join(this.dirOf(source), "SKILL.md"));
 				if (!sourceMd) return {
 					ok: false,
-					message: `Skill "${source}" not found.`
+					message: `技能「${source}」不存在。`
 				};
 				const parsed = parseFrontmatter(sourceMd);
 				if (!parsed) return {
 					ok: false,
-					message: `Skill "${source}" has no valid frontmatter; refusing to demote.`
+					message: `技能「${source}」没有有效的 frontmatter；拒绝降级。`
 				};
 				const refs = supportRefs(parsed.body);
 				let demotedBody = parsed.body;
@@ -10757,7 +10506,7 @@ var SkillLibrary = class {
 					const decision = await this.planSourceRehoming(source, targetName, parsed.body, rehomed.map((file) => file.to));
 					if (decision.kind === "blocked") return {
 						ok: false,
-						message: `Consolidation rejected: source "${source}" body references support files (${refs.join(", ")}) that would be left behind — archive the whole package instead.${decision.note}`
+						message: `合并被拒绝：来源技能「${source}」的正文引用了会被落下的支撑文件（${refs.join(", ")}）：请改为归档整个包。${decision.note}`
 					};
 					rehomed.push(...decision.files);
 					demotedBody = decision.rewritten;
@@ -10774,7 +10523,7 @@ var SkillLibrary = class {
 			try {
 				if (!await this.io.readText(join(targetDir, "SKILL.md"))) return {
 					ok: false,
-					message: `Skill "${targetName}" not found.`
+					message: `技能「${targetName}」不存在。`
 				};
 				for (const source of normalizedSources) {
 					if (plannedSourceBytes.has(source)) {
@@ -10837,7 +10586,7 @@ var SkillLibrary = class {
 				if (!result.ok) throw new Error(result.message);
 				return {
 					ok: true,
-					message: `Consolidated ${normalizedSources.join(", ")} into "${targetName}".`,
+					message: `已把 ${normalizedSources.join(", ")} 合并进「${targetName}」。`,
 					path: targetDir
 				};
 			} catch (error) {
@@ -10850,11 +10599,11 @@ var SkillLibrary = class {
 				}
 				if (failedRestores.length > 0) return {
 					ok: false,
-					message: `Consolidation failed (${reason}); rolled back EXCEPT ${failedRestores.join(", ")} — still in .archive, restore them with /evolution skill restore.`
+					message: `合并失败（${reason}）；已回滚，但以下未回滚：${failedRestores.join(", ")}：它们仍在 .archive 里，请用 /evolution skill restore 恢复。`
 				};
 				return {
 					ok: false,
-					message: `Consolidation failed and was rolled back: ${reason}`
+					message: `合并失败，已回滚：${reason}`
 				};
 			}
 		});
@@ -10883,21 +10632,21 @@ var SkillLibrary = class {
 		};
 		if (moves.length === 0) return {
 			ok: false,
-			message: "Restructure requires at least one section move."
+			message: "重构至少需要一次章节搬移。"
 		};
 		if (moves.length > 5) return {
 			ok: false,
-			message: `Restructure exceeds 5 moves.`
+			message: `重构超过 5 次搬移。`
 		};
 		for (const move of moves) {
 			const raw = move;
 			if (raw === null || typeof raw !== "object") return {
 				ok: false,
-				message: "Every restructure move must be an object with a heading."
+				message: "每次重构搬移都必须是带 heading 的对象。"
 			};
 			if (typeof move.heading !== "string" || !move.heading.trim()) return {
 				ok: false,
-				message: "Every restructure move needs a non-empty heading."
+				message: "每次重构搬移都需要非空的 heading。"
 			};
 			const targetIssue = validateRestructureTarget(move.toFile);
 			if (targetIssue) return {
@@ -10909,25 +10658,25 @@ var SkillLibrary = class {
 		const md = await this.io.readText(join(dir, "SKILL.md"));
 		if (!md) return {
 			ok: false,
-			message: `Skill "${name}" not found.`
+			message: `技能「${name}」不存在。`
 		};
 		const block = frontmatterBlock(md);
 		if (!block) return {
 			ok: false,
-			message: "SKILL.md has no valid frontmatter; refusing to restructure."
+			message: "SKILL.md 没有有效的 frontmatter；拒绝重构。"
 		};
 		const header = block.lines.slice(0, block.end + 1).join("\n");
 		const plan = planRestructureSections(md.slice(header.length).replace(/\r\n/g, "\n"), moves);
 		if ("error" in plan) return {
 			ok: false,
-			message: `Restructure rejected: ${plan.error}`
+			message: `重构被拒绝：${plan.error}`
 		};
 		const newMd = `${header}${plan.body}`.replace(/\r\n/g, "\n");
 		const finalMd = block.nl === "\r\n" ? newMd.replace(/\n/g, "\r\n") : newMd;
 		const newMdCheck = validateFrontmatter(finalMd, name, this.limits);
 		if (newMdCheck) return {
 			ok: false,
-			message: `Restructure rejected: ${newMdCheck}`
+			message: `重构被拒绝：${newMdCheck}`
 		};
 		const listing = (this.limits.citationPolicy ?? "verify") === "refuse" ? null : await this.listSupportFiles(name);
 		const files = listing !== null && isPresent(listing) ? listing.value : null;
@@ -10936,7 +10685,7 @@ var SkillLibrary = class {
 			if (refs.length === 0) continue;
 			if (files === null) return {
 				ok: false,
-				message: `Restructure rejected: section "## ${section.heading}" references support files (${refs.join(", ")}) that stay behind — split the section or move it with its files.`
+				message: `重构被拒绝：章节「## ${section.heading}」引用了会留在原地的支撑文件（${refs.join(", ")}）：请拆开该章节，或连同它的文件一起搬。`
 			};
 			const report = resolveCitations({
 				content: section.text,
@@ -10947,7 +10696,7 @@ var SkillLibrary = class {
 				const missing = report.dangling.map((ref) => ref.target ?? ref.raw).join(", ");
 				return {
 					ok: false,
-					message: `Restructure rejected: section "## ${section.heading}" cites support file(s) that do not exist (${missing}) — fix the citation or create the file first.`
+					message: `重构被拒绝：章节「## ${section.heading}」引用的支撑文件不存在（${missing}）：请修正引用，或先创建该文件。`
 				};
 			}
 		}
@@ -10988,7 +10737,7 @@ var SkillLibrary = class {
 		if (!result.ok) return result;
 		return {
 			ok: true,
-			message: `Restructured "${name}": moved ${plan.sections.length} section(s) to references/.`,
+			message: `已重构「${name}」：把 ${plan.sections.length} 个章节搬到 references/。`,
 			path: dir
 		};
 	}
@@ -11010,12 +10759,12 @@ var SkillLibrary = class {
 		const md = await this.io.readText(join(dir, "SKILL.md"));
 		if (!md) return {
 			ok: false,
-			message: `Skill "${name}" not found.`
+			message: `技能「${name}」不存在。`
 		};
 		const protection = plan.protection === "write" ? await this.writeProtection(name, plan.origin) : plan.protection === "delete" ? await this.deleteProtection(name) : null;
 		if (protection) return {
 			ok: false,
-			message: `Skill "${name}" is protected (${protection}).`
+			message: `技能「${name}」受保护（${protection}）。`
 		};
 		const landing = [];
 		for (const write of plan.writes) {
@@ -11025,12 +10774,12 @@ var SkillLibrary = class {
 			} catch (error) {
 				return {
 					ok: false,
-					message: `Tree change refused: cannot safely pre-read ${write.target} (${error instanceof Error ? error.message : String(error)}); no writes were performed`
+					message: `拒绝目录树变更：无法安全预读 ${write.target}（${error instanceof Error ? error.message : String(error)}）；未执行任何写入`
 				};
 			}
 			if (Buffer.byteLength(write.content, "utf8") > this.limits.maxSkillFileBytes) return {
 				ok: false,
-				message: `Write exceeds ${this.limits.maxSkillFileBytes} bytes: ${write.target}`
+				message: `写入超过 ${this.limits.maxSkillFileBytes} 字节：${write.target}`
 			};
 			const threat = this.contentThreatBlock(write.content);
 			if (threat) return {
@@ -11085,11 +10834,11 @@ var SkillLibrary = class {
 			const reason = error instanceof Error ? error.message : String(error);
 			if (stuck.length === 0) return {
 				ok: false,
-				message: `Tree change failed and was rolled back: ${reason}`
+				message: `目录树变更失败，已回滚：${reason}`
 			};
 			return {
 				ok: false,
-				message: `Tree change failed: ${reason}. The rollback could not restore ${stuck.join(", ")} — recover those targets from the .backups snapshot (or re-apply the change).`
+				message: `目录树变更失败：${reason}。回滚无法恢复 ${stuck.join(", ")}：请从 .backups 快照恢复这些目标（或重新应用这次变更）。`
 			};
 		}
 		const skillMdWrite = landing.find((entry) => entry.target.split(/[\\/]/).pop() === "SKILL.md");
@@ -11103,7 +10852,7 @@ var SkillLibrary = class {
 		});
 		return {
 			ok: true,
-			message: durabilityWarning === "" ? `${plan.eventAction} "${name}" succeeded.` : `${plan.eventAction} "${name}" succeeded (warning: the write landed but the directory fsync failed — durability unconfirmed: ${durabilityWarning})`,
+			message: durabilityWarning === "" ? `${plan.eventAction} "${name}" succeeded.` : `${plan.eventAction} "${name}" succeeded （警告：写入已落盘，但目录 fsync 失败 —— 持久性未确认：${durabilityWarning})`,
 			path: dir
 		};
 	}
@@ -11122,7 +10871,7 @@ var SkillLibrary = class {
 		const dest = this.dirOf(name);
 		if (await this.io.exists(dest)) return {
 			ok: false,
-			message: await this.io.exists(join(dest, "SKILL.md")) ? `Skill "${name}" already exists in the active root; refusing to overwrite.` : `Skill directory "${name}" already exists in the active root but carries no SKILL.md; remove or repair it before restoring.`
+			message: await this.io.exists(join(dest, "SKILL.md")) ? `技能「${name}」已存在于当前根目录；拒绝覆盖。` : `技能目录「${name}」已存在于当前根目录，但没有 SKILL.md；恢复前请先移除或修复它。`
 		};
 		let caseVariant;
 		try {
@@ -11130,7 +10879,7 @@ var SkillLibrary = class {
 		} catch {}
 		if (caseVariant !== void 0) return {
 			ok: false,
-			message: `Skill "${caseVariant}" (same name, different letter case) already exists in the active root; restoring "${name}" beside it would create ambiguous duplicates — restore as "${caseVariant}" or remove the variant first.`
+			message: `技能「${caseVariant}」（同名、仅大小写不同）已存在于当前根目录；把「${name}」恢复到它旁边会造成含义不清的重复：请恢复为「${caseVariant}」，或先移除该变体。`
 		};
 		const archiveRoot = join(this.root, ".archive");
 		let entries;
@@ -11139,7 +10888,7 @@ var SkillLibrary = class {
 		} catch {
 			return {
 				ok: false,
-				message: "No skill archive available."
+				message: "没有可用的技能归档。"
 			};
 		}
 		const candidates = entries.filter((entry) => entry === name || entry.startsWith(`${name}-`)).sort().reverse();
@@ -11174,30 +10923,29 @@ var SkillLibrary = class {
 		if (!chosen) {
 			if (unreadable.length === 0) return {
 				ok: false,
-				message: `Skill "${name}" is not in .archive.`
+				message: `技能「${name}」不在 .archive 里。`
 			};
 			return {
 				ok: false,
-				message: `No archived entry for "${name}" carries a matching frontmatter name, but .archive holds ${unreadable.length} entr(y/ies) named like it: ${unreadable.join(", ")}. Those entries have no readable SKILL.md (or none matching the name), so restoring by name cannot tell them apart — rename the directory to the skill name and restore again, or restore from a snapshot.`
+				message: `.archive 里没有「${name}」对应的 frontmatter 名，但有 ${unreadable.length} 个名字相似的归档项：${unreadable.join(", ")}。这些归档项没有可读的 SKILL.md（或名字对不上），按名字恢复无法区分它们：请把目录改成技能名后再次恢复，或改用快照恢复。`
 			};
 		}
 		const source = join(archiveRoot, chosen);
 		if (this.io.isSymlink) {
 			if (await this.io.isSymlink(source) === true) return {
 				ok: false,
-				message: `Archived entry "${chosen}" is a symlink; refusing to restore it.`
+				message: `归档项「${chosen}」是符号链接；拒绝恢复。`
 			};
 		}
-		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: `无法检查技能「${name}」是否有写入方（有一个支撑目录列不出来）：请重试恢复。`
 		};
 		const moveFailure = await this.moveDir(source, dest);
 		if (moveFailure !== void 0) return {
 			ok: false,
-			message: `Restore of "${name}" from .archive failed: ${moveFailure}`
+			message: `从 .archive 恢复「${name}」失败：${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`);
@@ -11209,7 +10957,7 @@ var SkillLibrary = class {
 		});
 		return {
 			ok: true,
-			message: `Skill "${name}" restored from .archive.`,
+			message: `技能「${name}」已从 .archive 恢复。`,
 			path: dest
 		};
 	}
@@ -11226,12 +10974,12 @@ var SkillLibrary = class {
 		const dir = this.dirOf(name);
 		if (!await this.io.exists(join(dir, "SKILL.md"))) return {
 			ok: false,
-			message: `Skill "${name}" not found.`
+			message: `技能「${name}」不存在。`
 		};
 		const protection = await this.writeProtection(name, origin);
 		if (protection) return {
 			ok: false,
-			message: `Skill "${name}" is protected (${protection}).`
+			message: `技能「${name}」受保护（${protection}）。`
 		};
 		const validation = validateSupportPath(filePath);
 		if (validation) return {
@@ -11240,7 +10988,7 @@ var SkillLibrary = class {
 		};
 		if (Buffer.byteLength(content, "utf8") > this.limits.maxSkillFileBytes) return {
 			ok: false,
-			message: `Support file exceeds ${this.limits.maxSkillFileBytes} bytes.`
+			message: `支撑文件超过 ${this.limits.maxSkillFileBytes} 字节。`
 		};
 		const threat = this.contentThreatBlock(content);
 		if (threat) return {
@@ -11260,14 +11008,14 @@ var SkillLibrary = class {
 			if (overCap && !repairing && this.supportFileCharPolicy() === "enforce") return {
 				result: {
 					ok: false,
-					message: `Support file "${filePath}" content exceeds ${this.limits.maxSkillContentChars} characters. ${CONTENT_SPLIT_HINT}`
+					message: `支撑文件「${filePath}」的内容超过 ${this.limits.maxSkillContentChars} 个字符。${CONTENT_SPLIT_HINT}`
 				},
 				write: null
 			};
 			if (current !== null && content.trimEnd() === current.trimEnd()) return {
 				result: {
 					ok: true,
-					message: `Support file "${filePath}" unchanged: the supplied content already matches the current file; nothing written.`,
+					message: `支撑文件「${filePath}」未变更：提供的内容与当前文件一致，未写入。`,
 					noop: true,
 					path: target
 				},
@@ -11276,7 +11024,7 @@ var SkillLibrary = class {
 			return {
 				result: {
 					ok: true,
-					message: `Support file "${filePath}" written to "${name}".${capAdvisory}`,
+					message: `支撑文件「${filePath}」已写入「${name}」。${capAdvisory}`,
 					path: target
 				},
 				write: content,
@@ -11310,12 +11058,12 @@ var SkillLibrary = class {
 		const dir = this.dirOf(name);
 		if (!await this.io.exists(join(dir, "SKILL.md"))) return {
 			ok: false,
-			message: `Skill "${name}" not found.`
+			message: `技能「${name}」不存在。`
 		};
 		const protection = await this.writeProtection(name, origin);
 		if (protection) return {
 			ok: false,
-			message: `Skill "${name}" is protected (${protection}).`
+			message: `技能「${name}」受保护（${protection}）。`
 		};
 		const validation = validateSupportPath(filePath);
 		if (validation) return {
@@ -11327,7 +11075,7 @@ var SkillLibrary = class {
 			if (anchor !== void 0) return anchorRefusalFile(name, filePath, "missing");
 			return {
 				ok: false,
-				message: `File "${filePath}" not found in skill "${name}".`
+				message: `文件「${filePath}」不在技能「${name}」里。`
 			};
 		}
 		const beforeProbe = await probeText(this.io, target);
@@ -11351,7 +11099,7 @@ var SkillLibrary = class {
 			});
 			if (!ran.done) return {
 				ok: false,
-				message: "internal error: the delete transaction did not invoke the task; nothing was removed"
+				message: "内部错误：删除事务没有调用任务；没有删除任何东西"
 			};
 		} else if (verdict === "match") await this.io.remove(target);
 		if (verdict !== "match") return anchorRefusalFile(name, filePath, verdict);
@@ -11364,7 +11112,7 @@ var SkillLibrary = class {
 		});
 		return {
 			ok: true,
-			message: `Support file "${filePath}" removed from "${name}".`,
+			message: `支撑文件「${filePath}」已从「${name}」移除。`,
 			path: target
 		};
 	}
@@ -11445,8 +11193,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 +11202,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);
@@ -11582,7 +11330,7 @@ var SkillLibrary = class {
 				out.push({
 					path: join(backupRoot, name),
 					createdAt: "",
-					reason: "unreadable or missing manifest (orphan snapshot)"
+					reason: "清单读不出来或缺失（孤儿快照）"
 				});
 				continue;
 			}
@@ -11624,12 +11372,12 @@ var SkillLibrary = class {
 		const listed = await this.listSnapshots();
 		if (isUnknown(listed)) return {
 			ok: false,
-			message: `Snapshot restore refused: the snapshot directory could not be read (${listed.reason}) — nothing was changed.`
+			message: `拒绝快照恢复：快照目录读不出来（${listed.reason}）—— 未做任何改动。`
 		};
 		const latest = isPresent(listed) ? listed.value[0] : void 0;
 		if (!latest) return {
 			ok: false,
-			message: "No skill snapshot available."
+			message: "没有可用的技能快照。"
 		};
 		let preRollbackPath;
 		try {
@@ -11637,7 +11385,7 @@ var SkillLibrary = class {
 		} catch (error) {
 			return {
 				ok: false,
-				message: `Snapshot restore was refused before anything was cleared: taking the pre-rollback snapshot failed (${error instanceof Error ? error.message : String(error)}) — the active tree is UNCHANGED. Resolve the snapshot write failure and retry.`
+				message: `在任何清理之前就拒绝了快照恢复：生成回滚前快照失败（${error instanceof Error ? error.message : String(error)}）—— 活动目录树未改变。请解决快照写入失败后重试。`
 			};
 		}
 		let snapshotExtras;
@@ -11646,7 +11394,7 @@ var SkillLibrary = class {
 		} catch (error) {
 			return {
 				ok: false,
-				message: `Snapshot restore was refused before anything was cleared: reading the snapshot manifest/extras failed (${error instanceof Error ? error.message : String(error)}) — the active tree is UNCHANGED. Resolve the read failure and retry.`
+				message: `在任何清理之前就拒绝了快照恢复：读取快照清单或附属文件失败（${error instanceof Error ? error.message : String(error)}）—— 活动目录树未改变。请解决读取失败后重试。`
 			};
 		}
 		try {
@@ -11657,17 +11405,17 @@ var SkillLibrary = class {
 				await this.restoreSnapshotIntoRoot(preRollbackPath);
 				return {
 					ok: false,
-					message: `Snapshot restore failed (${reason}); the active tree was rolled back to the pre-rollback snapshot.`
+					message: `快照恢复失败（${reason}）；活动目录树已回滚到回滚前的快照。`
 				};
 			} catch (rollbackError) {
 				const rb = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
 				if (isPreClearRefusal(reason) && isPreClearRefusal(rb)) return {
 					ok: false,
-					message: `Snapshot restore was refused before anything was cleared; the active tree is UNCHANGED.\n- target: ${reason}\n- pre-rollback: ${rb}\nResolve the cause (a live skill write, or an incomplete snapshot) and retry — no manual rescue is needed.`
+					message: `在任何清理之前就拒绝了快照恢复； 活动目录树未改变。\n- 目标：${reason}\n- 回滚前快照：${rb}\n请解决原因（有存活的技能写入，或快照不完整）后重试 —— 无需手动抢救。`
 				};
 				return {
 					ok: false,
-					message: `Snapshot restore failed (${reason}) AND pre-rollback restore failed (${rb}). Rescue manually from: ${preRollbackPath} (pre-rollback), ${latest.path} (target).`
+					message: `快照恢复失败（${reason}），且回滚前快照的恢复也失败（${rb}）。请手动抢救：${preRollbackPath}（回滚前）、${latest.path}（目标）。`
 				};
 			}
 		}
@@ -11677,7 +11425,7 @@ var SkillLibrary = class {
 		});
 		return {
 			ok: true,
-			message: `Restored skill tree from ${latest.path}`,
+			message: `已从 ${latest.path} 恢复技能目录树`,
 			path: latest.path,
 			...snapshotExtras.length === 0 ? {} : { extras: snapshotExtras }
 		};
@@ -11713,14 +11461,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 +11471,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 +11482,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 +12097,7 @@ const PARAM_EXPOSURE = Object.freeze([
 		control: "number",
 		unit: "天",
 		values: "",
+		relation: { atLeast: "staleAfterDays" },
 		card: "evolution-curator"
 	},
 	{
@@ -12999,6 +12739,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 +13026,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 +13056,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 +13064,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)) {
@@ -13324,7 +13073,7 @@ function planNamespaceMigration(documentText) {
 				skipped.push({
 					namespace,
 					key,
-					reason: "row `" + rowId + "` has no such parameter"
+					reason: "row `" + rowId + "` 没有这个参数"
 				});
 				continue;
 			}
@@ -13376,7 +13125,7 @@ function classifyNamespaceMigration(plan, read) {
 			for (const value of entry.values) skipped.push({
 				namespace: entry.namespace,
 				key: value.source,
-				reason: "row `" + entry.rowId + "` is not served in this composition"
+				reason: "row `" + entry.rowId + "` 在本组合中不提供服务"
 			});
 			continue;
 		}
@@ -13689,4 +13438,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 };