@lmzhen/dsh-evolution-merge 0.47.0 → 0.48.0

package/lib/types/round2-outcome.js

@@ -2,7 +2,6 @@ import { v4ToLegacy } from "./domain/row-v4.js";
 import { pairLedger } from "./domain/pair-ledger.js";
 import { dropStage } from "./domain/stage-aggregate.js";
 import { casExpiredHook } from "./domain/failure-route.js";
-import { recordPair } from "./domain/run-coordinator.js";
 export async function recordRound2Outcome(io, home, now, row, outcome, deferProjection = false, fence) {
     void now;
     const reportExtra = {
@@ -10,9 +9,13 @@ export async function recordRound2Outcome(io, home, now, row, outcome, deferProj
         ...(outcome.criteria === undefined ? {} : { criteria: outcome.criteria }),
         ...(outcome.validationIssues === undefined ? {} : { validation: { issues: outcome.validationIssues } }),
     };
+    const pair = (outcomeName, extra = {}, withDecision = true) => ({
+        id: row.id, pairKey: row.pairKey, a: row.a, b: row.b, queue: row.queue,
+        ...(withDecision && row.decision !== undefined ? { decision: row.decision } : {}),
+        outcome: outcomeName, archived: [], ...extra,
+    });
     if (outcome.kind === 'merged') {
         const unitRef = { unitId: outcome.unitId ?? 'unknown', evidenceSha256: outcome.evidenceSha256 ?? 'unknown' };
-        const target = outcome.target?.actual ?? outcome.target?.requested ?? row.decision?.target;
         const finalize = async () => {
             const removed = await pairLedger(io, home, fence).transact(tx => {
                 const current = tx.rows().find(item => item.id === row.id);
@@ -21,31 +24,20 @@ export async function recordRound2Outcome(io, home, now, row, outcome, deferProj
             if (!removed.ok)
                 throw new Error('row changed before commit record: ' + row.id);
             await dropStage(io, home, row.id);
-            await recordPair(io, home, {
-                pairKey: row.pairKey,
-                runId: row.runId ?? 'merge',
-                result: 'merged',
-                ...(target === undefined ? {} : { target }),
-                ...(outcome.unitId === undefined ? {} : { reportRef: outcome.unitId }),
-            });
         };
         if (deferProjection)
-            return { merged: true, finalize, pair: { id: row.id, pairKey: row.pairKey, a: row.a, b: row.b, queue: row.queue, ...(row.decision === undefined ? {} : { decision: row.decision }), outcome: 'merged', archived: outcome.archived ?? [], ...(outcome.lengths === undefined ? {} : { lengths: outcome.lengths }), ...(outcome.unitId === undefined ? {} : { unitId: outcome.unitId }), ...(outcome.target === undefined ? {} : { target: outcome.target }), ...reportExtra } };
-        {
-            await finalize();
-        }
+            return { merged: true, finalize, pair: pair('merged', { ...(outcome.lengths === undefined ? {} : { lengths: outcome.lengths }), ...(outcome.unitId === undefined ? {} : { unitId: outcome.unitId }), ...(outcome.target === undefined ? {} : { target: outcome.target }), ...reportExtra }) };
+        await finalize();
         return {
             merged: true,
-            pair: {
-                id: row.id, pairKey: row.pairKey, a: row.a, b: row.b, queue: row.queue,
-                ...(row.decision === undefined ? {} : { decision: row.decision }),
-                outcome: 'merged', archived: outcome.archived ?? [],
+            pair: pair('merged', {
+                ...(outcome.archived === undefined ? {} : { archived: outcome.archived }),
                 ...(outcome.lengths === undefined ? {} : { lengths: outcome.lengths }),
                 ...reportExtra,
                 ...(outcome.unitId === undefined ? {} : { unitId: outcome.unitId }),
                 ...(outcome.target === undefined ? {} : { target: outcome.target }),
                 ...(outcome.validationPlan === undefined ? {} : { validationPlan: outcome.validationPlan }),
-            },
+            }),
         };
     }
     const failure = outcome.failure ?? { stage: 'author', code: 'merge-failed', message: 'round2 failed', retryable: true, retryFrom: 'agent2' };
@@ -57,7 +49,7 @@ export async function recordRound2Outcome(io, home, now, row, outcome, deferProj
         });
         if (skipped)
             await dropStage(io, home, row.id);
-        return { merged: false, pair: { id: row.id, pairKey: row.pairKey, a: row.a, b: row.b, queue: row.queue, ...(row.decision === undefined ? {} : { decision: row.decision }), outcome: 'failed', archived: [], failure, ...reportExtra } };
+        return { merged: false, pair: pair('failed', { failure, ...reportExtra }) };
     }
     const cas = casExpiredHook(failure.code);
     if (cas !== null) {
@@ -70,7 +62,7 @@ export async function recordRound2Outcome(io, home, now, row, outcome, deferProj
             return moved.ok;
         });
         await dropStage(io, home, row.id);
-        return { merged: false, pair: { id: row.id, pairKey: row.pairKey, a: row.a, b: row.b, queue: row.queue, ...(row.decision === undefined ? {} : { decision: row.decision }), outcome: 'failed', archived: [], failure: terminalFailure, ...reportExtra } };
+        return { merged: false, pair: pair('failed', { failure: terminalFailure, ...reportExtra }) };
     }
     if (failure.code === 'commit-failed' || failure.code === 'validation-failed') {
         // FR-EXEC-11/14: report-only failure. The pair leaves the active queue (so a later scan
@@ -81,7 +73,6 @@ export async function recordRound2Outcome(io, home, now, row, outcome, deferProj
         });
         if (dropped) {
             await dropStage(io, home, row.id, row.stagingRef);
-            await recordPair(io, home, { pairKey: row.pairKey, runId: row.runId ?? 'merge', result: 'failed', ...(row.decision?.target === undefined ? {} : { target: row.decision.target }) });
         }
     }
     if (failure.code === 'source-gone') {
@@ -91,7 +82,7 @@ export async function recordRound2Outcome(io, home, now, row, outcome, deferProj
         });
         if (dropped)
             await dropStage(io, home, row.id, row.stagingRef);
-        return { merged: false, pair: { id: row.id, pairKey: row.pairKey, a: row.a, b: row.b, queue: row.queue, outcome: 'failed', archived: [], failure } };
+        return { merged: false, pair: pair('failed', { failure }, false) };
     }
     const projected = await pairLedger(io, home, fence).transact(tx => {
         const current = tx.rows().find(item => item.id === row.id);
@@ -101,23 +92,10 @@ export async function recordRound2Outcome(io, home, now, row, outcome, deferProj
         return moved.ok && moved.row !== null ? v4ToLegacy(moved.row) : null;
     });
     if (projected === null)
-        return { merged: false, pair: { id: row.id, pairKey: row.pairKey, a: row.a, b: row.b, queue: row.queue, outcome: 'failed', archived: [], failure: { ...failure, code: 'row-changed', message: 'row changed before failure record' }, ...reportExtra } };
-    {
-        await recordPair(io, home, {
-            pairKey: row.pairKey,
-            runId: row.runId ?? 'merge',
-            result: 'failed',
-            ...(row.decision?.target === undefined ? {} : { target: row.decision.target }),
-        });
-    }
+        return { merged: false, pair: pair('failed', { failure: { ...failure, code: 'row-changed', message: 'row changed before failure record' }, ...reportExtra }, false) };
     return {
         merged: false,
-        pair: {
-            id: row.id, pairKey: row.pairKey, a: row.a, b: row.b, queue: row.queue,
-            ...(row.decision === undefined ? {} : { decision: row.decision }),
-            outcome: 'failed', archived: [], failure,
-            ...reportExtra,
-        },
+        pair: pair('failed', { failure, ...reportExtra }),
     };
 }
 //# sourceMappingURL=round2-outcome.js.map

