@lmzhen/dsh-evolution-merge 0.47.0 → 0.49.0

package/lib/types/domain/row.js

@@ -1,111 +1,2 @@
-/** Pure v2 row transitions for G1 cutover. No IO. */
-import { pairKey, rowIdOf } from "../contracts.js";
-import { queueOf, transition as stateTransition } from "./state.js";
-function base(row, at) {
-    return {
-        id: row.id, pairKey: row.pairKey, a: row.a, b: row.b,
-        state: row.state, queue: row.queue, createdAt: row.createdAt, updatedAt: at,
-        ...(row.runId === undefined ? {} : { runId: row.runId }),
-        ...(row.unitId === undefined ? {} : { unitId: row.unitId }),
-        ...(row.origin === undefined ? {} : { origin: row.origin }),
-        ...(row.decision === undefined ? {} : { decision: row.decision }),
-        ...(row.sourceRevision === undefined ? {} : { sourceRevision: row.sourceRevision }),
-        ...(row.targetRevision === undefined ? {} : { targetRevision: row.targetRevision }),
-        ...(row.attempts === undefined ? {} : { attempts: row.attempts }),
-        ...(row.stagingRef === undefined ? {} : { stagingRef: row.stagingRef }),
-        ...(row.stagingExpiresAt === undefined ? {} : { stagingExpiresAt: row.stagingExpiresAt }),
-        ...(row.expired === undefined ? {} : { expired: row.expired }),
-        ...(row.target === undefined ? {} : { target: row.target }),
-        ...(row.reason === undefined ? {} : { reason: row.reason }),
-    };
-}
-function next(row, at, state, patch = {}) {
-    return { ok: true, row: { ...base(row, at), state, queue: queueOf(state), ...patch } };
-}
-function invalid(event, state) {
-    return { ok: false, code: 'invalid-transition', message: 'cannot apply ' + event.type + ' to ' + (state ?? 'no row') };
-}
-export function transitionRow(current, event) {
-    if (event.type === 'candidate') {
-        if (current !== undefined)
-            return { ok: true, row: current };
-        const key = pairKey(event.a, event.b);
-        return { ok: true, row: { id: rowIdOf(key), pairKey: key, a: event.a, b: event.b, state: 'verify', queue: 'verify', createdAt: event.at, updatedAt: event.at } };
-    }
-    if (event.type === 'source-gone')
-        return { ok: true, row: null };
-    if (event.type === 'gate-keep') {
-        if (current !== undefined)
-            return { ok: true, row: current };
-        const key = pairKey(event.a, event.b);
-        return { ok: true, row: { id: rowIdOf(key), pairKey: key, a: event.a, b: event.b, state: 'skipped', queue: 'skipped', origin: 'agent', createdAt: event.at, updatedAt: event.at } };
-    }
-    if (current === undefined)
-        return invalid(event, undefined);
-    if (event.type === 'discard') {
-        return current.state === 'pending' || current.state === 'approved' || current.state === 'fuse'
-            ? { ok: true, row: null }
-            : invalid(event, current.state);
-    }
-    if (event.type === 'restore') {
-        return current.state === 'skipped' ? next(current, event.at, 'verify') : invalid(event, current.state);
-    }
-    if (event.type === 'target-taken' || event.type === 'source-changed') {
-        return current.state === 'pending' || current.state === 'approved' || current.state === 'fuse'
-            ? next(current, event.at, current.state, { expired: event.type })
-            : invalid(event, current.state);
-    }
-    if (event.type === 'staging-expired') {
-        return current.state === 'fuse' || current.state === 'approved'
-            ? next(current, event.at, 'approved')
-            : invalid(event, current.state);
-    }
-    if (event.type === 'round2-cancel' || event.type === 'timeout' || event.type === 'cancel') {
-        return current.state === 'fuse' ? next(current, event.at, 'approved') : { ok: true, row: current };
-    }
-    const mapped = event.type === 'round2-success'
-        ? { type: 'round2-merged' }
-        : event.type === 'round2-fail'
-            ? { type: 'round2-fail' }
-            : event.type === 'round1-merge'
-                ? { type: 'round1-merge', approval: event.approval === 'on' }
-                : event.type === 'round1-start'
-                    ? { type: 'round1-start' }
-                    : event.type === 'round2-start'
-                        ? { type: 'round2-start' }
-                        : event.type === 'round1-keep'
-                            ? { type: 'round1-keep' }
-                            : event.type === 'round1-fail'
-                                ? { type: 'round1-fail' }
-                                : event.type === 'approve'
-                                    ? { type: 'approve' }
-                                    : { type: 'reject' };
-    const moved = stateTransition(current.state, mapped);
-    if (!moved.ok)
-        return invalid(event, current.state);
-    if (moved.state === null)
-        return { ok: true, row: null };
-    const patch = {};
-    if (event.type === 'round1-merge') {
-        if (event.decision !== undefined)
-            patch.decision = event.decision;
-        if (event.stagingRef !== undefined)
-            patch.stagingRef = event.stagingRef;
-        if (event.stagingExpiresAt !== undefined)
-            patch.stagingExpiresAt = event.stagingExpiresAt;
-    }
-    if (event.type === 'approve' && event.runId !== undefined)
-        patch.runId = event.runId;
-    if (event.type === 'round1-fail' || event.type === 'round2-fail') {
-        patch.failure = event.failure;
-        patch.attempts = (current.attempts ?? 0) + 1;
-    }
-    if (event.type === 'round1-keep')
-        patch.origin = 'agent';
-    if (event.type === 'reject')
-        patch.origin = 'human';
-    if (event.type === 'round2-success' && event.unitId !== undefined)
-        patch.unitId = event.unitId;
-    return next(current, event.at, moved.state, patch);
-}
+export {};
 //# sourceMappingURL=row.js.map

