@linzumi/cli 1.0.111 → 1.0.113

package/scripts/build-core-generation-overlap-parity-oracle.mjs

@@ -0,0 +1,288 @@
+// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
+// (M3 cluster 10, commander core) +
+// plans/2026-07-11-runner-generation-overlap-zero-downtime-updates.md
+// (the ported surface's own spec, CLI half #2981).
+// Relationship: Builds the TS-side PARITY ORACLE for the generation-overlap
+// slice of the ReScript commander port, the sibling of
+// build-pipeline-parity-oracle.mjs (cluster 9) and
+// build-session-registry-parity-oracle.mjs (cluster 6). The oracle bundles
+// the REAL TS generation-overlap module (src/generationOverlap.ts) - env
+// flag/readers, join-hello envelope, the supervisor<->child IPC codec, the
+// per-process overlap runtime, the dispatch gate's held-control queues,
+// and the cursor-persistence freeze - behind the cluster 1/2 one-shot
+// BATCH driver (a JSON array of cases on stdin, a JSON array of results on
+// stdout).
+//
+// Byte parity: envelopes, parsed/built IPC frames, and every scripted
+// trace entry are returned VERBATIM (the TS objects' own key order rides
+// JSON.stringify), so the ReScript side must reproduce field presence AND
+// insertion order exactly - the hello and IPC payloads are frozen wire
+// bytes. Determinism: nothing here reads env, clocks, or process.send -
+// env dicts are scripted per case, the runtime's send seam is injected,
+// and runtime/gate/freeze flows are driven by scripted op arrays.
+//
+// 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 { 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 {
+  buildGenerationIpcMessage,
+  createGenerationDispatchGate,
+  createGenerationOverlapRuntime,
+  defaultGenerationStillbornWindowMs,
+  generationEpochEnvKey,
+  generationHandoffPidEnvKey,
+  generationHelloEnvelope,
+  generationOverlapFlagEnvKey,
+  generationStillbornWindowEnvKey,
+  isGenerationOverlapEnabled,
+  parseGenerationIpcMessage,
+  readGenerationEpoch,
+  readGenerationHandoffPid,
+  resolveGenerationStillbornWindowMs,
+  withGenerationCursorFreeze,
+} from './src/generationOverlap';
+
+// Scripted runtime flow: hooks/log/send all trace-recording, ops drive the
+// REAL createGenerationOverlapRuntime.
+function runRuntimeCase(caseInput) {
+  const trace = [];
+  let sendOk = true;
+  const runtime = createGenerationOverlapRuntime({
+    env: caseInput.env,
+    log: (event, fields) => trace.push({ t: 'log', event, fields }),
+    send: (message) => {
+      trace.push({ t: 'send', message, ok: sendOk });
+      return sendOk;
+    },
+  });
+  if (runtime === undefined) {
+    return { created: false, trace };
+  }
+  if (caseInput.installHooks !== false) {
+    runtime.hooks.onOverlapDrain = (incomingEpoch) =>
+      trace.push({ t: 'hook.overlapDrain', incomingEpoch });
+    runtime.hooks.onOverlapAbort = () => trace.push({ t: 'hook.overlapAbort' });
+    runtime.hooks.onPinsReleased = (released) =>
+      trace.push({ t: 'hook.pinsReleased', released });
+    runtime.hooks.onPromote = () => trace.push({ t: 'hook.promote' });
+  }
+  for (const op of caseInput.ops ?? []) {
+    if (op.op === 'ipc') runtime.handleIpcMessage(op.value);
+    else if (op.op === 'beginDrain') runtime.beginOutgoingDrain(op.threadIds);
+    else if (op.op === 'send') {
+      const message = parseGenerationIpcMessage(op.message);
+      if (message === undefined) trace.push({ t: 'sendSkipped' });
+      else runtime.sendToSupervisor(message);
+    } else if (op.op === 'sendResult') sendOk = op.ok === true;
+    else if (op.op === 'pinOutgoing') runtime.outgoingPins.pin(op.threadId);
+    else if (op.op === 'releaseOutgoing')
+      trace.push({
+        t: 'released',
+        threadId: op.threadId,
+        released: runtime.outgoingPins.release(op.threadId),
+      });
+    else if (op.op === 'seams') {
+      runtime.requestUpdateDrain('parity-trigger');
+      trace.push({
+        t: 'seams',
+        cancel: runtime.cancelUpdateDrain('parity-reason'),
+        promote: runtime.promoteRunnerLock(),
+      });
+    } else if (op.op === 'query')
+      trace.push({
+        t: 'query',
+        epoch: runtime.epoch,
+        handoffFromPid: runtime.handoffFromPid ?? null,
+        outgoingDrainActive: runtime.outgoingDrainActive(),
+        pinsKnown: runtime.pinsKnown(),
+        role: runtime.currentRole() ?? null,
+        outgoingPins: runtime.outgoingPins.snapshot(),
+        incomingPins: runtime.incomingPins.snapshot(),
+      });
+  }
+  return { created: true, trace };
+}
+
+// Scripted gate flow: controls are plain JSON envelopes; the extractors
+// mirror the runner wiring (threadIdOf / controlTypeOf injected).
+function runGateCase(caseInput) {
+  const trace = [];
+  const runtime = createGenerationOverlapRuntime({
+    env: caseInput.env,
+    log: (event, fields) => trace.push({ t: 'log', event, fields }),
+    send: () => true,
+  });
+  if (runtime === undefined) {
+    return { created: false, trace };
+  }
+  const gate = createGenerationDispatchGate({
+    runtime,
+    threadIdOf: (control) =>
+      typeof control.threadId === 'string' ? control.threadId : undefined,
+    controlTypeOf: (control) =>
+      typeof control.type === 'string' ? control.type : '',
+    dispatch: (control, ack) => {
+      trace.push({
+        t: 'dispatched',
+        id: control.id ?? null,
+        threadId: typeof control.threadId === 'string' ? control.threadId : null,
+      });
+      ack();
+    },
+    log: (event, fields) => trace.push({ t: 'log', event, fields }),
+  });
+  for (const op of caseInput.ops ?? []) {
+    if (op.op === 'control') {
+      const control = op.control;
+      gate.dispatch(control, () =>
+        trace.push({ t: 'ack', id: control.id ?? null })
+      );
+    } else if (op.op === 'ipc') runtime.handleIpcMessage(op.value);
+    else if (op.op === 'beginDrain') runtime.beginOutgoingDrain(op.threadIds);
+    else if (op.op === 'dispatchUnpinned')
+      trace.push({ t: 'dispatchUnpinned', count: gate.dispatchUnpinned() });
+    else if (op.op === 'redispatch')
+      trace.push({ t: 'redispatch', count: gate.redispatchDeferredToIncoming() });
+    else if (op.op === 'held') {
+      const counts = gate.heldCounts();
+      trace.push({
+        t: 'held',
+        deferredToIncoming: counts.deferredToIncoming,
+        deferredPinned: counts.deferredPinned,
+      });
+    }
+  }
+  return { created: true, trace };
+}
+
+// Scripted cursor-freeze flow: the underlying store is trace-recording;
+// ops toggle the frozen predicate and drive the wrapped store.
+function runFreezeCase(caseInput) {
+  const trace = [];
+  let frozen = false;
+  const store = {
+    initial: (topic) => (caseInput.initialValues ?? {})[topic],
+    onAdvance: (topic, seq) => trace.push({ t: 'store.onAdvance', topic, seq }),
+    reset:
+      caseInput.hasReset === false
+        ? undefined
+        : (topic, seq) => trace.push({ t: 'store.reset', topic, seq }),
+    flush: () => trace.push({ t: 'store.flush' }),
+    epoch: () =>
+      typeof caseInput.storeEpoch === 'string' ? caseInput.storeEpoch : undefined,
+    adoptEpoch: (epoch) => {
+      trace.push({ t: 'store.adoptEpoch', epoch });
+      return caseInput.adoptResult === true;
+    },
+  };
+  const wrapped = withGenerationCursorFreeze(store, () => frozen);
+  for (const op of caseInput.ops ?? []) {
+    if (op.op === 'setFrozen') frozen = op.value === true;
+    else if (op.op === 'initial')
+      trace.push({ t: 'initial', topic: op.topic, value: wrapped.initial(op.topic) ?? null });
+    else if (op.op === 'advance') wrapped.onAdvance(op.topic, op.seq);
+    else if (op.op === 'reset') {
+      if (wrapped.reset === undefined) trace.push({ t: 'resetUnavailable' });
+      else wrapped.reset(op.topic, op.seq);
+    } else if (op.op === 'flush') wrapped.flush();
+    else if (op.op === 'epoch')
+      trace.push({ t: 'epoch', value: wrapped.epoch() ?? null });
+    else if (op.op === 'adoptEpoch')
+      trace.push({ t: 'adoptEpoch', result: wrapped.adoptEpoch(op.epoch) });
+  }
+  return { trace };
+}
+
+function runCase(input) {
+  switch (input.kind) {
+    case 'constants':
+      return {
+        flagKey: generationOverlapFlagEnvKey,
+        epochKey: generationEpochEnvKey,
+        handoffPidKey: generationHandoffPidEnvKey,
+        stillbornWindowKey: generationStillbornWindowEnvKey,
+        defaultStillbornWindowMs: defaultGenerationStillbornWindowMs,
+      };
+    case 'envRead': {
+      if (input.which === 'enabled') return isGenerationOverlapEnabled(input.env);
+      if (input.which === 'epoch') return readGenerationEpoch(input.env) ?? null;
+      if (input.which === 'handoffPid')
+        return readGenerationHandoffPid(input.env) ?? null;
+      return resolveGenerationStillbornWindowMs(input.env);
+    }
+    case 'helloEnvelope':
+      return generationHelloEnvelope(input.env);
+    case 'parseIpc': {
+      const parsed = parseGenerationIpcMessage(input.value);
+      return parsed === undefined ? null : parsed;
+    }
+    case 'buildIpc': {
+      const parsed = parseGenerationIpcMessage(input.message);
+      return parsed === undefined ? { unparsable: true } : buildGenerationIpcMessage(parsed);
+    }
+    case 'runtimeRun':
+      return runRuntimeCase(input);
+    case 'gateRun':
+      return runGateCase(input);
+    case 'freezeRun':
+      return runFreezeCase(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) {
+    results.push(runCase(testCase));
+  }
+  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-generation-overlap-parity-oracle.mjs');
+
+await mkdir(outDir, { recursive: true });
+
+await build({
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'core-generation-overlap-parity-driver.ts',
+    loader: 'ts',
+  },
+  bundle: true,
+  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-integration-parity-oracle.mjs

@@ -0,0 +1,361 @@
+// 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 the pipeline
+// INTEGRATION module of the ReScript commander port, the sibling of
+// build-pipeline-parity-oracle.mjs (cluster 9) and
+// build-queue-parity-oracle.mjs (cluster 5). The oracle bundles the REAL
+// TS pipeline integration module (src/pipeline/integration.ts - the
+// per-session loop + outbox lifecycle, the outbox entry builders, and the
+// completion-snapshot resolution helpers) plus the real phoenix push-error
+// factory and the turnTrace per-thread traceparent registry, behind the
+// cluster 1/2 one-shot BATCH driver (a JSON array of cases on stdin, a
+// JSON array of results on stdout).
+//
+// Byte parity: builder results and snapshot-helper outputs are returned
+// VERBATIM (the TS object literals' own key order rides JSON.stringify),
+// and scripted SESSION runs return their full event trace - pushes with
+// complete payloads, acks/failures, snapshot resolutions, terminal
+// callbacks, log events, flushes, metrics counters, close - so the
+// ReScript side must reproduce field presence AND insertion order exactly.
+// Determinism: hosts are fully scripted (push outcomes, snapshot outcomes,
+// wire contexts, envelope shapes, recovered turns, runtime metadata);
+// retry cadences are configured to millisecond-scale delays so the traces
+// pin the LOGGED delay values while real time stays tiny; the stats
+// interval is disabled (0) in session runs; traces capture only
+// deterministic metric counters (never wall-clock ages).
+//
+// 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 { 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 {
+  createSessionPipeline,
+  createSessionPipelineBuilders,
+  defaultOutboxMaxInFlightPushes,
+  isConnectionLostPushError,
+  isConnectionWaitPushError,
+  mergeSnapshotItems,
+  preReduceSnapshotItems,
+  rawSnapshotItemsForTurn,
+} from './src/pipeline/integration';
+import { outboxEntryKinds } from './src/pipeline/contracts';
+import { phoenixPushErrors } from './src/phoenix';
+import {
+  rememberTurnTraceparent,
+  __resetTurnTraceparentsForTest,
+} from './src/turnTrace';
+
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// The scripted row-command envelope shared with the ReScript conformance
+// side (both implement this exact shape over the same case JSON, so the
+// seam itself is identical while the builder's spread/override semantics
+// around it are what the comparison pins).
+function scriptedEnvelope(caseInput) {
+  return (eventType, sessionId, sourceMessageSeq, extraMetadata) => ({
+    ...(caseInput.envelopeBase ?? {}),
+    type: eventType,
+    thread: sessionId,
+    ...(sourceMessageSeq === undefined ? {} : { envelope_seq: sourceMessageSeq }),
+    ...(extraMetadata === undefined ? {} : { local_runner_metadata: extraMetadata }),
+  });
+}
+
+function wireOf(spec) {
+  return {
+    workspaceSlug: spec.workspaceSlug,
+    channelSlug: spec.channelSlug,
+    kandanThreadId: spec.threadId ?? undefined,
+    codexThreadId: spec.harnessSessionId ?? undefined,
+    rootSeq: spec.rootSeq ?? undefined,
+    ...(spec.leaseEpoch === undefined ? {} : { leaseEpoch: spec.leaseEpoch }),
+  };
+}
+
+function seedTraceparents(caseInput) {
+  __resetTurnTraceparentsForTest();
+  for (const entry of caseInput.traceparents ?? []) {
+    rememberTurnTraceparent(entry.threadId, entry.traceparent);
+  }
+}
+
+function runBuildersCase(caseInput) {
+  seedTraceparents(caseInput);
+  const recovered = new Set(caseInput.recoveredTurns ?? []);
+  const wires = (caseInput.wires ?? []).map(wireOf);
+  let wireIndex = 0;
+  const builders = createSessionPipelineBuilders({
+    instanceId: caseInput.instanceId ?? 'instance-parity',
+    wire: () => wires[wireIndex],
+    runnerPayload: scriptedEnvelope(caseInput),
+    isRecoveredTurn: (turnId) => recovered.has(turnId),
+  });
+  const context = {
+    remember: () => {},
+    recall: () => undefined,
+  };
+  return {
+    results: (caseInput.calls ?? []).map((call) => {
+      wireIndex = call.wireIndex ?? 0;
+      const builder = builders[call.kind];
+      if (builder === undefined) {
+        return { missingBuilder: true };
+      }
+      return builder.build(call.data ?? {}, context);
+    }),
+  };
+}
+
+function scriptedFailure(spec) {
+  switch (spec.factory) {
+    case 'socketClosed':
+      return phoenixPushErrors.socketClosed();
+    case 'reconnectFailed':
+      return phoenixPushErrors.reconnectFailed();
+    case 'socketNotOpen':
+      return phoenixPushErrors.socketNotOpen();
+    case 'clientClosedWait':
+      return phoenixPushErrors.clientClosed('wait_for_connection');
+    case 'clientClosedReply':
+      return phoenixPushErrors.clientClosed('reply');
+    case 'notConnected':
+      return phoenixPushErrors.notConnected();
+    case 'connectionWaitTimeout':
+      return phoenixPushErrors.connectionWaitTimeout(spec.timeoutMs ?? 5, spec.event ?? 'evt');
+    case 'replyTimeout':
+      return phoenixPushErrors.replyTimeout(spec.timeoutMs ?? 5, spec.event ?? 'evt');
+    default:
+      return new Error(spec.message ?? 'scripted push failure');
+  }
+}
+
+function runClassifierCase(caseInput) {
+  const failure = scriptedFailure(caseInput.failure ?? {});
+  return {
+    lost: isConnectionLostPushError(failure),
+    wait: isConnectionWaitPushError(failure),
+    message: failure.message,
+  };
+}
+
+async function runSessionCase(caseInput) {
+  seedTraceparents(caseInput);
+  const trace = [];
+  const recovered = new Set(caseInput.recoveredTurns ?? []);
+  const wires = (caseInput.wires ?? []).map(wireOf);
+  let wireIndex = 0;
+  const turnSeqs = new Map();
+  const retryAttempts = new Map();
+  const resumeAttempts = new Map();
+  const ladders = new Map();
+  const runtimeMetadata = new Map();
+  for (const entry of caseInput.runtimeMetadata ?? []) {
+    runtimeMetadata.set(entry.seq, entry.metadata);
+  }
+  const pushScript = [...(caseInput.pushScript ?? [])];
+  const snapshotScript = new Map();
+  for (const entry of caseInput.snapshotScript ?? []) {
+    const queue = snapshotScript.get(entry.turnId) ?? [];
+    queue.push(entry);
+    snapshotScript.set(entry.turnId, queue);
+  }
+
+  const pipeline = createSessionPipeline({
+    instanceId: caseInput.instanceId ?? 'instance-parity',
+    threadKey: caseInput.threadKey ?? 'thread-parity',
+    persistDir: undefined,
+    push: async (event, payload, _timeoutMs, onSent) => {
+      trace.push({ t: 'push', event, payload });
+      onSent?.();
+      const step = pushScript.shift() ?? { kind: 'ack' };
+      if (step.delayMs !== undefined) {
+        await sleep(step.delayMs);
+      }
+      if (step.kind === 'ack') {
+        trace.push({ t: 'ack' });
+        return step.reply ?? { ok: true };
+      }
+      trace.push({ t: 'pushFail', mode: step.mode ?? 'plain' });
+      if (step.mode === 'wait') {
+        throw phoenixPushErrors.connectionWaitTimeout(5, event);
+      }
+      if (step.mode === 'lost') {
+        throw phoenixPushErrors.socketClosed();
+      }
+      throw new Error(step.message ?? 'scripted push failure');
+    },
+    wire: () => wires[wireIndex],
+    runnerPayload: scriptedEnvelope(caseInput),
+    runtimeMetadataForSourceSeq: (seq) =>
+      seq === undefined ? undefined : runtimeMetadata.get(seq),
+    sourceSeqForTurn: (turnId) => turnSeqs.get(turnId),
+    autoRetryAttemptsForSeq: (seq) => retryAttempts.get(seq) ?? 0,
+    midStreamResumeAttemptAtMsForSeq: (seq) => resumeAttempts.get(seq),
+    ladderHistoryForSeq: (seq, fate) => ladders.get(seq + ':' + fate),
+    isRecoveredTurn: (turnId) => recovered.has(turnId),
+    resolveSnapshot: async (turnId) => {
+      const queue = snapshotScript.get(turnId) ?? [];
+      const step = queue.shift() ?? { ok: true, items: [] };
+      trace.push({ t: 'resolveSnapshot', turnId, ok: step.ok === true });
+      if (step.delayMs !== undefined) {
+        await sleep(step.delayMs);
+      }
+      if (step.ok === true) {
+        return { items: step.items ?? [] };
+      }
+      throw new Error(step.message ?? 'scripted snapshot failure');
+    },
+    onTurnTerminal: (turnId, outcome, reason, retryableEmptyTurn, autoResume, fate) => {
+      trace.push({
+        t: 'terminal',
+        turnId,
+        outcome,
+        reason: reason ?? null,
+        retryableEmptyTurn: retryableEmptyTurn === true,
+        autoResumeMidStreamStall: autoResume === true,
+        fate: fate ?? null,
+      });
+    },
+    log: (event, fields) => {
+      trace.push({ t: 'log', event, fields });
+    },
+    linzumiAgentSession: caseInput.linzumiAgentSession === true,
+    outboxRetryDelaysMs: caseInput.outboxRetryDelaysMs ?? [1, 2],
+    outboxMaxInFlightPushes: caseInput.maxInFlightPushes ?? 1,
+    snapshotRetryDelaysMs: caseInput.snapshotRetryDelaysMs ?? undefined,
+    // Determinism: the periodic stats interval is disabled; the reporter
+    // still stops on close in the same order as production.
+    statsIntervalMs: 0,
+  });
+
+  for (const op of caseInput.ops ?? []) {
+    if (op.op === 'submit') pipeline.submitNotification(op.method, op.params ?? undefined);
+    else if (op.op === 'mapTurn') turnSeqs.set(op.turnId, op.seq);
+    else if (op.op === 'retryAttempts') retryAttempts.set(op.seq, op.attempts);
+    else if (op.op === 'resumeAttemptAt') resumeAttempts.set(op.seq, op.atMs);
+    else if (op.op === 'ladder') ladders.set(op.seq + ':' + op.fate, op.ladder);
+    else if (op.op === 'recover') recovered.add(op.turnId);
+    else if (op.op === 'notifyReady') pipeline.notifyTurnMappingReady(op.turnId);
+    else if (op.op === 'notifyFailed') pipeline.notifyTurnMappingFailed(op.turnId, op.reason);
+    else if (op.op === 'noteActivity') pipeline.noteTurnActivity(op.turnId, op.kind);
+    else if (op.op === 'lifecycle') pipeline.submitLifecycle(op.kind, op.reason);
+    else if (op.op === 'pause') pipeline.pause();
+    else if (op.op === 'resume') pipeline.resume();
+    else if (op.op === 'rebind') pipeline.rebindThreadKey(op.threadKey);
+    else if (op.op === 'setWire') wireIndex = op.index;
+    else if (op.op === 'sleep') await sleep(op.ms);
+    else if (op.op === 'metrics') {
+      const metrics = pipeline.metrics();
+      trace.push({
+        t: 'metrics',
+        value: {
+          depth: metrics.depth,
+          totalEnqueued: metrics.totalEnqueued,
+          totalAcked: metrics.totalAcked,
+          totalRetried: metrics.totalRetried,
+          totalDroppedBestEffort: metrics.totalDroppedBestEffort,
+          totalPermanentFailures: metrics.totalPermanentFailures,
+          paused: metrics.paused,
+        },
+      });
+    } else if (op.op === 'flush') {
+      try {
+        await pipeline.flushOutbox(op.timeoutMs ?? undefined);
+        trace.push({ t: 'flushed', ok: true });
+      } catch (error) {
+        trace.push({
+          t: 'flushed',
+          ok: false,
+          message: error instanceof Error ? error.message : String(error),
+        });
+      }
+    } else if (op.op === 'close') {
+      await pipeline.close(op.timeoutMs ?? undefined);
+      trace.push({ t: 'closed' });
+    }
+  }
+  return { trace };
+}
+
+async function runCase(input) {
+  switch (input.kind) {
+    case 'constants':
+      return {
+        defaultOutboxMaxInFlightPushes,
+        outboxEntryKinds,
+      };
+    case 'builders':
+      return runBuildersCase(input);
+    case 'classifier':
+      return runClassifierCase(input);
+    case 'rawItems':
+      return rawSnapshotItemsForTurn(input.response, input.turnId);
+    case 'preReduce':
+      return preReduceSnapshotItems(input.items);
+    case 'merge':
+      return mergeSnapshotItems(input.readItems, input.sessionItems);
+    case 'sessionRun':
+      return runSessionCase(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) {
+    results.push(await runCase(testCase));
+  }
+  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-integration-parity-oracle.mjs');
+
+await mkdir(outDir, { recursive: true });
+
+await build({
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'core-integration-parity-driver.ts',
+    loader: 'ts',
+  },
+  bundle: true,
+  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');