@linzumi/cli 1.0.111 → 1.0.113

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

@@ -0,0 +1,455 @@
+// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
+// (M3 cluster 10, runner core - the workspace lock + operator takeover flow).
+// Relationship: Builds the TS-side PARITY ORACLE for the commander
+// workspace-lock port, the sibling of build-config-identity-parity-oracle.mjs
+// (cluster 2). The oracle bundles the REAL runnerLock.ts +
+// runnerLockTakeover.ts behind a one-shot batch driver: a JSON array of cases
+// on stdin, a JSON array of results on stdout. The ReScript package's
+// CoreLockParityConformance drives the SAME inputs through
+// src/core/CommanderLock.res / CommanderLockTakeover.res in its own scratch
+// directories and asserts accept/reject/value equivalence, pinned contract
+// error strings, log/prompt/signal trace parity AND byte-identical lock-file
+// trees - the cross-impl contract that lets both commanders share the
+// ~/.linzumi/runners locks through M4.
+//
+// Determinism: every source of nondeterminism is pinned per case - the clock
+// is a scripted per-case cell read through the injected `now`, pid liveness
+// is a scripted set, SIGKILL/SIGTERM outcomes are scripted (per-pid /
+// per-signal failure codes), prompts are scripted answer queues, and the
+// takeover waits run on a virtual clock advanced by the injected `sleep`.
+// Scratch paths are normalized through the "$DIR" placeholder in both
+// directions.
+//
+// Like the sibling oracles, 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,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, relative } from 'node:path';
+import {
+  acquireIncomingGenerationRunnerLock,
+  acquireRunnerLock,
+  assessRunnerLockHolder,
+  compareCliVersions,
+  electronAutoConnectLaunchSource,
+  incomingGenerationRunnerLockPath,
+  readRunnerLockOwner,
+  RunnerLockHeldError,
+  runnerLockHeartbeatIntervalMs,
+  runnerLockHeldErrorName,
+  runnerLockPath,
+  runnerLockTakeoverAfterMs,
+  shouldAutoTakeOverForUpdate,
+} from './src/runnerLock';
+import {
+  isRunnerLockConflictReportedError,
+  resolveRunnerLockConflict,
+  RunnerLockConflictReportedError,
+  runnerLockConflictReport,
+  runnerLockConflictReportedErrorName,
+  runnerLockTakeoverForcefulStopMs,
+  runnerLockTakeoverGracefulStopMs,
+  runnerLockTakeoverPollMs,
+  runnerLockTakeoverSleep,
+  shouldResolveRunnerLockConflict,
+} from './src/runnerLockTakeover';
+
+// --- 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-lock-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,
+      name: error instanceof Error ? error.name : 'Error',
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+// --- Pure surfaces ----------------------------------------------------------------
+
+function handleLockPath(testCase) {
+  const dir = scratch();
+  const configPath = join(dir, 'config.json');
+  const result = outcome(() =>
+    runnerLockPath(testCase.machineId, configPath, testCase.linzumiUrl)
+  );
+  return substitute(result, dir, dirPlaceholder);
+}
+
+function handleAssessHolder(testCase) {
+  const alive = new Set(testCase.alivePids ?? []);
+  return outcome(() =>
+    assessRunnerLockHolder(
+      testCase.record,
+      (pid) => alive.has(pid),
+      () => new Date(testCase.nowMs)
+    )
+  );
+}
+
+function handleShouldAutoTakeOver(testCase) {
+  return outcome(() =>
+    shouldAutoTakeOverForUpdate(
+      testCase.existing,
+      testCase.myVersion,
+      testCase.myLaunchSource,
+      testCase.holderState
+    )
+  );
+}
+
+function handleHeldMessage(testCase) {
+  return outcome(() => {
+    const error = new RunnerLockHeldError(testCase.lockPath, testCase.record);
+    return { name: error.name, message: error.message };
+  });
+}
+
+async function handleConstants() {
+  await runnerLockTakeoverSleep(0);
+  const reported = new RunnerLockConflictReportedError();
+  return {
+    heartbeatIntervalMs: runnerLockHeartbeatIntervalMs,
+    takeoverAfterMs: runnerLockTakeoverAfterMs,
+    heldErrorName: runnerLockHeldErrorName,
+    electronAutoConnectLaunchSource,
+    gracefulStopMs: runnerLockTakeoverGracefulStopMs,
+    forcefulStopMs: runnerLockTakeoverForcefulStopMs,
+    pollMs: runnerLockTakeoverPollMs,
+    conflictReportedErrorName: runnerLockConflictReportedErrorName,
+    conflictReportedError: {
+      name: reported.name,
+      message: reported.message,
+      guard: isRunnerLockConflictReportedError(reported),
+    },
+    sleepResolved: true,
+  };
+}
+
+// --- Lock lifecycle ------------------------------------------------------------------
+
+function handleLockLifecycle(testCase) {
+  const dir = scratch();
+  const configPath = join(dir, 'config.json');
+  const actions = substitute(testCase.actions ?? [], dirPlaceholder, dir);
+  const killFailures = testCase.killFailures ?? {};
+  let clockMs = 0;
+  const alive = new Set();
+  const events = [];
+  const handles = new Map();
+  const now = () => new Date(clockMs);
+  const isPidAlive = (pid) => alive.has(pid);
+  const killPid = (pid) => {
+    events.push({ type: 'kill', pid });
+    const code = killFailures[String(pid)];
+    if (code !== undefined) {
+      const error = new Error(code);
+      error.code = code;
+      throw error;
+    }
+    alive.delete(pid);
+  };
+  const onTakeover = (takeover) => {
+    events.push({
+      type: 'takeover',
+      lockPath: takeover.lockPath,
+      holderPid: takeover.holderPid,
+      holderRunnerId: takeover.holderRunnerId,
+      reason: takeover.reason,
+    });
+  };
+  const runSetup = (setup) => {
+    for (const sub of setup ?? []) {
+      runAction(sub);
+    }
+  };
+  const acquireOptions = (action) => ({
+    machineId: action.machineId,
+    runnerId: action.runnerId,
+    cwd: action.cwd,
+    workspace: action.workspace ?? null,
+    ...(action.linzumiUrl === undefined ? {} : { linzumiUrl: action.linzumiUrl }),
+    configPath,
+    pid: action.pid,
+    ...(action.launchSource === undefined ? {} : { launchSource: action.launchSource }),
+    now,
+    isPidAlive,
+    cliVersion: action.cliVersion,
+    ...(action.gracefulUpdateDrain === undefined
+      ? {}
+      : { gracefulUpdateDrain: action.gracefulUpdateDrain }),
+    killPid,
+    onTakeover,
+    ...(action.beforeReadExistingLock === undefined
+      ? {}
+      : { beforeReadExistingLock: () => runSetup(action.beforeReadExistingLock) }),
+    ...(action.beforeReplaceStaleLock === undefined
+      ? {}
+      : { beforeReplaceStaleLock: () => runSetup(action.beforeReplaceStaleLock) }),
+  });
+  const runAction = (action) => {
+    switch (action.act) {
+      case 'setClock':
+        return outcome(() => {
+          clockMs = action.ms;
+        });
+      case 'setAlive':
+        return outcome(() => {
+          alive.clear();
+          for (const pid of action.pids) {
+            alive.add(pid);
+          }
+        });
+      case 'mkdir':
+        return outcome(() => {
+          mkdirSync(action.path, { recursive: true });
+        });
+      case 'writeFile':
+        return outcome(() => writeFileSync(action.path, action.contents, 'utf8'));
+      case 'unlink':
+        return outcome(() => unlinkSync(action.path));
+      case 'acquire':
+        return outcome(() => {
+          const handle = acquireRunnerLock(acquireOptions(action));
+          handles.set(action.id, handle);
+          return { path: handle.path };
+        });
+      case 'acquireIncoming':
+        return outcome(() => {
+          const handle = acquireIncomingGenerationRunnerLock({
+            ...acquireOptions(action),
+            handoffHolderPid: action.handoffHolderPid,
+          });
+          handles.set(action.id, handle);
+          return { path: handle.path, promoted: handle.promoted() };
+        });
+      case 'heartbeat':
+        return outcome(() => handles.get(action.id).heartbeat());
+      case 'release':
+        return outcome(() => handles.get(action.id).release());
+      case 'promote':
+        return outcome(() => handles.get(action.id).promote());
+      case 'promoted':
+        return outcome(() => handles.get(action.id).promoted());
+      case 'handlePath':
+        return outcome(() => handles.get(action.id).path);
+      case 'readOwner':
+        return outcome(() => readRunnerLockOwner(action.path));
+      default:
+        return { threw: true, name: 'Error', message: 'unknown lock action ' + String(action.act) };
+    }
+  };
+  const results = actions.map((action) => runAction(action));
+  return substitute(
+    { results, files: snapshotFiles(dir), events },
+    dir,
+    dirPlaceholder
+  );
+}
+
+// --- Takeover flow ----------------------------------------------------------------------
+
+async function handleTakeoverFlow(testCase) {
+  const holder = testCase.holder;
+  const schedule = testCase.schedule ?? {};
+  let virtualMs = schedule.startMs ?? 0;
+  const sleeps = [];
+  const signals = [];
+  const reports = [];
+  const questions = [];
+  const logs = [];
+  const answers = [...(testCase.promptAnswers ?? [])];
+  const signalFailures = testCase.signalFailures ?? {};
+  const lockReleased = () =>
+    schedule.lockReleasedAtMs !== undefined && virtualMs >= schedule.lockReleasedAtMs;
+  const deps = {
+    isPidAlive: () =>
+      schedule.pidDeadAtMs === undefined ? true : virtualMs < schedule.pidDeadAtMs,
+    signalPid: (pid, signal) => {
+      signals.push({ pid, signal, atMs: virtualMs });
+      const code = signalFailures[signal];
+      if (code !== undefined) {
+        const error = new Error('scripted ' + signal + ' failure');
+        error.code = code;
+        throw error;
+      }
+    },
+    lockReleased,
+    currentLockOwner: () => {
+      if (schedule.ownerChange !== undefined && virtualMs >= schedule.ownerChange.atMs) {
+        return schedule.ownerChange.owner === null ? undefined : schedule.ownerChange.owner;
+      }
+      return holder;
+    },
+    sleep: (ms) => {
+      sleeps.push(ms);
+      virtualMs += ms;
+      return Promise.resolve();
+    },
+    now: () => virtualMs,
+    log: (event, payload) => {
+      logs.push({ event, payload });
+    },
+  };
+  const prompt = {
+    isInteractive: () => testCase.interactive === true,
+    writeReport: (text) => {
+      reports.push(text);
+    },
+    promptYesNo: (question) => {
+      questions.push(question);
+      return Promise.resolve(answers.length > 0 ? answers.shift() === true : false);
+    },
+  };
+  let result;
+  try {
+    const value = await resolveRunnerLockConflict({
+      holder,
+      lockPath: testCase.lockPath,
+      baseMessage: testCase.baseMessage,
+      takeOverWithoutPrompt: testCase.takeOverWithoutPrompt === true,
+      prompt,
+      takeover: deps,
+    });
+    result = { defined: true, value };
+  } catch (error) {
+    result = {
+      threw: true,
+      name: error instanceof Error ? error.name : 'Error',
+      message: error instanceof Error ? error.message : String(error),
+    };
+  }
+  return { outcome: result, sleeps, signals, reports, questions, logs, endMs: virtualMs };
+}
+
+// --- Dispatch --------------------------------------------------------------------------------
+
+async function handle(testCase) {
+  switch (testCase.op) {
+    case 'constants':
+      return await handleConstants();
+    case 'lockPath':
+      return handleLockPath(testCase);
+    case 'incomingPath':
+      return outcome(() => incomingGenerationRunnerLockPath(testCase.primaryPath));
+    case 'compareVersions':
+      return outcome(() => compareCliVersions(testCase.a, testCase.b));
+    case 'assessHolder':
+      return handleAssessHolder(testCase);
+    case 'shouldAutoTakeOver':
+      return handleShouldAutoTakeOver(testCase);
+    case 'heldMessage':
+      return handleHeldMessage(testCase);
+    case 'conflictReport':
+      return outcome(() => runnerLockConflictReport(testCase.baseMessage));
+    case 'shouldResolve':
+      return outcome(() =>
+        shouldResolveRunnerLockConflict(testCase.defined === true ? {} : undefined)
+      );
+    case 'lockLifecycle':
+      return handleLockLifecycle(testCase);
+    case 'takeoverFlow':
+      return await handleTakeoverFlow(testCase);
+    default:
+      return { threw: true, name: 'Error', 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));
+}
+process.stdout.write(JSON.stringify(results));
+`;
+
+await mkdir(join(packageRoot, '.differential'), { recursive: true });
+
+await build({
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'core-lock-parity-driver.ts',
+    loader: 'ts',
+  },
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outfile: join(packageRoot, '.differential/core-lock-parity-oracle.mjs'),
+  minify: false,
+  sourcemap: false,
+  legalComments: 'none',
+  // runnerLock.ts pulls localConfig/oauth; the same runtime externals as the
+  // sibling oracle builds stay external (installed in this package's
+  // node_modules; the oracle only exercises the lock/takeover exports).
+  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
+});

package/scripts/build-core-reconnect-resume-parity-oracle.mjs

@@ -0,0 +1,256 @@
+// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
+// (M3 cluster 10, commander core - the reconnect-resume recovery arm).
+// Relationship: Builds the TS-side PARITY ORACLE for the reconnect-path
+// resume orchestration of the ReScript commander port, the sibling of
+// build-pipeline-parity-oracle.mjs (cluster 9) and
+// build-harness-codex-parity-oracle.mjs (cluster 7). The oracle bundles
+// the REAL runner.ts reconnect-resume exports - the I200 resume decision
+// ladder (resumeCodexThreadForReconnect, transitively
+// unarchiveAndResumeCodexThread, the archived/missing recognizers, and
+// channelSession.ts's withCodexStartRequestTimeout) and the two rehydration
+// fetch legs (fetchThreadRehydrationMessagesForTest /
+// fetchThreadTranscriptForRehydrationForTest, transitively the
+// reconnectContext.ts message parser and the transcriptCompiler.ts
+// canonical-page parser) - behind the cluster 1/2 one-shot BATCH driver (a
+// JSON array of cases on stdin, a JSON array of results on stdout).
+//
+// Scripting: the codex JSON-RPC request seam and the Phoenix push seam are
+// per-case scripted reply queues (result / json-rpc error / rejection /
+// never-settle hang); the rehydration builders are scripted
+// (return/undefined/throw). Timeouts: the REAL withCodexStartRequestTimeout
+// runs inside the bundle, bounded per case through its own
+// LINZUMI_CODEX_START_REQUEST_TIMEOUT_MS knob (set from the case input
+// before each run), so a scripted hang fails with the genuine sentinel
+// bytes after a genuinely elapsed (small) bound. The batch loop holds a
+// keepAlive interval while awaiting - the sentinel timer is unref'd by
+// design and node would otherwise exit mid-hang (the cluster 7 lesson).
+//
+// Byte parity: every request (with params), push (with payload), log
+// event (with payload), builder invocation, and the final
+// outcome/thrown-message ride the returned trace VERBATIM (the TS
+// objects' own key order rides JSON.stringify), so the ReScript side's
+// trace serialization must reproduce field presence AND insertion order
+// exactly.
+//
+// Import-time side effects: runner.ts's graph resolves assets/ relative
+// to the bundle at import time (the hello-project scaffold's inlined
+// logo), so the asset is copied next to the emitted oracle - the
+// build-harness-codex-parity-oracle precedent. No other stubs are needed;
+// the externals list matches the other oracles.
+//
+// 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 { 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 {
+  fetchThreadRehydrationMessagesForTest,
+  fetchThreadTranscriptForRehydrationForTest,
+  resumeCodexThreadForReconnect,
+} from './src/runner';
+
+// Scripted codex JSON-RPC request seam: replies are consumed in call
+// order; every call is traced with its params. An exhausted script
+// REJECTS loudly (mirrored byte-for-byte by the ReScript scripted seam).
+function scriptedRequest(script, trace) {
+  let index = 0;
+  return (method, params) => {
+    trace.push({ t: 'request', method, params: params ?? null });
+    const step = script[index];
+    index += 1;
+    if (step === undefined) {
+      return Promise.reject(new Error('unscripted request: ' + method));
+    }
+    if (step.hang === true) {
+      return new Promise(() => {});
+    }
+    if (step.reject !== undefined) {
+      return Promise.reject(new Error(step.reject));
+    }
+    if (step.error !== undefined) {
+      return Promise.resolve({ error: step.error });
+    }
+    return Promise.resolve({ result: step.result ?? {} });
+  };
+}
+
+async function runResumeCase(input) {
+  // The REAL wrapper resolves its bound per call through this knob.
+  process.env.LINZUMI_CODEX_START_REQUEST_TIMEOUT_MS = String(
+    input.timeoutMs
+  );
+  const trace = [];
+  const request = scriptedRequest(input.requestScript ?? [], trace);
+  const rehydration = {
+    forceRehydrate: input.forceRehydrate === true,
+    buildRehydrationText: async (resumeFailure) => {
+      trace.push({ t: 'buildText', resumeFailure });
+      const script = input.textScript ?? {};
+      if (script.throw !== undefined) {
+        throw new Error(script.throw);
+      }
+      return script.text;
+    },
+    buildRehydrationItems:
+      input.itemsScript === undefined
+        ? undefined
+        : async (resumeFailure) => {
+            trace.push({ t: 'buildItems', resumeFailure });
+            const script = input.itemsScript;
+            if (script.throw !== undefined) {
+              throw new Error(script.throw);
+            }
+            return script.items;
+          },
+    log: (event, payload) => trace.push({ t: 'log', event, payload }),
+  };
+  const outcome = await resumeCodexThreadForReconnect(
+    { request },
+    input.codexThreadId,
+    input.resumeOverrides ?? {},
+    rehydration
+  ).then(
+    (value) => ({ ok: true, value }),
+    (error) => ({
+      ok: false,
+      message: error instanceof Error ? error.message : String(error),
+    })
+  );
+  trace.push({ t: 'outcome', outcome });
+  return { trace };
+}
+
+// Scripted Phoenix push seam shared by the two fetch legs.
+function scriptedPush(script, trace) {
+  let index = 0;
+  return {
+    push: async (topic, event, payload) => {
+      trace.push({ t: 'push', topic, event, payload });
+      const step = script[index];
+      index += 1;
+      if (step === undefined) {
+        throw new Error('unscripted push: ' + event);
+      }
+      if (step.throw !== undefined) {
+        throw new Error(step.throw);
+      }
+      return step.reply;
+    },
+  };
+}
+
+function fetchTarget(input) {
+  return {
+    workspace: input.target.workspace ?? undefined,
+    channel: input.target.channel ?? undefined,
+    threadId: input.target.threadId ?? undefined,
+  };
+}
+
+async function runFetchMessagesCase(input) {
+  const trace = [];
+  const client = scriptedPush(input.pushScript ?? [], trace);
+  const messages = await fetchThreadRehydrationMessagesForTest(
+    client,
+    input.topic,
+    fetchTarget(input),
+    (event, payload) => trace.push({ t: 'log', event, payload })
+  );
+  trace.push({ t: 'messages', messages });
+  return { trace };
+}
+
+async function runFetchTranscriptCase(input) {
+  const trace = [];
+  const client = scriptedPush(input.pushScript ?? [], trace);
+  const transcript = await fetchThreadTranscriptForRehydrationForTest(
+    client,
+    input.topic,
+    fetchTarget(input),
+    (event, payload) => trace.push({ t: 'log', event, payload })
+  );
+  trace.push({ t: 'transcript', value: transcript ?? null });
+  return { trace };
+}
+
+async function runCase(input) {
+  switch (input.kind) {
+    case 'resumeRun':
+      return runResumeCase(input);
+    case 'fetchMessagesRun':
+      return runFetchMessagesCase(input);
+    case 'fetchTranscriptRun':
+      return runFetchTranscriptCase(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) {
+    // The sentinel timer is unref'd by design; hold the event loop open
+    // while a hang case waits it out or node would exit mid-await.
+    const keepAlive = setInterval(() => {}, 1000);
+    try {
+      results.push(await runCase(testCase));
+    } finally {
+      clearInterval(keepAlive);
+    }
+  }
+  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-reconnect-resume-parity-oracle.mjs');
+
+await mkdir(outDir, { recursive: true });
+// runner.ts's graph resolves assets/ relative to the bundle at import time
+// (the hello-project scaffold's inlined logo), so the asset must sit next
+// to the emitted oracle - the build-harness-codex-parity-oracle precedent.
+await mkdir(join(outDir, 'assets'), { recursive: true });
+await copyFile(
+  join(packageRoot, 'src/assets/linzumi-logo.svg'),
+  join(outDir, 'assets/linzumi-logo.svg')
+);
+
+await build({
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'core-reconnect-resume-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');