@lmzhen/dsh-evolution-merge 0.46.0 → 0.48.0

package/lib/types/state.js

@@ -2,12 +2,12 @@
  * The one merge-state ledger: <home>/merge/merge-state.json.
  *
  * Reads are pure projections (no write, no reconciliation side effect). Every write goes
- * through mutateMergeState and a single transactIo, so there is no second file and no
+ * through pairLedger and a single transactIo, so there is no second file and no
  * incremental writer. A row's queue is always derived from its state on read; a hand-edited
  * mismatch is repaired by the next write, never by a GET.
  */
 import { join } from 'node:path';
-import { MERGE_STATE_VERSION, queueOf, } from "./contracts.js";
+import { MERGE_STATE_VERSION, } from "./contracts.js";
 import { parseLedger } from "./domain/ledger.js";
 import { parseV4State } from "./domain/schema4.js";
 import { v4ToLegacy } from "./domain/row-v4.js";
@@ -54,82 +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;
-    }
-}
-/** G3-5 runtime write API: only createVerify/createSkipped/transition. v2 writes are rejected. */
-export async function transactRows(_io, _home, _fn) {
-    throw new Error('legacy-writer-removed');
-}
-/** The ONE write point. The callback returns the whole row set, not a delta. */
-export async function mutateMergeState(_io, _home, _now, _fn) {
-    throw new Error('legacy-writer-removed');
-}
-export async function upsertRow(io, home, now, row, expect = 'any', cas) {
-    return await mutateMergeState(io, home, now, (rows) => {
-        const index = rows.findIndex(item => item.pairKey === row.pairKey);
-        const current = index < 0 ? undefined : rows[index];
-        if (cas !== undefined && ((cas === null && current !== undefined) || (cas !== null && current?.updatedAt !== cas))) {
-            return { rows, result: { ok: false, current: current ?? row } };
-        }
-        if (current !== undefined && expect !== 'any' && (expect === 'absent' || queueOf(current.state) !== expect)) {
-            return { rows, result: { ok: false, current } };
-        }
-        if (current === undefined && expect !== 'any' && expect !== 'absent' && expect !== 'verify') {
-            return { rows, result: { ok: false, current: row } };
-        }
-        const normalized = { ...row, queue: queueOf(row.state) };
-        const next = [...rows];
-        if (current === undefined)
-            next.push(normalized);
-        else
-            next[index] = { ...normalized, createdAt: current.createdAt };
-        return { rows: next, result: { ok: true } };
-    });
-}
-export async function moveRow(io, home, now, id, patch) {
-    return await mutateMergeState(io, home, now, (rows) => {
-        const index = rows.findIndex(item => item.id === id);
-        if (index < 0)
-            return { rows, result: undefined };
-        const current = rows[index];
-        const state = patch.state ?? current.state;
-        const next = {
-            ...current,
-            state,
-            queue: queueOf(state),
-            updatedAt: new Date(now()).toISOString(),
-            ...(patch.failure === undefined ? {} : { failure: patch.failure }),
-            ...(patch.runId === undefined ? {} : { runId: patch.runId }),
-            ...(patch.unitId === undefined ? {} : { unitId: patch.unitId }),
-            ...(patch.origin === undefined ? {} : { origin: patch.origin }),
-            ...(patch.attempts === undefined ? {} : { attempts: patch.attempts }),
-        };
-        const copy = [...rows];
-        copy[index] = next;
-        return { rows: copy, result: next };
-    });
-}
-/** G3-5 v3-aware drop: only terminal events. */
-export async function dropRowV3(_io, _home, _id, _event, _unitId = 'unknown') {
-    throw new Error('legacy-writer-removed');
-}
-export async function dropRow(io, home, now, id) {
-    return await mutateMergeState(io, home, now, (rows) => {
-        const next = rows.filter(item => item.id !== id);
-        return { rows: next, result: next.length !== rows.length };
-    });
-}
 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,12 +130,11 @@ 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)
         return null;