package/lib/types/scan-run.js

@@ -6,7 +6,6 @@ import { pairKey, rowIdOf, } from "./contracts.js";
 import { loadMergeState } from "./state.js";
 import { pairLedger } from "./domain/pair-ledger.js";
 import { presentStage, dropStage } from "./domain/stage-aggregate.js";
-import { recordPair } from "./domain/run-coordinator.js";
 import { v4ToLegacy } from "./domain/row-v4.js";
 import { criteriaFrom } from "./domain/engine-criteria.js";
 import { withDecisionRevisions } from "./revision.js";
@@ -176,7 +175,6 @@ export async function runScan(options) {
                 continue;
             }
             row = projected;
-            await recordPair(options.io, options.home, { pairKey: row.pairKey, runId: row.runId ?? 'merge', result: 'kept' });
             pairs.push(pairOf(row, candidate, 'kept', { ...(round1.decision === undefined ? {} : { decision: round1.decision }), ...(round1.usage === undefined ? {} : { usage: round1.usage }) }));
             totals.kept += 1;
             continue;
@@ -324,7 +322,6 @@ export async function runScan(options) {
             });
             if (dropped) {
                 await dropStage(options.io, options.home, row.id, row.stagingRef);
-                await recordPair(options.io, options.home, { pairKey: row.pairKey, runId: row.runId ?? 'merge', result: 'failed', ...(row.decision?.target === undefined ? {} : { target: row.decision.target }) });
             }
             pairs.push(pairOf(row, candidate, 'failed', { decision: mergeDecision, failure: failed, ...(round2.manifestFiles === undefined ? {} : { manifestFiles: round2.manifestFiles }), ...(round2.criteria === undefined ? {} : { criteria: round2.criteria }), ...(round2.validationIssues === undefined ? {} : { validation: { issues: round2.validationIssues } }) }));
             totals.failed += 1;

