@lmzhen/dsh-evolution-merge 0.47.0 → 0.49.0

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.49.0",
   "publishConfig": {
     "access": "public"
   },
@@ -13,6 +13,9 @@
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
+  "bin": {
+    "dsh-evolution-merge-migrate": "scripts/merge-migrate.mjs"
+  },
   "exports": {
     ".": {
       "types": "./lib/types/index.d.ts",
@@ -26,6 +29,9 @@
     "lib/**/*.js",
     "lib/types/**/*.d.ts",
     "data/**/*",
+    "scripts/merge-migrate.mjs",
+    "scripts/merge-restore.mjs",
+    "scripts/merge-backup.mjs",
     "package.json"
   ],
   "license": "MIT",
@@ -34,9 +40,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.49.0",
+    "@lmzhen/dsh-evolution-commands": "^0.49.0",
+    "@lmzhen/dsh-evolution-merge-engine": "0.49.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.5"

package/scripts/merge-backup.mjs

@@ -0,0 +1,31 @@
+import { createHash } from 'node:crypto'
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs'
+import { dirname, join, relative } from 'node:path'
+const args = new Map()
+for (let i = 2; i < process.argv.length; i += 2) args.set(process.argv[i], process.argv[i + 1])
+const home = args.get('--home')
+const out = args.get('--out')
+if (!home || !out) { console.error('usage: node scripts/merge-backup.mjs --home <home> --out <dir> [--quiesce <json>]'); process.exit(2) }
+const quiesce = args.get('--quiesce')
+if (!quiesce) { console.error('backup refused: --quiesce <json> required (stop plugin or fence writer)'); process.exit(2) }
+try { if (JSON.parse(readFileSync(quiesce, 'utf8')).stopped !== true) { console.error('backup refused: writer not stopped'); process.exit(3) } } catch { console.error('backup refused: unreadable quiesce marker'); process.exit(3) }
+const sha = file => createHash('sha256').update(readFileSync(file)).digest('hex')
+const roots = ['merge/merge-state.json', 'runs.json', 'merge/receipts', 'merge/journals', 'merge/runs', 'merge/snapshots']
+const files = []
+function walk(path) {
+  if (!existsSync(path)) return
+  const stat = statSync(path)
+  if (stat.isDirectory()) { for (const name of readdirSync(path)) walk(join(path, name)); return }
+  const rel = relative(home, path).replace(/\\/g, '/')
+  files.push({ path: rel, bytes: stat.size, sha256: sha(path) })
+}
+for (const root of roots) walk(join(home, root))
+mkdirSync(out, { recursive: true })
+for (const file of files) {
+  const target = join(out, file.path)
+  mkdirSync(dirname(target), { recursive: true })
+  copyFileSync(join(home, file.path), target)
+}
+const manifest = { schemaVersion: 1, createdAt: new Date().toISOString(), home, quiesce: { path: quiesce, sha256: sha(quiesce) }, files }
+writeFileSync(join(out, 'backup-manifest.json'), JSON.stringify(manifest, null, 2) + '\n')
+console.log('MERGE BACKUP OK files=' + files.length + ' out=' + out)

package/scripts/merge-migrate.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * One-time merge state migration: v1/v2 -> v3 -> v4, with a home-level lock.
+ *
+ * The runtime used to do v2->v3 on mount and v3->v4 on the first write. That left the old
+ * readers in the hot path and gave an operator no backup/dry-run/restore story. This CLI is
+ * the explicit entry: it reuses the SAME domain migrations (ensureMergeStateReady and
+ * normalizePairLedger), so it cannot drift from the runtime.
+ *
+ * Usage:
+ *   merge-migrate --home <dir> [--dry-run] [--apply] [--restore <backup-dir>] [--json]
+ *
+ * Stop every host that has this home open before --apply/--restore: the lock only serializes
+ * this CLI, not a mounted plugin.
+ */
+import { spawnSync } from 'node:child_process'
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const scriptDir = dirname(fileURLToPath(import.meta.url))
+const argv = process.argv.slice(2)
+const value = (flag) => {
+  const index = argv.indexOf(flag)
+  return index >= 0 ? argv[index + 1] : undefined
+}
+const homeArg = value('--home')
+if (homeArg === undefined || homeArg === '') {
+  console.error('usage: merge-migrate --home <dir> [--dry-run] [--apply] [--restore <backup-dir>] [--json]')
+  process.exit(2)
+}
+const home = resolve(homeArg)
+const apply = argv.includes('--apply')
+const restoreAt = argv.indexOf('--restore')
+const restore = restoreAt >= 0 ? argv[restoreAt + 1] : undefined
+if (restoreAt >= 0 && (restore === undefined || restore === '' || restore.startsWith('--'))) {
+  console.error('usage: merge-migrate --home <dir> [--dry-run] [--apply] [--restore <backup-dir>] [--json]')
+  process.exit(2)
+}
+const dryRun = argv.includes('--dry-run') || (!apply && restoreAt < 0)
+const asJson = argv.includes('--json')
+const lockDir = join(home, 'merge', '.migrate-lock')
+const LOCK_TTL_MS = 60 * 60 * 1000
+
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (error) {
+    return error?.code === 'EPERM'
+  }
+}
+
+function acquireLock() {
+  mkdirSync(join(home, 'merge'), { recursive: true })
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      mkdirSync(lockDir)
+      writeFileSync(join(lockDir, 'owner.json'), JSON.stringify({ pid: process.pid, at: new Date().toISOString() }) + '\n')
+      return
+    } catch (error) {
+      if (error?.code !== 'EEXIST') throw error
+      let owner = null
+      try { owner = JSON.parse(readFileSync(join(lockDir, 'owner.json'), 'utf8')) } catch { /* stale/incomplete */ }
+      const age = Date.now() - statSync(lockDir).mtimeMs
+      if (owner !== null && pidAlive(owner.pid) && age < LOCK_TTL_MS) {
+        const failure = { ok: false, code: 'migration-locked', message: 'another process owns ' + lockDir + ' (pid ' + String(owner.pid) + ')' }
+        if (asJson) console.log(JSON.stringify(failure, null, 2))
+        else console.error('merge-migrate: ' + failure.message)
+        process.exit(3)
+      }
+      rmSync(lockDir, { recursive: true, force: true })
+    }
+  }
+  throw new Error('could not acquire ' + lockDir)
+}
+
+if (restore !== undefined && restore !== '') {
+  if (dryRun && !apply) {
+    const report = { ok: true, dryRun: true, restore }
+    if (asJson) console.log(JSON.stringify(report, null, 2))
+    else console.log('DRY RUN: would restore ' + restore + ' into ' + home + ' (stop the host first)')
+    process.exit(0)
+  }
+  acquireLock()
+  let restoreStatus = 1
+  try {
+    const result = spawnSync(process.execPath, [join(scriptDir, 'merge-restore.mjs'), '--home', home, '--backup', restore], { stdio: 'inherit' })
+    restoreStatus = result.status ?? 1
+  } finally {
+    rmSync(lockDir, { recursive: true, force: true })
+  }
+  process.exit(restoreStatus)
+}
+
+async function inspect() {
+  let raw = null
+  try { raw = readFileSync(join(home, 'merge', 'merge-state.json'), 'utf8') } catch { /* unreadable is reported below */ }
+  let schema = null
+  let rows = 0
+  try {
+    const parsed = raw === null ? null : JSON.parse(raw)
+    schema = parsed?.schemaVersion ?? null
+    rows = Array.isArray(parsed?.rows) ? parsed.rows.length : 0
+  } catch { /* malformed is a blocker */ }
+  const v4 = schema === 4
+    ? { ok: true, rows }
+    : { ok: false, code: 'merge-state-migration-required', message: 'state is not v4' }
+  const v3 = schema === 3
+    ? { ok: true, rows }
+    : { ok: false, code: 'merge-state-migration-required', message: 'state is not v3 readable' }
+  return { home, state: { present: raw !== null, schema, rows }, v4, v3 }
+}
+
+if (dryRun && !apply) {
+  const report = { ok: true, dryRun: true, ...await inspect() }
+  if (asJson) console.log(JSON.stringify(report, null, 2))
+  else console.log('DRY RUN ' + JSON.stringify(report.state) + ' v4=' + JSON.stringify(report.v4) + ' v3=' + JSON.stringify(report.v3))
+  process.exit(0)
+}
+
+const core = await import('@lmzhen/dsh-evolution-core')
+const io = core.nodeEvolutionIo()
+const { migrateMergeStateToV4 } = await import('../lib/types/domain/state-migrate.js')
+const { readV4Readiness } = await import('../lib/types/domain/schema4.js')
+
+acquireLock()
+let exitCode = 0
+try {
+  const before = await inspect()
+  const beforeV4 = await readV4Readiness(io, home)
+  if (before.state.schema === 4 && beforeV4.ok) {
+    const report = { ok: true, applied: false, reason: 'already-v4', before }
+    if (asJson) console.log(JSON.stringify(report, null, 2))
+    else console.log('MIGRATE OK already v4 rows=' + String(beforeV4.state.rows.length))
+  } else {
+    const backupDir = value('--backup') ?? join(home, 'merge', '.backup', 'pre-migrate-' + new Date().toISOString().replace(/[:.]/g, '-'))
+    const quiesce = join(home, 'merge', '.migrate-quiesce.json')
+    writeFileSync(quiesce, JSON.stringify({ stopped: true, at: new Date().toISOString() }) + '\n')
+    try {
+      const backedUp = spawnSync(process.execPath, [join(scriptDir, 'merge-backup.mjs'), '--home', home, '--out', backupDir, '--quiesce', quiesce], { stdio: 'inherit' })
+      if (backedUp.status !== 0) throw new Error('backup failed with exit ' + String(backedUp.status))
+    } finally {
+      rmSync(quiesce, { force: true })
+    }
+    const migration = await migrateMergeStateToV4(io, home)
+    if (!migration.ok) throw new Error(migration.code + ': ' + migration.message)
+    const after = await inspect()
+    const afterV4 = await readV4Readiness(io, home)
+    if (!afterV4.ok) throw new Error(afterV4.code + ': ' + afterV4.message)
+    const report = { ok: true, applied: true, migrated: migration.migrated, backupRef: migration.backupRef, backupDir, before, after }
+    if (asJson) console.log(JSON.stringify(report, null, 2))
+    else console.log('MIGRATE OK v2/v3 -> v4 rows=' + String(afterV4.state.rows.length) + ' backup=' + backupDir + (migration.backupRef === undefined ? '' : ' pre1b=' + migration.backupRef))
+  }
+} catch (error) {
+  const failure = { ok: false, code: 'migration-failed', message: error instanceof Error ? error.message : String(error) }
+  if (asJson) console.log(JSON.stringify(failure, null, 2))
+  else console.error('merge-migrate: ' + failure.message)
+  exitCode = 1
+} finally {
+  rmSync(lockDir, { recursive: true, force: true })
+}
+process.exit(exitCode)

