@linzumi/cli 1.0.111 → 1.0.112

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.111 --version
+npx -y @linzumi/cli@1.0.112 --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.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)}
+`),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.112",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.111",
+  "version": "1.0.112",
   "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-core-commander-seams-parity-oracle.mjs

@@ -0,0 +1,586 @@
+// 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 three bounded
+// commander-core seams of the ReScript commander port, the sibling of
+// build-queue-parity-oracle.mjs (cluster 5) /
+// build-transport-parity-oracle.mjs (cluster 4). ONE bundle imports the
+// REAL commander-core exports from './src/runner' (the whole module graph
+// rides along - large by design, exactly like the transport/config oracles
+// that already import runner exports) behind the one-shot batch driver: a
+// JSON array of cases on stdin, a JSON array of results on stdout.
+//
+// The three seams:
+//   1. Control-dispatch dedup + commit-then-advance confirmation
+//      (staleStartInstanceWindowMs / staleStartInstanceAgeMs /
+//      shouldSkipReplayedStartInstanceForKnownSession /
+//      shouldSkipReplayedStartTurn / commitAppliedStartTurn /
+//      dispatchControlConfirmingStartTurn / settleControlDispatch).
+//   2. The connection-staleness tracker (constants +
+//      createConnectionStalenessTracker) driven by scripted clocks and
+//      scripted escalation callbacks.
+//   3. The app-server KILL/RESPAWN ladder (createCodexTurnFailureGuard,
+//      runnerOwnsRespawnableAppServer, awaitLossReportsThenExit, the
+//      crash-loop constants/store/classifier, appServerLossCwdDiagnosis).
+//
+// Determinism: clocks are scripted per case (every seam takes an injected
+// now/nowMs), timers are scripted callbacks, scripted promises resolve in
+// program order with explicit microtask flushes, and scratch paths are
+// normalized through the "$DIR" placeholder in both directions. The
+// turn-failure guard's lastActivityAtMs is wall-clock-stamped inside the TS
+// original, so both impls report it as a PRESENCE flag only.
+//
+// SECRETS: the oracle only ever sees the conformance suite's synthetic
+// payloads; nothing here logs case contents.
+//
+// The output is a local test artifact (.differential/ is gitignored, never
+// published) and stays unminified for debuggability.
+import { copyFile, mkdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { build } from 'esbuild';
+
+const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+
+const driverSource = `
+import {
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, relative } from 'node:path';
+import {
+  appServerCrashLoopExitCode,
+  appServerCrashLoopExitLimit,
+  appServerCrashLoopWindowMs,
+  appServerLossCwdDiagnosis,
+  awaitLossReportsThenExit,
+  commitAppliedStartTurn,
+  connectionStaleForcedReconnectAfterMs,
+  connectionStaleForcedReconnectRetryMs,
+  connectionStaleHardResetAfterUninitiatedDispatches,
+  connectionStaleHardResetFailureLimit,
+  connectionStaleThresholdMs,
+  connectionUnrecoverableAfterMs,
+  createCodexTurnFailureGuard,
+  createConnectionStalenessTracker,
+  defaultAppServerExitLoopStatePath,
+  dispatchControlConfirmingStartTurn,
+  fileAppServerExitLoopStore,
+  recordAppServerExitAndClassify,
+  runnerOwnsRespawnableAppServer,
+  settleControlDispatch,
+  shouldSkipReplayedStartInstanceForKnownSession,
+  shouldSkipReplayedStartTurn,
+  staleStartInstanceAgeMs,
+  staleStartInstanceWindowMs,
+} from './src/runner';
+
+// --- Placeholder + snapshot plumbing --------------------------------------------
+
+const dirPlaceholder = '$DIR';
+
+function scratch() {
+  // realpath so macOS /var -> /private/var never splits the two impls'
+  // placeholder substitution.
+  return realpathSync(mkdtempSync(join(tmpdir(), 'linzumi-core-oracle-')));
+}
+
+function substitute(value, from, to) {
+  if (typeof value === 'string') {
+    return value.split(from).join(to);
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => substitute(entry, from, to));
+  }
+  if (typeof value === 'object' && value !== null) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        substitute(key, from, to),
+        substitute(entry, from, to),
+      ])
+    );
+  }
+  return value;
+}
+
+function snapshotFiles(dir) {
+  const files = {};
+  const walk = (current) => {
+    for (const name of readdirSync(current).sort()) {
+      const full = join(current, name);
+      if (statSync(full).isDirectory()) {
+        walk(full);
+      } else {
+        files[relative(dir, full)] = readFileSync(full, 'utf8');
+      }
+    }
+  };
+  walk(dir);
+  return files;
+}
+
+function outcome(run) {
+  try {
+    const value = run();
+    return value === undefined ? { defined: false } : { defined: true, value };
+  } catch (error) {
+    return {
+      threw: true,
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function collectingLog(events) {
+  return (event, payload) => {
+    events.push({ trace: 'log', event, payload });
+  };
+}
+
+// Deterministic microtask flush: enough passes that a then-chain of any
+// scripted depth settles before the trace is read on both impls.
+async function flushMicrotasks() {
+  for (let i = 0; i < 8; i += 1) {
+    await Promise.resolve();
+  }
+}
+
+// --- Slice 1: control-dispatch dedup + commit-then-advance -----------------------
+
+async function handleControlDispatch(testCase) {
+  switch (testCase.fn) {
+    case 'constants':
+      return { staleStartInstanceWindowMs };
+    case 'staleAge':
+      return outcome(() =>
+        staleStartInstanceAgeMs(testCase.control, testCase.nowMs)
+      );
+    case 'skipKnownSession': {
+      const lookups = [];
+      const known = new Set(testCase.knownThreadIds ?? []);
+      const result = outcome(() =>
+        shouldSkipReplayedStartInstanceForKnownSession(
+          testCase.control,
+          (threadId) => {
+            lookups.push(threadId);
+            return known.has(threadId);
+          }
+        )
+      );
+      return { result, lookups };
+    }
+    case 'skipStartTurn':
+      return outcome(() =>
+        shouldSkipReplayedStartTurn(
+          testCase.applied ?? undefined,
+          testCase.controlSeq
+        )
+      );
+    case 'commit': {
+      const calls = [];
+      const store = {
+        onAdvance: (key, seq) => calls.push({ call: 'onAdvance', key, seq }),
+        flush: () => calls.push({ call: 'flush' }),
+      };
+      const result = outcome(() =>
+        commitAppliedStartTurn(store, testCase.watermarkKey, testCase.controlSeq)
+      );
+      return { result, calls };
+    }
+    case 'dispatchConfirm': {
+      const trace = [];
+      const dispatch = () => {
+        trace.push({ trace: 'dispatch_called' });
+        return testCase.dispatch.kind === 'resolve'
+          ? Promise.resolve(testCase.dispatch.value ?? null)
+          : Promise.reject(
+              new Error(String(testCase.dispatch.message ?? 'scripted dispatch rejection'))
+            );
+      };
+      const commit =
+        testCase.hasCommit === true
+          ? () => trace.push({ trace: 'commit_called' })
+          : undefined;
+      try {
+        const value = await dispatchControlConfirmingStartTurn(dispatch, commit);
+        trace.push({ trace: 'resolved', value: value ?? null });
+      } catch (error) {
+        trace.push({
+          trace: 'rejected',
+          message: error instanceof Error ? error.message : String(error),
+        });
+      }
+      return { trace };
+    }
+    case 'settle': {
+      const trace = [];
+      const log = collectingLog(trace);
+      const handler = testCase.handler ?? { kind: 'syncUndefined' };
+      const handle = () => {
+        trace.push({ trace: 'handle_called' });
+        switch (handler.kind) {
+          case 'syncThrow':
+            throw new Error(String(handler.message ?? 'scripted sync throw'));
+          case 'syncObject':
+            return handler.value ?? {};
+          case 'syncUndefined':
+            return undefined;
+          case 'asyncResolve':
+            return Promise.resolve(handler.value ?? null);
+          case 'asyncReject':
+            return Promise.reject(
+              new Error(String(handler.message ?? 'scripted async rejection'))
+            );
+          default:
+            throw new Error('unknown settle handler kind ' + String(handler.kind));
+        }
+      };
+      const onRejected =
+        testCase.onRejected === undefined
+          ? undefined
+          : (error) => {
+              trace.push({
+                trace: 'on_rejected',
+                message: error instanceof Error ? error.message : String(error),
+              });
+              return testCase.onRejected;
+            };
+      settleControlDispatch(
+        testCase.controlType ?? 'scripted_control',
+        handle,
+        () => trace.push({ trace: 'ack' }),
+        log,
+        onRejected
+      );
+      trace.push({ trace: 'settle_returned' });
+      await flushMicrotasks();
+      return { trace };
+    }
+    default:
+      return { threw: true, message: 'unknown controlDispatch fn ' + String(testCase.fn) };
+  }
+}
+
+// --- Slice 2: connection-staleness tracker ----------------------------------------
+
+function handleStaleness(testCase) {
+  if (testCase.fn === 'constants') {
+    return {
+      connectionStaleThresholdMs,
+      connectionStaleForcedReconnectAfterMs,
+      connectionStaleForcedReconnectRetryMs,
+      connectionStaleHardResetAfterUninitiatedDispatches,
+      connectionStaleHardResetFailureLimit,
+      connectionUnrecoverableAfterMs,
+    };
+  }
+  // fn === 'scenario': a scripted clock + scripted escalation callbacks.
+  const trace = [];
+  const log = collectingLog(trace);
+  let nowMs = testCase.startMs ?? 0;
+  const escalationSpec = testCase.escalation;
+  const reconnectReturns = [...(escalationSpec?.reconnectReturns ?? [])];
+  const hardResetReturns = [...(escalationSpec?.hardResetReturns ?? [])];
+  const escalation =
+    escalationSpec === undefined
+      ? undefined
+      : {
+          ...(escalationSpec.hasReconnect === true
+            ? {
+                onReconnectNeeded: (details) => {
+                  trace.push({ trace: 'reconnect_needed', details });
+                  const scripted = reconnectReturns.shift();
+                  return scripted === null || scripted === undefined
+                    ? undefined
+                    : scripted;
+                },
+              }
+            : {}),
+          ...(escalationSpec.hasHardReset === true
+            ? {
+                onHardResetNeeded: (details) => {
+                  trace.push({ trace: 'hard_reset_needed', details });
+                  const scripted = hardResetReturns.shift();
+                  return scripted === null || scripted === undefined
+                    ? undefined
+                    : scripted;
+                },
+              }
+            : {}),
+          ...(escalationSpec.forcedReconnectAfterMs === undefined
+            ? {}
+            : { forcedReconnectAfterMs: escalationSpec.forcedReconnectAfterMs }),
+          ...(escalationSpec.forcedReconnectRetryMs === undefined
+            ? {}
+            : { forcedReconnectRetryMs: escalationSpec.forcedReconnectRetryMs }),
+          onUnrecoverable: (details) => {
+            trace.push({ trace: 'unrecoverable', details });
+          },
+          ...(escalationSpec.afterMs === undefined
+            ? {}
+            : { afterMs: escalationSpec.afterMs }),
+        };
+  const tracker = createConnectionStalenessTracker(
+    log,
+    () => nowMs,
+    testCase.thresholdMs ?? undefined,
+    escalation
+  );
+  for (const step of testCase.steps ?? []) {
+    switch (step.fn) {
+      case 'advance':
+        nowMs += step.byMs;
+        break;
+      case 'ack':
+        tracker.recordServerAck();
+        break;
+      case 'check':
+        tracker.check();
+        break;
+      case 'isStale':
+        trace.push({ trace: 'is_stale', value: tracker.isStale() });
+        break;
+      default:
+        trace.push({ trace: 'unknown_step', fn: String(step.fn) });
+    }
+  }
+  return { trace };
+}
+
+// --- Slice 3: respawn ladder ---------------------------------------------------------
+
+async function handleRespawn(testCase) {
+  switch (testCase.fn) {
+    case 'constants':
+      return {
+        appServerCrashLoopWindowMs,
+        appServerCrashLoopExitLimit,
+        appServerCrashLoopExitCode,
+      };
+    case 'ownsRespawnable':
+      return outcome(() =>
+        runnerOwnsRespawnableAppServer({
+          codexUrl: testCase.codexUrl ?? undefined,
+          threadProcessRole: testCase.threadProcessRole ?? undefined,
+          ownsStartedAppServer: testCase.ownsStartedAppServer === true,
+        })
+      );
+    case 'statePath':
+      return outcome(() =>
+        defaultAppServerExitLoopStatePath(testCase.runnerId, testCase.env ?? {})
+      );
+    case 'cwdDiagnosis': {
+      const existsMode = testCase.existsMode ?? 'real';
+      const existsFn =
+        existsMode === 'real'
+          ? undefined
+          : () => {
+              if (existsMode === 'throw') {
+                throw new Error('scripted exists probe failure');
+              }
+              return existsMode === 'true';
+            };
+      return outcome(() =>
+        existsFn === undefined
+          ? appServerLossCwdDiagnosis(testCase.cwd)
+          : appServerLossCwdDiagnosis(testCase.cwd, existsFn)
+      );
+    }
+    case 'exitLoopScenario': {
+      const dir = scratch();
+      const path = join(dir, 'exit-loop.json');
+      if (testCase.initialContents !== undefined) {
+        writeFileSync(path, testCase.initialContents, 'utf8');
+      }
+      const writeErrors = [];
+      const store = fileAppServerExitLoopStore(path, (message) =>
+        writeErrors.push(message)
+      );
+      const results = (testCase.steps ?? []).map((step) => {
+        switch (step.fn) {
+          case 'record':
+            return outcome(() =>
+              recordAppServerExitAndClassify(
+                store,
+                step.nowMs,
+                step.windowMs ?? undefined,
+                step.limit ?? undefined
+              )
+            );
+          case 'load':
+            return outcome(() => store.load());
+          case 'save':
+            return outcome(() => store.save(step.record));
+          default:
+            return { threw: true, message: 'unknown exitLoop fn ' + String(step.fn) };
+        }
+      });
+      return substitute(
+        { results, writeErrors, files: snapshotFiles(dir) },
+        dir,
+        dirPlaceholder
+      );
+    }
+    case 'guardScenario': {
+      const trace = [];
+      const log = collectingLog(trace);
+      const sessionSpecs = testCase.sessions ?? [];
+      const sessions = sessionSpecs.map((spec, index) => ({
+        handleCodexNotification: (method, params) => {
+          trace.push({ trace: 'session_dispatch', session: index, method, params });
+          if (spec.throws === true) {
+            throw new Error('scripted session dispatch failure ' + String(index));
+          }
+        },
+      }));
+      const guard = createCodexTurnFailureGuard({
+        sessions: () => sessions,
+        log,
+        ...(testCase.hasOnActiveThreadsFailed === true
+          ? {
+              onActiveThreadsFailed: (threadIds) => {
+                trace.push({ trace: 'active_threads_failed', threadIds: [...threadIds] });
+              },
+            }
+          : {}),
+      });
+      for (const step of testCase.steps ?? []) {
+        switch (step.fn) {
+          case 'observe':
+            guard.observeNotification(step.method, step.params ?? {});
+            break;
+          case 'fail':
+            guard.failActiveTurns(String(step.cause ?? 'scripted cause'));
+            break;
+          case 'failPerTurn': {
+            const causes = step.causes ?? {};
+            guard.failActiveTurns(
+              (turn) =>
+                causes[turn.threadId + '|' + turn.turnId] ??
+                String(step.defaultCause ?? 'scripted default cause')
+            );
+            break;
+          }
+          case 'count':
+            trace.push({ trace: 'count', value: guard.activeTurnCount() });
+            break;
+          case 'turns':
+            trace.push({ trace: 'turns', value: guard.activeTurns().map((t) => ({ ...t })) });
+            break;
+          case 'lastActivity':
+            // Wall-clock stamped inside the TS original: presence only.
+            trace.push({
+              trace: 'last_activity_defined',
+              value: guard.lastActivityAtMs() !== undefined,
+            });
+            break;
+          default:
+            trace.push({ trace: 'unknown_step', fn: String(step.fn) });
+        }
+      }
+      return { trace };
+    }
+    case 'awaitLossReports': {
+      const trace = [];
+      const pushes = (testCase.pushes ?? []).map((push) => {
+        if (push.kind === 'resolve') {
+          return Promise.resolve(undefined);
+        }
+        if (push.kind === 'reject') {
+          const rejected = Promise.reject(
+            new Error(String(push.message ?? 'scripted push rejection'))
+          );
+          // Pre-observed so the scripted rejection can never trip the
+          // unhandled-rejection handler before allSettled adopts it.
+          rejected.catch(() => {});
+          return rejected;
+        }
+        // 'never': a push whose ack never comes back.
+        return new Promise(() => {});
+      });
+      await awaitLossReportsThenExit({
+        pushes,
+        exit: () => trace.push({ trace: 'exit' }),
+        safetyCapMs: testCase.safetyCapMs,
+        setTimeoutFn: (callback, ms) => {
+          trace.push({ trace: 'cap_scheduled', ms });
+          if (testCase.capFires === true) {
+            setImmediate(callback);
+          }
+          return undefined;
+        },
+      });
+      trace.push({ trace: 'returned' });
+      return { trace };
+    }
+    default:
+      return { threw: true, message: 'unknown respawn fn ' + String(testCase.fn) };
+  }
+}
+
+// --- Dispatch --------------------------------------------------------------------------------
+
+async function handle(testCase) {
+  switch (testCase.op) {
+    case 'controlDispatch':
+      return await handleControlDispatch(testCase);
+    case 'staleness':
+      return handleStaleness(testCase);
+    case 'respawn':
+      return await handleRespawn(testCase);
+    default:
+      return { threw: true, message: 'unknown op ' + String(testCase.op) };
+  }
+}
+
+let stdin = '';
+process.stdin.setEncoding('utf8');
+for await (const chunk of process.stdin) {
+  stdin += chunk;
+}
+const cases = JSON.parse(stdin);
+const results = [];
+for (const testCase of cases) {
+  results.push(await handle(testCase));
+}
+// Exit only after stdout is fully flushed: the runner graph can leave
+// unref'd handles alive, so the driver exits explicitly - but a bare
+// process.exit(0) truncates large result arrays mid-pipe.
+process.stdout.write(JSON.stringify(results), () => {
+  process.exit(0);
+});
+`;
+
+await mkdir(join(packageRoot, '.differential'), { recursive: true });
+
+// runner.ts's graph resolves assets/ relative to the bundle at import time
+// (same requirement as build-transport-parity-oracle.mjs).
+await mkdir(join(packageRoot, '.differential/assets'), { recursive: true });
+await copyFile(
+  join(packageRoot, 'src/assets/linzumi-logo.svg'),
+  join(packageRoot, '.differential/assets/linzumi-logo.svg')
+);
+
+await build({
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'core-commander-seams-parity-driver.ts',
+    loader: 'ts',
+  },
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outfile: join(packageRoot, '.differential/core-commander-seams-parity-oracle.mjs'),
+  minify: false,
+  sourcemap: false,
+  legalComments: 'none',
+  // runner.ts pulls the wider commander graph; the same runtime externals
+  // as the differential entry build stay external.
+  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
+});