@linzumi/cli 1.0.272 → 1.0.274

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

@@ -1,614 +0,0 @@
-// 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,
-        sdkRequestDeadlineMs: caseInput.sdkRequestDeadlineMs ?? undefined,
-        isTurnActive: () => turnActive,
-        onStall: (info) => trace.push({ t: 'stall', ...info }),
-        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 === 'transcriptVisible') watchdog.kick({ kind: 'transcript_visible' });
-      else if (op.op === 'sdkBookkeeping') watchdog.kick({ kind: 'sdk_bookkeeping' });
-      else if (op.op === 'sdkRequestStarted') watchdog.kick({ kind: 'sdk_request_started' });
-      else if (op.op === 'sdkRequestFinished') watchdog.kick({ kind: 'sdk_request_finished' });
-      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');