package/scripts/merge-restore.mjs

@@ -0,0 +1,36 @@
+import { createHash } from 'node:crypto'
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, statSync } from 'node:fs'
+import { dirname, join, resolve, sep } from 'node:path'
+import { tmpdir } from 'node:os'
+const args = new Map()
+for (let i = 2; i < process.argv.length; i += 2) args.set(process.argv[i], process.argv[i + 1])
+const home = args.get('--home')
+const backup = args.get('--backup')
+if (!home || !backup) { console.error('usage: node scripts/merge-restore.mjs --home <home> --backup <dir>'); process.exit(2) }
+const manifest = JSON.parse(readFileSync(join(backup, 'backup-manifest.json'), 'utf8'))
+const sha = file => createHash('sha256').update(readFileSync(file)).digest('hex')
+const safe = rel => { const target = resolve(home, rel); const base = resolve(home) + sep; if (!target.startsWith(base)) throw new Error('unsafe backup path: ' + rel); return target }
+for (const file of manifest.files) {
+  const source = join(backup, file.path)
+  if (!existsSync(source)) throw new Error('missing backup file: ' + file.path)
+  if (sha(source) !== file.sha256 || statSync(source).size !== file.bytes) throw new Error('backup hash mismatch: ' + file.path)
+  safe(file.path)
+}
+const temp = mkdtempSync(join(tmpdir(), 'dsh-merge-restore-'))
+try {
+  for (const file of manifest.files) {
+    const source = join(backup, file.path)
+    const staged = join(temp, file.path)
+    mkdirSync(dirname(staged), { recursive: true })
+    copyFileSync(source, staged)
+  }
+  for (const file of manifest.files) {
+    const target = safe(file.path)
+    mkdirSync(dirname(target), { recursive: true })
+    if (existsSync(target)) renameSync(target, target + '.pre-restore')
+    copyFileSync(join(temp, file.path), target)
+  }
+  console.log('MERGE RESTORE OK files=' + manifest.files.length)
+} finally {
+  rmSync(temp, { recursive: true, force: true })
+}

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