package/lib/types/skipped.d.ts

@@ -2,7 +2,6 @@
  * Skipped filtering: a pair the operator marked as not-worth-merging stays out of automatic
  * screening until mergeSkippedTtlDays expires. Explicit /merge pair ignores this set.
  */
-import { type MergeRow } from './contracts.ts';
+import type { MergeRow } from './contracts.ts';
 export declare function skippedPairKeys(rows: readonly MergeRow[], ttlDays: number, now: number): ReadonlySet<string>;
-export declare function isSkippedPair(keys: ReadonlySet<string>, a: string, b: string): boolean;
 //# sourceMappingURL=skipped.d.ts.map

package/lib/types/skipped.js

@@ -1,8 +1,3 @@
-/**
- * Skipped filtering: a pair the operator marked as not-worth-merging stays out of automatic
- * screening until mergeSkippedTtlDays expires. Explicit /merge pair ignores this set.
- */
-import { pairKey } from "./contracts.js";
 export function skippedPairKeys(rows, ttlDays, now) {
     const keys = new Set();
     for (const row of rows) {
@@ -18,7 +13,4 @@ export function skippedPairKeys(rows, ttlDays, now) {
     }
     return keys;
 }
-export function isSkippedPair(keys, a, b) {
-    return keys.has(pairKey(a, b));
-}
 //# sourceMappingURL=skipped.js.map

package/lib/types/staging.d.ts

@@ -43,9 +43,7 @@ export interface StagedView {
     readonly manifest: StagingManifest;
 }
 export declare function readStaging(io: EvolutionIoLike, home: string, runId: string): Promise<Probe<StagedView>>;
-export declare function ensureStaging(io: EvolutionIoLike, home: string, input: CreateStagingInput): Promise<CreateStagingResult>;
 export declare function setStagingTarget(io: EvolutionIoLike, home: string, stageKey: string, target: string, mode?: 'merge-into-existing' | 'create-umbrella' | 'keep'): Promise<boolean>;
-export declare function dropStaging(io: EvolutionIoLike, home: string, stageKey: string): Promise<void>;
 export interface StagingCleanupResult {
     readonly removed: readonly string[];
     readonly kept: readonly string[];

package/lib/types/staging.js

@@ -93,12 +93,6 @@ export async function readStaging(io, home, runId) {
         return probeUnknown('staging manifest is not JSON: ' + (error instanceof Error ? error.message : String(error)));
     }
 }
-export async function ensureStaging(io, home, input) {
-    const existing = await readStaging(io, home, input.runId);
-    if (existing.kind === 'present')
-        return { ok: true, path: stagingRoot(home, input.runId), manifest: existing.value.manifest };
-    return createStaging(io, home, input);
-}
 export async function setStagingTarget(io, home, stageKey, target, mode) {
     const view = await readStaging(io, home, stageKey);
     if (view.kind !== 'present')
@@ -107,9 +101,6 @@ export async function setStagingTarget(io, home, stageKey, target, mode) {
     await io.writeText(join(stagingRoot(home, stageKey), 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
     return true;
 }
-export async function dropStaging(io, home, stageKey) {
-    await io.remove(stagingRoot(home, stageKey));
-}
 /** Remove expired run-level staging trees; `keep` names runs a live row still points at. */
 export async function cleanupExpiredStaging(io, home, now, keep = new Set()) {
     let runs;

package/lib/types/state.d.ts

@@ -8,7 +8,5 @@ export interface LoadMergeStateResult {
 }
 /** Pure read: never writes, never deletes a row. */
 export declare function loadMergeState(io: EvolutionIoLike, home: string): Promise<LoadMergeStateResult>;
-/** Schema probe for doctor; the only other reader of mergeStatePath. */
-export declare function loadStateSchema(io: EvolutionIoLike, home: string): Promise<number | null>;
 export declare function rowsOf(io: EvolutionIoLike, home: string, queue?: MergeQueue): Promise<readonly MergeRow[]>;
 //# sourceMappingURL=state.d.ts.map

package/lib/types/state.js

@@ -54,19 +54,6 @@ export async function loadMergeState(io, home) {
         ...(parsed.note === undefined ? {} : { note: parsed.note }),
     };
 }
-/** Schema probe for doctor; the only other reader of mergeStatePath. */
-export async function loadStateSchema(io, home) {
-    try {
-        const raw = await io.readText(mergeStatePath(home));
-        if (raw === null)
-            return null;
-        const parsed = JSON.parse(raw);
-        return typeof parsed.schemaVersion === 'number' ? parsed.schemaVersion : null;
-    }
-    catch {
-        return null;
-    }
-}
 export async function rowsOf(io, home, queue) {
     const loaded = await loadMergeState(io, home);
     return queue === undefined ? loaded.state.rows : loaded.state.rows.filter(row => row.queue === queue);

package/lib/types/surface/merge-view.d.ts

@@ -1,13 +1,12 @@
 /** Pure wireVersion=1 builders over one MergeSnapshot. No IO, no writes. */
 import type { MergeSnapshot, SnapshotRow, BodyRef } from '../domain/merge-snapshot.ts';
-import type { Facts, QueuePage, RowFact, BodyView, HistoryView, RunView, RunDetail, RunsView, DoctorView, QueueId } from '../wire.ts';
+import type { Facts, QueuePage, RowFact, BodyView, HistoryView, RunDetail, RunsView, DoctorView, QueueId } from '../wire.ts';
 export declare function toRowFact(row: SnapshotRow): RowFact;
 export declare function buildFacts(snapshot: MergeSnapshot): Facts;
 export declare function parseCursor(cursor: string, snapshot: MergeSnapshot): number;
 export declare function buildQueuePage(snapshot: MergeSnapshot, queue: QueueId, expiredOnly: boolean, cursor?: string, limit?: number): QueuePage;
 export declare function buildBodyView(snapshot: MergeSnapshot, ref: BodyRef, text: string): BodyView;
 export declare function buildHistoryView(snapshot: MergeSnapshot): HistoryView;
-export declare function buildRunView(snapshot: MergeSnapshot, runId: string): RunView | null;
 export declare function buildRunDetail(snapshot: MergeSnapshot, runId: string): RunDetail | null;
 export declare function buildRunsView(snapshot: MergeSnapshot): RunsView;
 export declare function buildDoctorView(snapshot: MergeSnapshot): DoctorView;

package/lib/types/surface/merge-view.js

@@ -130,7 +130,6 @@ export function buildBodyView(snapshot, ref, text) {
     return { wireVersion: 1, readAt: snapshot.readAt, name: ref.name, side: ref.side, text: body, markdown: true, truncated, totalBytes: Buffer.byteLength(text, 'utf8') };
 }
 export function buildHistoryView(snapshot) { return { wireVersion: 1, readAt: snapshot.readAt, items: snapshot.history }; }
-export function buildRunView(snapshot, runId) { const run = snapshot.runs.find(item => item.record.id === runId); return run === undefined ? null : runView(run, snapshot.readAt); }
 export function buildRunDetail(snapshot, runId) {
     const run = snapshot.runs.find(item => item.record.id === runId);
     if (run === undefined)

package/lib/types/undo-operation.js

@@ -3,7 +3,6 @@ import { readCommitReceipts } from "./commit-receipt.js";
 import { undoMergeReceipt } from "./undo-merge.js";
 import { readUndoJournal, writeUndoJournal } from "./domain/undo-journal.js";
 import { readUndoReceipt, writeUndoReceipt } from "./domain/undo-receipt.js";
-import { recordPair } from "./domain/pair-index-store.js";
 import { readRunMeta, writeRunMeta } from "./domain/run-coordinator.js";
 import { readUnitEvidence } from '@lmzhen/dsh-evolution-core/write';
 import { evidenceSha256 as unitEvidenceDigest } from "./domain/evidence-hash.js";
@@ -115,9 +114,6 @@ async function runUndoSteps(options) {
         }
         const existing = await readUndoReceipt(options.io, options.home, options.runId, pairKey);
         if (existing !== null) {
-            await markPhase('pair-index');
-            await options.onPhase?.('pair-index', pairKey);
-            await recordPair(options.io, options.home, { pairKey, runId: options.runId, result: 'undone', target: receipt.target });
             await markPhase('run-meta');
             await options.onPhase?.('run-meta', pairKey);
             await settleRun(options.io, options.home, options.runId, pairKey, allPairKeys, options.now());
@@ -130,9 +126,6 @@ async function runUndoSteps(options) {
         if (checked.done) {
             await options.onPhase?.('receipt', pairKey);
             await writeUndoReceipt(options.io, options.home, { version: 1, runId: options.runId, ...(receipt.parentRunId === undefined ? {} : { parentRunId: receipt.parentRunId }), pairKey, unitId: receipt.unitId, evidenceSha256: receipt.evidenceSha256 ?? unitEvidenceDigest(checked.evidence), target: receipt.target, sources: checked.evidence.sources.map(source => source.name), restoredTargetHash: receipt.create ? null : digest(checked.evidence.target.before), restoredSourceHashes: Object.fromEntries(checked.evidence.sources.map(source => [source.name, contentHash(source.before)])), at: options.now() });
-            await markPhase('pair-index');
-            await options.onPhase?.('pair-index', pairKey);
-            await recordPair(options.io, options.home, { pairKey, runId: options.runId, result: 'undone', target: receipt.target });
             await markPhase('run-meta');
             await options.onPhase?.('run-meta', pairKey);
             await settleRun(options.io, options.home, options.runId, pairKey, allPairKeys, options.now());
@@ -156,8 +149,6 @@ async function runUndoSteps(options) {
         await writeUndoJournal(options.io, options.home, { version: 1, runId: options.runId, phase: 'running', pairs: pairs.map(pair => pair.pairKey === pairKey ? phase('receipt') : pair), updatedAt: new Date(options.now()).toISOString() });
         await options.onPhase?.('receipt', pairKey);
         await writeUndoReceipt(options.io, options.home, { version: 1, runId: options.runId, ...(receipt.parentRunId === undefined ? {} : { parentRunId: receipt.parentRunId }), pairKey, unitId: receipt.unitId, evidenceSha256: receipt.evidenceSha256 ?? unitEvidenceDigest(checked.evidence), target: receipt.target, sources: checked.evidence.sources.map(source => source.name), restoredTargetHash: receipt.create ? null : digest(checked.evidence.target.before), restoredSourceHashes: Object.fromEntries(checked.evidence.sources.map(source => [source.name, contentHash(source.before)])), at: options.now() });
-        await options.onPhase?.('pair-index', pairKey);
-        await recordPair(options.io, options.home, { pairKey, runId: options.runId, result: 'undone', target: receipt.target });
         await options.onPhase?.('run-meta', pairKey);
         await settleRun(options.io, options.home, options.runId, pairKey, allPairKeys, options.now());
         undone.push(pairKey);

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

@@ -165,6 +165,12 @@ export declare class MergeUnitTransactions implements UnitTransaction {
         runId: string;
     }): Promise<UnitEvidenceRecord | UnitEvidenceRecord[] | null>;
     private withRecoveryFence;
+    /** Acquire the one tree fence (or a HomeAuthority fallback) and prove it is held. */
+    private acquireTreeFence;
+    /** Finish the idempotent support writes from the prepared snapshot, or name the drift. */
+    private completeSupport;
+    /** The complete evidence record both settlement paths write. */
+    private evidenceFor;
     finalize(unitId: string): Promise<{
         ok: true;
         evidence: UnitEvidenceRecord;

package/lib/types/unit-protocol.js

@@ -157,22 +157,10 @@ export class MergeUnitTransactions {
             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 fallback = new HomeAuthority({ home: this.options.home, waitMs: this.options.waitMs ?? 5000 });
-                const fallbackLease = await fallback.lease("tree").catch(() => undefined);
-                if (fallbackLease === undefined)
-                    return { ok: false, code: "unit-fence-failed", message: "tree lock unavailable" };
-                fenceLease = { lock: leaseAsTreeLock(fallbackLease), release: async () => { await fallbackLease.release(); } };
-                lock = fenceLease.lock;
-                this.options.onLock?.("tree");
-            }
-            if (!(await lock.assertHeld()))
-                return { ok: false, code: "unit-fence-failed", message: "tree fence lost" };
+            const acquired = await this.acquireTreeFence();
+            fenceLease = acquired.fenceLease;
+            lock = acquired.lock;
+            this.options.onLock?.("tree");
             stage = 'claim';
             claim = await this.options.claim.acquire(stored.plan.target, stored.plan.runId);
             this.options.onLock?.("claim");
@@ -310,6 +298,63 @@ export class MergeUnitTransactions {
             await lease.release();
         }
     }
+    /** Acquire the one tree fence (or a HomeAuthority fallback) and prove it is held. */
+    async acquireTreeFence() {
+        let fenceLease;
+        if (this.options.fence !== undefined) {
+            fenceLease = await this.options.fence.acquire();
+        }
+        else {
+            const fallback = new HomeAuthority({ home: this.options.home, waitMs: this.options.waitMs ?? 5000 });
+            const fallbackLease = await fallback.lease("tree").catch(() => undefined);
+            if (fallbackLease === undefined)
+                throw new Error("tree lock unavailable");
+            fenceLease = { lock: leaseAsTreeLock(fallbackLease), release: async () => { await fallbackLease.release(); } };
+        }
+        if (!(await fenceLease.lock.assertHeld()))
+            throw new Error("tree fence lost");
+        return { fenceLease, lock: fenceLease.lock };
+    }
+    /** Finish the idempotent support writes from the prepared snapshot, or name the drift. */
+    async completeSupport(snapshot, journal) {
+        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())
+            return { ok: true };
+        if (!["support-pending", "sources-archived", "unit-written"].includes(journal.phase) || this.options.backend.restoreSupportFile === undefined)
+            return { ok: false, 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) })));
+        return supportMatches() ? { ok: true } : { ok: false, message: "support file could not be completed from the prepared snapshot" };
+    }
+    /** The complete evidence record both settlement paths write. */
+    async evidenceFor(unitId, snapshot, journal, targetAfter) {
+        const checkpoints = journal.checkpoints ?? [];
+        return {
+            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(),
+        };
+    }
     async finalize(unitId) {
         return await this.withRecoveryFence(async () => this.finalizeUnlocked(unitId));
     }
@@ -347,42 +392,10 @@ export class MergeUnitTransactions {
         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(),
-        };
+        const support = await this.completeSupport(snapshot, journal);
+        if (!support.ok)
+            return { ok: false, code: "unit-rollback-blocked", message: support.message };
+        const evidence = await this.evidenceFor(unitId, snapshot, journal, (await this.options.backend.readSkill(snapshot.target)) ?? "");
         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);
@@ -420,42 +433,10 @@ export class MergeUnitTransactions {
         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(),
-        };
+        const support = await this.completeSupport(snapshot, journal);
+        if (!support.ok)
+            return { ok: false, code: "unit-rollback-blocked", message: support.message };
+        const evidence = await this.evidenceFor(unitId, snapshot, journal, targetAfter);
         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 };
@@ -473,21 +454,10 @@ export class MergeUnitTransactions {
         let lock;
         let claim;
         try {
-            if (this.options.fence !== undefined) {
-                fenceLease = await this.options.fence.acquire();
-                lock = fenceLease.lock;
-            }
-            else {
-                const fallback = new HomeAuthority({ home: this.options.home, waitMs: this.options.waitMs ?? 5000 });
-                const fallbackLease = await fallback.lease("tree").catch(() => undefined);
-                if (fallbackLease === undefined)
-                    return { ok: false, code: "unit-fence-failed", message: "tree lock unavailable" };
-                fenceLease = { lock: leaseAsTreeLock(fallbackLease), release: async () => { await fallbackLease.release(); } };
-                lock = fenceLease.lock;
-            }
+            const acquired = await this.acquireTreeFence();
+            fenceLease = acquired.fenceLease;
+            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);

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.47.0",
+  "version": "0.48.0",
   "publishConfig": {
     "access": "public"
   },
@@ -34,9 +34,9 @@
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.5",
-    "@lmzhen/dsh-evolution-core": "^0.47.0",
-    "@lmzhen/dsh-evolution-commands": "^0.47.0",
-    "@lmzhen/dsh-evolution-merge-engine": "0.47.0"
+    "@lmzhen/dsh-evolution-core": "^0.48.0",
+    "@lmzhen/dsh-evolution-commands": "^0.48.0",
+    "@lmzhen/dsh-evolution-merge-engine": "0.48.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.5"

package/lib/types/commit-recovery.d.ts

@@ -1,14 +0,0 @@
-import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
-import type { CommitJournal } from './domain/commit-journal.ts';
-export interface CommitRecoveryReport {
-    readonly runId: string;
-    readonly phase: CommitJournal['phase'] | 'unknown';
-    readonly action: string;
-    readonly ok: boolean;
-    readonly target?: string;
-    readonly sources?: readonly string[];
-    readonly journalPath?: string;
-    readonly unitId?: string;
-}
-export declare function recoverCommitJournals(io: EvolutionIoLike, home: string, now: number, isActive?: (runId: string) => boolean): Promise<readonly CommitRecoveryReport[]>;
-//# sourceMappingURL=commit-recovery.d.ts.map