@lmzhen/dsh-evolution-core 0.22.0 → 0.23.0

package/lib/types/errors.d.ts

@@ -1,5 +1,5 @@
 /**
- * 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
@@ -36,6 +36,7 @@ export declare const EVOLUTION_ERRORS: Readonly<{
     readonly '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.";
     readonly '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.";
     readonly '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.";
+    readonly 'e-322-a-parameter-would-break-a': "E-322: %a1% must be at least %a2%, but this write sets it to %a3%. Nothing was written.";
     readonly '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.";
     readonly '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`.";
 }>;

package/lib/types/guards.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * 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.
+ */
+export declare function asRecord(value: unknown): Record<string, unknown> | undefined;
+//# sourceMappingURL=guards.d.ts.map

package/lib/types/index.d.ts

@@ -38,6 +38,7 @@ export * from './curator.ts';
 export * from './evolution-events.ts';
 export * from './fuzzy-match.ts';
 export * from './gates.ts';
+export * from './guards.ts';
 export * from './http-routes.ts';
 export * from './events.ts';
 export * from './env.ts';

package/lib/types/io.d.ts

@@ -98,18 +98,6 @@ export interface TransactTaskGuard {
 export declare function transactTaskGuard(what: string): TransactTaskGuard;
 /** Lazy adapter over an IO provider registry, shared by every evolution consumer. */
 export declare function evolutionIoAdapter(provider: () => EvolutionIoLike): EvolutionIoLike;
-/**
- * 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.
- */
-export declare const pendingSelfCleanup: Map<string, string>;
 /**
  * Retry a rename that a peer is temporarily holding on Windows (EPERM/EBUSY):
  * exponential backoff (50ms doubling, capped at 800ms) with a ~2s total
@@ -159,57 +147,6 @@ export declare function writeDurableTmp(target: string, content: string, openImp
  * stranded-lock sweep must use the same liveness rule.
  */
 export declare function isProcessAlive(pid: number): boolean;
-/** 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. */
-export declare 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). */
-export declare const LOCK_BODY_RE: RegExp;
-/** 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. */
-export declare function parseLockBody(body: string): number | null;
-/**
- * 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.
- */
-export declare class LostWriteLock extends Error {
-    constructor();
-}
-/** 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). */
-export declare const DEAD_LOCK_TAKEOVER_MS = 1000;
-/** 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). */
-export declare const EMPTY_LOCK_TAKEOVER_MS = 30000;
-/** A body with no parseable pid (crash mid-write): 1h, far above any legal hold
- * and far below "forever". */
-export declare const LOCK_TEAR_TAKEOVER_MS = 3600000;
-/** 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. */
-export declare const ALIVE_LOCK_TAKEOVER_MS = 86400000;
 /**
  * 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
@@ -219,49 +156,53 @@ export declare const ALIVE_LOCK_TAKEOVER_MS = 86400000;
  * shape as SUCCESS-with-warning, never as a rejection.
  */
 export declare function isCommittedWarning(error: unknown): boolean;
-/** V27 G1.1: the takeover branches, as a value. */
-type TakeoverDecision = 'none' | 'dead' | 'empty' | 'corrupt';
-/** V27 G1.1: one lock observation, plus the liveness probe for its pid. */
-interface TakeoverProbe {
-    /** Raw lock body. An empty string means the file exists with no content. */
-    body: string;
-    /** Lock mtime in epoch ms. */
-    mtimeMs: number;
-    /** Liveness probe for a pid (injected so the decision is a pure function). */
-    alive: (pid: number) => boolean;
-    /** Evaluation instant (defaults to now). */
-    nowMs?: number;
-    /** Threshold overrides — production callers use the protocol defaults. */
-    deadAfterMs?: number;
-    emptyAfterMs?: number;
-    corruptAfterMs?: number;
-    aliveAfterMs?: number;
-}
 /**
- * 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).
+ * 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`).
  */
-export declare function decideTakeover(probe: TakeoverProbe): TakeoverDecision;
+export declare function nodeEvolutionIo(): EvolutionIoLike;
+/** F-211: the fs surface atomicWriteFiles uses — injectable so the commit-phase
+ * rename-failure path is deterministically testable. Defaults to node:fs.
+ * `mtime` (optional) probes a path's last-write time so the failed-commit
+ * recovery message can name the generation it restored from. */
+interface FsOps {
+    writeFileSync(path: string, data: string | Uint8Array): void;
+    existsSync(path: string): boolean;
+    copyFileSync(from: string, to: string): void;
+    renameSync(from: string, to: string): void;
+    rmSync(path: string, options?: {
+        force?: boolean;
+        recursive?: boolean;
+    }): void;
+    mtime?(path: string): number | null;
+}
 /**
- * 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.
+ * 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.
  */
-export declare function nodeEvolutionIo(lockAttempts?: number): EvolutionIoLike;
+export declare function atomicWriteFiles(targetDir: string, writes: Array<{
+    name: string;
+    content: string | Uint8Array;
+}>, fs?: FsOps, logger?: (message: string) => void): void;
 export {};
 //# sourceMappingURL=io.d.ts.map

package/lib/types/params.d.ts