package/lib/types/coordinator.js

@@ -1,137 +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 { pairKey, queueOf, rowIdOf, } from "./contracts.js";
-function invalid(event, state) {
-    return {
-        ok: false,
-        code: 'invalid-transition',
-        message: 'cannot apply ' + event.type + ' to ' + (state ?? 'no row'),
-    };
-}
-/** Drop fields that must not survive a transition; optional fields stay absent. */
-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.reason === undefined ? {} : { reason: row.reason }),
-        ...(row.target === undefined ? {} : { target: row.target }),
-    };
-}
-function next(row, at, state, patch = {}) {
-    return {
-        ok: true,
-        row: {
-            ...base(row, at),
-            state,
-            queue: queueOf(state),
-            ...patch,
-        },
-    };
-}
-/** Legacy v2 projection only; runtime writes must use transitionV3/RowTx. */
-export function transitionLegacyForProjection(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);
-    switch (event.type) {
-        case 'round1-keep':
-            return current.state === 'verify' ? next(current, event.at, 'skipped', { origin: 'agent' }) : invalid(event, current.state);
-        case 'round1-merge':
-            if (current.state !== 'verify')
-                return invalid(event, current.state);
-            return event.approval === 'on'
-                ? next(current, event.at, 'pending', { ...(event.decision === undefined ? {} : { decision: event.decision }), ...(event.stagingRef === undefined ? {} : { stagingRef: event.stagingRef }), ...(event.stagingExpiresAt === undefined ? {} : { stagingExpiresAt: event.stagingExpiresAt }), ...(event.sourceRevision === undefined ? {} : { sourceRevision: event.sourceRevision }), ...(event.targetRevision === undefined ? {} : { targetRevision: event.targetRevision }) })
-                : next(current, event.at, 'approved', { ...(event.decision === undefined ? {} : { decision: event.decision }), ...(event.stagingRef === undefined ? {} : { stagingRef: event.stagingRef }), ...(event.stagingExpiresAt === undefined ? {} : { stagingExpiresAt: event.stagingExpiresAt }), ...(event.sourceRevision === undefined ? {} : { sourceRevision: event.sourceRevision }), ...(event.targetRevision === undefined ? {} : { targetRevision: event.targetRevision }) });
-        case 'round1-fail':
-            return current.state === 'verify'
-                ? next(current, event.at, 'verify', { failure: event.failure, attempts: (current.attempts ?? 0) + 1 })
-                : invalid(event, current.state);
-        case 'approve':
-            return current.state === 'pending'
-                ? next(current, event.at, 'approved', (event.runId === undefined ? {} : { runId: event.runId }))
-                : invalid(event, current.state);
-        case 'reject':
-            return current.state === 'pending' ? next(current, event.at, 'skipped', { origin: 'human' }) : invalid(event, current.state);
-        case 'round2-cancel':
-            return current.state === 'fuse' || current.state === 'approved'
-                ? next(current, event.at, 'approved')
-                : invalid(event, current.state);
-        case 'round2-fail':
-            return current.state === 'fuse' || current.state === 'approved'
-                ? next(current, event.at, 'approved', { failure: event.failure, attempts: (current.attempts ?? 0) + 1 })
-                : invalid(event, current.state);
-        case 'round2-success':
-            return current.state === 'fuse' || current.state === 'approved'
-                ? { ok: true, row: null }
-                : invalid(event, current.state);
-        case 'target-taken':
-        case '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);
-        case 'restore':
-            return current.state === 'skipped'
-                ? next(current, event.at, 'verify')
-                : invalid(event, current.state);
-    }
-}
-//# sourceMappingURL=coordinator.js.map

