@linzumi/cli 1.0.110 → 1.0.112

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

@@ -0,0 +1,610 @@
+// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
+// (M3 cluster 9, pipeline).
+// Relationship: Builds the TS-side PARITY ORACLE for the pipeline cluster
+// of the ReScript commander port, the sibling of
+// build-queue-parity-oracle.mjs (cluster 5) and
+// build-harness-codex-parity-oracle.mjs (cluster 7). The oracle bundles
+// the REAL TS pipeline surface - the pure transition core
+// (src/pipeline/transition.ts + contracts + itemProjection, transitively
+// the item-output rendering slice), the thread event-loop driver
+// (threadEventLoop.ts), the stats reporter + turn-stall detector
+// (statsReporter.ts), and the two recovery watchdog primitives
+// (claudeCodeTurnStallWatchdog.ts / claudeCodeDispatchLivenessWatchdog.ts)
+// - 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: transition effects are returned VERBATIM (the TS effect
+// objects' own key order rides JSON.stringify), so the ReScript side's
+// effectToJson must reproduce field presence AND insertion order exactly.
+// Determinism: clocks are injected per case (now()/scripted advance ops),
+// the driver's sweep interval is disabled (0) in loop cases, and watchdog
+// timers ride a scripted timer seam fired in scheduling order - nothing
+// here reads wall time.
+//
+// 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 {
+  classifyRejectionRetry,
+  classifyStallWindowEvidence,
+  createInitialLoopState,
+  idleStreamStallDisposition,
+  isUpstreamTerminal4xxHttpStatus,
+  maxConsecutiveEmptyTurns,
+  maxEmptyTurnAutoRetries,
+  maxIsolatedRejectionRetries,
+  maxReasoningStepsWithoutProgress,
+  maxTerminalTurnIds,
+  agentNarrationOnlyCompletionReason,
+  agentNarrationOnlyEmptyTurnCause,
+  autoRetriesBurnedSuffix,
+  completedWithoutAssistantOutputReason,
+  costCapAutoRetrySuppressedSuffix,
+  emptyTurnLoopGuardReason,
+  linzumiAgentReplyToolName,
+  midStreamResumeIncompleteSuffix,
+  midStreamResumeRateLimitSuppressedSuffix,
+  midStreamResumeStalledAgainSuffix,
+  reasoningLoopBreakerReason,
+  stallWindowEvidenceSignalClasses,
+  stallWindowRateLimited,
+  transition,
+  turnMappingFailedMethod,
+  turnMappingReadyMethod,
+  unsupportedCodexToolCallReasonPrefix,
+  upstreamHttpStatusRetryClass,
+  upstreamTurnErrorSummary,
+} from './src/pipeline/transition';
+import { pipelineItemKey, outboxEntryKinds } from './src/pipeline/contracts';
+import {
+  explicitNotificationItemId,
+  notificationTurnId,
+  pipelineClientMessageId,
+  projectSnapshotItems,
+} from './src/pipeline/itemProjection';
+import {
+  createThreadEventLoop,
+  defaultBufferedTurnMaxAgeMs,
+  defaultBufferedTurnMaxEvents,
+  defaultBufferedTurnSweepIntervalMs,
+} from './src/pipeline/threadEventLoop';
+import {
+  createPipelineStatsReporter,
+  defaultPipelineStatsIntervalMs,
+  defaultPipelineTurnStalledThresholdMs,
+  openItemTurnStalledThresholdMultiplier,
+} from './src/pipeline/statsReporter';
+import {
+  createClaudeCodeTurnStallWatchdog,
+  defaultClaudeCodeTurnStallThresholdMs,
+} from './src/claudeCodeTurnStallWatchdog';
+import {
+  armClaudeCodeDispatchLivenessWatchdog,
+  defaultClaudeCodeDispatchLivenessWindowMs,
+} from './src/claudeCodeDispatchLivenessWatchdog';
+
+// Scripted deps table shared by transition + loop runs. sourceSeq
+// mappings, burned-retry counts, resume attempts, and ladder receipts are
+// mutated by ops so terminal-time reads see the scripted values.
+function scriptedDeps(caseInput, tables) {
+  return {
+    threadKey: caseInput.threadKey ?? 'thread-parity',
+    instanceId: caseInput.instanceId ?? 'instance-parity',
+    sourceSeqForTurn: (turnId) => tables.turnSeqs.get(turnId),
+    autoRetryAttemptsForSeq: (seq) => tables.retryAttempts.get(seq) ?? 0,
+    midStreamResumeAttemptAtMsForSeq: (seq) => tables.resumeAttempts.get(seq),
+    ladderHistoryForSeq: (seq, fate) => tables.ladders.get(seq + ':' + fate),
+    linzumiAgentSession: caseInput.linzumiAgentSession === true,
+  };
+}
+
+function applyTableOp(tables, op) {
+  if (op.op === 'mapTurn') tables.turnSeqs.set(op.turnId, op.seq);
+  if (op.op === 'unmapTurn') tables.turnSeqs.delete(op.turnId);
+  if (op.op === 'retryAttempts') tables.retryAttempts.set(op.seq, op.attempts);
+  if (op.op === 'resumeAttemptAt') tables.resumeAttempts.set(op.seq, op.atMs);
+  if (op.op === 'ladder') tables.ladders.set(op.seq + ':' + op.fate, op.ladder);
+}
+
+function newTables() {
+  return {
+    turnSeqs: new Map(),
+    retryAttempts: new Map(),
+    resumeAttempts: new Map(),
+    ladders: new Map(),
+  };
+}
+
+function runTransitionCase(caseInput) {
+  const tables = newTables();
+  const state = createInitialLoopState();
+  const deps = scriptedDeps(caseInput, tables);
+  const steps = [];
+  for (const op of caseInput.ops ?? []) {
+    if (op.op === 'event') {
+      steps.push(transition(state, op.event, deps));
+    } else {
+      applyTableOp(tables, op);
+    }
+  }
+  return { steps };
+}
+
+function runLoopCase(caseInput) {
+  const tables = newTables();
+  let nowMs = caseInput.startMs ?? 0;
+  const trace = [];
+  const outbox = {
+    enqueue: (entry) => {
+      trace.push({
+        t: 'enqueue',
+        kind: entry.kind,
+        data: entry.data,
+        coalesceKey: entry.coalesceKey ?? null,
+        resolution: entry.resolution,
+      });
+      return 0;
+    },
+    flush: async () => {
+      if (caseInput.flushFails === true) {
+        throw new Error('scripted flush failure');
+      }
+      trace.push({ t: 'flushed' });
+    },
+    pause: () => {},
+    resume: () => {},
+    metrics: () => {
+      throw new Error('not used');
+    },
+    close: async () => {},
+  };
+  const loop = createThreadEventLoop({
+    threadKey: caseInput.threadKey ?? 'thread-parity',
+    outbox,
+    sourceSeqForTurn: (turnId) => tables.turnSeqs.get(turnId),
+    autoRetryAttemptsForSeq: (seq) => tables.retryAttempts.get(seq) ?? 0,
+    midStreamResumeAttemptAtMsForSeq: (seq) => tables.resumeAttempts.get(seq),
+    ladderHistoryForSeq: (seq, fate) => tables.ladders.get(seq + ':' + fate),
+    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,
+      });
+    },
+    requestSnapshot: (turnId) => {
+      trace.push({ t: 'requestSnapshot', turnId });
+    },
+    instanceId: caseInput.instanceId ?? 'instance-parity',
+    log: (event, fields) => {
+      trace.push({ t: 'log', event, fields });
+    },
+    linzumiAgentSession: caseInput.linzumiAgentSession === true,
+    now: () => nowMs,
+    bufferedTurnMaxAgeMs: caseInput.bufferedTurnMaxAgeMs,
+    bufferedTurnMaxEvents: caseInput.bufferedTurnMaxEvents,
+    // Determinism: the quiet-period sweep timer is disabled; the age cap
+    // still applies on every processed event.
+    bufferedTurnSweepIntervalMs: 0,
+  });
+  const metricsJson = () => {
+    const metrics = loop.metrics();
+    return {
+      queueDepth: metrics.queueDepth,
+      phase: metrics.phase,
+      activeTurns: metrics.activeTurns.map((turn) => ({
+        turnId: turn.turnId,
+        sourceSeq: turn.sourceSeq,
+        startedAtMs: turn.startedAtMs,
+        lastActivityAtMs: turn.lastActivityAtMs ?? null,
+        lastActivityKind: turn.lastActivityKind ?? null,
+        openItems: (turn.openItems ?? []).map((item) => ({
+          kind: item.kind,
+          startedAtMs: item.startedAtMs,
+        })),
+      })),
+      bufferedTurns: metrics.bufferedTurns.map((turn) => ({
+        turnId: turn.turnId,
+        bufferedEventCount: turn.bufferedEventCount,
+        firstBufferedAtMs: turn.firstBufferedAtMs,
+        lastActivityAtMs: turn.lastActivityAtMs ?? null,
+        lastActivityKind: turn.lastActivityKind ?? null,
+        openItems: (turn.openItems ?? []).map((item) => ({
+          kind: item.kind,
+          startedAtMs: item.startedAtMs,
+        })),
+      })),
+    };
+  };
+  const run = async () => {
+    for (const op of caseInput.ops ?? []) {
+      if (op.op === 'submit') loop.submit(op.event);
+      else if (op.op === 'advance') nowMs = op.toMs;
+      else if (op.op === 'metrics') trace.push({ t: 'metrics', value: metricsJson() });
+      else if (op.op === 'noteActivity') loop.noteTurnActivity(op.turnId, op.kind);
+      else if (op.op === 'drainAndClose') {
+        await loop.drainAndClose(op.timeoutMs);
+        trace.push({ t: 'drained' });
+      } else applyTableOp(tables, op);
+    }
+  };
+  return run().then(() => ({ trace }));
+}
+
+function runStatsCase(caseInput) {
+  let nowMs = caseInput.startMs ?? 0;
+  let outboxMetrics = caseInput.outbox;
+  let loopMetrics = caseInput.loop;
+  let waits = caseInput.waits ?? [];
+  const trace = [];
+  const reporter = createPipelineStatsReporter({
+    threadKey: caseInput.threadKey ?? 'thread-parity',
+    outboxMetrics: () => ({
+      ...outboxMetrics,
+      oldestEntryAgeMs: outboxMetrics.oldestEntryAgeMs ?? undefined,
+      pushLatency: outboxMetrics.pushLatency ?? undefined,
+    }),
+    loopMetrics: () => ({
+      queueDepth: loopMetrics.queueDepth,
+      phase: loopMetrics.phase,
+      activeTurns: loopMetrics.activeTurns.map((turn) => ({
+        ...turn,
+        lastActivityAtMs: turn.lastActivityAtMs ?? undefined,
+        lastActivityKind: turn.lastActivityKind ?? undefined,
+        openItems: turn.openItems ?? [],
+      })),
+      bufferedTurns: loopMetrics.bufferedTurns.map((turn) => ({
+        ...turn,
+        lastActivityAtMs: turn.lastActivityAtMs ?? undefined,
+        lastActivityKind: turn.lastActivityKind ?? undefined,
+        openItems: turn.openItems ?? [],
+      })),
+    }),
+    log: (event, fields) => trace.push({ t: 'log', event, fields }),
+    intervalMs: 0,
+    turnStalledThresholdMs: caseInput.thresholdMs,
+    turnWaitStates: () => waits.map((wait) => ({ turnId: wait.turnId, kind: wait.kind })),
+    now: () => nowMs,
+  });
+  for (const op of caseInput.ops ?? []) {
+    if (op.op === 'set') {
+      if (op.outbox !== undefined) outboxMetrics = op.outbox;
+      if (op.loop !== undefined) loopMetrics = op.loop;
+      if (op.waits !== undefined) waits = op.waits;
+    } else if (op.op === 'sample') {
+      nowMs = op.nowMs ?? nowMs;
+      reporter.sample();
+    } else if (op.op === 'stop') {
+      reporter.stop();
+    }
+  }
+  return { trace };
+}
+
+// Scripted timer seam shared by the watchdog runs: timers fire in
+// scheduling order once the scripted clock passes their due instant.
+function scriptedTimers(clock, trace, label) {
+  let nextId = 1;
+  const pending = [];
+  return {
+    setTimer: (callback, delayMs) => {
+      const id = nextId;
+      nextId += 1;
+      trace.push({ t: label + '.set', id, delayMs, dueAtMs: clock.nowMs + delayMs });
+      pending.push({ id, dueAtMs: clock.nowMs + delayMs, callback });
+      return id;
+    },
+    clearTimer: (handle) => {
+      const index = pending.findIndex((timer) => timer.id === handle);
+      if (index >= 0) {
+        trace.push({ t: label + '.clear', id: pending[index].id });
+        pending.splice(index, 1);
+      }
+    },
+    fireDue: () => {
+      let fired = true;
+      while (fired) {
+        fired = false;
+        const index = pending.findIndex((timer) => timer.dueAtMs <= clock.nowMs);
+        if (index >= 0) {
+          const timer = pending.splice(index, 1)[0];
+          trace.push({ t: label + '.fire', id: timer.id });
+          timer.callback();
+          fired = true;
+        }
+      }
+    },
+  };
+}
+
+function runTurnStallWatchdogCase(caseInput) {
+  const clock = { nowMs: caseInput.startMs ?? 0 };
+  const trace = [];
+  const timers = scriptedTimers(clock, trace, 'timer');
+  let turnActive = caseInput.turnActive === true;
+  let watchdog;
+  const outcome = (() => {
+    try {
+      watchdog = createClaudeCodeTurnStallWatchdog({
+        thresholdMs: caseInput.thresholdMs,
+        isTurnActive: () => turnActive,
+        onStall: (info) => trace.push({ t: 'stall', silentMs: info.silentMs }),
+        now: () => clock.nowMs,
+        setTimer: timers.setTimer,
+        clearTimer: timers.clearTimer,
+      });
+      return { ok: true };
+    } catch (error) {
+      return { ok: false, message: error instanceof Error ? error.message : String(error) };
+    }
+  })();
+  if (outcome.ok) {
+    for (const op of caseInput.ops ?? []) {
+      if (op.op === 'advance') {
+        clock.nowMs = op.toMs;
+        timers.fireDue();
+      } else if (op.op === 'kick') watchdog.kick();
+      else if (op.op === 'stop') watchdog.stop();
+      else if (op.op === 'setActive') turnActive = op.active === true;
+    }
+  }
+  return { outcome, trace };
+}
+
+function runDispatchWatchdogCase(caseInput) {
+  const clock = { nowMs: caseInput.startMs ?? 0 };
+  const trace = [];
+  const timers = scriptedTimers(clock, trace, 'timer');
+  let delivered = caseInput.delivered === true;
+  let sessionClosed = caseInput.sessionClosed === true;
+  let lastActivityMs = caseInput.lastActivityMs ?? 0;
+  let pendingBlocking = caseInput.pendingBlocking === true;
+  let watchdog;
+  const outcome = (() => {
+    try {
+      watchdog = armClaudeCodeDispatchLivenessWatchdog({
+        windowMs: caseInput.windowMs,
+        isDelivered: () => delivered,
+        isSessionClosed: () => sessionClosed,
+        lastSdkActivityMs: () => lastActivityMs,
+        hasPendingBlockingRequest: () => pendingBlocking,
+        onWedged: (info) => trace.push({ t: 'wedged', waitedMs: info.waitedMs, cause: info.cause }),
+        now: () => clock.nowMs,
+        setTimer: timers.setTimer,
+        clearTimer: timers.clearTimer,
+      });
+      return { ok: true };
+    } catch (error) {
+      return { ok: false, message: error instanceof Error ? error.message : String(error) };
+    }
+  })();
+  if (outcome.ok) {
+    for (const op of caseInput.ops ?? []) {
+      if (op.op === 'advance') {
+        clock.nowMs = op.toMs;
+        timers.fireDue();
+      } else if (op.op === 'setDelivered') delivered = op.value === true;
+      else if (op.op === 'setSessionClosed') sessionClosed = op.value === true;
+      else if (op.op === 'setActivity') lastActivityMs = op.atMs;
+      else if (op.op === 'setPendingBlocking') pendingBlocking = op.value === true;
+      else if (op.op === 'stop') watchdog.stop();
+    }
+  }
+  return { outcome, trace };
+}
+
+async function runCase(input) {
+  switch (input.kind) {
+    case 'constants':
+      return {
+        outboxEntryKinds,
+        turnMappingReadyMethod,
+        turnMappingFailedMethod,
+        maxTerminalTurnIds,
+        maxEmptyTurnAutoRetries,
+        maxConsecutiveEmptyTurns,
+        maxReasoningStepsWithoutProgress,
+        maxIsolatedRejectionRetries,
+        completedWithoutAssistantOutputReason,
+        linzumiAgentReplyToolName,
+        agentNarrationOnlyCompletionReason,
+        agentNarrationOnlyEmptyTurnCause,
+        emptyTurnLoopGuardReason,
+        unsupportedCodexToolCallReasonPrefix,
+        midStreamResumeRateLimitSuppressedSuffix,
+        costCapAutoRetrySuppressedSuffix,
+        stallWindowEvidenceSignalClasses,
+        defaultBufferedTurnMaxAgeMs,
+        defaultBufferedTurnMaxEvents,
+        defaultBufferedTurnSweepIntervalMs,
+        defaultPipelineStatsIntervalMs,
+        defaultPipelineTurnStalledThresholdMs,
+        openItemTurnStalledThresholdMultiplier,
+        defaultClaudeCodeTurnStallThresholdMs,
+        defaultClaudeCodeDispatchLivenessWindowMs,
+      };
+    case 'reasoningLoopBreakerReason':
+      return reasoningLoopBreakerReason(input.steps);
+    case 'autoRetriesBurnedSuffix':
+      return autoRetriesBurnedSuffix(input.attempts);
+    case 'midStreamResumeStalledAgainSuffix':
+      return midStreamResumeStalledAgainSuffix(input.attemptAtMs);
+    case 'midStreamResumeIncompleteSuffix':
+      return midStreamResumeIncompleteSuffix(input.attemptAtMs);
+    case 'upstreamHttpStatusRetryClass':
+      return upstreamHttpStatusRetryClass(input.status);
+    case 'isUpstreamTerminal4xxHttpStatus':
+      return isUpstreamTerminal4xxHttpStatus(input.status ?? undefined);
+    case 'classifyStallWindowEvidence':
+      return classifyStallWindowEvidence({
+        lastUpstreamErrorReason: input.turn.lastUpstreamErrorReason ?? undefined,
+        lastErrorDiagnosticText: input.turn.lastErrorDiagnosticText ?? undefined,
+        lastUpstreamErrorHttpStatus: input.turn.lastUpstreamErrorHttpStatus ?? undefined,
+        upstreamRejectedSeen: input.turn.upstreamRejectedSeen === true,
+        providerOutageFlaggedSeen: input.turn.providerOutageFlaggedSeen === true,
+        toolFatalSeen: input.turn.toolFatalSeen === true,
+        errorNotificationCount: input.turn.errorNotificationCount ?? 0,
+        unattributedErrorNotificationCount:
+          input.turn.unattributedErrorNotificationCount ?? 0,
+        modelInteractionSeen: input.turn.modelInteractionSeen === true,
+      });
+    case 'stallWindowRateLimited':
+      return stallWindowRateLimited({
+        lastUpstreamErrorReason: input.turn.lastUpstreamErrorReason ?? undefined,
+        lastErrorDiagnosticText: input.turn.lastErrorDiagnosticText ?? undefined,
+        lastUpstreamErrorHttpStatus: input.turn.lastUpstreamErrorHttpStatus ?? undefined,
+        upstreamRejectedSeen: input.turn.upstreamRejectedSeen === true,
+        providerOutageFlaggedSeen: input.turn.providerOutageFlaggedSeen === true,
+        toolFatalSeen: input.turn.toolFatalSeen === true,
+        errorNotificationCount: input.turn.errorNotificationCount ?? 0,
+        unattributedErrorNotificationCount:
+          input.turn.unattributedErrorNotificationCount ?? 0,
+        modelInteractionSeen: input.turn.modelInteractionSeen === true,
+      });
+    case 'idleStreamStallDisposition': {
+      const disposition = idleStreamStallDisposition(
+        input.method,
+        input.params,
+        {
+          lastUpstreamErrorReason: input.turn.lastUpstreamErrorReason ?? undefined,
+          lastErrorDiagnosticText: input.turn.lastErrorDiagnosticText ?? undefined,
+          lastUpstreamErrorHttpStatus: input.turn.lastUpstreamErrorHttpStatus ?? undefined,
+          upstreamRejectedSeen: input.turn.upstreamRejectedSeen === true,
+          providerOutageFlaggedSeen: input.turn.providerOutageFlaggedSeen === true,
+          toolFatalSeen: input.turn.toolFatalSeen === true,
+          errorNotificationCount: input.turn.errorNotificationCount ?? 0,
+          unattributedErrorNotificationCount:
+            input.turn.unattributedErrorNotificationCount ?? 0,
+          modelInteractionSeen: input.turn.modelInteractionSeen === true,
+        },
+        {
+          costCap402Seen: input.session.costCap402Seen === true,
+          midStreamResumeAttemptAtMs: input.session.midStreamResumeAttemptAtMs ?? undefined,
+        }
+      );
+      return {
+        autoRetryPreFirstByteStall: disposition.autoRetryPreFirstByteStall,
+        messageStateRetryable: disposition.messageStateRetryable,
+        costCapAutoRetrySuppressed: disposition.costCapAutoRetrySuppressed,
+        messageStateFate: disposition.messageStateFate ?? null,
+        autoResumeMidStreamStall: disposition.autoResumeMidStreamStall,
+        midStreamResumeRateLimitSuppressed: disposition.midStreamResumeRateLimitSuppressed,
+        midStreamResumeAttemptBurnedAtMs:
+          disposition.midStreamResumeAttemptBurnedAtMs ?? null,
+      };
+    }
+    case 'classifyRejectionRetry': {
+      const disposition = classifyRejectionRetry({
+        providerOutageFlagged: input.providerOutageFlagged === true,
+        priorConsecutiveIsolatedRejections: input.priorConsecutiveIsolatedRejections,
+        stormDetail: input.stormDetail ?? undefined,
+        rejectionDetail: input.rejectionDetail ?? undefined,
+      });
+      return {
+        kind: disposition.kind,
+        retryable: disposition.retryable,
+        reason: disposition.reason,
+      };
+    }
+    case 'upstreamTurnErrorSummary':
+      return upstreamTurnErrorSummary(input.params) ?? null;
+    case 'itemKey':
+      return pipelineItemKey({
+        turnId: input.identity.turnId,
+        itemId: input.identity.itemId ?? undefined,
+        itemIndex: input.identity.itemIndex,
+        streamKind: input.identity.streamKind,
+      });
+    case 'clientMessageId':
+      return pipelineClientMessageId(
+        input.instanceId,
+        input.turnId,
+        input.streamKind,
+        input.wireItemKey
+      );
+    case 'notificationTurnId':
+      return notificationTurnId(input.params) ?? null;
+    case 'explicitItemId':
+      return explicitNotificationItemId(input.params) ?? null;
+    case 'projectSnapshotItems':
+      return projectSnapshotItems(input.items).map((proj) => ({
+        snapshotIndex: proj.snapshotIndex,
+        itemId: proj.itemId ?? null,
+        streamKind: proj.streamKind,
+        body: proj.body,
+        structured: proj.structured,
+      }));
+    case 'transitionRun':
+      return runTransitionCase(input);
+    case 'loopRun':
+      return runLoopCase(input);
+    case 'statsRun':
+      return runStatsCase(input);
+    case 'turnStallWatchdogRun':
+      return runTurnStallWatchdogCase(input);
+    case 'dispatchWatchdogRun':
+      return runDispatchWatchdogCase(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, 'pipeline-parity-oracle.mjs');
+
+await mkdir(outDir, { recursive: true });
+
+await build({
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'pipeline-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');