@linzumi/cli 1.0.109 → 1.0.111

package/README.md

@@ -58,7 +58,7 @@ Install the CLI or run it with `npx`:
 ```bash
 npm install -g @linzumi/cli@latest
 npx -y @linzumi/cli@latest signup
-npx -y @linzumi/cli@1.0.109 --version
+npx -y @linzumi/cli@1.0.111 --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -1473,7 +1473,7 @@ To kick the agent off:
 `,L=Buffer.byteLength(P,"utf8");if(L>s)return l("runner_diagnostics.spool_entry_dropped",{reason:"entry_too_large",entry_bytes:L,max_entry_bytes:s}),!1;jSe(n,{recursive:!0}),m(u)+L>i&&f(),_(L);let D=w()?`
 `:"";return $Se(u,`${D}${P}`,"utf8"),!0}catch(R){return l("runner_diagnostics.spool_failed",{error:R instanceof Error?R.message:String(R)}),!1}},v=k=>{let R=[],P=zSe(k,"utf8");for(let L of P.split(`
 `))if(L.trim()!=="")try{let D=JSON.parse(L);D!==null&&typeof D=="object"&&R.push({parsed:D,raw:L})}catch{}return R};return{append:S,drain:async k=>{if(c)return{uploadedBatches:0,uploadedEntries:0,remainingBatches:p().length,skipped:!0};c=!0;let R=0,P=0;try{f(),_(0);let L=a()-o;for(let D of p()){let j;try{j=v(D)}catch(Z){l("runner_diagnostics.spool_batch_unreadable",{file:D,error:Z instanceof Error?Z.message:String(Z)}),y(D,"unreadable");continue}let z=j.filter(Z=>{let me=tke(Z.parsed);return me===void 0||me>=L});if(z.length===0){y(D,"empty_or_expired");continue}let E=hP(D,".jsonl"),B=z.map(Z=>Z.raw).join(`
-`),q=z.map(Z=>Z.parsed.spooled_at).filter(Z=>typeof Z=="string"),W={bundle_name:"runner-diagnostics-spool",exported_at:new Date(a()).toISOString(),idempotency_key:E,diagnostics:{kind:"runner_diagnostic_log",spool_batch:!0,idempotency_key:E,entry_count:z.length,...q.length===0?{}:{first_spooled_at:q[0],last_spooled_at:q[q.length-1]}},telemetry_ndjson:B};try{await k(W)}catch(Z){l("runner_diagnostics.spool_upload_failed",{file:D,remaining_batches:p().length,error:Z instanceof Error?Z.message:String(Z)});break}R+=1,P+=z.length;try{F9(D)}catch(Z){l("runner_diagnostics.spool_delete_failed",{file:D,error:Z instanceof Error?Z.message:String(Z)})}}}catch(L){l("runner_diagnostics.spool_drain_failed",{error:L instanceof Error?L.message:String(L)})}finally{c=!1}return{uploadedBatches:R,uploadedEntries:P,remainingBatches:p().length,skipped:!1}},pendingBatchFiles:p}}var KSe,VSe,WSe,HSe,GSe,z9,QSe,XSe,N9=F(()=>{"use strict";ax();KSe=32*1024*1024,VSe=10080*60*1e3,WSe=4*1024*1024,HSe=1024*1024,GSe="spool.jsonl",z9=/^batch-(\d{1,16})-[0-9a-f-]+\.jsonl$/;QSe=/\b([A-Z][A-Z0-9_]{1,})=("[^"\n]*"|'[^'\n]*'|[^\s"'`;,)\]}]+)/g,XSe=/(?:\/(?:[A-Za-z0-9._@~+-]|%[0-9A-Fa-f]{2})+){2,}/g});var qt,yP,ta=F(()=>{"use strict";qt="1.0.109",yP=`linzumi ${qt}`});import{closeSync as B9,existsSync as _P,mkdirSync as rke,openSync as J9,readFileSync as K9,renameSync as oke,unlinkSync as _d,writeFileSync as ike,writeSync as V9}from"node:fs";import{dirname as W9,join as ske}from"node:path";function bP(e){return e instanceof ys||e instanceof Error&&e.name===G9&&"lockPath"in e&&"heldBy"in e}function wP(e,n=Wn(),t){let r=t===void 0?encodeURIComponent(e):ld(t);return ske(W9(n),"runners",`${r}.lock`)}function x_(e){let n=wP(e.machineId,e.configPath,e.linzumiUrl),t=e.isPidAlive??t3,r=e.now??(()=>new Date),o=e.killPid??_ke,i=r().toISOString(),s={version:1,machineId:e.machineId,runnerId:e.runnerId,pid:e.pid??process.pid,cwd:e.cwd,workspace:e.workspace,...e.linzumiUrl===void 0?{}:{linzumiUrl:zn(e.linzumiUrl)},...e.launchSource===void 0?{}:{launchSource:e.launchSource},startedAt:i,heartbeatAt:i,cliVersion:e.cliVersion??qt,...e.gracefulUpdateDrain===!0?{gracefulUpdateDrain:!0}:{}};cke(e.machineId,e.configPath,e.linzumiUrl,t,r,o,e.onTakeover),lke(n,s,t,r,o,e.onTakeover,e.beforeReadExistingLock,e.beforeReplaceStaleLock);let a=()=>Z9(n,s,r),d=setInterval(a,H9);return d.unref(),{path:n,record:s,heartbeat:a,release:()=>{clearInterval(d),e3(n,s)}}}function Z9(e,n,t){try{let r=b_(e);if(r===void 0||r.machineId!==n.machineId||r.runnerId!==n.runnerId||r.pid!==n.pid||r.startedAt!==n.startedAt)return;let o={...r,heartbeatAt:t().toISOString()},i=`${e}.tmp`;ike(i,`${JSON.stringify(o,null,2)}
+`),q=z.map(Z=>Z.parsed.spooled_at).filter(Z=>typeof Z=="string"),W={bundle_name:"runner-diagnostics-spool",exported_at:new Date(a()).toISOString(),idempotency_key:E,diagnostics:{kind:"runner_diagnostic_log",spool_batch:!0,idempotency_key:E,entry_count:z.length,...q.length===0?{}:{first_spooled_at:q[0],last_spooled_at:q[q.length-1]}},telemetry_ndjson:B};try{await k(W)}catch(Z){l("runner_diagnostics.spool_upload_failed",{file:D,remaining_batches:p().length,error:Z instanceof Error?Z.message:String(Z)});break}R+=1,P+=z.length;try{F9(D)}catch(Z){l("runner_diagnostics.spool_delete_failed",{file:D,error:Z instanceof Error?Z.message:String(Z)})}}}catch(L){l("runner_diagnostics.spool_drain_failed",{error:L instanceof Error?L.message:String(L)})}finally{c=!1}return{uploadedBatches:R,uploadedEntries:P,remainingBatches:p().length,skipped:!1}},pendingBatchFiles:p}}var KSe,VSe,WSe,HSe,GSe,z9,QSe,XSe,N9=F(()=>{"use strict";ax();KSe=32*1024*1024,VSe=10080*60*1e3,WSe=4*1024*1024,HSe=1024*1024,GSe="spool.jsonl",z9=/^batch-(\d{1,16})-[0-9a-f-]+\.jsonl$/;QSe=/\b([A-Z][A-Z0-9_]{1,})=("[^"\n]*"|'[^'\n]*'|[^\s"'`;,)\]}]+)/g,XSe=/(?:\/(?:[A-Za-z0-9._@~+-]|%[0-9A-Fa-f]{2})+){2,}/g});var qt,yP,ta=F(()=>{"use strict";qt="1.0.111",yP=`linzumi ${qt}`});import{closeSync as B9,existsSync as _P,mkdirSync as rke,openSync as J9,readFileSync as K9,renameSync as oke,unlinkSync as _d,writeFileSync as ike,writeSync as V9}from"node:fs";import{dirname as W9,join as ske}from"node:path";function bP(e){return e instanceof ys||e instanceof Error&&e.name===G9&&"lockPath"in e&&"heldBy"in e}function wP(e,n=Wn(),t){let r=t===void 0?encodeURIComponent(e):ld(t);return ske(W9(n),"runners",`${r}.lock`)}function x_(e){let n=wP(e.machineId,e.configPath,e.linzumiUrl),t=e.isPidAlive??t3,r=e.now??(()=>new Date),o=e.killPid??_ke,i=r().toISOString(),s={version:1,machineId:e.machineId,runnerId:e.runnerId,pid:e.pid??process.pid,cwd:e.cwd,workspace:e.workspace,...e.linzumiUrl===void 0?{}:{linzumiUrl:zn(e.linzumiUrl)},...e.launchSource===void 0?{}:{launchSource:e.launchSource},startedAt:i,heartbeatAt:i,cliVersion:e.cliVersion??qt,...e.gracefulUpdateDrain===!0?{gracefulUpdateDrain:!0}:{}};cke(e.machineId,e.configPath,e.linzumiUrl,t,r,o,e.onTakeover),lke(n,s,t,r,o,e.onTakeover,e.beforeReadExistingLock,e.beforeReplaceStaleLock);let a=()=>Z9(n,s,r),d=setInterval(a,H9);return d.unref(),{path:n,record:s,heartbeat:a,release:()=>{clearInterval(d),e3(n,s)}}}function Z9(e,n,t){try{let r=b_(e);if(r===void 0||r.machineId!==n.machineId||r.runnerId!==n.runnerId||r.pid!==n.pid||r.startedAt!==n.startedAt)return;let o={...r,heartbeatAt:t().toISOString()},i=`${e}.tmp`;ike(i,`${JSON.stringify(o,null,2)}
 `,"utf8"),oke(i,e)}catch{}}function bd(e,n,t){if(!n(e.pid))return{state:"dead"};let r=e.heartbeatAt??e.startedAt,o=Date.parse(r);return Number.isNaN(o)||t().getTime()-o>ake?{state:"wedged",reason:e.heartbeatAt===void 0?"missing_heartbeat":"stale_heartbeat"}:{state:"live"}}function Q9(e,n,t,r){return t!==__||e.launchSource!==__?!1:r.state!=="live"?!0:dke(n,e.cliVersion)>0}function dke(e,n){let t=U9(e),r=U9(n);for(let o=0;o<3;o++){let i=t.core[o],s=r.core[o];if(i===void 0||s===void 0)throw new Error(`compareCliVersions: unexpected undefined at core index ${o}`);if(i!==s)return i>s?1:-1}return t.prerelease.length===0&&r.prerelease.length===0?0:t.prerelease.length===0?1:r.prerelease.length===0?-1:uke(t.prerelease,r.prerelease)}function U9(e){let n=e.trim().replace(/^v/i,"").split("+",1)[0]??"",t=n.indexOf("-"),r=t===-1?n:n.slice(0,t),o=t===-1?"":n.slice(t+1),i=r.split("."),s=[xP(i[0]),xP(i[1]),xP(i[2])],a=o===""?[]:o.split(".").filter(d=>d!=="");return{core:s,prerelease:a}}function xP(e){let n=Number.parseInt(e??"",10);return Number.isInteger(n)&&n>=0?n:0}function uke(e,n){let t=Math.max(e.length,n.length);for(let r=0;r<t;r++){let o=e[r],i=n[r];if(o===void 0)return-1;if(i===void 0)return 1;let s=Number.parseInt(o,10),a=Number.parseInt(i,10),d=s.toString()===o,u=a.toString()===i;if(d&&u){if(s!==a)return s>a?1:-1}else{if(d!==u)return d?-1:1;if(o!==i)return o>i?1:-1}}return 0}function X9(e,n,t,r,o){try{r(n.pid)}catch(i){let s=i!==null&&typeof i=="object"&&"code"in i?i.code:void 0;if(s!=="ESRCH")throw s==="EPERM"||s==="EACCES"?new Error(`Cannot take over the runner lock at ${e}: its holder process (pid ${n.pid}) is owned by another user and cannot be stopped. Stop that process, or remove the lock file, then retry.`):i}o?.({lockPath:e,holderPid:n.pid,holderRunnerId:n.runnerId,reason:t})}function cke(e,n,t,r,o,i,s){if(t===void 0||yr(t)!==yr(Jt))return;let a=wP(e,n),d=b_(a);if(d!==void 0){if(bd(d,r,o).state==="live")throw new ys(a,d);Y9(a,r,()=>{let u=_P(a)?vP(a):void 0;if(u===void 0)return;let c=bd(u,r,o);if(c.state==="live")throw new ys(a,u);c.state==="wedged"&&X9(a,u,c.reason,i,s),_d(a)})}}function lke(e,n,t,r,o,i,s,a){if(y_(e,n))return;s?.();let d=b_(e);if(d===void 0){if(y_(e,n))return;throw new Error(`another Linzumi runner lock appeared while starting: ${e}`)}if(bd(d,t,r).state==="live")throw new ys(e,d);a?.(),Y9(e,t,()=>{let u=_P(e)?vP(e):void 0;if(u!==void 0){let c=bd(u,t,r);if(c.state==="live")throw new ys(e,u);c.state==="wedged"&&X9(e,u,c.reason,o,i),_d(e)}if(!y_(e,n))throw new Error(`another Linzumi runner lock appeared while starting: ${e}`)})}function y_(e,n){rke(W9(e),{recursive:!0});try{let t=J9(e,"wx");try{V9(t,`${JSON.stringify(n,null,2)}
 `)}finally{B9(t)}return!0}catch(t){if(Vc(t,"EEXIST"))return!1;throw t}}function Y9(e,n,t){let r=`${e}.replace`;for(;;)try{let o=J9(r,"wx");try{V9(o,`${process.pid}
 `),t()}finally{B9(o),_d(r)}return}catch(o){if(Vc(o,"EEXIST")){let i=pke(r);if(i===void 0)continue;if(n(i))throw new Error(["another Linzumi runner is already replacing a stale runner lock",`lock: ${e}`,"Wait for that startup to finish, then retry."].join(`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "1.0.109",
+  "version": "1.0.111",
   "description": "Linzumi CLI \u2014 point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {

package/scripts/build-harness-claude-parity-oracle.mjs

@@ -0,0 +1,308 @@
+// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
+// (M3 cluster 8, harness-claude-adapter / workstream H.3).
+// Relationship: Builds the TS-side PARITY ORACLE for the claude-adapter
+// cluster of the ReScript commander port, the sibling of
+// build-harness-codex-parity-oracle.mjs (cluster 7). The oracle runs the
+// REAL TS claude session driver (startClaudeCodeSession + the resume
+// validation + the canUseTool bridge) with '@anthropic-ai/claude-agent-sdk'
+// ALIASED to the M2.3 scripted stub
+// (packages/commander-harness/src/scripted/ScriptedClaudeAgentSdk.res.mjs)
+// - the exact import-seam substitution the stub was built for - and prints
+// the stub recorder's transcript for one named scenario. The dual-impl
+// differential in @linzumi/commander-harness
+// (HarnessClaudeDifferentialConformance) runs the same scenario through
+// the ReScript adapter in-process and requires the two double transcripts
+// byte-identical.
+//
+// Determinism: the scenarios are scripted data, the driver's only waits
+// are milestone polls over the in-process transcript, and the recorder
+// rows carry no wall-clock values.
+//
+// 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 stubModulePath = join(
+  packageRoot,
+  '..',
+  'commander-harness',
+  'src',
+  'scripted',
+  'ScriptedClaudeAgentSdk.res.mjs'
+);
+const scriptModulePath = join(
+  packageRoot,
+  '..',
+  'commander-harness',
+  'src',
+  'scripted',
+  'ScriptedClaudeAgentSdkScript.res.mjs'
+);
+
+const driverSource = `
+import {
+  startClaudeCodeSession,
+  validateClaudeCodeResumeSession,
+} from './src/claudeCodeSession';
+import type { ClaudeCodeTranscriptEvent } from './src/claudeCodeSession';
+// The scenario side-channel of the SAME stub instance the alias bundles in
+// (esbuild dedupes by resolved path, so install/recorder observe the
+// aliased SDK the session driver consumes).
+import { install, recorder } from '${scriptModulePath.replace(/\\\\/g, '/')}';
+
+const cwd = '/scripted/workspace';
+const model = 'scripted-model-alpha';
+
+// The recorded API-provenance error text (must stay byte-identical to the
+// ReScript differential leg's scenario data).
+const apiErrorText =
+  'API Error: 401 {"type":"error","error":{"type":"authentication_error","message":"invalid x-api-key"},"request_id":"req_scripted42"}';
+
+const scenarios: Record<string, unknown> = {
+  'clean-turn': {
+    queries: [{ TAG: 'CleanText', assistantText: 'scripted claude answer' }],
+    startupBehavior: 'StartupOk',
+    sessionInfo: 'SessionFound',
+    sessionFirstPrompts: [],
+  },
+  'approval-accept': {
+    queries: [
+      {
+        TAG: 'ToolUseWithPermission',
+        toolName: 'Bash',
+        toolInputJson: '{"command":"curl https://api.example.test/v1/voices"}',
+        assistantText: 'voice roster fetched',
+      },
+    ],
+    startupBehavior: 'StartupOk',
+    sessionInfo: 'SessionFound',
+    sessionFirstPrompts: [],
+  },
+  'approval-decline': {
+    queries: [
+      {
+        TAG: 'ToolUseWithPermission',
+        toolName: 'Bash',
+        toolInputJson: '{"command":"curl https://api.example.test/v1/voices"}',
+        assistantText: 'voice roster fetched',
+      },
+    ],
+    startupBehavior: 'StartupOk',
+    sessionInfo: 'SessionFound',
+    sessionFirstPrompts: [],
+  },
+  error: {
+    queries: [{ TAG: 'ResultApiError', errorText: apiErrorText }],
+    startupBehavior: 'StartupOk',
+    sessionInfo: 'SessionFound',
+    sessionFirstPrompts: [],
+  },
+  interrupt: {
+    queries: [{ TAG: 'MidTurnPark', assistantText: 'partial answer, then' }],
+    startupBehavior: 'StartupOk',
+    sessionInfo: 'SessionFound',
+    sessionFirstPrompts: [],
+    interruptBehavior: 'YieldInterruptResult',
+  },
+  'resume-attach': {
+    queries: [{ TAG: 'CleanText', assistantText: 'resumed answer' }],
+    startupBehavior: 'StartupOk',
+    sessionInfo: 'SessionFound',
+    sessionFirstPrompts: [],
+  },
+};
+
+// The runner-shaped streaming input queue (the live multi-turn channel:
+// only the owner closes it).
+function createInputQueue() {
+  const pending: unknown[] = [];
+  const waiters: Array<(step: { done: boolean; value: unknown }) => void> = [];
+  let closed = false;
+  return {
+    messages: {
+      [Symbol.asyncIterator]() {
+        return {
+          next(): Promise<{ done: boolean; value: unknown }> {
+            if (pending.length > 0) {
+              return Promise.resolve({ done: false, value: pending.shift() });
+            }
+            if (closed) {
+              return Promise.resolve({ done: true, value: undefined });
+            }
+            return new Promise((resolve) => waiters.push(resolve));
+          },
+        };
+      },
+    },
+    push(message: unknown) {
+      const waiter = waiters.shift();
+      if (waiter !== undefined) {
+        waiter({ done: false, value: message });
+      } else {
+        pending.push(message);
+      }
+    },
+    close() {
+      closed = true;
+      while (waiters.length > 0) {
+        waiters.shift()!({ done: true, value: undefined });
+      }
+    },
+  };
+}
+
+function userMessage(text: string) {
+  return {
+    type: 'user' as const,
+    message: { role: 'user' as const, content: text },
+    parent_tool_use_id: null,
+  };
+}
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function waitFor(predicate: () => boolean): Promise<void> {
+  while (!predicate()) {
+    await sleep(5);
+  }
+}
+
+function transcript(): string[] {
+  return (recorder as { events: Array<{ label: string; detail: string }> }).events.map(
+    (event) => event.label + '|' + event.detail
+  );
+}
+
+async function run(): Promise<void> {
+  const scenarioName = process.argv[2];
+  const scenario = scenarios[scenarioName ?? ''];
+  if (scenario === undefined) {
+    throw new Error('unknown scenario: ' + String(scenarioName));
+  }
+  install(scenario);
+
+  const events: ClaudeCodeTranscriptEvent[] = [];
+  const has = (type: string) => events.some((event) => event.type === type);
+  let controls:
+    | { interrupt: () => Promise<void> }
+    | undefined;
+  const queue = createInputQueue();
+
+  if (scenarioName === 'resume-attach') {
+    await validateClaudeCodeResumeSession({
+      cwd,
+      sessionId: 'scripted-claude-session-resumed-7',
+    });
+  }
+
+  const sessionPromise = startClaudeCodeSession({
+    cwd,
+    prompt: '',
+    streamingInput: queue,
+    developerInstructions: undefined,
+    model,
+    permissionMode: 'default',
+    ...(scenarioName === 'resume-attach'
+      ? { resumeSessionId: 'scripted-claude-session-resumed-7' }
+      : {}),
+    canUseTool: async () =>
+      scenarioName === 'approval-decline'
+        ? { type: 'deny' as const, message: 'not on this machine' }
+        : { type: 'allow' as const },
+    onSessionControls: (liveControls) => {
+      controls = liveControls;
+    },
+    onTranscriptEvent: (event) => {
+      events.push(event);
+    },
+  });
+  // The session settles by scenario design; failures are the error leg's
+  // expected outcome and are re-checked below.
+  const settled = sessionPromise.then(
+    () => undefined,
+    (error: unknown) => (error instanceof Error ? error.message : String(error))
+  );
+
+  queue.push(userMessage('do the thing'));
+
+  switch (scenarioName) {
+    case 'error': {
+      // The TS session driver THROWS on the result error after emitting
+      // session_failed; the transcript snapshot is taken AT the terminal
+      // (the abandoned generator never closes the stub query - the
+      // documented TS lifecycle - so the close rows are not part of this
+      // scenario's comparison surface).
+      await waitFor(() => has('session_failed'));
+      const failure = await settled;
+      if (failure === undefined) {
+        throw new Error('the error scenario must fail the session');
+      }
+      process.stdout.write(JSON.stringify(transcript()) + '\\n');
+      return;
+    }
+    case 'interrupt': {
+      await waitFor(() => has('assistant_message'));
+      await controls!.interrupt();
+      await waitFor(() => has('turn_interrupted'));
+      queue.close();
+      // An interrupted single-turn session settles as the documented
+      // no-text-response failure; the transcript is the comparison
+      // surface.
+      await settled;
+      process.stdout.write(JSON.stringify(transcript()) + '\\n');
+      return;
+    }
+    default: {
+      await waitFor(() => has('turn_completed'));
+      queue.close();
+      const failure = await settled;
+      if (failure !== undefined) {
+        throw new Error('scenario ' + scenarioName + ' must complete: ' + failure);
+      }
+      process.stdout.write(JSON.stringify(transcript()) + '\\n');
+    }
+  }
+}
+
+run().then(
+  () => process.exit(0),
+  (error) => {
+    process.stderr.write(String(error && error.stack ? error.stack : error) + '\\n');
+    process.exit(1);
+  }
+);
+`;
+
+const outDir = join(packageRoot, '.differential');
+const outPath = join(outDir, 'harness-claude-parity-oracle.mjs');
+
+await mkdir(outDir, { recursive: true });
+
+await build({
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'harness-claude-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'],
+  alias: {
+    '@anthropic-ai/claude-agent-sdk': stubModulePath,
+  },
+});
+
+process.stdout.write(outPath + '\n');

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');