@lmzhen/dsh-evolution-merge 0.40.1 → 0.42.0

package/lib/types/unit-protocol.js

@@ -0,0 +1,566 @@
+/** G2 opaque UnitTransaction. Core owns prepare/commit/verify/rollback lifecycle. */
+import { createHash } from "node:crypto";
+import { acquireTreeWriteLock } from '@lmzhen/dsh-evolution-core';
+import { readUnitEvidence, readUnitReceipt, readUnitIndex, readUnitSnapshot, unitStorageKey, writeUnitEvidence, writeUnitReceipt, writeUnitSnapshot, } from '@lmzhen/dsh-evolution-core/write';
+import { readUnitJournal, writeUnitJournal } from '@lmzhen/dsh-evolution-core/write';
+function canonicalJson(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return '[' + value.map(canonicalJson).join(',') + ']';
+    const object = value;
+    return '{' + Object.keys(object).sort().map(key => JSON.stringify(key) + ':' + canonicalJson(object[key])).join(',') + '}';
+}
+function sameTarget(a, b) {
+    return (a ?? '').trimEnd() === (b ?? '').trimEnd();
+}
+function digest(plan) {
+    return createHash("sha256").update(canonicalJson(plan)).digest("hex");
+}
+export function unitEvidenceDigest(evidence) {
+    return createHash("sha256").update(canonicalJson({ ...evidence, at: 0, mutations: 0 })).digest("hex");
+}
+export class MergeUnitTransactions {
+    options;
+    prepared = new Map();
+    commits = new Map();
+    now;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? (() => Date.now());
+    }
+    unitId(plan) {
+        // DEC-D5: the caller may provide the unitId and still get idempotent prepare/commit.
+        // Deriving one remains the fallback for callers that do not.
+        return plan.unitId ?? plan.runId + ":" + createHash("sha256").update(plan.pairKey).digest("hex").slice(0, 16);
+    }
+    async snapshot(plan, unitId, planDigest) {
+        const targetBefore = await this.options.backend.readSkill(plan.target);
+        const supportBefore = await Promise.all(plan.supportFiles.map(async (file) => ({
+            path: file.path,
+            content: await this.options.backend.readSupportFile(plan.target, file.path),
+        })));
+        const sourceBefore = await Promise.all(plan.sources
+            .filter((source) => source !== plan.target)
+            .map(async (name) => ({ name, body: (await this.options.backend.readSkill(name)) ?? "" })));
+        return {
+            schemaVersion: 1,
+            unitId,
+            planDigest,
+            runId: plan.runId,
+            target: plan.target,
+            targetExists: plan.targetExists,
+            targetBefore,
+            targetAfter: plan.body,
+            supportBefore,
+            supportAfter: plan.supportFiles,
+            sourceBefore,
+            origin: plan.origin,
+            summary: plan.summary,
+            ...(plan.validationPlan === undefined ? {} : { validationPlan: plan.validationPlan }),
+            createdAt: this.now(),
+        };
+    }
+    async prepare(plan) {
+        const unitId = this.unitId(plan);
+        const planDigest = digest(plan);
+        const existing = this.prepared.get(unitId);
+        if (existing !== undefined)
+            return existing.digest === planDigest
+                ? { ok: true, prepared: { unitId, planDigest } }
+                : { ok: false, code: "unit-conflict", message: "unitId already prepared with a different plan" };
+        const snapshot = await this.snapshot(plan, unitId, planDigest);
+        const path = await writeUnitSnapshot(this.options.io, this.options.home, snapshot);
+        const journal = {
+            schemaVersion: 1,
+            unitId,
+            runId: plan.runId,
+            planDigest,
+            target: plan.target,
+            sources: plan.sources,
+            phase: "prepared",
+            storageKey: unitStorageKey(unitId),
+            snapshotSha256: createHash("sha256")
+                .update(JSON.stringify(snapshot, null, 2) + "\n")
+                .digest("hex"),
+            updatedAt: this.now(),
+        };
+        await writeUnitJournal(this.options.io, this.options.home, journal);
+        await this.options.onPhase?.("prepared");
+        this.prepared.set(unitId, {
+            plan,
+            digest: planDigest,
+            at: this.now(),
+            snapshotSha256: createHash("sha256")
+                .update(JSON.stringify(snapshot, null, 2) + "\n")
+                .digest("hex"),
+        });
+        void path;
+        return { ok: true, prepared: { unitId, planDigest } };
+    }
+    async commit(prepared, options) {
+        const running = this.commits.get(prepared.unitId);
+        if (running !== undefined)
+            return await running;
+        const run = () => this.commitOnce(prepared, options);
+        const task = this.options.serial === undefined ? run() : this.options.serial(run);
+        this.commits.set(prepared.unitId, task);
+        try {
+            return await task;
+        }
+        finally {
+            this.commits.delete(prepared.unitId);
+        }
+    }
+    async commitOnce(prepared, options) {
+        const existing = await readUnitEvidence(this.options.io, this.options.home, prepared.unitId);
+        if (existing !== null)
+            return existing.planDigest === prepared.planDigest
+                ? { ok: true, evidence: existing }
+                : { ok: false, code: "unit-conflict", message: "unit already committed with a different digest" };
+        const stored = this.prepared.get(prepared.unitId);
+        if (stored === undefined || stored.digest !== prepared.planDigest)
+            return {
+                ok: false,
+                code: "unit-plan-missing",
+                message: "prepared plan is not in this process; manual recovery required",
+            };
+        if (options?.signal?.aborted === true)
+            return { ok: false, code: "unit-commit-failed", message: "cancelled before commit" };
+        if (this.options.isActive !== undefined && !(await this.options.isActive(stored.plan.runId))) {
+            return { ok: false, code: "unit-run-inactive", message: "run is no longer active; refusing to commit" };
+        }
+        const journalBase = {
+            schemaVersion: 1,
+            unitId: prepared.unitId,
+            runId: stored.plan.runId,
+            planDigest: stored.digest,
+            target: stored.plan.target,
+            sources: stored.plan.sources,
+            storageKey: unitStorageKey(prepared.unitId),
+            snapshotSha256: stored.snapshotSha256,
+            updatedAt: this.now(),
+        };
+        let lock;
+        let fenceLease;
+        let claim;
+        let stage = 'fence';
+        const checkpoints = [];
+        const writePhase = async (phase, checkpointsNext = checkpoints) => {
+            if (lock !== undefined && !(await lock.assertHeld()))
+                throw new Error("unit-fence-lost");
+            await writeUnitJournal(this.options.io, this.options.home, {
+                ...journalBase,
+                phase,
+                checkpoints: checkpointsNext,
+            });
+            await this.options.onPhase?.(phase);
+        };
+        try {
+            if (this.options.fence !== undefined) {
+                fenceLease = await this.options.fence.acquire();
+                lock = fenceLease.lock;
+                this.options.onLock?.("tree");
+            }
+            else {
+                const acquired = await acquireTreeWriteLock({ io: this.options.io, home: this.options.home, waitMs: this.options.waitMs ?? 5000 });
+                if (!acquired.ok)
+                    return { ok: false, code: "unit-fence-failed", message: acquired.message ?? acquired.reason };
+                lock = acquired.lock;
+                this.options.onLock?.("tree");
+            }
+            if (!(await lock.assertHeld()))
+                return { ok: false, code: "unit-fence-failed", message: "tree fence lost" };
+            stage = 'claim';
+            claim = await this.options.claim.acquire(stored.plan.target, stored.plan.runId);
+            this.options.onLock?.("claim");
+            // Re-read under the fence: another instance may have committed while we queued.
+            const committedWhileWaiting = await readUnitEvidence(this.options.io, this.options.home, prepared.unitId);
+            if (committedWhileWaiting !== null) {
+                return committedWhileWaiting.planDigest === prepared.planDigest
+                    ? { ok: true, evidence: committedWhileWaiting }
+                    : { ok: false, code: "unit-conflict", message: "unit already committed with a different digest" };
+            }
+            stage = 'commit';
+            await writeUnitJournal(this.options.io, this.options.home, { ...journalBase, phase: "target-pending" });
+            const result = await this.options.backend.commit({ ...stored.plan, unitId: prepared.unitId }, async (phase, detail) => {
+                if (phase === "support-pending") {
+                    await writePhase("support-pending");
+                    await this.options.onPhase?.("support-pending");
+                    return;
+                }
+                if (phase === "target-applied") {
+                    await this.options.onPhase?.("target-applied");
+                    return;
+                }
+                if (phase === "unit-written") {
+                    if (lock !== undefined && !(await lock.assertHeld()))
+                        throw new Error("unit-fence-lost");
+                    await writeUnitReceipt(this.options.io, this.options.home, {
+                        schemaVersion: 1,
+                        unitId: prepared.unitId,
+                        runId: stored.plan.runId,
+                        planDigest: stored.digest,
+                        target: stored.plan.target,
+                        archived: stored.plan.sources.filter((source) => source !== stored.plan.target),
+                        at: this.now(),
+                    });
+                    await writePhase("unit-written");
+                    return;
+                }
+                if (phase === "source-archiving" && detail?.source !== undefined) {
+                    checkpoints.push({
+                        source: detail.source,
+                        phase: "archived",
+                        hash: createHash("sha256")
+                            .update(stored.plan.expectedSourceBodies.find((item) => item.name === detail.source)?.body ?? "")
+                            .digest("hex"),
+                        at: this.now(),
+                    });
+                }
+                await writePhase(phase, checkpoints);
+            }, options?.signal, async () => lock !== undefined && (await lock.assertHeld()), this.options.serial === undefined ? undefined : { serialized: true });
+            if (!result.ok) {
+                await writePhase("failed");
+                return { ok: false, code: result.code ?? "unit-commit-failed", message: result.message };
+            }
+            const targetAfter = (await this.options.backend.readSkill(stored.plan.target)) ?? "";
+            const evidence = {
+                schemaVersion: 1,
+                unitId: prepared.unitId,
+                runId: stored.plan.runId,
+                planDigest: stored.digest,
+                state: "complete",
+                target: {
+                    before: stored.plan.expectedTargetBody,
+                    after: targetAfter,
+                    supportDigest: createHash("sha256").update(JSON.stringify(stored.plan.supportFiles)).digest("hex"),
+                    created: !stored.plan.targetExists,
+                },
+                sources: stored.plan.sources
+                    .filter((source) => source !== stored.plan.target)
+                    .map((name) => ({
+                    name,
+                    before: stored.plan.expectedSourceBodies.find((item) => item.name === name)?.body ?? "",
+                    after: null,
+                    archived: (result.archived ?? []).includes(name),
+                    absorbedInto: stored.plan.target,
+                })),
+                mutations: result.mutations ?? 0,
+                ...(stored.plan.validationPlan === undefined ? {} : { validationPlan: stored.plan.validationPlan }),
+                at: this.now(),
+            };
+            if (!(await lock.assertHeld()))
+                throw new Error("unit-fence-lost");
+            const evidenceSha256 = unitEvidenceDigest(evidence);
+            await writeUnitEvidence(this.options.io, this.options.home, evidence);
+            await writeUnitReceipt(this.options.io, this.options.home, {
+                schemaVersion: 1, unitId: prepared.unitId, runId: stored.plan.runId, planDigest: stored.digest,
+                target: stored.plan.target, archived: stored.plan.sources.filter((source) => source !== stored.plan.target), at: this.now(), evidenceSha256,
+            });
+            await writePhase("committed", checkpoints);
+            this.prepared.delete(prepared.unitId);
+            return { ok: true, evidence };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                code: message === "unit-fence-lost"
+                    ? "unit-fence-failed"
+                    : stage === "claim"
+                        ? "unit-claim-failed"
+                        : stage === "fence"
+                            ? "unit-fence-failed"
+                            : "unit-commit-failed",
+                message,
+            };
+        }
+        finally {
+            try {
+                await claim?.release();
+            }
+            finally {
+                if (fenceLease !== undefined)
+                    await fenceLease.release();
+                else
+                    await lock?.release();
+            }
+        }
+    }
+    async verify(ref) {
+        if ("unitId" in ref)
+            return await readUnitEvidence(this.options.io, this.options.home, ref.unitId);
+        const entries = (await readUnitIndex(this.options.io, this.options.home)).filter(entry => entry.runId === ref.runId);
+        const all = await Promise.all(entries.map(async (entry) => readUnitEvidence(this.options.io, this.options.home, entry.unitId)));
+        const found = all.filter((item) => item !== null && item.runId === ref.runId);
+        const only = found[0];
+        return found.length === 0 ? null : found.length === 1 ? (only ?? null) : found;
+    }
+    async withRecoveryFence(task) {
+        if (this.options.fence === undefined)
+            return await task();
+        const lease = await this.options.fence.acquire();
+        try {
+            return await task();
+        }
+        finally {
+            await lease.release();
+        }
+    }
+    async finalize(unitId) {
+        return await this.withRecoveryFence(async () => this.finalizeUnlocked(unitId));
+    }
+    async finalizeUnlocked(unitId) {
+        const existing = await readUnitEvidence(this.options.io, this.options.home, unitId);
+        if (existing !== null)
+            return { ok: true, evidence: existing };
+        const snapshot = await readUnitSnapshot(this.options.io, this.options.home, unitId);
+        const journal = await readUnitJournal(this.options.io, this.options.home, unitId);
+        const receipt = await readUnitReceipt(this.options.io, this.options.home, unitId);
+        if (snapshot === null || journal === null || (journal.phase !== "committed" && receipt === null))
+            return { ok: false, code: "unit-rollback-blocked", message: "unit is not committed; manual recovery required" };
+        if (receipt !== null &&
+            (receipt.unitId !== unitId ||
+                receipt.runId !== snapshot.runId ||
+                receipt.planDigest !== snapshot.planDigest ||
+                receipt.target !== snapshot.target))
+            return {
+                ok: false,
+                code: "unit-rollback-blocked",
+                message: "unit receipt does not match snapshot; manual recovery required",
+            };
+        const checkpoints = journal.checkpoints ?? [];
+        const missing = snapshot.sourceBefore.filter((source) => !checkpoints.some((item) => item.source === source.name));
+        if (missing.length > 0)
+            return {
+                ok: false,
+                code: "unit-rollback-blocked",
+                message: "source checkpoint missing: " + missing.map((item) => item.name).join(","),
+            };
+        const liveTarget = await this.options.backend.readSkill(snapshot.target);
+        if (liveTarget === null || !sameTarget(liveTarget, snapshot.targetAfter))
+            return { ok: false, code: "unit-rollback-blocked", message: "target live hash does not match the prepared target; manual recovery required" };
+        const liveSources = await Promise.all(snapshot.sourceBefore.map(async (source) => ({ name: source.name, body: await this.options.backend.readSkill(source.name) })));
+        const liveSource = liveSources.find(source => source.body !== null);
+        if (liveSource !== undefined)
+            return { ok: false, code: "unit-rollback-blocked", message: "source is still live: " + liveSource.name };
+        let liveSupport = await Promise.all(snapshot.supportAfter.map(async (file) => ({ path: file.path, content: await this.options.backend.readSupportFile(snapshot.target, file.path) })));
+        const supportMatches = () => liveSupport.every(file => file.content === (snapshot.supportAfter.find(item => item.path === file.path)?.content ?? null));
+        if (!supportMatches()) {
+            // Crash after the sources are archived but before the support files land: finish the
+            // idempotent support write from the prepared snapshot, then re-check.
+            if (!["support-pending", "sources-archived", "unit-written"].includes(journal.phase) || this.options.backend.restoreSupportFile === undefined)
+                return { ok: false, code: "unit-rollback-blocked", message: "support file live hash does not match the prepared support; manual recovery required" };
+            for (const file of snapshot.supportAfter)
+                await this.options.backend.restoreSupportFile(snapshot.target, file.path, file.content);
+            liveSupport = await Promise.all(snapshot.supportAfter.map(async (file) => ({ path: file.path, content: await this.options.backend.readSupportFile(snapshot.target, file.path) })));
+            if (!supportMatches())
+                return { ok: false, code: "unit-rollback-blocked", message: "support file could not be completed from the prepared snapshot" };
+        }
+        const evidence = {
+            schemaVersion: 1,
+            unitId,
+            runId: snapshot.runId,
+            planDigest: snapshot.planDigest,
+            state: "complete",
+            target: {
+                before: snapshot.targetBefore,
+                after: (await this.options.backend.readSkill(snapshot.target)) ?? "",
+                supportDigest: createHash("sha256").update(JSON.stringify(snapshot.supportAfter)).digest("hex"),
+                created: !snapshot.targetExists,
+            },
+            sources: snapshot.sourceBefore.map((source) => ({
+                name: source.name,
+                before: source.body,
+                after: null,
+                archived: checkpoints.some((item) => item.source === source.name),
+                absorbedInto: snapshot.target,
+            })),
+            mutations: 0,
+            ...(snapshot.validationPlan === undefined ? {} : { validationPlan: snapshot.validationPlan }),
+            at: this.now(),
+        };
+        if (receipt?.evidenceSha256 !== undefined && unitEvidenceDigest(evidence) !== receipt.evidenceSha256)
+            return { ok: false, code: "unit-rollback-blocked", message: "receipt evidence hash does not match rebuilt evidence" };
+        await writeUnitEvidence(this.options.io, this.options.home, evidence);
+        if (journal.phase !== "committed")
+            await writeUnitJournal(this.options.io, this.options.home, { ...journal, phase: "committed", checkpoints, updatedAt: this.now() });
+        return { ok: true, evidence };
+    }
+    async rollForward(unitId) {
+        return await this.withRecoveryFence(async () => this.rollForwardUnlocked(unitId));
+    }
+    async rollForwardUnlocked(unitId) {
+        const existing = await readUnitEvidence(this.options.io, this.options.home, unitId);
+        if (existing !== null)
+            return { ok: true, evidence: existing };
+        const snapshot = await readUnitSnapshot(this.options.io, this.options.home, unitId);
+        const journal = await readUnitJournal(this.options.io, this.options.home, unitId);
+        if (snapshot === null || journal === null || !["target-written", "support-pending", "source-archiving", "sources-archived", "unit-written"].includes(journal.phase))
+            return {
+                ok: false,
+                code: "unit-rollback-blocked",
+                message: "unit is not roll-forwardable; manual recovery required",
+            };
+        const checkpoints = journal.checkpoints ?? [];
+        const missing = snapshot.sourceBefore.filter((source) => !checkpoints.some((item) => item.source === source.name));
+        if (missing.length > 0)
+            return {
+                ok: false,
+                code: "unit-rollback-blocked",
+                message: "source checkpoint missing: " + missing.map((item) => item.name).join(","),
+            };
+        const targetAfter = await this.options.backend.readSkill(snapshot.target);
+        if (targetAfter === null || !sameTarget(targetAfter, snapshot.targetAfter))
+            return { ok: false, code: "unit-rollback-blocked", message: "target missing or drifted; manual recovery required" };
+        const liveSources = await Promise.all(snapshot.sourceBefore.map(async (source) => ({ name: source.name, body: await this.options.backend.readSkill(source.name) })));
+        const liveSource = liveSources.find(source => source.body !== null);
+        if (liveSource !== undefined)
+            return { ok: false, code: "unit-rollback-blocked", message: "source is still live: " + liveSource.name };
+        let liveSupport = await Promise.all(snapshot.supportAfter.map(async (file) => ({ path: file.path, content: await this.options.backend.readSupportFile(snapshot.target, file.path) })));
+        const supportMatches = () => liveSupport.every(file => file.content === (snapshot.supportAfter.find(item => item.path === file.path)?.content ?? null));
+        if (!supportMatches()) {
+            // Crash after the sources are archived but before the support files land: finish the
+            // idempotent support write from the prepared snapshot, then re-check.
+            if (!["support-pending", "sources-archived", "unit-written"].includes(journal.phase) || this.options.backend.restoreSupportFile === undefined)
+                return { ok: false, code: "unit-rollback-blocked", message: "support file live hash does not match the prepared support; manual recovery required" };
+            for (const file of snapshot.supportAfter)
+                await this.options.backend.restoreSupportFile(snapshot.target, file.path, file.content);
+            liveSupport = await Promise.all(snapshot.supportAfter.map(async (file) => ({ path: file.path, content: await this.options.backend.readSupportFile(snapshot.target, file.path) })));
+            if (!supportMatches())
+                return { ok: false, code: "unit-rollback-blocked", message: "support file could not be completed from the prepared snapshot" };
+        }
+        const evidence = {
+            schemaVersion: 1,
+            unitId,
+            runId: snapshot.runId,
+            planDigest: snapshot.planDigest,
+            state: "complete",
+            target: {
+                before: snapshot.targetBefore,
+                after: targetAfter,
+                supportDigest: createHash("sha256").update(JSON.stringify(snapshot.supportAfter)).digest("hex"),
+                created: !snapshot.targetExists,
+            },
+            sources: snapshot.sourceBefore.map((source) => ({
+                name: source.name,
+                before: source.body,
+                after: null,
+                archived: checkpoints.some((item) => item.source === source.name),
+                absorbedInto: snapshot.target,
+            })),
+            mutations: 0,
+            ...(snapshot.validationPlan === undefined ? {} : { validationPlan: snapshot.validationPlan }),
+            at: this.now(),
+        };
+        await writeUnitEvidence(this.options.io, this.options.home, evidence);
+        await writeUnitJournal(this.options.io, this.options.home, { ...journal, phase: "committed", checkpoints, updatedAt: this.now() });
+        return { ok: true, evidence };
+    }
+    async rollback(ref) {
+        const evidence = await readUnitEvidence(this.options.io, this.options.home, ref.unitId);
+        const receipt = await readUnitReceipt(this.options.io, this.options.home, ref.unitId);
+        if (evidence !== null || receipt !== null)
+            return { ok: false, code: "unit-committed", message: "committed unit cannot roll back" };
+        const snapshot = await readUnitSnapshot(this.options.io, this.options.home, ref.unitId);
+        if (snapshot === null)
+            return { ok: false, code: "unit-rollback-blocked", message: "snapshot missing" };
+        const journal = await readUnitJournal(this.options.io, this.options.home, ref.unitId);
+        let fenceLease;
+        let lock;
+        let claim;
+        try {
+            if (this.options.fence !== undefined) {
+                fenceLease = await this.options.fence.acquire();
+                lock = fenceLease.lock;
+            }
+            else {
+                const acquired = await acquireTreeWriteLock({ io: this.options.io, home: this.options.home, waitMs: this.options.waitMs ?? 5000 });
+                if (!acquired.ok)
+                    return { ok: false, code: "unit-fence-failed", message: acquired.message ?? acquired.reason };
+                lock = acquired.lock;
+            }
+            this.options.onLock?.("tree");
+            if (!(await lock.assertHeld()))
+                return { ok: false, code: "unit-fence-failed", message: "tree fence lost" };
+            claim = await this.options.claim.acquire(snapshot.target, snapshot.runId);
+            this.options.onLock?.("claim");
+            const currentTarget = await this.options.backend.readSkill(snapshot.target);
+            if (currentTarget !== snapshot.targetBefore && !sameTarget(currentTarget, snapshot.targetAfter))
+                return {
+                    ok: false,
+                    code: "unit-rollback-blocked",
+                    message: "target drifted since snapshot; manual recovery required",
+                };
+            for (const source of snapshot.sourceBefore) {
+                const current = await this.options.backend.readSkill(source.name);
+                if (current !== null && current !== source.body)
+                    return { ok: false, code: "unit-rollback-blocked", message: "source drifted since snapshot: " + source.name };
+            }
+            if (!(await lock.assertHeld()))
+                return { ok: false, code: "unit-fence-failed", message: "tree fence lost before target restore" };
+            await this.options.backend.restoreTarget(snapshot.target, snapshot.targetBefore);
+            for (const file of snapshot.supportBefore) {
+                if (!(await lock.assertHeld()))
+                    return { ok: false, code: "unit-fence-failed", message: "tree fence lost before support restore" };
+                await this.options.backend.restoreSupportFile?.(snapshot.target, file.path, file.content);
+            }
+            for (const source of snapshot.sourceBefore) {
+                if (!(await lock.assertHeld()))
+                    return { ok: false, code: "unit-fence-failed", message: "tree fence lost before source restore" };
+                await this.options.backend.restoreSource(source.name, source.body);
+            }
+            if (journal !== null)
+                await writeUnitJournal(this.options.io, this.options.home, { ...journal, phase: "rolled-back", updatedAt: this.now() });
+            const evidenceRecord = {
+                schemaVersion: 1,
+                unitId: ref.unitId,
+                runId: snapshot.runId,
+                planDigest: snapshot.planDigest,
+                state: "target-only",
+                target: { before: snapshot.targetBefore, after: snapshot.targetBefore ?? "", supportDigest: "", created: false },
+                sources: snapshot.sourceBefore.map((source) => ({
+                    name: source.name,
+                    before: source.body,
+                    after: null,
+                    archived: false,
+                    absorbedInto: snapshot.target,
+                })),
+                mutations: 0,
+                at: this.now(),
+            };
+            return { ok: true, evidence: evidenceRecord };
+        }
+        finally {
+            try {
+                await claim?.release();
+            }
+            finally {
+                if (fenceLease !== undefined)
+                    await fenceLease.release();
+                else
+                    await lock?.release();
+            }
+        }
+    }
+    async cancel(unitId, reason) {
+        const journal = await readUnitJournal(this.options.io, this.options.home, unitId);
+        if (journal === null)
+            return { ok: false, phase: "none" };
+        if (journal.phase === "prepared" && this.prepared.has(unitId)) {
+            this.prepared.delete(unitId);
+            return { ok: true, phase: "prepared" };
+        }
+        if (journal.phase === "target-pending" ||
+            journal.phase === "target-written" ||
+            journal.phase === "source-archiving" ||
+            journal.phase === "support-pending" ||
+            journal.phase === "sources-archived") {
+            const rolled = await this.rollback({ unitId, reason });
+            return { ok: rolled.ok, phase: journal.phase };
+        }
+        return { ok: false, phase: journal.phase };
+    }
+}
+//# sourceMappingURL=unit-protocol.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-merge",
   "description": "Skill auto-merge domain: screening, two-round authoring, queues and commit orchestration (community build)",
-  "version": "0.40.1",
+  "version": "0.42.0",
   "publishConfig": {
     "access": "public"
   },
@@ -32,13 +32,12 @@
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.5",
-    "@lmzhen/dsh-evolution-core": "^0.40.1",
-    "@lmzhen/dsh-evolution-commands": "^0.40.1",
-    "@lmzhen/dsh-evolution-merge-engine": "0.40.1"
+    "@lmzhen/dsh-evolution-core": "^0.42.0",
+    "@lmzhen/dsh-evolution-commands": "^0.42.0",
+    "@lmzhen/dsh-evolution-merge-engine": "0.42.0"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.5",
-    "@deepseek-ai/dsh-llm": "^0.2.2-rc.0"
+    "@deepseek-ai/cordis": "^4.0.5"
   },
   "engines": {
     "dsh": ">=0.2.2-rc.0 <0.2.3-0"