@linzumi/cli 1.0.272 → 1.0.274

package/scripts/build-queue-parity-oracle.mjs

@@ -1,1012 +0,0 @@
-// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
-// (M3 cluster 5, queues-watermarks).
-// Relationship: Builds the TS-side PARITY ORACLE for the queues/watermarks
-// cluster of the ReScript commander port, the sibling of
-// build-config-identity-parity-oracle.mjs (cluster 2). The oracle bundles
-// the REAL TS queue/watermark modules (kandanQueue.ts,
-// pendingKandanMessageQueue.ts, appliedSourceSeqWatermark.ts,
-// durableInboundQueue.ts, controlQuarantine.ts, resumeKeystone.ts +
-// threadReconcilerLock.ts/leaseEpochGuard.ts, pipeline/outbox.ts +
-// pipeline/outboxJournal.ts) behind the cluster 1/2 one-shot batch driver:
-// a JSON array of cases on stdin, a JSON array of results on stdout. The
-// ReScript package's QueueParityConformance drives the SAME scripted
-// inputs through the ported modules in its own scratch directories and
-// asserts per-action outcome equivalence AND byte-identical durable files
-// (inbound-queue logs, commander-outbox journals, withheld-ack records,
-// quarantine evidence) - the cross-impl round-trip contract that lets both
-// commanders share ~/.linzumi through M4.
-//
-// Determinism: every source of nondeterminism is pinned per case - clocks
-// come from a fixed `nowMs` (the queue/outbox/keystone seams are all
-// injectable), scripted push outcomes resolve in order, and scratch paths
-// are normalized through the "$DIR" placeholder in both directions. Retry
-// delays in scripted outbox scenarios are millisecond-scale so a scenario
-// settles fast without changing the ladder's shape.
-//
-// SECRETS: the oracle only ever sees the conformance suite's synthetic
-// payloads; nothing here logs case contents.
-//
-// The output is a local test artifact (.differential/ is gitignored, never
-// published) and stays unminified for debuggability.
-import { mkdir } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { build } from 'esbuild';
-
-const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
-
-const driverSource = `
-import {
-  appendFileSync,
-  mkdtempSync,
-  mkdirSync,
-  readdirSync,
-  rmSync,
-  readFileSync,
-  realpathSync,
-  renameSync,
-  statSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, relative } from 'node:path';
-import {
-  codexInputForQueuedKandanMessage,
-  formatQueuedKandanMessage,
-  interruptQueuedMessages,
-  normalizeCodexSteerInput,
-  queuedKandanMessageSourceSeqs,
-  steerInputText,
-} from './src/kandanQueue';
-import {
-  createPendingKandanMessageQueue,
-  dequeuePendingKandanMessage,
-  drainAllPendingKandanMessages,
-  enqueuePendingKandanMessage,
-  interruptPendingKandanMessages,
-  listPendingKandanMessages,
-  pendingKandanMessageQueueHasSeq,
-  pendingKandanMessageQueueLength,
-  requeuePendingKandanMessageFront,
-} from './src/pendingKandanMessageQueue';
-import {
-  commitAppliedSourceSeq,
-  createInFlightSourceSeqGuard,
-  highestProcessedSourceSeq,
-  parseResumeReconcileEntries,
-  parseServerMessageStateRows,
-  reconcileAppliedSourceSeq,
-  resumeReconcileServerRows,
-  shouldApplySourceSeq,
-  sourceSeqAppliedOrInFlight,
-  threadSourceSeqWatermarkKey,
-} from './src/appliedSourceSeqWatermark';
-import {
-  createDurableInboundThreadQueue,
-  defaultDeadLetterPolicy,
-  durableInboundQueuePath,
-  foldQueueRecords,
-  shouldDeadLetter,
-} from './src/durableInboundQueue';
-import {
-  controlQuarantineFilePath,
-  createControlQuarantine,
-  fileWithheldControlAckStore,
-  withheldControlAckStorePath,
-} from './src/controlQuarantine';
-import {
-  outboxJournalPath,
-  recoverOutboxJournal,
-  createOutboxJournal,
-} from './src/pipeline/outboxJournal';
-import { createThreadOutbox } from './src/pipeline/outbox';
-import { createSessionPipelineBuilders, enqueueTerminalDebtRepair } from './src/pipeline/integration';
-import {
-  applyResumeDispatchOutcome,
-  commitLiveAcceptedSourceSeq,
-  drainResumeQueue,
-  receiveResumeMessage,
-} from './src/resumeKeystone';
-import { createLeaseEpochRegistry, isFencedClaim } from './src/leaseEpochGuard';
-import { createThreadReconcilerLock } from './src/threadReconcilerLock';
-
-// --- Placeholder + snapshot plumbing --------------------------------------------
-
-const dirPlaceholder = '$DIR';
-
-function scratch() {
-  // realpath so macOS /var -> /private/var never splits the two impls'
-  // placeholder substitution.
-  return realpathSync(mkdtempSync(join(tmpdir(), 'linzumi-queue-oracle-')));
-}
-
-function substitute(value, from, to) {
-  if (typeof value === 'string') {
-    return value.split(from).join(to);
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => substitute(entry, from, to));
-  }
-  if (typeof value === 'object' && value !== null) {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, entry]) => [
-        substitute(key, from, to),
-        substitute(entry, from, to),
-      ])
-    );
-  }
-  return value;
-}
-
-function snapshotFiles(dir) {
-  const files = {};
-  const walk = (current) => {
-    for (const name of readdirSync(current).sort()) {
-      const full = join(current, name);
-      if (statSync(full).isDirectory()) {
-        walk(full);
-      } else {
-        files[relative(dir, full)] = readFileSync(full, 'utf8');
-      }
-    }
-  };
-  walk(dir);
-  return files;
-}
-
-function outcome(run) {
-  try {
-    const value = run();
-    return value === undefined ? { defined: false } : { defined: true, value };
-  } catch (error) {
-    return {
-      threw: true,
-      message: error instanceof Error ? error.message : String(error),
-    };
-  }
-}
-
-function collectingLog(events, dir) {
-  return (event, payload) => {
-    events.push({ event, payload: substitute(payload, dir, dirPlaceholder) });
-  };
-}
-
-// --- Queued-message pure transforms ------------------------------------------------
-
-function handleQueuedMessage(testCase) {
-  switch (testCase.fn) {
-    case 'normalizeCodexSteerInput':
-      return outcome(() => normalizeCodexSteerInput(testCase.input));
-    case 'steerInputText':
-      return outcome(() => steerInputText(testCase.input));
-    case 'format':
-      return outcome(() => formatQueuedKandanMessage(testCase.message));
-    case 'codexInput':
-      return outcome(() => codexInputForQueuedKandanMessage(testCase.message));
-    case 'sourceSeqs':
-      return outcome(() => queuedKandanMessageSourceSeqs(testCase.message));
-    case 'interrupt':
-      return outcome(() =>
-        interruptQueuedMessages(testCase.queue, testCase.throughSeq ?? undefined)
-      );
-    default:
-      return { threw: true, message: 'unknown queuedMessage fn ' + String(testCase.fn) };
-  }
-}
-
-// --- Pending FIFO ---------------------------------------------------------------------
-
-function handlePendingQueue(testCase) {
-  const queue = createPendingKandanMessageQueue();
-  const results = (testCase.actions ?? []).map((action) => {
-    switch (action.fn) {
-      case 'enqueue':
-        return outcome(() => enqueuePendingKandanMessage(queue, action.message));
-      case 'dequeue':
-        return outcome(() => dequeuePendingKandanMessage(queue));
-      case 'requeueFront':
-        return outcome(() => requeuePendingKandanMessageFront(queue, action.message));
-      case 'drainAll':
-        return outcome(() => drainAllPendingKandanMessages(queue));
-      case 'interrupt':
-        return outcome(() =>
-          interruptPendingKandanMessages(queue, action.throughSeq ?? undefined)
-        );
-      case 'hasSeq':
-        return outcome(() => pendingKandanMessageQueueHasSeq(queue, action.seq));
-      case 'list':
-        return outcome(() => listPendingKandanMessages(queue));
-      case 'length':
-        return outcome(() => pendingKandanMessageQueueLength(queue));
-      default:
-        return { threw: true, message: 'unknown pendingQueue fn ' + String(action.fn) };
-    }
-  });
-  return { results };
-}
-
-// --- Watermark pure semantics -----------------------------------------------------------
-
-function watermarkMemStore(calls) {
-  const map = new Map();
-  return {
-    initial: (key) => map.get(key),
-    onAdvance: (key, seq) => {
-      calls.push({ call: 'onAdvance', key, seq });
-      const existing = map.get(key);
-      if (existing === undefined || seq > existing) {
-        map.set(key, seq);
-      }
-    },
-    flush: () => {
-      calls.push({ call: 'flush' });
-    },
-    dump: () => Object.fromEntries(map),
-  };
-}
-
-function handleWatermark(testCase) {
-  switch (testCase.fn) {
-    case 'shouldApply':
-      return outcome(() =>
-        shouldApplySourceSeq(testCase.applied ?? undefined, testCase.sourceSeq)
-      );
-    case 'key':
-      return outcome(() =>
-        threadSourceSeqWatermarkKey(testCase.workspace, testCase.channel, testCase.threadId)
-      );
-    case 'highestProcessed':
-      return outcome(() => highestProcessedSourceSeq(testCase.rows));
-    case 'reconcile':
-      return outcome(() =>
-        reconcileAppliedSourceSeq(testCase.local ?? undefined, testCase.rows)
-      );
-    case 'parseRows':
-      return outcome(() => parseServerMessageStateRows(testCase.value));
-    case 'parseResumeReconcile':
-      return outcome(() => parseResumeReconcileEntries(testCase.value));
-    case 'resumeReconcileRows':
-      return outcome(() => resumeReconcileServerRows(testCase.entry));
-    case 'isFencedClaim':
-      return outcome(() =>
-        isFencedClaim(testCase.held ?? undefined, testCase.control ?? undefined)
-      );
-    case 'guardScenario': {
-      const calls = [];
-      const store = watermarkMemStore(calls);
-      const guard = createInFlightSourceSeqGuard();
-      const results = (testCase.actions ?? []).map((action) => {
-        switch (action.fn) {
-          case 'mark':
-            return outcome(() => guard.mark(action.key, action.seq));
-          case 'has':
-            return outcome(() => guard.has(action.key, action.seq));
-          case 'clearSeq':
-            return outcome(() => guard.clearSeq(action.key, action.seq));
-          case 'clearThread':
-            return outcome(() => guard.clearThread(action.key));
-          case 'commit':
-            return outcome(() => commitAppliedSourceSeq(store, action.key, action.seq));
-          case 'commitLiveAccepted':
-            return outcome(() =>
-              commitLiveAcceptedSourceSeq({
-                store,
-                watermarkKey: action.key,
-                sourceSeq: action.seq,
-              })
-            );
-          case 'appliedOrInFlight':
-            return outcome(() =>
-              sourceSeqAppliedOrInFlight(
-                store.initial(action.key),
-                guard,
-                action.key,
-                action.seq
-              )
-            );
-          default:
-            return { threw: true, message: 'unknown guard fn ' + String(action.fn) };
-        }
-      });
-      return { results, storeCalls: calls, store: store.dump() };
-    }
-    default:
-      return { threw: true, message: 'unknown watermark fn ' + String(testCase.fn) };
-  }
-}
-
-// --- Durable inbound queue --------------------------------------------------------------
-
-function normalizeEntry(entry) {
-  return entry === undefined ? undefined : { ...entry };
-}
-
-function handleInboundQueue(testCase) {
-  if (testCase.fn === 'foldLines') {
-    return outcome(() => foldQueueRecords(testCase.lines));
-  }
-  if (testCase.fn === 'shouldDeadLetter') {
-    return outcome(() =>
-      shouldDeadLetter(testCase.entry, testCase.policy ?? defaultDeadLetterPolicy, testCase.nowMs)
-    );
-  }
-  if (testCase.fn === 'path') {
-    process.env.LINZUMI_INBOUND_QUEUE_DIR = testCase.envDir ?? '';
-    const result = outcome(() =>
-      durableInboundQueuePath(testCase.workspace, testCase.channel, testCase.threadId)
-    );
-    delete process.env.LINZUMI_INBOUND_QUEUE_DIR;
-    return result;
-  }
-  // Scripted lifecycle in a scratch dir. fsync spies record ORDERING facts
-  // (an 'fsync' event lands in the stream before the action result is
-  // recorded), proving fsync-before-return (#2974) on BOTH impls.
-  const dir = scratch();
-  const path = join(dir, 'thread.log');
-  if (testCase.initialContents !== undefined) {
-    writeFileSync(path, testCase.initialContents, 'utf8');
-  }
-  const events = [];
-  const log = collectingLog(events, dir);
-  const deps = {
-    fsyncFd: () => {
-      events.push({ event: 'spy.fsync_data' });
-    },
-    fsyncDirFd: () => {
-      events.push({ event: 'spy.fsync_dir' });
-    },
-  };
-  let queue = createDurableInboundThreadQueue(path, log, deps);
-  const results = (testCase.actions ?? []).map((action) => {
-    switch (action.fn) {
-      case 'enqueue': {
-        const result = outcome(() =>
-          queue.enqueue(action.sourceSeq, action.kind ?? 'live', action.payload ?? {}, action.nowMs)
-        );
-        events.push({ event: 'action.enqueue_returned', sourceSeq: action.sourceSeq });
-        return result;
-      }
-      case 'ack':
-        return outcome(() => queue.ack(action.sourceSeq));
-      case 'recordAttempt':
-        return outcome(() => queue.recordAttempt(action.sourceSeq));
-      case 'deadLetter':
-        return outcome(() => normalizeEntry(queue.deadLetter(action.sourceSeq)));
-      case 'compact':
-        return outcome(() => queue.compact());
-      case 'entries':
-        return outcome(() => queue.entries().map(normalizeEntry));
-      case 'ackedEntries':
-        return outcome(() => queue.ackedEntries().map(normalizeEntry));
-      case 'head':
-        return outcome(() => normalizeEntry(queue.head()));
-      case 'highWater':
-        return outcome(() => queue.highWaterSourceSeq());
-      case 'tornTail':
-        return outcome(() => queue.tornTail());
-      case 'reconciledTornTail':
-        return outcome(() => queue.reconciledTornTail());
-      case 'appendRaw':
-        // Simulate a crash-torn tail / foreign bytes.
-        return outcome(() => appendFileSync(path, action.raw, 'utf8'));
-      case 'reload': {
-        // Simulated SIGKILL + restart: a fresh handle folds the same file.
-        queue = createDurableInboundThreadQueue(path, log, deps);
-        return { defined: false };
-      }
-      default:
-        return { threw: true, message: 'unknown inboundQueue fn ' + String(action.fn) };
-    }
-  });
-  return substitute(
-    { results, events, files: snapshotFiles(dir) },
-    dir,
-    dirPlaceholder
-  );
-}
-
-// --- Control quarantine -------------------------------------------------------------------
-
-function handleQuarantine(testCase) {
-  if (testCase.fn === 'paths') {
-    return {
-      store: outcome(() => withheldControlAckStorePath('$STATE', testCase.runnerId)),
-      quarantine: outcome(() => controlQuarantineFilePath('$STATE', testCase.runnerId)),
-    };
-  }
-  const dir = scratch();
-  const storePath = join(dir, 'withheld-acks.json');
-  const quarantinePath = join(dir, 'quarantined-controls.jsonl');
-  if (testCase.initialStoreContents !== undefined) {
-    writeFileSync(storePath, testCase.initialStoreContents, 'utf8');
-  }
-  if (testCase.initialQuarantineContents !== undefined) {
-    writeFileSync(quarantinePath, testCase.initialQuarantineContents, 'utf8');
-  }
-  const events = [];
-  const emitted = [];
-  const log = collectingLog(events, dir);
-  const writeErrors = [];
-  const store = fileWithheldControlAckStore(storePath, (message) =>
-    writeErrors.push(message)
-  );
-  let epoch = testCase.epoch ?? undefined;
-  const quarantine = createControlQuarantine({
-    store,
-    quarantineFilePath: quarantinePath,
-    log,
-    emitRunnerEvent: (payload) => {
-      emitted.push(substitute(payload, dir, dirPlaceholder));
-    },
-    currentEpoch: () => epoch,
-    ...(testCase.limit === undefined ? {} : { limit: testCase.limit }),
-    now: () => new Date(testCase.nowMs ?? 0),
-  });
-  const results = (testCase.rejections ?? []).map((rejection) => {
-    if (rejection.setEpoch !== undefined) {
-      epoch = rejection.setEpoch === null ? undefined : rejection.setEpoch;
-    }
-    return outcome(() =>
-      quarantine.onControlRejected(
-        rejection.control,
-        new Error(rejection.message ?? 'scripted rejection')
-      )
-    );
-  });
-  return substitute(
-    { results, events, emitted, writeErrors, files: snapshotFiles(dir) },
-    dir,
-    dirPlaceholder
-  );
-}
-
-// --- Outbox journal (recover-from-bytes) -----------------------------------------------------
-
-function normalizeRecovered(recovered) {
-  return {
-    pendingEntries: recovered.pendingEntries,
-    kv: Object.fromEntries(recovered.kv),
-    counters: recovered.counters,
-  };
-}
-
-function handleOutboxJournal(testCase) {
-  if (testCase.fn === 'path') {
-    return outcome(() => outboxJournalPath('$PERSIST', testCase.threadKey));
-  }
-  // recover: fold the given journal bytes.
-  const dir = scratch();
-  const path = join(dir, 'thread.outbox.jsonl');
-  if (testCase.contents !== undefined) {
-    writeFileSync(path, testCase.contents, 'utf8');
-  }
-  const events = [];
-  const recovered = outcome(() =>
-    normalizeRecovered(recoverOutboxJournal(path, collectingLog(events, dir)))
-  );
-  return substitute({ recovered, events }, dir, dirPlaceholder);
-}
-
-// Spec: spec/commander-recovery-rules.md rule01. Failed terminal publication
-// remains evidence/debt, never ordinary replay or an acknowledged terminal.
-async function handleFailedTerminalJournal(testCase) {
-  const dir = scratch();
-  const path = join(dir, 'failed-terminal.outbox.jsonl');
-  try {
-    writeFileSync(path, testCase.contents, 'utf8');
-    const events = [];
-    let recovered = recoverOutboxJournal(path, collectingLog(events, dir));
-    // Spec: commander-recovery rules1/5. A decoded healthy snapshot must remain
-    // classifiable after repeated real compaction, not merely retain a counter.
-    if (recovered.recovery.type !== 'healthy') throw new Error('initial failure inventory unavailable');
-    if (testCase.compact) {
-      for (let cycle = 0; cycle < 2; cycle += 1) {
-      const snapshot = recovered;
-      const journal = createOutboxJournal({path, compactionThreshold: 1,
-        snapshot: () => snapshot, log: collectingLog(events, dir)});
-      journal.appendAck(63);
-      await journal.settled();
-      await journal.close();
-      recovered = recoverOutboxJournal(path, collectingLog(events, dir));
-      if (recovered.recovery.type !== 'healthy') throw new Error('compacted failure inventory unavailable');
-      if (recovered.counters.knownNonterminalFailures !== 1 || recovered.counters.totalPermanentFailures !== 2)
-        throw new Error('compaction changed observed failure classification');
-      }
-    }
-    return {pendingEntries: recovered.pendingEntries,
-      failedTerminalEntries: recovered.failedTerminalEntries, counters: recovered.counters, events};
-  } finally {rmSync(dir, {recursive: true, force: true});}
-}
-
-// --- Outbox flow scenarios ---------------------------------------------------------------------
-
-function buildersFromSpec(spec, recordedReplies) {
-  const builders = {};
-  for (const [kind, config] of Object.entries(spec ?? {})) {
-    builders[kind] = {
-      build: (data) => {
-        if (config.mode === 'skip') {
-          return { skip: true, reason: String(data.skipReason ?? 'scripted-skip') };
-        }
-        if (config.mode === 'fail') {
-          throw new Error(String(data.failMessage ?? 'scripted-build-failure'));
-        }
-        return {
-          event: 'evt:' + kind,
-          payload: { ...data },
-          ...(config.timeoutMs === undefined ? {} : { timeoutMs: config.timeoutMs }),
-        };
-      },
-      // Spec: spec/commander-recovery-rules.md. These generic parity entries
-      // exercise must_ack/best_effort transport acknowledgement, never the
-      // approval-failure consensus protocol.
-      replyPolicy: { kind: 'transport_ack' },
-      ...(config.onReply === 'record'
-        ? {
-            onReply: (data, reply) => {
-              recordedReplies.push({ kind, data, reply });
-            },
-          }
-        : {}),
-      ...(config.coalesce === 'concat-bodies'
-        ? {
-            coalesce: (older, newer) => ({
-              ...newer,
-              body: String(older.body ?? '') + '|' + String(newer.body ?? ''),
-            }),
-          }
-        : {}),
-    };
-  }
-  return builders;
-}
-
-async function runOutboxPhase(phase, shared) {
-  // The outbox unrefs its retry timers by design (a pending backoff must
-  // never hold the runner process open), so a one-shot driver awaiting a
-  // flush across a backoff would see its event loop empty. Keep it alive
-  // for the phase.
-  const keepAlive = setInterval(() => {}, 25);
-  try {
-    return await runOutboxPhaseInner(phase, shared);
-  } finally {
-    clearInterval(keepAlive);
-  }
-}
-
-async function runOutboxPhaseInner(phase, shared) {
-  const pushScript = [...(phase.pushScript ?? [])];
-  const pushes = [];
-  const permanentFailures = [];
-  const recordedReplies = [];
-  const events = [];
-  const log = collectingLog(events, shared.dir);
-  let nowMs = phase.nowMs ?? 1_000;
-  const builders = buildersFromSpec(phase.builders ?? shared.builders, recordedReplies);
-  if (phase.terminalRepairBuilder === true) {
-    builders['adt.terminal_attempt'] = createSessionPipelineBuilders({
-      instanceId: 'repair-fixture', wire: () => ({workspaceSlug: 'synthetic', channelSlug: 'synthetic',
-        kandanThreadId: shared.threadKey, codexThreadId: 'synthetic-provider'}),
-      runnerPayload: () => ({}), messageStateReplyShape: {kind: 'full_reply'}, log,
-    })['adt.terminal_attempt'];
-  }
-  const outbox = createThreadOutbox({
-    threadKey: phase.threadKey ?? shared.threadKey,
-    push: async (event, payload, timeoutMs, onSent) => {
-      const step = pushScript.shift() ?? { kind: 'fail', message: 'push script exhausted' };
-      pushes.push({
-        event,
-        payload,
-        hasTimeout: timeoutMs !== undefined,
-      });
-      onSent?.();
-      if (step.delayMs !== undefined) {
-        await new Promise((resolve) => setTimeout(resolve, step.delayMs));
-      }
-      if (step.kind === 'ack') {
-        return step.reply ?? { ok: true };
-      }
-      const failure = new Error(String(step.message ?? 'scripted push failure'));
-      if (step.budgetExempt === true) {
-        failure.name = 'ScriptedBudgetExempt';
-      }
-      throw failure;
-    },
-    builders,
-    persistDir: shared.persistDir,
-    retryDelaysMs: phase.retryDelaysMs ?? [1, 1],
-    isRetryBudgetExempt: (error) => error.name === 'ScriptedBudgetExempt',
-    onPermanentFailure: (entry, error) => {
-      permanentFailures.push({
-        entrySeq: entry.entrySeq,
-        kind: entry.kind,
-        error: error.message,
-      });
-    },
-    log,
-    now: () => nowMs,
-    ...(phase.maxInFlightPushes === undefined
-      ? {}
-      : { maxInFlightPushes: phase.maxInFlightPushes }),
-    ...(phase.journalCompactionThreshold === undefined
-      ? {}
-      : { journalCompactionThreshold: phase.journalCompactionThreshold }),
-    ...(phase.journalRecoveryMaxAgeMs === undefined
-      ? {}
-      : { journalRecoveryMaxAgeMs: phase.journalRecoveryMaxAgeMs }),
-  });
-
-  const results = [];
-  for (const action of phase.actions ?? []) {
-    switch (action.fn) {
-      case 'advanceNow':
-        nowMs += action.byMs;
-        results.push({ defined: false });
-        break;
-      case 'enqueue':
-        results.push(
-          outcome(() =>
-            outbox.enqueue({
-              kind: action.kind,
-              data: action.data ?? {},
-              ...(action.coalesceKey === undefined ? {} : { coalesceKey: action.coalesceKey }),
-              resolution: action.resolution ?? 'must_ack',
-            })
-          )
-        );
-        break;
-      case 'cycleReceipt': {
-        const receipt = outbox.recallDurableFact(action.key);
-        if(receipt === null || typeof receipt !== 'object') throw new Error('cyclic receipt fixture missing stored object');
-        receipt.cycle = receipt;
-        results.push({defined:false});
-        break;
-      }
-      case 'pause':
-        results.push(outcome(() => outbox.pause()));
-        break;
-      case 'resume':
-        results.push(outcome(() => outbox.resume()));
-        break;
-      case 'flush': {
-        try {
-          await outbox.flush(action.timeoutMs);
-          results.push({ flushed: true });
-        } catch (error) {
-          results.push({
-            flushed: false,
-            message: error instanceof Error ? error.message : String(error),
-          });
-        }
-        break;
-      }
-      case 'metrics': {
-        const metrics = outbox.metrics();
-        results.push({
-          defined: true,
-          value: {
-            depth: metrics.depth,
-            totalEnqueued: metrics.totalEnqueued,
-            totalAcked: metrics.totalAcked,
-            totalRetried: metrics.totalRetried,
-            totalDroppedBestEffort: metrics.totalDroppedBestEffort,
-            totalPermanentFailures: metrics.totalPermanentFailures,
-            totalExpiredOnRecovery: metrics.totalExpiredOnRecovery,
-            journalDegraded: metrics.journalDegraded,
-            paused: metrics.paused,
-            ackedInWindow: metrics.pushLatency?.ackedInWindow ?? 0,
-          },
-        });
-        break;
-      }
-      case 'journalSettled':
-        await outbox.journalSettled();
-        results.push({ defined: false });
-        break;
-      // Spec: spec/commander-recovery-rules.md. Only this scenario's fresh
-      // scratch directory is moved; a real filesystem refusal tests both implementations.
-      case 'blockJournalWrites':
-      case 'restoreJournalWrites': {
-        await outbox.journalSettled();
-        const blocked = shared.persistDir + '.blocked';
-        if (action.fn === 'blockJournalWrites') renameSync(shared.persistDir, blocked);
-        else renameSync(blocked, shared.persistDir);
-        results.push({defined: false});
-        break;
-      }
-      case 'appendUncertainTail':
-      case 'blockJournalCompaction':
-      case 'blockRekeyDestination':
-      case 'restoreJournalCompaction': {
-        await outbox.journalSettled();
-        const path = outboxJournalPath(shared.persistDir, shared.threadKey);
-        if (action.fn === 'blockRekeyDestination') mkdirSync(outboxJournalPath(shared.persistDir, action.threadKey));
-        else if (action.fn === 'appendUncertainTail') appendFileSync(path, '{"t":"kv","key":', 'utf8');
-        else if (action.fn === 'blockJournalCompaction') mkdirSync(path + '.tmp');
-        else renameSync(path + '.tmp', path + '.blocked-compaction');
-        results.push({defined: false});
-        break;
-      }
-      case 'failedTerminalEntries':
-        results.push({failedTerminalEntries: outbox.failedTerminalEntries()});
-        break;
-      case 'terminalPublicationDebt':
-        results.push({terminalPublicationDebt: outbox.terminalPublicationDebt()});
-        break;
-      case 'rememberDurableFact':
-        outbox.rememberDurableFact(action.key, action.value);
-        await outbox.journalSettled();
-        results.push({defined: false});
-        break;
-      case 'rememberWithoutSettle':
-        outbox.rememberDurableFact(action.key, action.value);
-        results.push({defined: false});
-        break;
-      case 'repairTerminalDebt':
-        results.push({repair: await enqueueTerminalDebtRepair(outbox, {
-          threadId: shared.threadKey, sourceSeq: 44, sessionId: 3600, originalLeaseEpoch: 1,
-          binding: action.binding, authoritativeTerminal: action.authoritativeTerminal === true,
-          authorize: () => true,
-        }, log)});
-        break;
-      case 'rekeyJournal':
-        results.push(outcome(() => outbox.rekeyJournal(action.threadKey)));
-        await outbox.journalSettled();
-        break;
-      case 'sleep':
-        await new Promise((resolve) => setTimeout(resolve, action.ms));
-        results.push({ defined: false });
-        break;
-      case 'close':
-        await outbox.close(action.timeoutMs);
-        results.push({ defined: false });
-        break;
-      default:
-        results.push({ threw: true, message: 'unknown outbox fn ' + String(action.fn) });
-    }
-  }
-  // Make phase end deterministic: everything journaled so far is on disk.
-  await outbox.journalSettled();
-  return {
-    results,
-    pushes,
-    permanentFailures,
-    recordedReplies,
-    // Log EVENT NAMES in order (payloads carry timing values that legally
-    // differ across impls; names + counts are the stable contract).
-    logEvents: events.map((entry) => entry.event),
-  };
-}
-
-async function handleOutboxScenario(testCase) {
-  const dir = scratch();
-  // Cross-impl seed: files the OTHER impl wrote (journal bytes), laid down
-  // before any phase so recovery reads foreign-written bytes.
-  for (const [relPath, contents] of Object.entries(testCase.initialFiles ?? {})) {
-    const full = join(dir, relPath);
-    mkdirSync(join(full, '..'), { recursive: true });
-    writeFileSync(full, contents, 'utf8');
-  }
-  const shared = {
-    dir,
-    persistDir: testCase.inMemory === true ? undefined : join(dir, 'commander-outbox'),
-    threadKey: testCase.threadKey ?? 'linzumi:42:thread-a',
-    builders: testCase.builders ?? {},
-  };
-  const phases = [];
-  for (const phase of testCase.phases ?? []) {
-    phases.push(await runOutboxPhase(phase, shared));
-  }
-  return substitute(
-    { phases, files: snapshotFiles(dir) },
-    dir,
-    dirPlaceholder
-  );
-}
-
-// --- Resume keystone flow scenarios ----------------------------------------------------------
-
-async function handleKeystoneScenario(testCase) {
-  const dir = scratch();
-  const path = join(dir, 'thread.log');
-  if (testCase.initialContents !== undefined) {
-    writeFileSync(path, testCase.initialContents, 'utf8');
-  }
-  const events = [];
-  const log = collectingLog(events, dir);
-  const queue = createDurableInboundThreadQueue(path, log);
-  const storeCalls = [];
-  const store = watermarkMemStore(storeCalls);
-  if (typeof testCase.initialWatermark === 'number') {
-    store.onAdvance(testCase.watermarkKey, testCase.initialWatermark);
-    storeCalls.length = 0;
-  }
-  const lock = createThreadReconcilerLock();
-  const leases = createLeaseEpochRegistry();
-  const guard = createInFlightSourceSeqGuard();
-  const deadLetters = [];
-  const dispatchScript = [...(testCase.dispatchScript ?? [])];
-  const dispatchCalls = [];
-  const dispatch = async (sourceSeq, payload) => {
-    dispatchCalls.push({ sourceSeq, payload });
-    const step = dispatchScript.shift() ?? { outcome: 'ignored' };
-    return step.outcome;
-  };
-  const onDeadLetter = (args) => {
-    deadLetters.push({
-      threadId: args.threadId,
-      sourceSeq: args.sourceSeq,
-      reason: args.reason,
-      attempts: args.attempts,
-      alreadyPublished: args.alreadyPublished,
-    });
-  };
-  const results = [];
-  for (const step of testCase.steps ?? []) {
-    if (step.fn === 'receive') {
-      const outcomeValue = await receiveResumeMessage({
-        queue,
-        store,
-        lock,
-        leases,
-        threadId: testCase.threadId,
-        watermarkKey: testCase.watermarkKey,
-        sourceSeq: step.sourceSeq,
-        kind: step.kind ?? 'live',
-        payload: step.payload ?? {},
-        leaseEpoch: step.leaseEpoch ?? undefined,
-        dispatch,
-        serverRows: step.serverRows ?? [],
-        log,
-        nowMs: step.nowMs ?? 1_000,
-        ...(step.policy === undefined ? {} : { policy: step.policy }),
-        onlyDispatchUnattempted: step.onlyDispatchUnattempted ?? false,
-        onDeadLetter,
-        inFlightGuard: guard,
-      });
-      results.push({ receive: outcomeValue });
-    } else if (step.fn === 'drain') {
-      const dispatched = await drainResumeQueue({
-        queue,
-        store,
-        lock,
-        threadId: testCase.threadId,
-        watermarkKey: testCase.watermarkKey,
-        serverRows: step.serverRows ?? [],
-        dispatch,
-        log,
-        nowMs: step.nowMs ?? 1_000,
-        ...(step.policy === undefined ? {} : { policy: step.policy }),
-        onlyDispatchUnattempted: step.onlyDispatchUnattempted ?? false,
-        onTornTailUnrecoverable: (threadId) => {
-          deadLetters.push({ threadId, tornTailSurfaced: true });
-        },
-        onDeadLetter,
-        inFlightGuard: guard,
-      });
-      results.push({ drained: dispatched });
-    } else if (step.fn === 'executionCommit') {
-      // The turn EXECUTED to a terminal: the live path commits the floor
-      // (I58 execution-confirm) and clears the in-flight guard.
-      const advanced = commitLiveAcceptedSourceSeq({
-        store,
-        watermarkKey: testCase.watermarkKey,
-        sourceSeq: step.sourceSeq,
-      });
-      guard.clearSeq(testCase.watermarkKey, step.sourceSeq);
-      results.push({ executionCommit: advanced });
-    } else if (step.fn === 'workerDeath') {
-      guard.clearThread(testCase.watermarkKey);
-      results.push({ workerDeath: true });
-    } else if (step.fn === 'applyOutcome') {
-      await applyResumeDispatchOutcome({
-        queue,
-        store,
-        watermarkKey: testCase.watermarkKey,
-        sourceSeq: step.sourceSeq,
-        threadId: testCase.threadId,
-        outcome: step.outcome,
-        log,
-        nowMs: step.nowMs ?? 1_000,
-        ...(step.policy === undefined ? {} : { policy: step.policy }),
-        onDeadLetter,
-        inFlightGuard: guard,
-      });
-      results.push({ applied: step.outcome });
-    } else {
-      results.push({ threw: true, message: 'unknown keystone fn ' + String(step.fn) });
-    }
-  }
-  return substitute(
-    {
-      results,
-      dispatchCalls,
-      deadLetters,
-      storeCalls,
-      store: store.dump(),
-      liveEntries: queue.entries().map((entry) => ({ ...entry })),
-      ackedEntries: queue.ackedEntries().map((entry) => ({ ...entry })),
-      logEvents: events.map((entry) => entry.event),
-      files: snapshotFiles(dir),
-    },
-    dir,
-    dirPlaceholder
-  );
-}
-
-// --- Dispatch --------------------------------------------------------------------------------
-
-async function handle(testCase) {
-  switch (testCase.op) {
-    case 'queuedMessage':
-      return handleQueuedMessage(testCase);
-    case 'pendingQueue':
-      return handlePendingQueue(testCase);
-    case 'watermark':
-      return handleWatermark(testCase);
-    case 'inboundQueue':
-      return handleInboundQueue(testCase);
-    case 'quarantine':
-      return handleQuarantine(testCase);
-    case 'outboxJournal':
-      return handleOutboxJournal(testCase);
-    case 'failedTerminalJournal':
-      return await handleFailedTerminalJournal(testCase);
-    case 'outboxScenario':
-      return await handleOutboxScenario(testCase);
-    case 'keystoneScenario':
-      return await handleKeystoneScenario(testCase);
-    default:
-      return { threw: true, message: 'unknown op ' + String(testCase.op) };
-  }
-}
-
-let stdin = '';
-process.stdin.setEncoding('utf8');
-for await (const chunk of process.stdin) {
-  stdin += chunk;
-}
-const cases = JSON.parse(stdin);
-const results = [];
-for (const testCase of cases) {
-  results.push(await handle(testCase));
-}
-// Exit only after stdout is fully flushed: scripted outbox scenarios can
-// leave unref'd timers alive, so the driver exits explicitly - but a bare
-// process.exit(0) truncates large result arrays mid-pipe.
-process.stdout.write(JSON.stringify(results), () => {
-  process.exit(0);
-});
-`;
-
-await mkdir(join(packageRoot, '.differential'), { recursive: true });
-
-await build({
-  stdin: {
-    contents: driverSource,
-    resolveDir: packageRoot,
-    sourcefile: 'queue-parity-driver.ts',
-    loader: 'ts',
-  },
-  bundle: true,
-  // Same production ESM/CJS bridge as the existing core integration oracle;
-  // the shared typed terminal-repair validator reaches CommanderNode bindings.
-  banner: {
-    js: "import { createRequire as __queueOracleCreateRequire } from 'node:module';\nconst require = __queueOracleCreateRequire(import.meta.url);",
-  },
-  platform: 'node',
-  target: 'node20',
-  format: 'esm',
-  // Match the transport/session-registry oracles: generated native Node seams
-  // reach CommonJS dependencies. Keep real Node require semantics in this ESM
-  // test artifact; the unique alias avoids bundled createRequire collisions.
-  banner: {
-    js: "import { createRequire as __queueOracleCreateRequire } from 'node:module';\nconst require = __queueOracleCreateRequire(import.meta.url);",
-  },
-  outfile: join(packageRoot, '.differential/queue-parity-oracle.mjs'),
-  minify: false,
-  sourcemap: false,
-  legalComments: 'none',
-  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
-});