@linzumi/cli 1.0.272 → 1.0.274

package/scripts/build-core-commander-seams-parity-oracle.mjs

@@ -1,799 +0,0 @@
-// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
-// (M3 cluster 10, runner core).
-// Relationship: Builds the TS-side PARITY ORACLE for three bounded
-// commander-core seams of the ReScript commander port, the sibling of
-// build-queue-parity-oracle.mjs (cluster 5) /
-// build-transport-parity-oracle.mjs (cluster 4). ONE bundle imports the
-// REAL commander-core exports from './src/runner' (the whole module graph
-// rides along - large by design, exactly like the transport/config oracles
-// that already import runner exports) behind the one-shot batch driver: a
-// JSON array of cases on stdin, a JSON array of results on stdout.
-//
-// The three seams:
-//   1. Control-dispatch dedup + commit-then-advance confirmation
-//      (staleStartInstanceWindowMs / staleStartInstanceAgeMs /
-//      shouldSkipReplayedStartInstanceForKnownSession /
-//      shouldSkipReplayedStartTurn / commitAppliedStartTurn /
-//      dispatchControlConfirmingStartTurn / settleControlDispatch).
-//   2. The connection-staleness tracker (constants +
-//      createConnectionStalenessTracker) driven by scripted clocks and
-//      scripted escalation callbacks.
-//   3. The app-server KILL/RESPAWN ladder (createCodexTurnFailureGuard,
-//      runnerOwnsRespawnableAppServer, awaitLossReportsThenExit, the
-//      crash-loop constants/store/classifier, appServerLossCwdDiagnosis).
-//
-// Determinism: clocks are scripted per case (every seam takes an injected
-// now/nowMs), timers are scripted callbacks, scripted promises resolve in
-// program order with explicit microtask flushes, and scratch paths are
-// normalized through the "$DIR" placeholder in both directions. The
-// turn-failure guard's lastActivityAtMs is wall-clock-stamped inside the TS
-// original, so both impls report it as a PRESENCE flag only.
-//
-// 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 { copyFile, 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 {
-  mkdtempSync,
-  readdirSync,
-  readFileSync,
-  realpathSync,
-  statSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, relative } from 'node:path';
-import {
-  appServerCrashLoopExitCode,
-  appServerCrashLoopExitLimit,
-  appServerCrashLoopWindowMs,
-  appServerLossCwdDiagnosis,
-  awaitLossReportsThenExit,
-  commitAppliedStartTurn,
-  connectionStaleForcedReconnectAfterMs,
-  connectionStaleForcedReconnectRetryMs,
-  connectionStaleHardResetAfterUninitiatedDispatches,
-  connectionStaleHardResetFailureLimit,
-  connectionStaleThresholdMs,
-  connectionUnrecoverableAfterMs,
-  createCodexTurnFailureGuard,
-  createConnectionStalenessTracker,
-  defaultAppServerExitLoopStatePath,
-  dispatchControlConfirmingStartTurn,
-  fileAppServerExitLoopStore,
-  recordAppServerExitAndClassify,
-  runnerOwnsRespawnableAppServer,
-  settleControlDispatch,
-  shouldSkipReplayedStartInstanceForKnownSession,
-  shouldSkipReplayedStartTurn,
-  staleStartInstanceAgeMs,
-  staleStartInstanceWindowMs,
-} from './src/runner';
-import {
-  registerRequiredAdtCandidate, acknowledgeRequiredAdtCandidate,
-  consumeRequiredAdtAdmission, closeRequiredAdtAdmissionForDisconnect,
-  reconcileRequiredAdtCandidates, requiredTransportFinalAdmission,
-  findRequiredAdtCandidate, releaseRequiredAdtCandidate,
-  recoverRetainedTerminalDebt,
-} from './src/channelSession';
-import {adoptAdtStreamBinding, installAdtPublicationBinding} from './src/pipeline/contracts';
-import {createThreadOutbox} from './src/pipeline/outbox';
-import {enqueueTerminalDebtRepair} from './src/pipeline/integration';
-import {createHash} from 'node:crypto';
-
-// --- 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-core-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) {
-  return (event, payload) => {
-    events.push({ trace: 'log', event, payload });
-  };
-}
-
-// Deterministic microtask flush: enough passes that a then-chain of any
-// scripted depth settles before the trace is read on both impls.
-async function flushMicrotasks() {
-  for (let i = 0; i < 8; i += 1) {
-    await Promise.resolve();
-  }
-}
-
-// --- Slice 1: control-dispatch dedup + commit-then-advance -----------------------
-
-async function handleControlDispatch(testCase) {
-  switch (testCase.fn) {
-    case 'constants':
-      return { staleStartInstanceWindowMs };
-    case 'staleAge':
-      return outcome(() =>
-        staleStartInstanceAgeMs(testCase.control, testCase.nowMs)
-      );
-    case 'skipKnownSession': {
-      const lookups = [];
-      const known = new Set(testCase.knownThreadIds ?? []);
-      const result = outcome(() =>
-        shouldSkipReplayedStartInstanceForKnownSession(
-          testCase.control,
-          (threadId) => {
-            lookups.push(threadId);
-            return known.has(threadId);
-          }
-        )
-      );
-      return { result, lookups };
-    }
-    case 'skipStartTurn':
-      return outcome(() =>
-        shouldSkipReplayedStartTurn(
-          testCase.applied ?? undefined,
-          testCase.controlSeq
-        )
-      );
-    case 'commit': {
-      const calls = [];
-      const store = {
-        onAdvance: (key, seq) => calls.push({ call: 'onAdvance', key, seq }),
-        flush: () => calls.push({ call: 'flush' }),
-      };
-      const result = outcome(() =>
-        commitAppliedStartTurn(store, testCase.watermarkKey, testCase.controlSeq)
-      );
-      return { result, calls };
-    }
-    case 'dispatchConfirm': {
-      const trace = [];
-      const dispatch = () => {
-        trace.push({ trace: 'dispatch_called' });
-        return testCase.dispatch.kind === 'resolve'
-          ? Promise.resolve(testCase.dispatch.value ?? null)
-          : Promise.reject(
-              new Error(String(testCase.dispatch.message ?? 'scripted dispatch rejection'))
-            );
-      };
-      const commit =
-        testCase.hasCommit === true
-          ? () => trace.push({ trace: 'commit_called' })
-          : undefined;
-      try {
-        const value = await dispatchControlConfirmingStartTurn(dispatch, commit);
-        trace.push({ trace: 'resolved', value: value ?? null });
-      } catch (error) {
-        trace.push({
-          trace: 'rejected',
-          message: error instanceof Error ? error.message : String(error),
-        });
-      }
-      return { trace };
-    }
-    case 'settle': {
-      const trace = [];
-      const log = collectingLog(trace);
-      const handler = testCase.handler ?? { kind: 'syncUndefined' };
-      const handle = () => {
-        trace.push({ trace: 'handle_called' });
-        switch (handler.kind) {
-          case 'syncThrow':
-            throw new Error(String(handler.message ?? 'scripted sync throw'));
-          case 'syncObject':
-            return handler.value ?? {};
-          case 'syncUndefined':
-            return undefined;
-          case 'asyncResolve':
-            return Promise.resolve(handler.value ?? null);
-          case 'asyncReject':
-            return Promise.reject(
-              new Error(String(handler.message ?? 'scripted async rejection'))
-            );
-          default:
-            throw new Error('unknown settle handler kind ' + String(handler.kind));
-        }
-      };
-      const onRejected =
-        testCase.onRejected === undefined
-          ? undefined
-          : (error) => {
-              trace.push({
-                trace: 'on_rejected',
-                message: error instanceof Error ? error.message : String(error),
-              });
-              return testCase.onRejected;
-            };
-      settleControlDispatch(
-        testCase.controlType ?? 'scripted_control',
-        handle,
-        () => trace.push({ trace: 'ack' }),
-        log,
-        onRejected
-      );
-      trace.push({ trace: 'settle_returned' });
-      await flushMicrotasks();
-      return { trace };
-    }
-    default:
-      return { threw: true, message: 'unknown controlDispatch fn ' + String(testCase.fn) };
-  }
-}
-
-// --- Slice 2: connection-staleness tracker ----------------------------------------
-
-function handleStaleness(testCase) {
-  if (testCase.fn === 'constants') {
-    return {
-      connectionStaleThresholdMs,
-      connectionStaleForcedReconnectAfterMs,
-      connectionStaleForcedReconnectRetryMs,
-      connectionStaleHardResetAfterUninitiatedDispatches,
-      connectionStaleHardResetFailureLimit,
-      connectionUnrecoverableAfterMs,
-    };
-  }
-  // fn === 'scenario': a scripted clock + scripted escalation callbacks.
-  const trace = [];
-  const log = collectingLog(trace);
-  let nowMs = testCase.startMs ?? 0;
-  const escalationSpec = testCase.escalation;
-  const reconnectReturns = [...(escalationSpec?.reconnectReturns ?? [])];
-  const hardResetReturns = [...(escalationSpec?.hardResetReturns ?? [])];
-  const escalation =
-    escalationSpec === undefined
-      ? undefined
-      : {
-          ...(escalationSpec.hasReconnect === true
-            ? {
-                onReconnectNeeded: (details) => {
-                  trace.push({ trace: 'reconnect_needed', details });
-                  const scripted = reconnectReturns.shift();
-                  return scripted === null || scripted === undefined
-                    ? undefined
-                    : scripted;
-                },
-              }
-            : {}),
-          ...(escalationSpec.hasHardReset === true
-            ? {
-                onHardResetNeeded: (details) => {
-                  trace.push({ trace: 'hard_reset_needed', details });
-                  const scripted = hardResetReturns.shift();
-                  return scripted === null || scripted === undefined
-                    ? undefined
-                    : scripted;
-                },
-              }
-            : {}),
-          ...(escalationSpec.forcedReconnectAfterMs === undefined
-            ? {}
-            : { forcedReconnectAfterMs: escalationSpec.forcedReconnectAfterMs }),
-          ...(escalationSpec.forcedReconnectRetryMs === undefined
-            ? {}
-            : { forcedReconnectRetryMs: escalationSpec.forcedReconnectRetryMs }),
-          onUnrecoverable: (details) => {
-            trace.push({ trace: 'unrecoverable', details });
-          },
-          ...(escalationSpec.afterMs === undefined
-            ? {}
-            : { afterMs: escalationSpec.afterMs }),
-        };
-  const tracker = createConnectionStalenessTracker(
-    log,
-    () => nowMs,
-    testCase.thresholdMs ?? undefined,
-    escalation
-  );
-  for (const step of testCase.steps ?? []) {
-    switch (step.fn) {
-      case 'advance':
-        nowMs += step.byMs;
-        break;
-      case 'ack':
-        tracker.recordServerAck();
-        break;
-      case 'check':
-        tracker.check();
-        break;
-      case 'isStale':
-        trace.push({ trace: 'is_stale', value: tracker.isStale() });
-        break;
-      default:
-        trace.push({ trace: 'unknown_step', fn: String(step.fn) });
-    }
-  }
-  return { trace };
-}
-
-// --- Slice 3: respawn ladder ---------------------------------------------------------
-
-async function handleRespawn(testCase) {
-  switch (testCase.fn) {
-    case 'constants':
-      return {
-        appServerCrashLoopWindowMs,
-        appServerCrashLoopExitLimit,
-        appServerCrashLoopExitCode,
-      };
-    case 'ownsRespawnable':
-      return outcome(() =>
-        runnerOwnsRespawnableAppServer({
-          codexUrl: testCase.codexUrl ?? undefined,
-          threadProcessRole: testCase.threadProcessRole ?? undefined,
-          ownsStartedAppServer: testCase.ownsStartedAppServer === true,
-        })
-      );
-    case 'statePath':
-      return outcome(() =>
-        defaultAppServerExitLoopStatePath(testCase.runnerId, testCase.env ?? {})
-      );
-    case 'cwdDiagnosis': {
-      const existsMode = testCase.existsMode ?? 'real';
-      const existsFn =
-        existsMode === 'real'
-          ? undefined
-          : () => {
-              if (existsMode === 'throw') {
-                throw new Error('scripted exists probe failure');
-              }
-              return existsMode === 'true';
-            };
-      return outcome(() =>
-        existsFn === undefined
-          ? appServerLossCwdDiagnosis(testCase.cwd)
-          : appServerLossCwdDiagnosis(testCase.cwd, existsFn)
-      );
-    }
-    case 'exitLoopScenario': {
-      const dir = scratch();
-      const path = join(dir, 'exit-loop.json');
-      if (testCase.initialContents !== undefined) {
-        writeFileSync(path, testCase.initialContents, 'utf8');
-      }
-      const writeErrors = [];
-      const store = fileAppServerExitLoopStore(path, (message) =>
-        writeErrors.push(message)
-      );
-      const results = (testCase.steps ?? []).map((step) => {
-        switch (step.fn) {
-          case 'record':
-            return outcome(() =>
-              recordAppServerExitAndClassify(
-                store,
-                step.nowMs,
-                step.windowMs ?? undefined,
-                step.limit ?? undefined
-              )
-            );
-          case 'load':
-            return outcome(() => store.load());
-          case 'save':
-            return outcome(() => store.save(step.record));
-          default:
-            return { threw: true, message: 'unknown exitLoop fn ' + String(step.fn) };
-        }
-      });
-      return substitute(
-        { results, writeErrors, files: snapshotFiles(dir) },
-        dir,
-        dirPlaceholder
-      );
-    }
-    case 'guardScenario': {
-      const trace = [];
-      const log = collectingLog(trace);
-      const sessionSpecs = testCase.sessions ?? [];
-      const sessions = sessionSpecs.map((spec, index) => ({
-        handleCodexNotification: (method, params) => {
-          trace.push({ trace: 'session_dispatch', session: index, method, params });
-          if (spec.throws === true) {
-            throw new Error('scripted session dispatch failure ' + String(index));
-          }
-        },
-      }));
-      const guard = createCodexTurnFailureGuard({
-        sessions: () => sessions,
-        log,
-        ...(testCase.hasOnActiveThreadsFailed === true
-          ? {
-              onActiveThreadsFailed: (threadIds) => {
-                trace.push({ trace: 'active_threads_failed', threadIds: [...threadIds] });
-              },
-            }
-          : {}),
-      });
-      for (const step of testCase.steps ?? []) {
-        switch (step.fn) {
-          case 'observe':
-            guard.observeNotification(step.method, step.params ?? {});
-            break;
-          case 'fail':
-            guard.failActiveTurns(String(step.cause ?? 'scripted cause'));
-            break;
-          case 'failPerTurn': {
-            const causes = step.causes ?? {};
-            guard.failActiveTurns(
-              (turn) =>
-                causes[turn.threadId + '|' + turn.turnId] ??
-                String(step.defaultCause ?? 'scripted default cause')
-            );
-            break;
-          }
-          case 'count':
-            trace.push({ trace: 'count', value: guard.activeTurnCount() });
-            break;
-          case 'turns':
-            trace.push({ trace: 'turns', value: guard.activeTurns().map((t) => ({ ...t })) });
-            break;
-          case 'lastActivity':
-            // Wall-clock stamped inside the TS original: presence only.
-            trace.push({
-              trace: 'last_activity_defined',
-              value: guard.lastActivityAtMs() !== undefined,
-            });
-            break;
-          default:
-            trace.push({ trace: 'unknown_step', fn: String(step.fn) });
-        }
-      }
-      return { trace };
-    }
-    case 'awaitLossReports': {
-      const trace = [];
-      const pushes = (testCase.pushes ?? []).map((push) => {
-        if (push.kind === 'resolve') {
-          return Promise.resolve(undefined);
-        }
-        if (push.kind === 'reject') {
-          const rejected = Promise.reject(
-            new Error(String(push.message ?? 'scripted push rejection'))
-          );
-          // Pre-observed so the scripted rejection can never trip the
-          // unhandled-rejection handler before allSettled adopts it.
-          rejected.catch(() => {});
-          return rejected;
-        }
-        // 'never': a push whose ack never comes back.
-        return new Promise(() => {});
-      });
-      await awaitLossReportsThenExit({
-        pushes,
-        exit: () => trace.push({ trace: 'exit' }),
-        safetyCapMs: testCase.safetyCapMs,
-        setTimeoutFn: (callback, ms) => {
-          trace.push({ trace: 'cap_scheduled', ms });
-          if (testCase.capFires === true) {
-            setImmediate(callback);
-          }
-          return undefined;
-        },
-      });
-      trace.push({ trace: 'returned' });
-      return { trace };
-    }
-    default:
-      return { threw: true, message: 'unknown respawn fn ' + String(testCase.fn) };
-  }
-}
-
-// --- Dispatch --------------------------------------------------------------------------------
-
-// Spec: spec/commander-recovery-rules.md rule01 and rule05; retained terminal
-// debt is not an unknown provider-start ACK and cannot reset unrelated jobs.
-async function terminalDebtJournal(testCase) {
-  const control = testCase.control;
-  const logs = [];
-  const body = 'Synthetic completed answer.';
-  const outbox = createThreadOutbox({threadKey:'synthetic-terminal-debt', persistDir:scratch(),
-    push:async()=>{throw new Error('pending repair must not publish or resend provider work');},
-    builders:{'adt.terminal_attempt':{build:()=>{throw new Error('synthetic retained failure');}}},
-    retryDelaysMs:[], onPermanentFailure:()=>{}, log:(event,fields)=>logs.push({event,fields}),
-  });
-  try {
-    outbox.enqueue({kind:'adt.terminal_attempt',resolution:'must_ack',data:{seq:44,status:'processed',
-      turn_id:'synthetic-completed-turn',terminal_frame:{session_id:3600,lease_epoch:2,frame_index:40,
-      frame_kind:'terminal',assistant_phase:'final_answer',source_stream_key:'synthetic-rejected-key',body}}});
-    await outbox.flush(1000);
-    outbox.pause();
-    await outbox.journalSettled();
-    const gate = Promise.withResolvers();
-    const entered = Promise.withResolvers();
-    let settled = false;
-    let authority = true;
-    const barrierOutbox = {...outbox,
-      journalSettled:async()=>{entered.resolve();await gate.promise;await outbox.journalSettled();settled=true;},
-      terminalPublicationDebt:()=>!settled || control==='write-failure'
-        ? {kind:'unavailable',reason:'controlled journal not durable'} : outbox.terminalPublicationDebt(),
-    };
-    const repair = enqueueTerminalDebtRepair(barrierOutbox,{threadId:'synthetic-terminal-debt',sourceSeq:44,
-      sessionId:3600,originalLeaseEpoch:2,authoritativeTerminal:false,authorize:()=>authority,
-      binding:{session_id:3600,lease_epoch:4,next_frame_index:39,
-        checkpoint_config:{version:3,thresholds:{max_bytes:512,max_deltas:1,max_interval_ms:2000}},
-        final_checkpoint:{frame_index:38,source_stream_key:'synthetic-canonical-key',
-          body_sha256:createHash('sha256').update(body).digest('hex'),byte_len:Buffer.byteLength(body)}}},
-      (event,fields)=>logs.push({event,fields}));
-    const first = await Promise.race([entered.promise.then(()=>'waiting'),repair.then(()=>'finished')]);
-    const before = outbox.pendingTerminalEntries().length;
-    authority = control !== 'superseded';
-    gate.resolve();
-    const result = await repair;
-    return {first,before,count:outbox.pendingTerminalEntries().length,ready:result.kind==='ready',result,logs};
-  } finally {await outbox.close(0);}
-}
-
-async function terminalDebtStorm(testCase) {
-  const ackLease = testCase.control === 'newer-ack-lease' ? 2 : testCase.control === 'future-ack' ? 4 : 1;
-  const binding = {session_id: 3600, lease_epoch: ackLease, next_frame_index: 39,
-    checkpoint_config: {version: 3, thresholds: {max_bytes: 1, max_deltas: 1, max_interval_ms: 2000}}};
-  // Spec: commander-recovery-rules authenticated-terminal-evidence. The
-  // retained frame and original ACK belong to one attempt across lease churn.
-  const retainedLease = testCase.control === 'newer-retained-lease' ? 2 : 1;
-  const body = 'Synthetic completed answer.';
-  const reconciledBinding = {...binding, lease_epoch: 3, final_checkpoint: {
-    frame_index: 38, source_stream_key: 'synthetic-canonical-key',
-    body_sha256: createHash('sha256').update(body).digest('hex'), byte_len: Buffer.byteLength(body),
-  }};
-  const adopted = adoptAdtStreamBinding(binding, 44, 0);
-  if (adopted.kind !== 'accepted') throw new Error('terminal debt fixture binding refused');
-  const session = adopted.session;
-  const logs = [];
-  let resets = 0;
-  let restarts = 0;
-  let reconciliations = 0;
-  let repairs = 0;
-  const outbox = createThreadOutbox({threadKey:'synthetic-terminal-debt',
-    persistDir:scratch(),
-    push:async()=>{throw new Error('failed builder must not publish');},
-    builders:{'adt.terminal_attempt':{build:()=>{throw new Error('synthetic final rejection');}}},
-    retryDelaysMs:[], onPermanentFailure:()=>{}, log:(event,fields)=>logs.push({event,fields}),
-  });
-  try {
-  outbox.enqueue({kind:'adt.terminal_attempt',resolution:'must_ack',data:{seq:44,status:'processed',
-    turn_id:'synthetic-completed-turn',terminal_frame:{session_id:3600,lease_epoch:retainedLease,
-    frame_index:40,frame_kind:'terminal',assistant_phase:'final_answer',source_stream_key:'synthetic-rejected-key',body}}});
-  await outbox.flush(1000);
-  outbox.pause();
-  // Queue drain completion is distinct from durable journal settlement.
-  await outbox.journalSettled();
-  const durableDebt = outbox.terminalPublicationDebt();
-  if (typeof durableDebt !== 'object' || durableDebt.kind !== 'repair_needed' || durableDebt.count !== 1) {
-    throw new Error('warm repair fixture must have one durable failed terminal: ' + JSON.stringify(durableDebt));
-  }
-  const original = JSON.stringify(outbox.failedTerminalEntries());
-  const transport = {
-    push: async (_topic, event) => {
-      if (event === 'adt_binding_ack') return {status: 'ok', response: {ok: true}};
-      if (event === 'adt_binding_reconcile') {
-        reconciliations += 1;
-        if(testCase.control === 'repair-unavailable' && reconciliations > 1) return {status:'ok',response:{ok:true,adt:{verdict:'still_unavailable'}}};
-        return {status: 'ok', response: {
-        ok: true, adt: {verdict: 'already_applied', binding: testCase.control === 'malformed-binding' ? {session_id: 3600} : reconciledBinding},
-      }};
-      }
-      throw new Error('unexpected terminal-debt fixture event: ' + event);
-    },
-    hardReset: () => {resets += 1; return true;},
-  };
-  const candidate = registerRequiredAdtCandidate({transport,
-    identity: {thread_id: 'synthetic-terminal-debt', source_seq: 44, session_id: 3600,
-      lease_epoch: ackLease, checkpoint_config_version: 3},
-    installFreshBinding: raw => {
-      const fresh = adoptAdtStreamBinding(raw, 44, 0);
-      if (fresh.kind !== 'accepted') return false;
-      if (testCase.localState === 'idle') return false;
-      return installAdtPublicationBinding(session, fresh.session.binding, true).kind === 'accepted';
-    },
-    publicationSession: () => testCase.localState === 'idle' ? undefined : session,
-    failedTerminalEntries: () => {
-      const entries = outbox.failedTerminalEntries().map(entry => ({...entry,data:{...entry.data,
-        ...(testCase.control === 'malformed-repair-presence' ? {terminal_repair:undefined} : {}),
-        terminal_frame:{...entry.data.terminal_frame,session_id:testCase.control === 'foreign-debt' ? 3601 : 3600,
-          lease_epoch:testCase.control === 'future-debt' ? 4 : testCase.control === 'fractional-debt' ? 1.5 : retainedLease}}}));
-      if (testCase.control === 'missing-debt') return [];
-      if (testCase.control === 'ambiguous-debt') return [...entries, {...entries[0], entrySeq: 62}];
-      return entries;
-    },
-    repairTerminalDebt:async (fresh,authoritativeTerminal,authorize,evidenceEpoch)=>{
-      if(evidenceEpoch !== retainedLease) throw new Error('repair callback received ACK lease instead of retained evidence');
-      const result=await enqueueTerminalDebtRepair(outbox,{threadId:'synthetic-terminal-debt',sourceSeq:44,
-        sessionId:3600,originalLeaseEpoch:evidenceEpoch,binding:fresh,authoritativeTerminal,authorize},()=>{});
-      if(result.kind!=='ready') throw new Error('actual repair selector refused: '+result.message);
-      repairs += 1;
-    },
-    onUnrecoverable: () => {restarts += 1;},
-    log: (event,fields) => logs.push({event,fields}),
-  });
-  try {
-    await acknowledgeRequiredAdtCandidate({topic: 'local_runner:fixture', payload: adopted.ackPayload, ticket: candidate});
-    if (testCase.control !== 'unconsumed-provider' && consumeRequiredAdtAdmission(candidate).kind !== 'admitted') throw new Error('fixture provider was not admitted');
-    session.emitter.fenced = true;
-    session.done = true;
-    for (let reconnect = 0; reconnect < 3; reconnect += 1) {
-      closeRequiredAdtAdmissionForDisconnect(transport);
-      await reconcileRequiredAdtCandidates({transport, topic: 'local_runner:fixture'});
-    }
-    return {resets, restarts, repairs, originalUnchanged:JSON.stringify(outbox.failedTerminalEntries())===original,
-      corrections:outbox.pendingTerminalEntries().map(entry=>({originalLease:entry.data.terminal_repair?.original_lease_epoch,
-        lease:entry.data.terminal_frame?.lease_epoch,body:entry.data.terminal_frame?.body})),
-      retained: findRequiredAdtCandidate(transport,
-      identity => identity.thread_id === 'synthetic-terminal-debt' && identity.source_seq === 44) === candidate,
-      providerEffect: candidate.providerEffect, verdict: candidate.verdict,
-      nextProviderAdmission: consumeRequiredAdtAdmission(candidate).kind,
-      admission: requiredTransportFinalAdmission(transport).kind, logs};
-  } finally {releaseRequiredAdtCandidate(candidate);}
-  } finally {await outbox.close(0);}
-}
-
-async function handle(testCase) {
-  switch (testCase.op) {
-    case 'terminalDebtCold': {
-      const events = [];
-      let repairs = 0;
-      const retainedEpoch = ['ack-before-frame','binding-before-frame'].includes(testCase.control) ? 2 : 1;
-      const ackEpoch = ['ack-after-frame','binding-before-ack'].includes(testCase.control) ? 2 : 1;
-      const freshEpoch = testCase.control.startsWith('binding-before-') ? 1 : testCase.control.startsWith('ack-') ? 4 : 2;
-      const hasAnchor = testCase.control !== 'missing-anchor';
-      const ackVersion = ['ready','authoritative-terminal','missing-anchor'].includes(testCase.control) ? 7 : 9;
-      const identity = {thread_id:'synthetic-terminal-debt',source_seq:44,session_id:3600,lease_epoch:retainedEpoch,checkpoint_config_version:7};
-      const anchor = testCase.control === 'malformed-anchor' ? null : {...identity,
-        thread_id:testCase.control === 'foreign-anchor' ? 'foreign-thread' : identity.thread_id,
-        lease_epoch:testCase.control === 'fractional-anchor' ? 1.5 : ackEpoch,checkpoint_config_version:ackVersion};
-      const binding = {session_id:3600,lease_epoch:freshEpoch,next_frame_index:39,checkpoint_config:{version:8,thresholds:{max_bytes:512,max_deltas:1,max_interval_ms:2000}}};
-      const transport = {push:async (_topic,event,payload) => {
-        events.push(event);
-        if(event === 'terminal_debt_identity') {
-          if(testCase.control === 'disconnect') closeRequiredAdtAdmissionForDisconnect(transport);
-          return {status:'ok',response:{ok:true,identity:{...identity,...(hasAnchor ? {ack_identity:anchor} : {}),...(testCase.control === 'foreign' ? {thread_id:'foreign-thread'} : {})}}};
-        }
-        if(event === 'adt_binding_reconcile') {
-          if(payload.checkpoint_config_version !== ackVersion || payload.lease_epoch !== ackEpoch) throw new Error('cold lookup changed durable ACK identity');
-          return {status:'ok',response:{ok:true,adt:{verdict:testCase.control === 'authoritative-terminal' ? 'authoritative_terminal' : testCase.control === 'missing-anchor' ? 'applied' : 'already_applied',binding}}};
-        }
-        throw new Error('cold recovery attempted unexpected event: '+event);
-      }};
-      const pipeline = {
-        failedTerminalEntries:()=>[{entrySeq:61,kind:'adt.terminal_attempt',data:{seq:44,status:'processed',turn_id:'synthetic-completed-turn',terminal_frame:{session_id:3600,lease_epoch:retainedEpoch,frame_index:40,frame_kind:'terminal',assistant_phase:'final_answer',source_stream_key:'wrong-key',body:'Synthetic completed answer.'}}}],
-        repairTerminalDebt:async request => {
-          const terminal = testCase.control === 'authoritative-terminal';
-          if(request.sessionId !== 3600 || request.originalLeaseEpoch !== retainedEpoch || request.sourceSeq !== 44 || request.binding !== (terminal ? null : binding) || request.authoritativeTerminal !== terminal) throw new Error('cold repair identity mismatch');
-          if(!request.authorize({seq:44})) throw new Error('cold repair unexpectedly unauthorized');
-          repairs += 1;
-          return {kind:'ready',id:'fixture',serializedData:'fixture'};
-        },
-      };
-      try {
-        await recoverRetainedTerminalDebt({transport,topic:'local_runner:fixture',threadId:identity.thread_id,pipeline,log:()=>{}});
-        return {events,repairs};
-      } finally {
-        const candidate = findRequiredAdtCandidate(transport, value => value.thread_id === identity.thread_id);
-        if(candidate !== undefined) releaseRequiredAdtCandidate(candidate);
-      }
-    }
-    case 'terminalDebtStorm':
-      return await terminalDebtStorm(testCase);
-    case 'terminalDebtJournal':
-      return await terminalDebtJournal(testCase);
-    case 'controlDispatch':
-      return await handleControlDispatch(testCase);
-    case 'staleness':
-      return handleStaleness(testCase);
-    case 'respawn':
-      return await handleRespawn(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: the runner graph can leave
-// unref'd handles 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 });
-
-// runner.ts's graph resolves assets/ relative to the bundle at import time
-// (same requirement as build-transport-parity-oracle.mjs).
-await mkdir(join(packageRoot, '.differential/assets'), { recursive: true });
-await copyFile(
-  join(packageRoot, 'src/assets/linzumi-logo.svg'),
-  join(packageRoot, '.differential/assets/linzumi-logo.svg')
-);
-
-await build({
-  stdin: {
-    contents: driverSource,
-    resolveDir: packageRoot,
-    sourcefile: 'core-commander-seams-parity-driver.ts',
-    loader: 'ts',
-  },
-  bundle: true,
-  // Spec: plans/2026-09-09-ts-native-account-continuation.md. Match the
-  // production/auth-oracle ESM bridge for reachable CJS runtime dependencies;
-  // the distinct banner binding cannot collide with bundled createRequire.
-  banner: {
-    js: "import { createRequire as __coreCommanderSeamsOracleCreateRequire } from 'node:module';\nconst require = __coreCommanderSeamsOracleCreateRequire(import.meta.url);",
-  },
-  platform: 'node',
-  target: 'node20',
-  format: 'esm',
-  outfile: join(
-    packageRoot,
-    '.differential/core-commander-seams-parity-oracle.mjs'
-  ),
-  minify: false,
-  sourcemap: false,
-  legalComments: 'none',
-  // runner.ts pulls the wider commander graph; the same runtime externals
-  // as the differential entry build stay external.
-  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
-});