package/lib/types/domain/run-coordinator.d.ts

@@ -28,29 +28,6 @@ export interface MergeRunMeta {
     readonly createdAt: string;
     readonly updatedAt: string;
 }
-export interface PairIndexEntry {
-    readonly version: 1;
-    readonly runId: string;
-    readonly pairKey: string;
-    readonly a: string;
-    readonly b: string;
-    readonly target: string;
-    readonly targetRevision?: string;
-    readonly sourceRevisions?: Readonly<Record<string, string>>;
-    readonly state: 'pending' | 'approved' | 'fused' | 'skipped';
-    readonly updatedAt: string;
-}
-export interface RunCoordinatorRead {
-    readonly runId: string;
-    readonly meta: MergeRunMeta | null;
-    readonly pairs: readonly PairIndexEntry[];
-    readonly consistency: 'eventual';
-}
-export interface RunCoordinator {
-    begin(meta: MergeRunMeta): Promise<void>;
-    recordPair(entry: PairIndexEntry): Promise<void>;
-    read(runId: string): Promise<RunCoordinatorRead>;
-}
 export declare function runMetaPath(home: string, runId: string): string;
 export declare function writeRunMeta(io: EvolutionIoLike, home: string, meta: MergeRunMeta, fence?: {
     run<T>(body: () => Promise<T>): Promise<T>;
@@ -60,5 +37,4 @@ export declare function readRunMeta(io: EvolutionIoLike, home: string, runId: st
 export declare function readRunMetas(io: EvolutionIoLike, home: string): Promise<readonly MergeRunMeta[]>;
 /** The run currently working on this pair, if any (pairKey is written at run begin). */
 export declare function inFlightPairRun(metas: readonly MergeRunMeta[], pairKeyValue: string): MergeRunMeta | undefined;
-export { recordPair } from './pair-index-store.ts';
 //# sourceMappingURL=run-coordinator.d.ts.map

package/lib/types/domain/run-coordinator.js

@@ -74,5 +74,4 @@ export async function readRunMetas(io, home) {
 export function inFlightPairRun(metas, pairKeyValue) {
     return metas.find(meta => meta.phase === 'running' && meta.pairKey === pairKeyValue);
 }
-export { recordPair } from "./pair-index-store.js";
 //# sourceMappingURL=run-coordinator.js.map

package/lib/types/domain/stage-aggregate.d.ts

@@ -1,12 +1,6 @@
 import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 import { type StagingEntry } from './staging-index.ts';
 import { readStaging, type CreateStagingInput, type CreateStagingResult } from '../staging.ts';
-/**
- * Old production staging writers (grep baseline at Batch 1b-1). Their production
- * path is merge/staging-index + runs/<runId>/pairs/<hash>. adoptLegacy must never
- * call any of these; it only writes merge/.shadow/staging-index.
- */
-export declare const LEGACY_STAGING_WRITER_FILES: readonly ["src/scan-ports.ts", "src/scan-run.ts", "src/staging.ts", "src/new-child-authoring.ts", "src/domain/staging-index.ts", "src/state.ts", "src/domain/state-bootstrap.ts"];
 export type StageState = 'reserved' | 'present' | 'expired' | 'lost';
 export interface StageEntry {
     readonly version: 1;
@@ -33,48 +27,12 @@ export interface ShadowAdoptResult {
     readonly shadowPath: string;
     readonly wrote: boolean;
 }
-export interface StageAggregateRead {
-    readonly entries: readonly StageEntry[];
-    readonly shadowPath: string;
-}
-export declare function shadowStagingIndexPath(home: string, rowId: string): string;
-export declare function shadowStagingRoot(home: string): string;
-/** Read-only adoption into the shadow index; never writes production staging-index. */
-export declare function adoptLegacy(io: EvolutionIoLike, home: string): Promise<ShadowAdoptResult>;
-export declare function readShadowStageAggregate(io: EvolutionIoLike, home: string, rowId?: string): Promise<StageAggregateRead>;
-/** 1b-2b execution order; kept here so 1b-2a tests can pin the contract. */
-export declare const STAGE_WRITE_ORDER: readonly ["index:reserved", "tree", "index:present"];
-export type StageAdmission = {
-    readonly ok: true;
-} | {
-    readonly ok: false;
-    readonly message: string;
-};
-export declare function admitStage(rowState: string): StageAdmission;
-export type ApprovedReservedPlan = {
-    readonly kind: 'transition-fuse';
-    readonly rowId: string;
-    readonly ref: string;
-    readonly expiresAt: number;
-} | {
-    readonly kind: 'write-present';
-    readonly rowId: string;
-    readonly ref: string;
-} | {
-    readonly kind: 'drop-orphan';
-    readonly rowId: string;
-} | {
-    readonly kind: 'none';
-};
-export declare function planApprovedReserved(rowState: string, entry: StageEntry | null): ApprovedReservedPlan;
 /** Production adoption for 1b-2b normalize; writes the existing staging-index, not shadow. */
 export declare function adoptLegacyProduction(io: EvolutionIoLike, home: string): Promise<ShadowAdoptResult>;
 /** Production stage-tree facade. These wrappers keep the low-level tree module private to StageAggregate. */
-export declare function ensureStageTree(io: EvolutionIoLike, home: string, input: CreateStagingInput): Promise<CreateStagingResult>;
 export declare function createStageTree(io: EvolutionIoLike, home: string, input: CreateStagingInput): Promise<CreateStagingResult>;
 export declare function readStageTree(io: EvolutionIoLike, home: string, runId: string): Promise<Awaited<ReturnType<typeof readStaging>>>;
 export declare function setStageTreeTarget(io: EvolutionIoLike, home: string, stageKey: string, target: string, mode?: 'merge-into-existing' | 'create-umbrella' | 'keep'): Promise<boolean>;
-export declare function dropStageTree(io: EvolutionIoLike, home: string, stageKey: string): Promise<void>;
 export declare function writeStageIndex(io: EvolutionIoLike, home: string, entry: StagingEntry): Promise<void>;
 export declare function readStageIndex(io: EvolutionIoLike, home: string, rowId: string, now?: number): Promise<StagingEntry | null>;
 export declare function readStageEntry(io: EvolutionIoLike, home: string, rowId: string): Promise<StageEntry | null>;

package/lib/types/domain/stage-aggregate.js

@@ -3,27 +3,7 @@ import { readTextOrNull, listOrEmpty } from "./read-probe.js";
 import { isAbsolute, join } from 'node:path';
 import { readPairLedger } from "./pair-ledger.js";
 import { readStagingIndex, writeStagingIndex } from "./staging-index.js";
-import { createStaging, dropStaging, ensureStaging, readStaging, setStagingTarget } from "../staging.js";
-/**
- * Old production staging writers (grep baseline at Batch 1b-1). Their production
- * path is merge/staging-index + runs/<runId>/pairs/<hash>. adoptLegacy must never
- * call any of these; it only writes merge/.shadow/staging-index.
- */
-export const LEGACY_STAGING_WRITER_FILES = [
-    'src/scan-ports.ts',
-    'src/scan-run.ts',
-    'src/staging.ts',
-    'src/new-child-authoring.ts',
-    'src/domain/staging-index.ts',
-    'src/state.ts',
-    'src/domain/state-bootstrap.ts',
-];
-export function shadowStagingIndexPath(home, rowId) {
-    return join(home, 'merge', '.shadow', 'staging-index', encodeURIComponent(rowId) + '.json');
-}
-export function shadowStagingRoot(home) {
-    return join(home, 'merge', '.shadow', 'staging-index');
-}
+import { createStaging, readStaging, setStagingTarget } from "../staging.js";
 function stagingTreePath(home, ref) {
     return join(home, 'merge', 'runs', ref);
 }
@@ -44,99 +24,6 @@ function markerStaging(migration) {
     }
     return facts;
 }
-/** Read-only adoption into the shadow index; never writes production staging-index. */
-export async function adoptLegacy(io, home) {
-    const ledger = await readPairLedger(io, home);
-    const entries = new Map();
-    const anomalies = [];
-    const now = Date.now();
-    for (const fact of markerStaging(ledger.migration)) {
-        const present = fact.ref !== '' && await io.exists(stagingTreePath(home, fact.ref));
-        entries.set(fact.rowId, { version: 1, rowId: fact.rowId, pairKey: fact.pairKey, ...(fact.runId === undefined ? {} : { runId: fact.runId }), ref: fact.ref, state: present ? 'present' : 'lost', createdAt: fact.createdAt, expiresAt: fact.expiresAt, updatedAt: now });
-    }
-    for (const row of ledger.rows) {
-        if (row.state === 'fuse' && !entries.has(row.id)) {
-            if (row.staging.kind === 'present')
-                entries.set(row.id, { version: 1, rowId: row.id, pairKey: row.pairKey, ...(row.runId === undefined ? {} : { runId: row.runId }), ref: row.staging.ref, state: 'present', createdAt: now, expiresAt: row.staging.expiresAt, updatedAt: now });
-            else if (row.staging.kind === 'expired')
-                entries.set(row.id, { version: 1, rowId: row.id, pairKey: row.pairKey, ...(row.runId === undefined ? {} : { runId: row.runId }), ref: row.staging.ref ?? '', state: 'expired', createdAt: now, expiresAt: row.staging.expiresAt, updatedAt: now });
-            continue;
-        }
-        if (row.state === 'pending') {
-            if (await readStagingIndex(io, home, row.id, now) !== null)
-                anomalies.push('pending-staging-index:' + row.id);
-            continue;
-        }
-        if (row.state === 'approved' && !entries.has(row.id)) {
-            const old = await readStagingIndex(io, home, row.id, now);
-            if (old !== null)
-                entries.set(row.id, { version: 1, rowId: row.id, pairKey: row.pairKey, ...(row.runId === undefined ? {} : { runId: row.runId }), ref: old.ref, state: 'reserved', createdAt: old.createdAt, expiresAt: old.expiresAt, updatedAt: now });
-        }
-    }
-    const adopted = [...entries.values()].sort((a, b) => a.rowId.localeCompare(b.rowId));
-    let wrote = false;
-    for (const entry of adopted) {
-        const path = shadowStagingIndexPath(home, entry.rowId);
-        const text = JSON.stringify(entry, null, 2) + '\n';
-        const current = await readTextOrNull(io, path);
-        if (current !== null) {
-            try {
-                const previous = JSON.parse(current);
-                if (previous.rowId === entry.rowId && previous.state === entry.state && previous.ref === entry.ref && previous.expiresAt === entry.expiresAt)
-                    continue;
-            }
-            catch { /* malformed shadow entry is replaced below */ }
-        }
-        if (io.transact !== undefined)
-            await io.transact(path, () => text);
-        else
-            await io.writeText(path, text);
-        wrote = true;
-    }
-    return { entries: adopted, anomalies, shadowPath: shadowStagingRoot(home), wrote };
-}
-export async function readShadowStageAggregate(io, home, rowId) {
-    if (rowId !== undefined) {
-        const raw = await readTextOrNull(io, shadowStagingIndexPath(home, rowId));
-        if (raw === null)
-            return { entries: [], shadowPath: shadowStagingRoot(home) };
-        try {
-            return { entries: [JSON.parse(raw)], shadowPath: shadowStagingRoot(home) };
-        }
-        catch {
-            return { entries: [], shadowPath: shadowStagingRoot(home) };
-        }
-    }
-    const listed = await io.exists(shadowStagingRoot(home)) ? await io.list(shadowStagingRoot(home)) : [];
-    const entries = [];
-    for (const name of listed) {
-        const raw = await readTextOrNull(io, join(shadowStagingRoot(home), name));
-        if (raw === null)
-            continue;
-        try {
-            entries.push(JSON.parse(raw));
-        }
-        catch { /* ignore malformed shadow */ }
-    }
-    entries.sort((a, b) => a.rowId.localeCompare(b.rowId));
-    return { entries, shadowPath: shadowStagingRoot(home) };
-}
-/** 1b-2b execution order; kept here so 1b-2a tests can pin the contract. */
-export const STAGE_WRITE_ORDER = ['index:reserved', 'tree', 'index:present'];
-export function admitStage(rowState) {
-    return rowState === 'approved' || rowState === 'fuse' ? { ok: true } : { ok: false, message: 'stage requires approved or fuse: ' + rowState };
-}
-export function planApprovedReserved(rowState, entry) {
-    if (entry === null)
-        return rowState === 'approved' || rowState === 'fuse' ? { kind: 'drop-orphan', rowId: '' } : { kind: 'none' };
-    if (rowState === 'approved' && entry.state === 'reserved')
-        return { kind: 'transition-fuse', rowId: entry.rowId, ref: entry.ref, expiresAt: entry.expiresAt };
-    if (rowState === 'approved' && entry.state === 'present')
-        return { kind: 'transition-fuse', rowId: entry.rowId, ref: entry.ref, expiresAt: entry.expiresAt };
-    if (rowState === 'fuse' && entry.state === 'reserved')
-        return { kind: 'write-present', rowId: entry.rowId, ref: entry.ref };
-    return { kind: 'none' };
-}
 /** Production adoption for 1b-2b normalize; writes the existing staging-index, not shadow. */
 export async function adoptLegacyProduction(io, home) {
     const ledger = await readPairLedger(io, home);
@@ -178,11 +65,9 @@ export async function adoptLegacyProduction(io, home) {
     return { entries: adopted, anomalies, shadowPath: join(home, 'merge', 'staging-index'), wrote };
 }
 /** Production stage-tree facade. These wrappers keep the low-level tree module private to StageAggregate. */
-export async function ensureStageTree(io, home, input) { return await ensureStaging(io, home, input); }
 export async function createStageTree(io, home, input) { return await createStaging(io, home, input); }
 export async function readStageTree(io, home, runId) { return await readStaging(io, home, runId); }
 export async function setStageTreeTarget(io, home, stageKey, target, mode) { return await setStagingTarget(io, home, stageKey, target, mode); }
-export async function dropStageTree(io, home, stageKey) { await dropStaging(io, home, stageKey); }
 export async function writeStageIndex(io, home, entry) { await writeStagingIndex(io, home, entry); }
 export async function readStageIndex(io, home, rowId, now = Date.now()) { return await readStagingIndex(io, home, rowId, now); }
 export async function readStageEntry(io, home, rowId) {

package/lib/types/domain/state-migrate.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The one v2/v3→v4 migration seam. The startup gate and the operator CLI both call this,
+ * so a backup/journal fix in one path cannot drift from the other.
+ */
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+/** Outcome of the one-time migration. */
+export type MigrateToV4Result = {
+    readonly ok: true;
+    readonly migrated: boolean;
+    readonly backupRef?: string;
+} | {
+    readonly ok: false;
+    readonly code: string;
+    readonly message: string;
+};
+/**
+ * Migrate v1/v2/v3 merge state to v4. v4 is a no-op; forward-only/needs-repair are reported
+ * before attempting anything, so a newer state is never overwritten.
+ * @param io - the evolution IO seam.
+ * @param home - the evolution home.
+ * @param fence - optional home write fence used by the host.
+ * @returns the migration outcome.
+ */
+export declare function migrateMergeStateToV4(io: EvolutionIoLike, home: string, fence?: {
+    run<T>(body: () => Promise<T>): Promise<T>;
+}): Promise<MigrateToV4Result>;
+//# sourceMappingURL=state-migrate.d.ts.map

package/lib/types/domain/state-migrate.js

@@ -0,0 +1,29 @@
+import { ensureMergeStateReady } from "./state-bootstrap.js";
+import { normalizePairLedger } from "./pair-ledger.js";
+import { readV4Readiness } from "./schema4.js";
+/**
+ * Migrate v1/v2/v3 merge state to v4. v4 is a no-op; forward-only/needs-repair are reported
+ * before attempting anything, so a newer state is never overwritten.
+ * @param io - the evolution IO seam.
+ * @param home - the evolution home.
+ * @param fence - optional home write fence used by the host.
+ * @returns the migration outcome.
+ */
+export async function migrateMergeStateToV4(io, home, fence) {
+    const v4 = await readV4Readiness(io, home);
+    if (v4.ok)
+        return { ok: true, migrated: false };
+    if (v4.code === 'merge-state-forward-only' || v4.code === 'merge-state-needs-repair') {
+        return { ok: false, code: v4.code, message: v4.message };
+    }
+    const v3 = await ensureMergeStateReady(io, home, fence);
+    if (!v3.ok)
+        return { ok: false, code: v3.code, message: v3.message };
+    const normalized = await normalizePairLedger(io, home);
+    if (!normalized.ok)
+        return { ok: false, code: 'merge-state-needs-repair', message: normalized.message ?? 'v3->v4 normalize failed' };
+    return normalized.backupRef === undefined
+        ? { ok: true, migrated: normalized.migrated }
+        : { ok: true, migrated: normalized.migrated, backupRef: normalized.backupRef };
+}
+//# sourceMappingURL=state-migrate.js.map

package/lib/types/domain/state.d.ts

@@ -1,57 +1,5 @@
-/** Pure merge decision state machine. No IO, no host imports. */
+/** Merge state vocabulary shared by the row types and the queue projection. */
 export type MergeState = 'verify' | 'pending' | 'approved' | 'fuse' | 'skipped';
 export type MergeQueue = 'verify' | 'pending' | 'fuse' | 'skipped';
-export type MergeEvent = {
-    readonly type: 'candidate';
-} | {
-    readonly type: 'round1-start';
-} | {
-    readonly type: 'round1-keep';
-} | {
-    readonly type: 'round1-merge';
-    readonly approval: boolean;
-} | {
-    readonly type: 'round1-fail';
-} | {
-    readonly type: 'approve';
-} | {
-    readonly type: 'reject';
-} | {
-    readonly type: 'round2-start';
-} | {
-    readonly type: 'round2-fail';
-} | {
-    readonly type: 'round2-merged';
-} | {
-    readonly type: 'round2-cancel';
-} | {
-    readonly type: 'staging-expired';
-} | {
-    readonly type: 'source-gone';
-} | {
-    readonly type: 'target-taken';
-} | {
-    readonly type: 'source-changed';
-} | {
-    readonly type: 'cancel';
-} | {
-    readonly type: 'timeout';
-};
-export type TransitionResult = {
-    readonly ok: true;
-    readonly state: MergeState;
-} | {
-    readonly ok: true;
-    readonly state: null;
-    readonly removed: true;
-} | {
-    readonly ok: false;
-    readonly code: 'invalid-transition';
-    readonly message: string;
-};
 export declare function queueOf(state: MergeState): MergeQueue;
-export declare function isTerminal(state: MergeState): boolean;
-/** Single transition point; callers must not mutate fields outside this function. */
-export declare function transition(state: MergeState, event: MergeEvent): TransitionResult;
-export declare function allowedEvents(state: MergeState): readonly MergeEvent['type'][];
 //# sourceMappingURL=state.d.ts.map

package/lib/types/domain/state.js

@@ -7,59 +7,4 @@ export function queueOf(state) {
         case 'skipped': return 'skipped';
     }
 }
-export function isTerminal(state) {
-    return state === 'skipped';
-}
-function fail(state, event) {
-    return { ok: false, code: 'invalid-transition', message: 'cannot apply ' + event.type + ' to ' + state };
-}
-/** Single transition point; callers must not mutate fields outside this function. */
-export function transition(state, event) {
-    switch (event.type) {
-        case 'candidate':
-            return state === 'verify' ? { ok: true, state: 'verify' } : fail(state, event);
-        case 'round1-start':
-            return state === 'verify' ? { ok: true, state: 'verify' } : fail(state, event);
-        case 'round1-keep':
-            return state === 'verify' ? { ok: true, state: 'skipped' } : fail(state, event);
-        case 'round1-merge':
-            return state === 'verify'
-                ? { ok: true, state: event.approval ? 'pending' : 'approved' }
-                : fail(state, event);
-        case 'round1-fail':
-            return state === 'verify' ? { ok: true, state: 'verify' } : fail(state, event);
-        case 'approve':
-            return state === 'pending' ? { ok: true, state: 'approved' } : fail(state, event);
-        case 'reject':
-            return state === 'pending' || state === 'approved' || state === 'fuse'
-                ? { ok: true, state: 'skipped' }
-                : fail(state, event);
-        case 'round2-start':
-            return state === 'approved' ? { ok: true, state: 'fuse' } : fail(state, event);
-        case 'round2-fail':
-        case 'round2-cancel':
-            return state === 'fuse' || state === 'approved' ? { ok: true, state: 'approved' } : fail(state, event);
-        case 'round2-merged':
-            return state === 'fuse' || state === 'approved' ? { ok: true, state: null, removed: true } : fail(state, event);
-        case 'staging-expired':
-            return state === 'fuse' ? { ok: true, state: 'approved' } : fail(state, event);
-        case 'source-gone':
-            return { ok: true, state: null, removed: true };
-        case 'target-taken':
-        case 'source-changed':
-            return state === 'pending' ? { ok: true, state: 'pending' } : fail(state, event);
-        case 'cancel':
-        case 'timeout':
-            return state === 'verify' || state === 'approved' || state === 'fuse' ? { ok: true, state } : fail(state, event);
-    }
-}
-export function allowedEvents(state) {
-    switch (state) {
-        case 'verify': return ['candidate', 'round1-start', 'round1-keep', 'round1-merge', 'round1-fail', 'source-gone', 'cancel', 'timeout'];
-        case 'pending': return ['approve', 'reject', 'target-taken', 'source-changed', 'source-gone'];
-        case 'approved': return ['round2-start', 'reject', 'staging-expired', 'source-gone', 'cancel', 'timeout'];
-        case 'fuse': return ['round2-fail', 'round2-merged', 'round2-cancel', 'staging-expired', 'reject', 'source-gone', 'cancel', 'timeout'];
-        case 'skipped': return [];
-    }
-}
 //# sourceMappingURL=state.js.map

package/lib/types/domain/undo-journal.d.ts

@@ -1,6 +1,6 @@
 import { type EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
 import type { JournalProtocol } from '@lmzhen/dsh-evolution-core';
-export type UndoPairPhase = 'pending' | 'restore-target' | 'restore-source' | 'receipt' | 'pair-index' | 'run-meta' | 'done';
+export type UndoPairPhase = 'pending' | 'restore-target' | 'restore-source' | 'receipt' | 'run-meta' | 'done';
 export interface UndoPairState {
     readonly pairKey: string;
     readonly unitId: string;
@@ -15,9 +15,9 @@ export interface UndoJournal {
     readonly updatedAt: string;
 }
 /**
- * The undo journal's protocol (W9-commit-protocol §3.1): `pair-index` and `run-meta` are explicit
- * phases, because "the receipt was written but the pair index was not" is exactly the state a
- * restart has to recognise.
+ * The undo journal's protocol (W9-commit-protocol §3.1): `receipt` and `run-meta` are explicit
+ * phases, because "the receipt was written but the run metadata was not" is exactly the state a
+ * restart has to recognise. The pair-index ledger is gone in 0.48, so it has no phase.
  */
 export declare const UNDO_PAIR_PROTOCOL: JournalProtocol<UndoPairPhase>;
 export declare function undoJournalPath(home: string, runId: string): string;

package/lib/types/domain/undo-journal.js

@@ -3,18 +3,17 @@ import { readTextOrNull } from "./read-probe.js";
 import { join } from 'node:path';
 import { transactIo } from '@lmzhen/dsh-evolution-core';
 /**
- * The undo journal's protocol (W9-commit-protocol §3.1): `pair-index` and `run-meta` are explicit
- * phases, because "the receipt was written but the pair index was not" is exactly the state a
- * restart has to recognise.
+ * The undo journal's protocol (W9-commit-protocol §3.1): `receipt` and `run-meta` are explicit
+ * phases, because "the receipt was written but the run metadata was not" is exactly the state a
+ * restart has to recognise. The pair-index ledger is gone in 0.48, so it has no phase.
  */
 export const UNDO_PAIR_PROTOCOL = {
-    phases: ['pending', 'restore-target', 'restore-source', 'receipt', 'pair-index', 'run-meta', 'done'],
+    phases: ['pending', 'restore-target', 'restore-source', 'receipt', 'run-meta', 'done'],
     next: {
         pending: ['restore-target', 'receipt', 'done'],
         'restore-target': ['restore-source', 'receipt'],
         'restore-source': ['receipt'],
-        receipt: ['pair-index'],
-        'pair-index': ['run-meta'],
+        receipt: ['run-meta'],
         'run-meta': ['done'],
         done: [],
     },
@@ -25,7 +24,6 @@ export const UNDO_PAIR_PROTOCOL = {
             case 'restore-target':
             case 'restore-source':
             case 'receipt':
-            case 'pair-index':
             case 'run-meta': return 'continue';
             default: return 'refuse';
         }

package/lib/types/index.d.ts

@@ -38,7 +38,6 @@ export declare function configureMergePresentation(ctx: MergePresentationContext
 export * from './contracts.ts';
 export * from './skill-card.ts';
 export * from './state.ts';
-export * from './coordinator.ts';
 export * from './report.ts';
 export * from './staging.ts';
 export * from './staging-files.ts';

package/lib/types/index.js

@@ -8,7 +8,7 @@ import { authorityFrom, createSubagentChannel, evolutionHome, evolutionIoAdapter
 import { newSkillLibrary } from '@lmzhen/dsh-evolution-core/skills';
 import { registerHostRoutes } from '@lmzhen/dsh-evolution-core/http-routes';
 import { loadMergeState } from "./state.js";
-import { pairLedger, normalizePairLedger } from "./domain/pair-ledger.js";
+import { pairLedger } from "./domain/pair-ledger.js";
 import { legacyToV3 } from "./domain/row-v3-bridge.js";
 import { readV4Readiness } from "./domain/schema4.js";
 import { readMergeSnapshot } from "./domain/merge-snapshot.js";
@@ -27,7 +27,7 @@ import { buildDoctorView } from "./surface/merge-view.js";
 import { mergeDoctorFact } from "./doctor.js";
 import { commandError, formatMergeError } from "./domain/errors.js";
 import { resolveBody } from "./surface/body.js";
-import { ensureMergeStateReady } from "./domain/state-bootstrap.js";
+import { migrateMergeStateToV4 } from "./domain/state-migrate.js";
 import { recoverCommitUnits } from "./recovery-coordinator.js";
 import { pairKey, rowIdOf } from "./contracts.js";
 import { makeMergeRoutes } from "./merge-routes.js";
@@ -85,7 +85,6 @@ export function configureMergePresentation(ctx) {
 export * from "./contracts.js";
 export * from "./skill-card.js";
 export * from "./state.js";
-export * from "./coordinator.js";
 export * from "./report.js";
 export * from "./staging.js";
 export * from "./staging-files.js";
@@ -172,19 +171,14 @@ export function apply(ctx, rawConfig = {}) {
             return;
         const io = evolutionIoAdapter(() => registry.provider());
         const home = evolutionHome();
+        const homeFence = ctx.get('evolutionMutationAuthority')?.homeFence;
         const ready = (async () => {
-            const v4 = await readV4Readiness(io, home);
-            if (v4.ok) {
-                const loaded = await loadMergeState(io, home);
-                return { ok: true, schema: 3, migrated: false, state: { schemaVersion: 3, rows: loaded.state.rows.map(legacyToV3).filter((row) => row !== null) }, quarantine: [], report: null };
-            }
-            const state = await ensureMergeStateReady(io, home, ctx.get('evolutionMutationAuthority')?.homeFence);
-            if (!state.ok)
-                return v4.code === 'merge-state-forward-only' || v4.code === 'merge-state-needs-repair' ? { ok: false, code: v4.code, message: v4.message } : state;
-            const normalized = await normalizePairLedger(io, home);
-            return normalized.ok ? state : { ok: false, code: 'merge-state-needs-repair', message: normalized.message ?? 'v4 normalize failed' };
+            const migration = await migrateMergeStateToV4(io, home, homeFence);
+            if (!migration.ok)
+                return migration;
+            const loaded = await loadMergeState(io, home);
+            return { ok: true, schema: 3, migrated: migration.migrated, state: { schemaVersion: 3, rows: loaded.state.rows.map(legacyToV3).filter((row) => row !== null) }, quarantine: [], report: null };
         })().catch(error => ({ ok: false, code: 'merge-state-migration-blocked', message: error instanceof Error ? error.message : String(error) }));
-        const homeFence = ctx.get('evolutionMutationAuthority')?.homeFence;
         const runs = newRunRegistry({ io, home, warn: (message) => { ctx.logger.warn(message); }, ...(homeFence === undefined ? {} : { fence: homeFence }) });
         ctx.effect(() => {
             const host = ctx;