@lmzhen/dsh-evolution-core 0.30.37 → 0.30.38

package/lib/types/unit-members.js

@@ -50,9 +50,9 @@ export function resolveUnitMembersFromIndexes(head, indexes, readEntries) {
         for (const path of shardPaths)
             if (!wanted.includes(path))
                 conflicts.push({ kind: 'foreign', path });
-        for (const path of wanted)
-            if (shardPaths.filter(p => p === path).length > 1)
-                conflicts.push({ kind: 'duplicated', path });
+        // No duplicated-path check: the manifest path is skill-relative and carries no skill, so one
+        // path in TWO skills (extract's source support removal + target support write) is the normal
+        // shape. A path-only duplicate refusal made every cross-skill support move un-undoable.
     }
     return { members, missing, conflicts };
 }

package/lib/types/unit-storage.d.ts

@@ -23,6 +23,16 @@ export interface UnitSnapshot {
     }[];
     readonly origin: string;
     readonly summary: string;
+    /** Tree-change units reuse this store; merge snapshots leave these absent. */
+    readonly kind?: 'merge' | 'tree-change';
+    readonly mutationState?: 'prepared' | 'committed' | 'undone';
+    readonly ops?: readonly {
+        readonly target: string;
+        readonly before: string | null;
+        readonly after: string | null;
+        readonly skill?: string;
+    }[];
+    readonly cleanup?: readonly string[];
     readonly validationPlan?: {
         readonly planVersion: 1;
         readonly stageDigest: string;

package/lib/types/unit-transaction.d.ts

@@ -214,7 +214,7 @@ export declare class UnitTransactions implements UnitTransaction {
         phase: "target-pending" | "target-written" | "source-archiving" | "sources-archived";
     } | {
         ok: boolean;
-        phase: "failed" | "prepared" | "support-pending" | "unit-written" | "committed" | "rolled-back";
+        phase: "failed" | "prepared" | "unit-written" | "committed" | "support-pending" | "rolled-back";
     }>;
 }
 //# sourceMappingURL=unit-transaction.d.ts.map

package/lib/types/unit-undo-plan.js

@@ -13,6 +13,7 @@
  * means the caller writes nothing.
  */
 import { BASELINE_ACTION, entryTarget } from "./skill-history.js";
+import { contentHash } from "./mutations.js";
 function slotsOf(entries) {
     const body = {};
     const support = new Map();
@@ -72,13 +73,14 @@ export function planUnitUndoAcross(members) {
         for (const [path, slot] of support) {
             if (slot.newest === undefined)
                 continue;
-            const preUnitHash = slot.baseline !== undefined ? slot.baseline.hash : slot.oldest?.beforeHash;
+            const removal = slot.oldest?.removed === true;
+            const preUnitHash = removal ? slot.oldest?.hash : slot.baseline !== undefined ? slot.baseline.hash : slot.oldest?.beforeHash;
             ops.push({
                 skill: member.skill,
                 path,
-                remove: preUnitHash === undefined,
+                remove: !removal && preUnitHash === undefined,
                 ...(preUnitHash === undefined ? {} : { preUnitHash }),
-                expectedHash: slot.newest.hash,
+                expectedHash: removal ? contentHash('') : slot.newest.hash,
             });
         }
         if (body.newest !== undefined) {

package/lib/types/unit-undo.d.ts

@@ -12,7 +12,7 @@ export interface UnitUndoSink {
     updateSkill(skill: string, body: string, anchor: {
         sha256: string;
     }): Promise<SkillActionResult>;
-    writeSupportFile(skill: string, path: string, content: string, anchor: {
+    writeSupportFile(skill: string, path: string, content: string, anchor?: {
         sha256: string;
     }): Promise<SkillActionResult>;
     removeSupportFile(skill: string, path: string, anchor: {

package/lib/types/unit-undo.js

@@ -25,6 +25,21 @@ export async function executeUnitUndo(plan, sink) {
     for (const op of plan.ops) {
         const live = op.path === '' ? await sink.readSkill(op.skill) : await sink.readSupport(op.skill, op.path);
         if (live === null) {
+            // The unit may have DELETED this path (extract moving an exclusive support file). Its
+            // after-hash is then the absent-content hash, and undo must recreate it from the pre-unit
+            // blob. A remove op against an already-absent path is a no-op.
+            // A remove op against an already-absent path is a no-op (the unit's deletion landed).
+            if (op.remove)
+                continue;
+            if (op.expectedHash === contentHash('')) {
+                const bytes = op.preUnitHash === undefined ? null : await sink.readBlob(op.preUnitHash);
+                if (bytes === null) {
+                    refusals.push(`${op.skill}/${op.path === '' ? 'SKILL.md' : op.path}（单元前字节读不到：blob ${op.preUnitHash ?? '(missing)'}）`);
+                    continue;
+                }
+                prepared.push({ ...op, bytes, live: '', absent: true });
+                continue;
+            }
             refusals.push(`${op.skill}/${op.path === '' ? 'SKILL.md' : op.path}（盘上文件不存在）`);
             continue;
         }
@@ -33,7 +48,7 @@ export async function executeUnitUndo(plan, sink) {
             continue;
         }
         if (op.remove) {
-            prepared.push({ ...op, bytes: '', live });
+            prepared.push({ ...op, bytes: '', live, absent: false });
             continue;
         }
         const bytes = op.preUnitHash === undefined ? null : await sink.readBlob(op.preUnitHash);
@@ -41,7 +56,7 @@ export async function executeUnitUndo(plan, sink) {
             refusals.push(`${op.skill}/${op.path === '' ? 'SKILL.md' : op.path}（单元前字节读不到：blob ${op.preUnitHash ?? '(missing)'}）`);
             continue;
         }
-        prepared.push({ ...op, bytes, live });
+        prepared.push({ ...op, bytes, live, absent: false });
     }
     if (refusals.length > 0) {
         return { ok: false, message: `整单元撤销未开始（零写）—— 预检未通过：${refusals.join('；')}。修好后可重试。`, reverted: [] };
@@ -59,7 +74,7 @@ export async function executeUnitUndo(plan, sink) {
     for (const op of supportOps) {
         const result = op.remove
             ? await sink.removeSupportFile(op.skill, op.path, { sha256: op.expectedHash })
-            : await sink.writeSupportFile(op.skill, op.path, op.bytes, { sha256: op.expectedHash });
+            : op.absent ? await sink.writeSupportFile(op.skill, op.path, op.bytes) : await sink.writeSupportFile(op.skill, op.path, op.bytes, { sha256: op.expectedHash });
         if (!result.ok)
             return { ok: false, message: `${op.skill}/${op.path}：${result.message} —— 撤销未完成（已回退：${done()}）。`, reverted };
         reverted.push(op.skill + '/' + op.path);

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.30.37",
+  "version": "0.30.38",
   "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": "transact",
-      "marker": "this.transact(this.io, path",
+      "serializedBy": "write-lock",
+      "marker": "fileMutationLock(",
       "state": [],
-      "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)."
+      "note": "The skill tree itself. G1: ordinary byte writers take the root mutation lock (fileMutationLock) and still run their per-file read-modify-write through `transact`; the root lock is what keeps extract/restructure/update/patch/create from interleaving. Destructive movers refuse only when a support directory cannot be listed (fail-closed)."
     },
     {
       "id": "activity-log",