-    return { ...runView(run, snapshot.readAt, true), ...(run.meta === null ? {} : { meta: { phase: run.meta.phase, ...(run.meta.approval === undefined ? {} : { approval: run.meta.approval }) } }), ...(run.reportRef === null ? {} : { reportRef: run.reportRef }), pairs: run.pairs.map(pair => ({ pairKey: pair.pairKey, a: pair.pairKey.split('\u0000')[0] ?? '', b: pair.pairKey.split('\u0000')[1] ?? '', outcome: pair.result === 'kept' ? 'kept' : pair.result === 'failed' ? 'failed' : pair.result === 'cancelled' ? 'cancelled' : 'merged', ...(pair.target === undefined ? {} : { target: { requested: pair.target } }) })), pairsTruncated: false };
+    return { ...runView(run, snapshot.readAt, true), ...(run.meta === null ? {} : { meta: { phase: run.meta.phase, ...(run.meta.approval === undefined ? {} : { approval: run.meta.approval }) } }), ...(run.reportRef === null ? {} : { reportRef: run.reportRef }), pairs: run.pairs.map(pair => ({ pairKey: pair.pairKey, a: pair.pairKey.split('\u0000')[0] ?? '', b: pair.pairKey.split('\u0000')[1] ?? '', outcome: pair.result === 'kept' ? 'kept' : pair.result === 'failed' ? 'failed' : pair.result === 'cancelled' ? 'cancelled' : pair.result === 'undone' ? 'undone' : 'merged', ...(pair.target === undefined ? {} : { target: { requested: pair.target } }) })), pairsTruncated: false };
 }
 export function buildRunsView(snapshot) { return { wireVersion: 1, readAt: snapshot.readAt, runs: [...snapshot.runs].sort((a, b) => b.record.startedAt - a.record.startedAt).map(run => runView(run, snapshot.readAt, true)) }; }
 export function buildDoctorView(snapshot) {

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

package/lib/types/commit-recovery.js

@@ -1,96 +0,0 @@
-/** Startup replay for non-terminal commit journals: report only, never write skills. */
-import { join } from 'node:path';
-import { writeJournal } from "./domain/commit-journal-store.js";
-import { readCommitReceipt } from "./commit-receipt.js";
-import { readUnitEvidence } from '@lmzhen/dsh-evolution-core/write';
-export async function recoverCommitJournals(io, home, now, isActive) {
-    const dir = join(home, 'merge', 'journals');
-    const reports = [];
-    let files = [];
-    if (await io.exists(dir)) {
-        try {
-            files = (await io.list(dir)).filter(name => name.endsWith('.json'));
-        }
-        catch {
-            reports.push({ runId: '(list)', phase: 'unknown', action: 'journal-list-failed', ok: false, journalPath: dir });
-        }
-    }
-    for (const file of files) {
-        const path = join(dir, file);
-        try {
-            let journal;
-            try {
-                journal = JSON.parse(await io.readText(path) ?? '');
-            }
-            catch {
-                reports.push({ runId: file.replace(/\.json$/, ''), phase: 'unknown', action: 'journal-unreadable', ok: false, journalPath: path });
-                continue;
-            }
-            if (isActive?.(journal.runId) === true) {
-                reports.push({ runId: journal.runId, phase: journal.phase, action: 'skipped-active-run', ok: true, target: journal.target, sources: journal.sources, journalPath: path });
-                continue;
-            }
-            let receipt = null;
-            try {
-                receipt = await readCommitReceipt(io, home, journal.runId, journal.target);
-            }
-            catch {
-                reports.push({ runId: journal.runId, phase: journal.phase, action: 'receipt-read-failed', ok: false, target: journal.target, sources: journal.sources, journalPath: path });
-                continue;
-            }
-            if (receipt !== null) {
-                await writeJournal(io, home, { ...journal, phase: 'committed', unitId: receipt.unitId, updatedAt: new Date(now).toISOString() });
-                reports.push({ runId: journal.runId, phase: journal.phase, action: 'receipt-committed', ok: true, target: journal.target, sources: journal.sources, journalPath: path, unitId: receipt.unitId });
-                continue;
-            }
-            if (journal.phase === 'committed') {
-                reports.push({ runId: journal.runId, phase: journal.phase, action: 'receipt-missing', ok: false, target: journal.target, sources: journal.sources, journalPath: path });
-                continue;
-            }
-            if (journal.phase === 'failed' || journal.phase === 'rolled-back')
-                continue;
-            reports.push({
-                runId: journal.runId, phase: journal.phase, action: 'manual-required', ok: false,
-                target: journal.target, sources: journal.sources, journalPath: path,
-            });
-        }
-        catch (error) {
-            reports.push({ runId: file.replace(/\.json$/, ''), phase: 'unknown', action: 'recovery-error: ' + (error instanceof Error ? error.message : String(error)), ok: false, journalPath: path });
-        }
-    }
-    const unitDir = join(home, 'merge', 'unit-journals');
-    if (await io.exists(unitDir)) {
-        let unitFiles = [];
-        try {
-            unitFiles = (await io.list(unitDir)).filter(name => name.endsWith('.json'));
-        }
-        catch { /* no unit journals */ }
-        for (const file of unitFiles) {
-            const path = join(unitDir, file);
-            try {
-                const journal = JSON.parse(await io.readText(path) ?? '');
-                const evidence = await readUnitEvidence(io, home, journal.unitId);
-                if (evidence !== null) {
-                    reports.push({ runId: journal.runId, phase: 'committed', action: 'unit-committed', ok: true, target: journal.target, sources: journal.sources, journalPath: path, unitId: journal.unitId });
-                    continue;
-                }
-                if (journal.phase === 'committed') {
-                    reports.push({ runId: journal.runId, phase: 'committed', action: 'unit-evidence-missing', ok: false, target: journal.target, sources: journal.sources, journalPath: path, unitId: journal.unitId });
-                    continue;
-                }
-                if (journal.phase === 'failed' || journal.phase === 'rolled-back')
-                    continue;
-                reports.push({ runId: journal.runId, phase: journal.phase, action: 'unit-manual-required', ok: false, target: journal.target, sources: journal.sources, journalPath: path, unitId: journal.unitId });
-            }
-            catch {
-                reports.push({ runId: '(unit)', phase: 'unknown', action: 'unit-journal-unreadable', ok: false, journalPath: path });
-            }
-        }
-    }
-    try {
-        await io.writeText(join(home, 'merge', 'recovery.json'), JSON.stringify(reports, null, 2));
-    }
-    catch { /* report file is best-effort; reports are still returned */ }
-    return reports;
-}
-//# sourceMappingURL=commit-recovery.js.map

package/lib/types/coordinator.d.ts

@@ -1,77 +0,0 @@
-/**
- * Pure merge transition table. No io, no run shell, no subagents.
- *
- * Every transition returns the whole next row (or a drop), so the caller can persist it
- * through one state transaction. Invalid transitions are refused by name;
- * a caller never "repairs" a row by guessing which state the operator meant.
- */
-import { type MergeDecision, type MergeFailure, type MergeRow } from './contracts.ts';
-export type MergeEvent = {
-    readonly type: 'candidate';
-    readonly a: string;
-    readonly b: string;
-    readonly at: string;
-} | {
-    readonly type: 'round1-keep';
-    readonly at: string;
-} | {
-    readonly type: 'round1-merge';
-    readonly approval: 'on' | 'off';
-    readonly decision?: MergeDecision;
-    readonly stagingRef?: string;
-    readonly stagingExpiresAt?: number;
-    readonly sourceRevision?: string;
-    readonly targetRevision?: string;
-    readonly at: string;
-} | {
-    readonly type: 'round1-fail';
-    readonly failure: MergeFailure;
-    readonly at: string;
-} | {
-    readonly type: 'approve';
-    readonly runId?: string;
-    readonly at: string;
-} | {
-    readonly type: 'reject';
-    readonly at: string;
-} | {
-    readonly type: 'round2-fail';
-    readonly failure: MergeFailure;
-    readonly at: string;
-} | {
-    readonly type: 'round2-cancel';
-    readonly at: string;
-} | {
-    readonly type: 'round2-success';
-    readonly unitId?: string;
-    readonly at: string;
-} | {
-    readonly type: 'restore';
-    readonly at: string;
-} | {
-    readonly type: 'source-gone';
-    readonly at: string;
-} | {
-    readonly type: 'target-taken';
-    readonly at: string;
-} | {
-    readonly type: 'source-changed';
-    readonly at: string;
-} | {
-    readonly type: 'gate-keep';
-    readonly a: string;
-    readonly b: string;
-    readonly reason?: string;
-    readonly at: string;
-};
-export type TransitionResult = {
-    readonly ok: true;
-    readonly row: MergeRow | null;
-} | {
-    readonly ok: false;
-    readonly code: 'invalid-transition';
-    readonly message: string;
-};
-/** Legacy v2 projection only; runtime writes must use transitionV3/RowTx. */
-export declare function transitionLegacyForProjection(current: MergeRow | undefined, event: MergeEvent): TransitionResult;
-//# sourceMappingURL=coordinator.d.ts.map