@@ -112,6 +112,16 @@ export interface ParamExposure {
     /** The registered reason this row has NO card. Required on every non-E3 row; mutually exclusive
      * with `card`. This is what makes "an E3 row that no card renders" unspellable. */
     why?: ParamWhy;
+    /**
+     * A cross-field constraint this row must satisfy, declared ONCE here (U-4). The card checks it
+     * before a save is attempted and the Host write path derives the same check from the same column,
+     * so "保存前就知道输入合不合法" needs no second rule table. Only relations with real behaviour
+     * behind them are declared; this is not a constraint language.
+     */
+    relation?: {
+        /** The sibling id in the SAME group whose value this row may not go below. */
+        readonly atLeast?: string;
+    };
     /** Unit suffix shown next to a number (empty when it carries none). */
     unit?: string;
     /** Pipe-joined allowed values; non-empty exactly when control is 'select'. */

package/lib/types/platform-services.d.ts

@@ -1,7 +1,7 @@
 /**
  * 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
@@ -20,7 +20,7 @@ export interface PlatformServiceProbe {
     /** Where the probe runs. */
     readonly side: 'host' | 'client';
 }
-/** 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). */
 export declare const PLATFORM_SERVICE_PROBES: readonly PlatformServiceProbe[];
 /**
  * The HOST-side probes that do not resolve in this runtime — what `/evolution doctor` prints as

package/lib/types/preset-composition.d.ts

@@ -58,11 +58,29 @@ interface RowOverride {
 }
 /**
  * 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.
  */
-export declare function loadRowOverrides(): RowOverride[];
+export declare function loadRowOverrides(path?: string): RowOverride[];
+/**
+ * Row ids of a composition fragment (line scan, no YAML library).
+ *
+ * PLAN S5.9 (2026-09-16, audit P2-27): the id extraction accepts INDENTED
+ * `- id:` rows too, so a collision hidden in a nested group is still caught —
+ * the old `^- id:` anchored at column 0 and was blind to exactly the rows an
+ * upstream group nesting would produce. Twin of `rowIds` in
+ * `scripts/install-layered.mjs` (installer.spec pins detection parity).
+ * Boundary (current, deliberate): DETECTION covers nested rows, while the
+ * override INJECTION anchors (`applyOneOverride` below) still match top-level
+ * rows only — the injection indent contract (`^ {2}key:`) is defined against a
+ * column-0 row.
+ */
+export declare function compositionRowIds(composition: string): Set<string>;
 /** The platform package a DECLARATIVE preset row names (0.2.x replaced preset directories with it). */
 export declare const AGENT_PRESET_PACKAGE = "@deepseek-ai/dsh-agent-preset";
 /** Identity and display metadata of one generated preset row. */
@@ -78,6 +96,31 @@ export interface PresetRowIdentity {
     /** Sort order among the registered presets. */
     readonly order: number;
 }
+/**
+ * Compose the DECLARATIVE preset row from the platform base composition and the family delta.
+ *
+ * 0.2.x removed the directory mechanism: `dsh-agent-preset` is an ordinary composition row whose
+ * `config.plugins` carries the preset's complete child plugin list
+ * (`packages/preset/agent-preset/src/index.ts`, `agent-preset-registry/src/definition.ts` — the
+ * definition has NO base/extends field, which is why the platform base is merged in here).
+ *
+ * The composition itself is {@link composePresetComposition}: same row-collision contract and the
+ * same `row-overrides.json` injection, applied while the composed rows are still at column 0 — the
+ * override anchors are defined against a column-0 `- id:` row, so the indentation that puts them
+ * under `plugins:` must come last.
+ * @param baseComposition - the platform base preset patch/composition rows.
+ * @param deltaComposition - the family delta rows.
+ * @param identity - row id, preset id, display fields and order.
+ * @returns the row text, newline-terminated, ready to merge into a profile patch.
+ */
+/**
+ * Drop the blank lines that merely separate block-sequence items, keeping the ones INSIDE a block
+ * literal (`key: |` / `>`): there a blank line is part of the value, and filtering it flattened a
+ * platform base preset's multi-paragraph prompt into one paragraph (G6 review, P1).
+ * @param text - the composition rows.
+ * @returns the rows with the separating blank lines removed.
+ */
+export declare function denseBlockSequence(text: string): string;
 export declare function composePresetRow(baseComposition: string, deltaComposition: string, identity: PresetRowIdentity): string;
 /**
  * Wrap a composed row as the patch entry a profile patch needs.
@@ -183,6 +226,36 @@ export interface BasePresetPatchSources {
  * @throws {Error} when no candidate exists.
  */
 export declare function resolveBasePresetPatch(base: string, sources: BasePresetPatchSources): string;
