@linzumi/cli 1.0.272 → 1.0.273

package/scripts/build-core-supervisor-parity-oracle.mjs

@@ -1,781 +0,0 @@
-// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
-// (M3 cluster 10, commander-core / supervisor).
-// Relationship: Builds the TS-side PARITY ORACLE for the `connect
-// --supervise` supervisor port (src/supervisor.ts -> ReScript
-// CommanderSupervisor), the sibling of build-pipeline-parity-oracle.mjs
-// (cluster 9). The oracle bundles the REAL supervisor module - the flag
-// helpers, the code fingerprint, the supervisor lock (real fs on a scratch
-// dir, byte-compared records), the console logger + signal disposition, the
-// gone-TTY write-guard slice of ttyTeardownGuard.ts, the runSuperviseLoop
-// refusal legs, and createSupervisor (THE state machine) driven through
-// fully scripted deps: a scripted scheduler/clock (the scriptedTimers
-// pattern), a scripted child-process seam (ops declare exits with
-// codes/signals and IPC frames; spawns/kills/sends land in the trace), and
-// scripted probe/install/fingerprint/reexec seams - behind the one-shot
-// stdin/stdout JSON batch driver. Every supervision run returns the FULL
-// trace (spawn calls with argv/env deltas, signals sent, timer set/clear,
-// log events, store writes) for byte comparison.
-//
-// Determinism: clocks are injected per case; timers fire in scheduling
-// order once the scripted clock passes their due instant, with a full
-// microtask settle between fires and between ops (both drivers settle
-// identically, so async update-check chains interleave identically); the
-// only non-injectable TS timestamp (the lock record's startedAt) is pinned
-// with a scoped global-Date override, the cluster 2 oracle's technique.
-//
-// SECRETS: the oracle only ever sees the conformance suite's synthetic
-// argv/env/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 { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import {
-  acquireSupervisorLock,
-  createSupervisor,
-  createSupervisorConsoleLogger,
-  defaultSupervisorReexecStatePath,
-  defaultSupervisorTiming,
-  hasSuperviseFlag,
-  installSupervisorSignalHandlers,
-  isSupervisedChild,
-  runSuperviseLoop,
-  supervisedChildEnvKey,
-  supervisorCodeFingerprint,
-  supervisorLockKey,
-  supervisorLockPath,
-  withoutSuperviseFlags,
-} from './src/supervisor';
-import {
-  defaultGenerationStillbornWindowMs,
-  generationEpochEnvKey,
-  generationHandoffPidEnvKey,
-  generationOverlapFlagEnvKey,
-  generationTtyOwnerEnvKey,
-} from './src/generationOverlap';
-import { defaultLinzumiWebSocketUrl } from './src/defaultUrls';
-// Spec: plans/2026-09-11-computer-metadata-commander-restart.spec.md.
-// Mirror the real supervisor's explicit planned-restart support declaration.
-import { supervisorSupportEnvKey } from '../linzumi-cli-rescript/src/core/CommanderRequestedRestart.gen';
-import {
-  goneTtyErrorCode,
-  goneTtyWriteErrorCode,
-  guardStreamWriteAgainstGoneTty,
-  streamGoneTtyWriteCodeForTest,
-} from './src/ttyTeardownGuard';
-
-const RealDate = Date;
-
-function withPinnedDate(nowMs, fn) {
-  class PinnedDate extends RealDate {
-    constructor(...args) {
-      if (args.length === 0) {
-        super(nowMs);
-      } else {
-        super(...args);
-      }
-    }
-  }
-  PinnedDate.now = () => nowMs;
-  globalThis.Date = PinnedDate;
-  try {
-    return fn();
-  } finally {
-    globalThis.Date = RealDate;
-  }
-}
-
-const settle = () => new Promise((resolve) => setImmediate(resolve));
-
-// --- Scripted scheduler (the scriptedTimers pattern; ids in creation order) ---
-
-function scriptedScheduler(clock, trace) {
-  let nextId = 1;
-  const pending = [];
-  return {
-    scheduler: {
-      setTimeout: (callback, ms) => {
-        const id = nextId;
-        nextId += 1;
-        trace.push({ t: 'timer_set', id, delayMs: ms });
-        pending.push({ id, dueAtMs: clock.nowMs + ms, callback });
-        return id;
-      },
-      clearTimeout: (handle) => {
-        const index = pending.findIndex((timer) => timer.id === handle);
-        if (index >= 0) {
-          trace.push({ t: 'timer_clear', id: pending[index].id });
-          pending.splice(index, 1);
-        }
-      },
-    },
-    fireNextDue: () => {
-      const index = pending.findIndex((timer) => timer.dueAtMs <= clock.nowMs);
-      if (index < 0) return false;
-      const timer = pending.splice(index, 1)[0];
-      trace.push({ t: 'timer_fire', id: timer.id });
-      timer.callback();
-      return true;
-    },
-  };
-}
-
-// --- The scripted supervision run --------------------------------------------------
-
-async function runSupervisionCase(caseInput) {
-  // The TS serial drain reads process.platform at drain time (the win32
-  // SIGTERM fallback); the ReScript port injects isWin32. Pin the live
-  // platform for win32 cases so both impls run the same branch.
-  const platformDescriptor = Object.getOwnPropertyDescriptor(process, 'platform');
-  if (caseInput.win32 === true) {
-    Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
-  }
-  try {
-    return await runSupervisionCaseInner(caseInput);
-  } finally {
-    if (caseInput.win32 === true && platformDescriptor !== undefined) {
-      Object.defineProperty(process, 'platform', platformDescriptor);
-    }
-  }
-}
-
-async function runSupervisionCaseInner(caseInput) {
-  const clock = { nowMs: caseInput.startMs ?? 0 };
-  const trace = [];
-  const timers = scriptedScheduler(clock, trace);
-  const children = [];
-  const entryBytes = new Map(Object.entries(caseInput.entryBytes ?? {}));
-  let probeState = { kind: 'none' };
-  let installState = { kind: 'none' };
-  let storedAttempt = caseInput.attemptRecord ?? undefined;
-
-  const initialEntryPath = caseInput.initialEntryPath ?? '/stable/v-base/bin/linzumi.js';
-  const childArgs = caseInput.childArgs ?? ['--workspace', 'ws-parity'];
-
-  const supervisor = createSupervisor({
-    childArgs,
-    initialEntryPath,
-    initialVersion: caseInput.initialVersion ?? '1.0.0',
-    ownEntryPath:
-      caseInput.ownEntryPath === null
-        ? undefined
-        : (caseInput.ownEntryPath ?? initialEntryPath),
-    spawnChild: ({
-      entryPath,
-      childArgs: spawnArgs,
-      onExit,
-      onSpawnError,
-      generation,
-    }) => {
-      const index = children.length;
-      const pid = 4200 + index;
-      const record = {
-        index,
-        pid,
-        alive: true,
-        onExit,
-        onSpawnError,
-        generation,
-        sendOk: true,
-      };
-      children.push(record);
-      trace.push({
-        t: 'spawn',
-        index,
-        pid,
-        entryPath,
-        argv: [entryPath, 'connect', ...spawnArgs],
-        generation:
-          generation === undefined
-            ? null
-            : {
-                epoch: generation.epoch,
-                handoffFromPid: generation.handoffFromPid ?? null,
-                ipc: generation.onMessage !== undefined,
-                // B7a: the TTY single-owner stamp is part of the pinned
-                // spawn contract - an incoming overlap child must never be
-                // spawned as an owner.
-                ttyOwner: generation.ttyOwner,
-              },
-        envDelta:
-          generation === undefined
-            ? { [supervisedChildEnvKey]: '1', [supervisorSupportEnvKey]: '1' }
-            : {
-                [supervisedChildEnvKey]: '1',
-                [supervisorSupportEnvKey]: '1',
-                [generationEpochEnvKey]: String(generation.epoch),
-                [generationTtyOwnerEnvKey]: generation.ttyOwner ? '1' : '0',
-                ...(generation.handoffFromPid === undefined
-                  ? {}
-                  : {
-                      [generationHandoffPidEnvKey]: String(generation.handoffFromPid),
-                    }),
-              },
-      });
-      return {
-        pid,
-        kill: (signal) => trace.push({ t: 'kill', child: index, signal }),
-        ...(generation === undefined
-          ? {}
-          : {
-              send: (message) => {
-                trace.push({ t: 'send', child: index, message, ok: record.sendOk });
-                return record.sendOk;
-              },
-            }),
-      };
-    },
-    probeLatestVersion: async () => {
-      trace.push({ t: 'probe' });
-      if (probeState.kind === 'error') throw new Error(probeState.message);
-      return probeState.kind === 'version' ? probeState.version : undefined;
-    },
-    installVersion: async (version) => {
-      trace.push({ t: 'install', version });
-      if (installState.kind === 'error') throw new Error(installState.message);
-      if (installState.kind === 'entry') return { entryPath: installState.entryPath };
-      throw new Error('no scripted install result');
-    },
-    readEntryBytes: (entryPath) => {
-      trace.push({ t: 'read_bytes', path: entryPath });
-      return entryBytes.get(entryPath);
-    },
-    reexecSelf: ({ entryPath }) => trace.push({ t: 'reexec', entryPath }),
-    reexecAttemptStore: {
-      load: () => storedAttempt,
-      save: (record) => {
-        trace.push({ t: 'attempt_save', record });
-        storedAttempt = record;
-      },
-    },
-    log: (event, payload = {}) => trace.push({ t: 'log', event, payload }),
-    scheduler: timers.scheduler,
-    now: () => clock.nowMs,
-    // Spec: plans/2026-08-16-pr-5159-terminal-supervisor-liveness.md.
-    // The scripted oracle acknowledges manager-visible terminal handoff just
-    // like the ReScript parity driver; notifier failure is tested separately.
-    notifyTerminalFailure: () => undefined,
-    timing: caseInput.timing ?? undefined,
-    ...(caseInput.overlap === undefined
-      ? {}
-      : {
-          generationOverlap: {
-            enabled: caseInput.overlap.enabled === true,
-            stillbornWindowMs: caseInput.overlap.stillbornWindowMs,
-          },
-        }),
-  });
-
-  const aliveChildren = () => children.filter((child) => child.alive);
-  const exitChild = (record, code, signal) => {
-    record.alive = false;
-    trace.push({ t: 'exit', child: record.index, code, signal });
-    record.onExit({ code, signal });
-  };
-  const ipcTo = (record, label, message) => {
-    if (
-      record === undefined ||
-      record.generation === undefined ||
-      record.generation.onMessage === undefined
-    ) {
-      trace.push({ t: 'ipc_no_channel', op: label });
-      return;
-    }
-    trace.push({ t: 'ipc', child: record.index, message });
-    record.generation.onMessage(message);
-  };
-
-  for (const op of caseInput.ops ?? []) {
-    switch (op.op) {
-      case 'start':
-        supervisor.start();
-        break;
-      case 'advance': {
-        clock.nowMs += op.byMs;
-        let fired = timers.fireNextDue();
-        while (fired) {
-          await settle();
-          fired = timers.fireNextDue();
-        }
-        break;
-      }
-      case 'spawnErrorNewest': {
-        // Behavioral oracle for
-        // :machine-liveness/respawn-failures-stay-loud-and-retrying.
-        const alive = aliveChildren();
-        const target = alive[alive.length - 1];
-        if (target === undefined) {
-          trace.push({ t: 'no_child', op: op.op });
-        } else {
-          target.alive = false;
-          trace.push({
-            t: 'spawn_error',
-            child: target.index,
-            message: op.message,
-          });
-          target.onSpawnError(new Error(op.message));
-        }
-        break;
-      }
-      case 'exitNewest':
-      case 'exitOldest': {
-        const alive = aliveChildren();
-        const target = op.op === 'exitNewest' ? alive[alive.length - 1] : alive[0];
-        if (target === undefined) {
-          trace.push({ t: 'no_child', op: op.op });
-        } else {
-          exitChild(target, op.code ?? null, op.signal ?? null);
-        }
-        break;
-      }
-      case 'exitAll': {
-        for (const record of aliveChildren()) {
-          exitChild(record, op.code ?? null, op.signal ?? null);
-          await settle();
-        }
-        break;
-      }
-      case 'ipcReadyNewest': {
-        const alive = aliveChildren();
-        const target = alive[alive.length - 1];
-        ipcTo(target, op.op, {
-          type: 'generation_ready',
-          epoch: target?.generation?.epoch ?? 0,
-        });
-        break;
-      }
-      case 'ipcPinSnapshotOldest': {
-        const target = aliveChildren()[0];
-        ipcTo(target, op.op, {
-          type: 'generation_pin_snapshot',
-          epoch: target?.generation?.epoch ?? 0,
-          threadIds: op.threadIds,
-        });
-        break;
-      }
-      case 'ipcPinReleasedOldest': {
-        const target = aliveChildren()[0];
-        ipcTo(target, op.op, {
-          type: 'generation_pin_released',
-          epoch: target?.generation?.epoch ?? 0,
-          threadId: op.threadId,
-        });
-        break;
-      }
-      case 'ipcGarbageNewest': {
-        const alive = aliveChildren();
-        ipcTo(alive[alive.length - 1], op.op, op.message);
-        break;
-      }
-      case 'setLatest':
-        probeState =
-          op.version === null ? { kind: 'none' } : { kind: 'version', version: op.version };
-        break;
-      case 'probeError':
-        probeState = { kind: 'error', message: op.message };
-        break;
-      case 'setInstall':
-        installState = { kind: 'entry', entryPath: op.entryPath };
-        break;
-      case 'installError':
-        installState = { kind: 'error', message: op.message };
-        break;
-      case 'setBytes':
-        if (op.bytes === null) entryBytes.delete(op.path);
-        else entryBytes.set(op.path, op.bytes);
-        break;
-      case 'setSendNewest': {
-        const alive = aliveChildren();
-        const target = alive[alive.length - 1];
-        if (target === undefined) trace.push({ t: 'no_child', op: op.op });
-        else target.sendOk = op.ok === true;
-        break;
-      }
-      case 'requestStop':
-        supervisor.requestStop(
-          op.forwardSignal === undefined ? undefined : { forwardSignal: op.forwardSignal }
-        );
-        break;
-      case 'childActive':
-        trace.push({ t: 'child_active', value: supervisor.childActive() });
-        break;
-      case 'awaitDone': {
-        const outcome = await Promise.race([
-          supervisor.done.then(() => 'done'),
-          new Promise((resolve) => setTimeout(() => resolve('done_timeout'), 5000)),
-        ]);
-        trace.push({ t: outcome });
-        break;
-      }
-      default:
-        trace.push({ t: 'unknown_op', op: op.op });
-    }
-    await settle();
-  }
-
-  return { trace };
-}
-
-// --- Lock acquire runs (real fs on a scratch dir; startedAt pinned) --------------------
-
-function runAcquireLockCase(caseInput) {
-  const scratch = mkdtempSync(join(tmpdir(), 'linzumi-core-sup-lock-'));
-  const lockPath = join(scratch, 'sup.lock');
-  const trace = [];
-  const releases = [];
-  for (const step of caseInput.steps ?? []) {
-    if (step.action === 'acquire') {
-      const alivePids = step.alivePids ?? [];
-      const result = withPinnedDate(caseInput.nowMs ?? 0, () =>
-        acquireSupervisorLock({
-          path: lockPath,
-          workspace: caseInput.workspace ?? 'ws-lock',
-          linzumiUrl: caseInput.linzumiUrl ?? 'wss://parity.example',
-          pid: step.pid,
-          isPidAlive: (candidate) => alivePids.includes(candidate),
-        })
-      );
-      if (result.ok) {
-        releases.push(result.release);
-        trace.push({ t: 'acquired' });
-      } else {
-        trace.push({ t: 'held', holderPid: result.holderPid ?? null });
-      }
-      trace.push({
-        t: 'lock_bytes',
-        bytes: existsSync(lockPath) ? readFileSync(lockPath, 'utf8') : null,
-      });
-    } else if (step.action === 'releaseLast') {
-      const release = releases.pop();
-      if (release !== undefined) release();
-      trace.push({ t: 'released', fileExists: existsSync(lockPath) });
-    } else if (step.action === 'seedLock') {
-      writeFileSync(lockPath, step.content);
-      trace.push({ t: 'seeded' });
-    }
-  }
-  return { trace };
-}
-
-// --- Console logger / signal handlers / tty guard --------------------------------------
-
-function runConsoleLoggerCase(caseInput) {
-  const stderrLines = [];
-  const audits = [];
-  let writes = 0;
-  const logger = createSupervisorConsoleLogger({
-    writeStderr: (line) => {
-      writes += 1;
-      if (
-        caseInput.stderrFailAfter !== undefined &&
-        writes > caseInput.stderrFailAfter
-      ) {
-        throw new Error('EIO scripted console death');
-      }
-      stderrLines.push(line);
-    },
-    audit: (event, payload) => {
-      if (caseInput.auditFails === true) throw new Error('scripted audit failure');
-      audits.push({ event, payload });
-    },
-    now: () => new RealDate(caseInput.nowMs ?? 0),
-  });
-  for (const entry of caseInput.events ?? []) {
-    logger(entry.event, entry.payload);
-  }
-  return { stderrLines, audits };
-}
-
-function runSignalHandlersCase(caseInput) {
-  const trace = [];
-  const once = new Map();
-  const on = new Map();
-  installSupervisorSignalHandlers(
-    {
-      requestStop: (options) =>
-        trace.push({ t: 'request_stop', forwardSignal: options?.forwardSignal ?? null }),
-    },
-    (event, payload = {}) => trace.push({ t: 'log', event, payload }),
-    {
-      once: (event, listener) => {
-        const queue = once.get(event) ?? [];
-        queue.push(listener);
-        once.set(event, queue);
-        trace.push({ t: 'registered_once', event });
-      },
-      on: (event, listener) => {
-        const queue = on.get(event) ?? [];
-        queue.push(listener);
-        on.set(event, queue);
-        trace.push({ t: 'registered_on', event });
-      },
-    }
-  );
-  for (const signal of caseInput.fires ?? []) {
-    trace.push({ t: 'fire', signal });
-    const onceQueue = once.get(signal) ?? [];
-    if (onceQueue.length > 0) {
-      const listener = onceQueue.shift();
-      listener();
-    }
-    for (const listener of on.get(signal) ?? []) {
-      listener();
-    }
-  }
-  return { trace };
-}
-
-function errorOfSpec(spec) {
-  if (spec.kind === 'null') return null;
-  if (spec.kind === 'string') return spec.value;
-  if (spec.kind === 'number') return spec.value;
-  const error = {};
-  if (spec.code !== undefined) error.code = spec.code;
-  if (spec.message !== undefined) error.message = spec.message;
-  return error;
-}
-
-function runTtyClassifyCase(caseInput) {
-  return (caseInput.errors ?? []).map((spec) => {
-    const error = errorOfSpec(spec);
-    return {
-      gone: goneTtyErrorCode(error) ?? null,
-      write: goneTtyWriteErrorCode(error) ?? null,
-    };
-  });
-}
-
-function runTtyGuardCase(caseInput) {
-  const trace = [];
-  const errorListeners = [];
-  let throwSpec;
-  const stream = {
-    isTTY: true,
-    write: (chunk) => {
-      if (throwSpec !== undefined) {
-        const error = new Error(throwSpec.message);
-        if (throwSpec.code !== undefined) error.code = throwSpec.code;
-        throwSpec = undefined;
-        throw error;
-      }
-      trace.push({ t: 'underlying_write', chunk });
-      return true;
-    },
-    on: (event, listener) => {
-      if (event === 'error') errorListeners.push(listener);
-      trace.push({ t: 'listener_added', event });
-    },
-    listenerCount: (event) => (event === 'error' ? errorListeners.length : 0),
-  };
-  const sinks = {
-    audit: (event, fields) => trace.push({ t: 'sink', leg: 'audit', event, fields }),
-    log: (event, fields) => trace.push({ t: 'sink', leg: 'log', event, fields }),
-  };
-  const guard = (label) =>
-    trace.push({
-      t: 'guarded',
-      label,
-      result: guardStreamWriteAgainstGoneTty(stream, {
-        context: { surface: 'parity_surface' },
-        sinks,
-        onGoneTty: (code) => trace.push({ t: 'gone_tty', label, code }),
-        rethrow: (error) =>
-          trace.push({
-            t: 'rethrown',
-            message: error instanceof Error ? error.message : String(error),
-          }),
-      }),
-    });
-  guard('first');
-  for (const op of caseInput.ops ?? []) {
-    if (op.op === 'write') {
-      if (op.throwCode !== undefined || op.throwMessage !== undefined) {
-        throwSpec = { code: op.throwCode, message: op.throwMessage ?? 'scripted write failure' };
-      }
-      let outcome;
-      let threwMessage = null;
-      try {
-        outcome = stream.write(op.data);
-      } catch (error) {
-        outcome = null;
-        threwMessage = error instanceof Error ? error.message : String(error);
-      }
-      trace.push({ t: 'write_result', returned: outcome, threw: threwMessage });
-    } else if (op.op === 'emitError') {
-      const error = new Error(op.message ?? 'scripted stream error');
-      if (op.code !== undefined) error.code = op.code;
-      trace.push({ t: 'emit_error', code: op.code ?? null });
-      for (const listener of [...errorListeners]) listener(error);
-    } else if (op.op === 'guardAgain') {
-      guard(op.label ?? 'again');
-    }
-  }
-  return { trace, goneCode: streamGoneTtyWriteCodeForTest(stream) ?? null };
-}
-
-// --- runSuperviseLoop refusal legs -----------------------------------------------------
-
-async function runLockRefusalCase(caseInput) {
-  const scratch = mkdtempSync(join(tmpdir(), 'linzumi-core-sup-home-'));
-  const workspace = caseInput.workspace ?? '';
-  const args = workspace === '' ? [] : ['--workspace', workspace];
-  const lockPath = supervisorLockPath(
-    { workspace, linzumiUrl: defaultLinzumiWebSocketUrl },
-    scratch
-  );
-  mkdirSync(dirname(lockPath), { recursive: true });
-  writeFileSync(
-    lockPath,
-    JSON.stringify({
-      pid: 1,
-      workspace,
-      linzumiUrl: defaultLinzumiWebSocketUrl,
-      startedAt: '2026-01-01T00:00:00.000Z',
-    }) + '\\n'
-  );
-  const previousHome = process.env.HOME;
-  process.env.HOME = scratch;
-  try {
-    await runSuperviseLoop(['--supervise', ...args]);
-    return { message: null };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { message: message.split(scratch).join('$SCRATCH') };
-  } finally {
-    process.env.HOME = previousHome;
-  }
-}
-
-async function runEmptyEntryCase() {
-  const scratch = mkdtempSync(join(tmpdir(), 'linzumi-core-sup-home-'));
-  const previousHome = process.env.HOME;
-  const previousArgv1 = process.argv[1];
-  process.env.HOME = scratch;
-  process.argv[1] = '';
-  try {
-    await runSuperviseLoop(['--supervise', '--workspace', 'ws-empty']);
-    return { message: null };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { message: message.split(scratch).join('$SCRATCH') };
-  } finally {
-    process.env.HOME = previousHome;
-    process.argv[1] = previousArgv1;
-  }
-}
-
-// --- Case dispatch -----------------------------------------------------------------------
-
-async function runCase(input) {
-  switch (input.kind) {
-    case 'constants':
-      return {
-        supervisedChildEnvKey,
-        generationOverlapFlagEnvKey,
-        generationEpochEnvKey,
-        generationHandoffPidEnvKey,
-        generationTtyOwnerEnvKey,
-        defaultGenerationStillbornWindowMs,
-        defaultSupervisorTiming,
-        defaultLinzumiWebSocketUrl,
-      };
-    case 'isSupervisedChild':
-      return isSupervisedChild(input.env);
-    case 'withoutSuperviseFlags':
-      return withoutSuperviseFlags(input.args);
-    case 'hasSuperviseFlag':
-      return hasSuperviseFlag(input.args);
-    case 'fingerprint':
-      return (
-        supervisorCodeFingerprint(input.entryPath, (path) => {
-          const bytes = (input.files ?? {})[path];
-          return bytes === undefined ? undefined : bytes;
-        }) ?? null
-      );
-    case 'lockKey':
-      return supervisorLockKey({ workspace: input.workspace, linzumiUrl: input.linzumiUrl });
-    case 'lockPath':
-      return supervisorLockPath(
-        { workspace: input.workspace, linzumiUrl: input.linzumiUrl },
-        input.homeDir
-      );
-    case 'reexecStatePath':
-      return defaultSupervisorReexecStatePath(input.env);
-    case 'acquireLockRun':
-      return runAcquireLockCase(input);
-    case 'consoleLogger':
-      return runConsoleLoggerCase(input);
-    case 'signalHandlers':
-      return runSignalHandlersCase(input);
-    case 'ttyClassify':
-      return runTtyClassifyCase(input);
-    case 'ttyGuardRun':
-      return runTtyGuardCase(input);
-    case 'lockRefusalLoop':
-      return runLockRefusalCase(input);
-    case 'emptyEntryLoop':
-      return runEmptyEntryCase();
-    case 'supervisionRun':
-      return runSupervisionCase(input);
-    default:
-      return { error: 'unknown case kind ' + String(input.kind) };
-  }
-}
-
-async function runBatch() {
-  const chunks = [];
-  for await (const chunk of process.stdin) chunks.push(chunk);
-  const cases = JSON.parse(Buffer.concat(chunks).toString('utf8'));
-  const results = [];
-  for (const testCase of cases) {
-    results.push(await runCase(testCase));
-  }
-  process.stdout.write(JSON.stringify(results), () => {
-    process.exit(0);
-  });
-}
-
-runBatch().then(
-  () => {},
-  (error) => {
-    process.stderr.write(String(error && error.stack ? error.stack : error) + '\\n');
-    process.exit(1);
-  }
-);
-`;
-
-const outDir = join(packageRoot, '.differential');
-const outPath = join(outDir, 'core-supervisor-parity-oracle.mjs');
-
-await mkdir(outDir, { recursive: true });
-
-await build({
-  stdin: {
-    contents: driverSource,
-    resolveDir: packageRoot,
-    sourcefile: 'core-supervisor-parity-driver.ts',
-    loader: 'ts',
-  },
-  bundle: true,
-  platform: 'node',
-  target: 'node20',
-  format: 'esm',
-  outfile: outPath,
-  minify: false,
-  sourcemap: false,
-  legalComments: 'none',
-  logLevel: 'silent',
-  // supervisor.ts pulls the wider commander graph (updateNudge,
-  // workerEntryStability, runnerLogger); the same runtime externals as the
-  // differential entry build stay external.
-  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
-});
-
-process.stdout.write(outPath + '\n');