package/lib/types/domain/commit-journal-store.d.ts

@@ -1,6 +0,0 @@
-import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
-import type { CommitJournal } from './commit-journal.ts';
-export declare function journalPath(home: string, runId: string): string;
-export declare function writeJournal(io: EvolutionIoLike, home: string, journal: CommitJournal): Promise<string>;
-export declare function readJournal(io: EvolutionIoLike, home: string, runId: string): Promise<CommitJournal | null>;
-//# sourceMappingURL=commit-journal-store.d.ts.map

package/lib/types/domain/commit-journal-store.js

@@ -1,26 +0,0 @@
-/** Durable commit journal: <home>/merge/journals/<run>.json. */
-import { join } from 'node:path';
-export function journalPath(home, runId) {
-    return join(home, 'merge', 'journals', runId.replace(/[^A-Za-z0-9_-]+/g, '_') + '.json');
-}
-export async function writeJournal(io, home, journal) {
-    const path = journalPath(home, journal.runId);
-    const content = JSON.stringify(journal, null, 2);
-    if (io.transact !== undefined)
-        await io.transact(path, () => content);
-    else
-        await io.writeText(path, content);
-    return path;
-}
-export async function readJournal(io, home, runId) {
-    const raw = await io.readText(journalPath(home, runId));
-    if (raw === null)
-        return null;
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=commit-journal-store.js.map

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

@@ -1,16 +0,0 @@
-/** Pure commit-journal phases for target-first merge. */
-export type JournalPhase = 'prepared' | 'target-written' | 'sources-archived' | 'committed' | 'rolled-back' | 'failed';
-export interface CommitJournal {
-    readonly runId: string;
-    readonly unitId?: string;
-    readonly target: string;
-    readonly create: boolean;
-    readonly sources: readonly string[];
-    readonly phase: JournalPhase;
-    readonly updatedAt: string;
-}
-export declare function advanceJournal(journal: CommitJournal, phase: JournalPhase, at: string): CommitJournal;
-export type JournalRecovery = 'none' | 'retry-commit' | 'rollback-target' | 'rollback-sources' | 'refuse';
-/** What a restart may do with the last durable phase. */
-export declare function recoveryFor(journal: CommitJournal): JournalRecovery;
-//# sourceMappingURL=commit-journal.d.ts.map