@linzumi/cli 1.0.272 → 1.0.273

package/scripts/build-core-reconnect-resume-parity-oracle.mjs

@@ -1,365 +0,0 @@
-// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
-// (M3 cluster 10, commander core - the reconnect-resume recovery arm).
-// Relationship: Builds the TS-side PARITY ORACLE for the reconnect-path
-// resume orchestration of the ReScript commander port, the sibling of
-// build-pipeline-parity-oracle.mjs (cluster 9) and
-// build-harness-codex-parity-oracle.mjs (cluster 7). The oracle bundles
-// the REAL runner.ts reconnect-resume exports - the I200 resume decision
-// ladder (resumeCodexThreadForReconnect, transitively
-// unarchiveAndResumeCodexThread, the archived/missing recognizers, and
-// channelSession.ts's withCodexStartRequestTimeout) and the two rehydration
-// fetch legs (fetchThreadRehydrationMessagesForTest /
-// fetchThreadTranscriptForRehydrationForTest, transitively the
-// reconnectContext.ts message parser and the transcriptCompiler.ts
-// canonical-page parser) - behind the cluster 1/2 one-shot BATCH driver (a
-// JSON array of cases on stdin, a JSON array of results on stdout).
-//
-// Scripting: the codex JSON-RPC request seam and the Phoenix push seam are
-// per-case scripted reply queues (result / json-rpc error / rejection /
-// never-settle hang); the rehydration builders are scripted
-// (return/undefined/throw). Timeouts: the REAL withCodexStartRequestTimeout
-// runs inside the bundle, bounded per case through its own
-// LINZUMI_CODEX_START_REQUEST_TIMEOUT_MS knob (set from the case input
-// before each run), so a scripted hang fails with the genuine sentinel
-// bytes after a genuinely elapsed (small) bound. The batch loop holds a
-// keepAlive interval while awaiting - the sentinel timer is unref'd by
-// design and node would otherwise exit mid-hang (the cluster 7 lesson).
-//
-// Byte parity: every request (with params), push (with payload), log
-// event (with payload), builder invocation, and the final
-// outcome/thrown-message ride the returned trace VERBATIM (the TS
-// objects' own key order rides JSON.stringify), so the ReScript side's
-// trace serialization must reproduce field presence AND insertion order
-// exactly.
-//
-// Import-time side effects: runner.ts's graph resolves assets/ relative
-// to the bundle at import time (the hello-project scaffold's inlined
-// logo), so the asset is copied next to the emitted oracle - the
-// build-harness-codex-parity-oracle precedent. No other stubs are needed;
-// the externals list matches the other oracles.
-//
-// SECRETS: the oracle only ever sees the conformance suite's synthetic
-// payloads. 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 {
-  fetchThreadRehydrationMessagesForTest,
-  fetchThreadTranscriptForRehydrationForTest,
-  resumeCodexThreadForReconnect,
-} from './src/runner';
-import {
-  resumeOrRehydrateCodexThread,
-  withCodexCompletionSnapshotRequestTimeout,
-} from './src/channelSession';
-
-// Scripted codex JSON-RPC request seam: replies are consumed in call
-// order; every call is traced with its params. An exhausted script
-// REJECTS loudly (mirrored byte-for-byte by the ReScript scripted seam).
-function scriptedRequest(script, trace) {
-  let index = 0;
-  return (method, params) => {
-    trace.push({ t: 'request', method, params: params ?? null });
-    const step = script[index];
-    index += 1;
-    if (step === undefined) {
-      return Promise.reject(new Error('unscripted request: ' + method));
-    }
-    if (step.hang === true) {
-      return new Promise(() => {});
-    }
-    if (step.reject !== undefined) {
-      return Promise.reject(new Error(step.reject));
-    }
-    if (step.error !== undefined) {
-      return Promise.resolve({ error: step.error });
-    }
-    return Promise.resolve({ result: step.result ?? {} });
-  };
-}
-
-async function runResumeCase(input) {
-  // The REAL wrapper resolves its bound per call through this knob.
-  process.env.LINZUMI_CODEX_START_REQUEST_TIMEOUT_MS = String(
-    input.timeoutMs
-  );
-  const trace = [];
-  const request = scriptedRequest(input.requestScript ?? [], trace);
-  const rehydration = {
-    forceRehydrate: input.forceRehydrate === true,
-    buildRehydrationText: async (resumeFailure) => {
-      trace.push({ t: 'buildText', resumeFailure });
-      const script = input.textScript ?? {};
-      if (script.throw !== undefined) {
-        throw new Error(script.throw);
-      }
-      return script.text;
-    },
-    buildRehydrationItems:
-      input.itemsScript === undefined
-        ? undefined
-        : async (resumeFailure) => {
-            trace.push({ t: 'buildItems', resumeFailure });
-            const script = input.itemsScript;
-            if (script.throw !== undefined) {
-              throw new Error(script.throw);
-            }
-            return script.items;
-          },
-    log: (event, payload) => trace.push({ t: 'log', event, payload }),
-  };
-  const outcome = await resumeCodexThreadForReconnect(
-    { request },
-    input.codexThreadId,
-    input.resumeOverrides ?? {},
-    rehydration
-  ).then(
-    (value) => ({ ok: true, value }),
-    (error) => ({
-      ok: false,
-      message: error instanceof Error ? error.message : String(error),
-    })
-  );
-  trace.push({ t: 'outcome', outcome });
-  return { trace };
-}
-
-// I200 hosted-agent narrow resume: the same shared core as reconnect, but
-// with the deliberately narrow missing-rollout-only recovery gate and the
-// path-specific loud error prefix/final log used by
-// narrowExistingLinzumiAgentThread.
-async function runNarrowCase(input) {
-  process.env.LINZUMI_CODEX_START_REQUEST_TIMEOUT_MS = String(
-    input.timeoutMs
-  );
-  const trace = [];
-  const request = scriptedRequest(input.requestScript ?? [], trace);
-  const rehydration = {
-    forceRehydrate: false,
-    buildRehydrationText: async (resumeFailure) => {
-      trace.push({ t: 'buildText', resumeFailure });
-      return input.textScript?.text;
-    },
-    buildRehydrationItems:
-      input.itemsScript === undefined
-        ? undefined
-        : async (resumeFailure) => {
-            trace.push({ t: 'buildItems', resumeFailure });
-            return input.itemsScript.items;
-          },
-    log: (event, payload) => trace.push({ t: 'log', event, payload }),
-  };
-  const outcome = await resumeOrRehydrateCodexThread({
-    codex: { request },
-    codexThreadId: input.codexThreadId,
-    resumeOverrides: input.resumeOverrides ?? {},
-    rebuildWhen: 'missing-rollout-only',
-    rehydration,
-  }).then(
-    (value) => {
-      trace.push({
-        t: 'log',
-        event: 'linzumi.agent_thread_narrowed',
-        payload: {
-          codex_thread_id: input.codexThreadId,
-          approval_policy: 'never',
-          sandbox: 'read-only',
-          rehydrated: value.mode === 'rehydrated',
-        },
-      });
-      return { ok: true, value };
-    },
-    (error) => ({
-      ok: false,
-      message:
-        'failed to narrow existing @linzumi Codex thread: ' +
-        (error instanceof Error ? error.message : String(error)),
-    })
-  );
-  trace.push({ t: 'outcome', outcome });
-  return { trace };
-}
-
-// Scripted Phoenix push seam shared by the two fetch legs.
-function scriptedPush(script, trace) {
-  let index = 0;
-  return {
-    push: async (topic, event, payload) => {
-      trace.push({ t: 'push', topic, event, payload });
-      const step = script[index];
-      index += 1;
-      if (step === undefined) {
-        throw new Error('unscripted push: ' + event);
-      }
-      if (step.throw !== undefined) {
-        throw new Error(step.throw);
-      }
-      return step.reply;
-    },
-  };
-}
-
-function fetchTarget(input) {
-  return {
-    workspace: input.target.workspace ?? undefined,
-    channel: input.target.channel ?? undefined,
-    threadId: input.target.threadId ?? undefined,
-  };
-}
-
-async function runFetchMessagesCase(input) {
-  const trace = [];
-  const client = scriptedPush(input.pushScript ?? [], trace);
-  const messages = await fetchThreadRehydrationMessagesForTest(
-    client,
-    input.topic,
-    fetchTarget(input),
-    (event, payload) => trace.push({ t: 'log', event, payload })
-  );
-  trace.push({ t: 'messages', messages });
-  return { trace };
-}
-
-async function runFetchTranscriptCase(input) {
-  const trace = [];
-  const client = scriptedPush(input.pushScript ?? [], trace);
-  const transcript = await fetchThreadTranscriptForRehydrationForTest(
-    client,
-    input.topic,
-    fetchTarget(input),
-    (event, payload) => trace.push({ t: 'log', event, payload })
-  );
-  trace.push({ t: 'transcript', value: transcript ?? null });
-  return { trace };
-}
-
-// The completion-snapshot bound (channelSession.ts
-// withCodexCompletionSnapshotRequestTimeout - the 2026-07-28 impl-res
-// silent-wedge law): the REAL wrapper runs against a scripted request
-// (result / rejection / never-settle hang). When the case carries an
-// explicit boundMs, it is passed as the third argument (the non-positive
-// unbounded guard); otherwise the wrapper resolves its bound through the
-// SAME LINZUMI_CODEX_START_REQUEST_TIMEOUT_MS knob as the start bound
-// (codexCompletionSnapshotRequestTimeoutMs delegates to it), set per case
-// - a hang genuinely waits the (small) bound out.
-async function runSnapshotTimeoutCase(input) {
-  process.env.LINZUMI_CODEX_START_REQUEST_TIMEOUT_MS = String(
-    input.timeoutMs
-  );
-  const trace = [];
-  const step = input.requestStep ?? {};
-  const request =
-    step.hang === true
-      ? new Promise(() => {})
-      : step.reject !== undefined
-        ? Promise.reject(new Error(step.reject))
-        : Promise.resolve({ result: step.result ?? {} });
-  const outcome = await (input.boundMs === undefined
-    ? withCodexCompletionSnapshotRequestTimeout(input.method, request)
-    : withCodexCompletionSnapshotRequestTimeout(
-        input.method,
-        request,
-        input.boundMs
-      )
-  ).then(
-    (value) => ({ ok: true, value }),
-    (error) => ({
-      ok: false,
-      message: error instanceof Error ? error.message : String(error),
-    })
-  );
-  trace.push({ t: 'outcome', outcome });
-  return { trace };
-}
-
-async function runCase(input) {
-  switch (input.kind) {
-    case 'resumeRun':
-      return runResumeCase(input);
-    case 'narrowRun':
-      return runNarrowCase(input);
-    case 'fetchMessagesRun':
-      return runFetchMessagesCase(input);
-    case 'fetchTranscriptRun':
-      return runFetchTranscriptCase(input);
-    case 'snapshotTimeoutRun':
-      return runSnapshotTimeoutCase(input);
-    default:
-      return { error: 'unknown case kind ' + String(input.kind) };
-  }
-}
-
-async function runBatch() {
-  const chunks = [];
-  for await (const chunk of process.stdin) chunks.push(chunk);
-  const cases = JSON.parse(Buffer.concat(chunks).toString('utf8'));
-  const results = [];
-  for (const testCase of cases) {
-    // The sentinel timer is unref'd by design; hold the event loop open
-    // while a hang case waits it out or node would exit mid-await.
-    const keepAlive = setInterval(() => {}, 1000);
-    try {
-      results.push(await runCase(testCase));
-    } finally {
-      clearInterval(keepAlive);
-    }
-  }
-  process.stdout.write(JSON.stringify(results), () => {
-    process.exit(0);
-  });
-}
-
-runBatch().then(
-  () => {},
-  (error) => {
-    process.stderr.write(String(error && error.stack ? error.stack : error) + '\\n');
-    process.exit(1);
-  }
-);
-`;
-
-const outDir = join(packageRoot, '.differential');
-const outPath = join(outDir, 'core-reconnect-resume-parity-oracle.mjs');
-
-await mkdir(outDir, { recursive: true });
-// runner.ts's graph resolves assets/ relative to the bundle at import time
-// (the hello-project scaffold's inlined logo), so the asset must sit next
-// to the emitted oracle - the build-harness-codex-parity-oracle precedent.
-await mkdir(join(outDir, 'assets'), { recursive: true });
-await copyFile(
-  join(packageRoot, 'src/assets/linzumi-logo.svg'),
-  join(outDir, 'assets/linzumi-logo.svg')
-);
-
-await build({
-  stdin: {
-    contents: driverSource,
-    resolveDir: packageRoot,
-    sourcefile: 'core-reconnect-resume-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 __coreReconnectResumeOracleCreateRequire } from 'node:module';\nconst require = __coreReconnectResumeOracleCreateRequire(import.meta.url);",
-  },
-  platform: 'node',
-  target: 'node20',
-  format: 'esm',
-  outfile: outPath,
-  minify: false,
-  sourcemap: false,
-  legalComments: 'none',
-  logLevel: 'silent',
-  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
-});
-
-process.stdout.write(outPath + '\n');

package/scripts/build-core-startup-resume-scan-parity-oracle.mjs

@@ -1,296 +0,0 @@
-// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
-// (M3 cluster 10, commander core).
-// Relationship: Builds the TS-side PARITY ORACLE for the startup
-// resurrection scan of the ReScript commander port, the sibling of
-// build-queue-parity-oracle.mjs (cluster 5). The oracle bundles the REAL
-// TS module (src/startupResumeScan.ts - the 2026-07-11
-// lease-adopted-no-resurrection incident fix; dossier:
-// kandan/server_v2/test/fixtures/prod-failures/
-// runner_restart_lease_adopted_no_resurrection_2026-07-11.md) 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
-// CoreStartupResumeScanParityConformance drives the SAME inputs through
-// the ported module and asserts:
-//   - constants parity (terminal statuses, age gate, concurrency /
-//     stagger / retry-backoff ladders);
-//   - fold parity (foldOutboxTurnSignals over raw journal bytes, encoded
-//     in map-insertion order so even the fold's internal ordering is
-//     pinned);
-//   - classification parity (classifyUnfinishedThreadWork matrices);
-//   - scripted SCAN RUNS: runStartupResumeScan with every effect
-//     (inspect/drain/respawn/publish/seq-in-flight/shutdown/sleep/log)
-//     scripted, a virtual clock advanced only by the scripted sleep, and
-//     ONE shared trace of effect calls + log events in order - compared
-//     byte-for-byte across impls, so the bounded scheduler's interleaving
-//     itself (worker pool, shared stagger chain, retry ladders, shutdown
-//     aborts) is the contract.
-//
-// Determinism: nothing in a scan case touches the real clock or timers -
-// sleep records the requested delay, advances the virtual clock, and
-// resolves immediately; scripted effect outcomes resolve in order;
-// shutdown flips on a scripted effect-call count. The driver's effect
-// functions return plain resolved/rejected promises (never async
-// functions) so both impls award identical microtask hops.
-//
-// SECRETS: the oracle only ever sees the conformance suite's synthetic
-// fixtures; 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 {
-  classifyUnfinishedThreadWork,
-  defaultResumeSignalMaxAgeMs,
-  defaultStartupResumeConcurrency,
-  defaultStartupResumeRetryBackoffMs,
-  defaultStartupResumeStaggerMs,
-  defaultStartupRespawnRetryBackoffMs,
-  foldOutboxTurnSignals,
-  runStartupResumeScan,
-  terminalMessageStateStatuses,
-} from './src/startupResumeScan';
-
-// --- Encoding helpers -------------------------------------------------------------
-
-// Signals encoded in MAP-INSERTION ORDER: the fold's internal ordering is
-// part of the parity contract (classification iterates the map).
-function encodeSignals(map) {
-  return Array.from(map.values()).map((signal) => ({
-    sourceSeq: signal.sourceSeq,
-    sawActivity: signal.sawActivity,
-    ...(signal.lastMessageStateStatus === undefined
-      ? {}
-      : { lastMessageStateStatus: signal.lastMessageStateStatus }),
-    ...(signal.newestAtMs === undefined ? {} : { newestAtMs: signal.newestAtMs }),
-  }));
-}
-
-function signalMapOf(spec) {
-  if (typeof spec.journalRaw === 'string') {
-    return foldOutboxTurnSignals(spec.journalRaw);
-  }
-  const map = new Map();
-  for (const signal of spec.signals ?? []) {
-    map.set(signal.sourceSeq, {
-      sourceSeq: signal.sourceSeq,
-      sawActivity: signal.sawActivity ?? false,
-      lastMessageStateStatus: signal.lastMessageStateStatus ?? undefined,
-      newestAtMs: signal.newestAtMs ?? undefined,
-    });
-  }
-  return map;
-}
-
-function inputsOf(spec) {
-  return {
-    pendingInboundSeqs: spec.pendingInboundSeqs ?? [],
-    ackedInboundSeqs: spec.ackedInboundSeqs ?? [],
-    inboundHighWaterSeq: spec.inboundHighWaterSeq ?? undefined,
-    appliedFloorSeq: spec.appliedFloorSeq ?? undefined,
-    outboxTurnSignals: signalMapOf(spec),
-  };
-}
-
-function encodeWork(work) {
-  return {
-    unfinished: work.unfinished,
-    seqs: work.seqs.map((entry) => ({ sourceSeq: entry.sourceSeq, shape: entry.shape })),
-    hasPendingInbound: work.hasPendingInbound,
-    loudTerminalSeqs: [...work.loudTerminalSeqs],
-    watermarkGapOnly: work.watermarkGapOnly,
-  };
-}
-
-// --- Case handlers ----------------------------------------------------------------
-
-function handleConstants() {
-  return {
-    terminalMessageStateStatuses: Array.from(terminalMessageStateStatuses),
-    defaultResumeSignalMaxAgeMs,
-    defaultStartupResumeConcurrency,
-    defaultStartupResumeStaggerMs,
-    defaultStartupResumeRetryBackoffMs: [...defaultStartupResumeRetryBackoffMs],
-    defaultStartupRespawnRetryBackoffMs: [...defaultStartupRespawnRetryBackoffMs],
-  };
-}
-
-function handleFold(testCase) {
-  return { signals: encodeSignals(foldOutboxTurnSignals(testCase.raw ?? '')) };
-}
-
-function handleClassify(testCase) {
-  return encodeWork(
-    classifyUnfinishedThreadWork(inputsOf(testCase.inputs ?? {}), {
-      nowMs: testCase.nowMs ?? 0,
-      maxSignalAgeMs: testCase.maxSignalAgeMs ?? undefined,
-    })
-  );
-}
-
-// One scripted scan run. Every effect resolves from the case script; the
-// shared events array is the trace both impls must reproduce byte for
-// byte (virtual-time stamps included).
-async function handleScan(testCase) {
-  const options = testCase.options ?? {};
-  const threads = testCase.threads ?? [];
-  const events = [];
-  let vnow = 0;
-  let effectOps = 0;
-  const shutdownAfterOps = options.shutdownAfterOps ?? undefined;
-  const scripts = new Map(
-    threads.map((thread) => [
-      thread.threadId,
-      {
-        drain: [...(thread.drainScript ?? [])],
-        respawn: [...(thread.respawnScript ?? [])],
-        publish: [...(thread.publishScript ?? [])],
-        inFlight: new Set(thread.inFlightSeqs ?? []),
-      },
-    ])
-  );
-
-  const summary = await runStartupResumeScan({
-    records: threads,
-    threadId: (record) => record.threadId,
-    inspect: (record) => {
-      events.push({ e: 'inspect', vt: vnow, thread: record.threadId });
-      const spec = record.inspect ?? {};
-      if (typeof spec.throw === 'string') {
-        throw new Error(spec.throw);
-      }
-      return inputsOf(spec);
-    },
-    resumePendingInbound: (record) => {
-      effectOps += 1;
-      const step = scripts.get(record.threadId).drain.shift() ?? 'clear';
-      if (typeof step === 'object' && step !== null) {
-        events.push({
-          e: 'drain',
-          vt: vnow,
-          thread: record.threadId,
-          outcome: 'throw:' + step.throw,
-        });
-        return Promise.reject(new Error(step.throw));
-      }
-      events.push({ e: 'drain', vt: vnow, thread: record.threadId, outcome: step });
-      return Promise.resolve(step);
-    },
-    respawnWorker: (record) => {
-      effectOps += 1;
-      const step = scripts.get(record.threadId).respawn.shift() ?? true;
-      if (typeof step === 'object' && step !== null) {
-        events.push({
-          e: 'respawn',
-          vt: vnow,
-          thread: record.threadId,
-          outcome: 'throw:' + step.throw,
-        });
-        return Promise.reject(new Error(step.throw));
-      }
-      events.push({ e: 'respawn', vt: vnow, thread: record.threadId, outcome: step });
-      return Promise.resolve(step);
-    },
-    seqInFlight: (record, sourceSeq) => scripts.get(record.threadId).inFlight.has(sourceSeq),
-    publishInterruptedTurnState: (record, sourceSeq, shape) => {
-      effectOps += 1;
-      const step = scripts.get(record.threadId).publish.shift() ?? 'ok';
-      if (typeof step === 'object' && step !== null) {
-        events.push({
-          e: 'publish',
-          vt: vnow,
-          thread: record.threadId,
-          seq: sourceSeq,
-          shape,
-          outcome: 'throw:' + step.throw,
-        });
-        return Promise.reject(new Error(step.throw));
-      }
-      events.push({
-        e: 'publish',
-        vt: vnow,
-        thread: record.threadId,
-        seq: sourceSeq,
-        shape,
-        outcome: step,
-      });
-      return Promise.resolve(undefined);
-    },
-    shuttingDown: () => shutdownAfterOps !== undefined && effectOps >= shutdownAfterOps,
-    log: (event, fields) => {
-      events.push({ e: 'log', vt: vnow, event, fields });
-    },
-    nowMs: options.nowMs ?? 0,
-    maxSignalAgeMs: options.maxSignalAgeMs ?? undefined,
-    concurrency: options.concurrency ?? undefined,
-    staggerMs: options.staggerMs ?? undefined,
-    retryBackoffMs: options.retryBackoffMs ?? undefined,
-    respawnRetryBackoffMs: options.respawnRetryBackoffMs ?? undefined,
-    sleep: (ms) => {
-      effectOps += 1;
-      events.push({ e: 'sleep', vt: vnow, ms });
-      vnow += ms;
-      return Promise.resolve(undefined);
-    },
-  });
-
-  return { summary, events };
-}
-
-async function handle(testCase) {
-  switch (testCase.op) {
-    case 'constants':
-      return handleConstants();
-    case 'fold':
-      return handleFold(testCase);
-    case 'classify':
-      return handleClassify(testCase);
-    case 'scan':
-      return await handleScan(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 after stdout is fully flushed (the cluster 5 lesson: 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: 'core-startup-resume-scan-parity-driver.ts',
-    loader: 'ts',
-  },
-  bundle: true,
-  platform: 'node',
-  target: 'node20',
-  format: 'esm',
-  outfile: join(packageRoot, '.differential/core-startup-resume-scan-parity-oracle.mjs'),
-  minify: false,
-  sourcemap: false,
-  legalComments: 'none',
-  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
-});