+/**
+ * Probe every `@deepseek-ai/dsh-*` package under one unpacked resource root.
+ * @param resourceRoot - e.g. `<install>/resources/app.asar.unpacked`.
+ * @param file - the patch file name to look for.
+ * @param probes - the caller's probe log, appended to for the failure report.
+ * @returns the patch path when one exists.
+ */
+export declare function probeDesktopScope(resourceRoot: string, file: string, probes: string[]): string | undefined;
+/**
+ * Subdirectories of one directory, or none when it does not exist: a missing level is an ordinary
+ * miss on a candidate walk, not a failure.
+ * @param dir - the directory to list.
+ * @returns the directory names.
+ */
+export declare function listDirectories(dir: string): string[];
+/**
+ * The block of one row id: the enclosing column-0 list item and the row's own first line.
+ *
+ * An installer-written row sits inside `- insert:` (four spaces deeper); a row the Web editor
+ * saved is that column-0 item itself. Both must be replaced whole, so the span reaches back to the
+ * enclosing item and forward to the next one.
+ * @param lines - the patch text's lines.
+ * @param rowId - the row id to locate.
+ * @returns the span, or null when the patch carries no such row.
+ */
+export declare function rowBlockSpan(lines: string[], rowId: string): {
+    start: number;
+    end: number;
+    rowStart: number;
+} | null;
 /**
  * Remove one row from a patch, taking its `- insert:` item with it when that item holds nothing
  * else (an empty insert entry is left-over structure the platform would keep parsing).
@@ -191,6 +264,14 @@ export declare function resolveBasePresetPatch(base: string, sources: BasePreset
  * @returns the patch text, newline-terminated; byte-identical when the id is absent.
  */
 export declare function removePresetRow(patchText: string, rowId: string): string;
+/**
+ * The end of one nested row's own block inside a patch entry.
+ * @param lines - the patch text's lines.
+ * @param rowStart - the row's `- id:` line.
+ * @param itemEnd - the enclosing item's end.
+ * @returns the index of the next sibling row, or the item's end.
+ */
+export declare function rowSiblingEnd(lines: string[], rowStart: number, itemEnd: number): number;
 /**
  * Merge one generated row into a composition (a profile patch) by row id.
  *
@@ -212,6 +293,8 @@ export declare function removePresetRow(patchText: string, rowId: string): strin
 export declare function mergePresetRow(patchText: string, row: string, rowId: string): string;
 /** The empty patch list the platform seeds a profile patch with; see {@link mergePresetRow}. */
 export declare const EMPTY_PATCH_SEED = "[]";
+/** Drop trailing blank lines only: a kept line's own terminator (a CRLF file's `\r`) is never touched. */
+export declare function trimTrailingBlankLines(lines: string[]): string[];
 /**
  * The text to write when a patch is left with no entries.
  *

package/lib/types/skill-row-cells.d.ts

@@ -57,6 +57,8 @@ export interface VersionRowFacts {
     readonly charsDelta?: number;
     readonly path?: string;
     readonly summary?: string;
+    /** U-5: the body hash the host recorded for this version (the row shows a short code, hover = full). */
+    readonly hash?: string;
 }
 /** The facts a skill row needs. The client's `SkillRow` satisfies this structurally. */
 export interface SkillRowFacts {

package/lib/types/skill-store.d.ts

@@ -19,7 +19,7 @@
  *    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
@@ -306,9 +306,8 @@ export declare class SkillLibrary {
      * 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).
      */
     private cleanupGhostDir;
@@ -481,58 +480,19 @@ export declare class SkillLibrary {
      * 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.
      */
-    private hasWriteLock;
-    /** 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. */
-    private isWriterLock;
-    /** 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. */
-    private deleteStrandedLocks;
-    /** 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. */
-    private lockHolderAgedOut;
-    /** 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. */
-    private sweepLockIfStranded;
+    private supportDirsUnlistable;
     /** A1-4 (v18): a manifest-declared name is copied with `join(root, name)`;
      * only a single, non-traversing path component is safe. Dotfiles
      * (`.usage.json`) stay allowed — sidecars are legitimately dot-prefixed.
      * P2-4 (v19): a non-string entry (`skills: [123]`) is refused structurally
      * instead of throwing `name.includes is not a function`. */
     private safeSnapshotEntryName;
-    /** 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). */
-    private refuseLiveLockOrSweep;
     archive(rawName: string, options?: ArchiveOptions): Promise<SkillActionResult>;
     /**
      * V2 (design §16.7): what an apply-mode consolidation would do for ONE source,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-core",
   "description": "Shared stores, prompts, signals and lifecycle logic for the dsh-evolution plugin family (community build)",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "publishConfig": {
     "access": "public"
   },

package/persisted-write-inventory.json

@@ -122,10 +122,10 @@
       "id": "skill-tree",
       "path": "<skillsRoot>/**",
       "writer": "evolution-core/src/skill-store.ts",
-      "serializedBy": "write-lock",
-      "marker": "LOCK_SUFFIX",
+      "serializedBy": "transact",
+      "marker": "this.transact(this.io, path",
       "state": [],
-      "note": "The skill tree itself. Per-target `<path>.lock` claims (pid:token body) guard every byte writer; destructive movers refuse a live lock."
+      "note": "The skill tree itself. G2 S4: the family write-lock protocol is retired; every byte writer goes through the provider's versioned read-modify-write (`transact`), so this entry is serialized by the same seam as the rest. Destructive movers refuse only when a support directory cannot be listed (fail-closed)."
     },
     {
       "id": "activity-log",