@linzumi/cli 1.0.271 → 1.0.273

package/scripts/build-session-registry-parity-oracle.mjs

@@ -1,582 +0,0 @@
-// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
-// (M3 cluster 6, session-registry/leases).
-// Relationship: Builds the TS-side PARITY ORACLE for the session-registry/
-// leases cluster of the ReScript commander port, the sibling of
-// build-queue-parity-oracle.mjs (cluster 5). The oracle bundles the REAL
-// TS session/lease modules (runnerThreadSessionRegistry.ts,
-// codexSessionOwnership.ts, leaseEpochGuard.ts, threadReconcilerLock.ts,
-// the pin-registry/disposition slice of generationOverlap.ts, and the
-// exported liveness classifiers from runner.ts - threadRunnerEntryLiveness
-// + processIsAlive) behind the cluster 1/2 one-shot batch driver: a JSON
-// array of cases on stdin, a JSON array of results on stdout. The ReScript
-// package's RegistryParityConformance drives the SAME scripted inputs
-// through the ported modules in its own scratch directories and asserts
-// per-action outcome equivalence AND byte-identical registry files - the
-// cross-impl round-trip contract that lets both commanders share
-// ~/.linzumi through M4.
-//
-// Determinism: clocks are pinned per case (updatedAtMs/nowMs ride the
-// inputs; the registry store takes nowMs on rebind), scripted lock
-// sections use millisecond-scale sleeps sized so outcomes (not timings)
-// are deterministic, timing NUMBERS inside diagnostics are normalized on
-// both sides, and scratch paths are normalized through the "$DIR"
-// placeholder in both directions. Worker-liveness pid probes use the
-// driver's own live pid and a genuinely-dead child pid so the REAL
-// process.kill(pid, 0) probe is exercised identically by both impls.
-//
-// 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 { spawnSync } from 'node:child_process';
-import {
-  mkdtempSync,
-  readdirSync,
-  readFileSync,
-  realpathSync,
-  statSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, relative } from 'node:path';
-import {
-  createRunnerThreadSessionRegistryStore,
-  defaultThreadSessionRehydrationMaxAgeMs,
-  reannounceThreadSessionCap,
-  reannounceableThreadSessions,
-  rehydrateThreadSessions,
-  runnerThreadSessionRegistryDir,
-  runnerThreadSessionRegistryPath,
-} from './src/runnerThreadSessionRegistry';
-import {
-  CodexSessionOwnershipConflictError,
-  findCodexSessionOwnerConflict,
-  sanitizeCodexSessionOwnership,
-} from './src/codexSessionOwnership';
-import {
-  createLeaseEpochRegistry,
-  isFencedClaim,
-  leaseEpochEnvelope,
-  readLeaseEpoch,
-} from './src/leaseEpochGuard';
-import {
-  ReconcilerLockQueuedTimeoutError,
-  ReconcilerLockTimeoutError,
-  createThreadReconcilerLock,
-} from './src/threadReconcilerLock';
-import {
-  createGenerationPinRegistry,
-  generationControlDisposition,
-} from './src/generationOverlap';
-import { processIsAlive, threadRunnerEntryLiveness } 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-registry-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, dir) {
-  return (event, payload) => {
-    events.push({ event, payload: substitute(payload, dir, dirPlaceholder) });
-  };
-}
-
-// --- Ownership pure transforms -----------------------------------------------------
-
-function handleOwnership(testCase) {
-  switch (testCase.fn) {
-    case 'conflictMessage': {
-      const error = new CodexSessionOwnershipConflictError({
-        codexThreadId: testCase.codexThreadId,
-        ownerKandanThreadId: testCase.ownerThreadId,
-        requestingKandanThreadId: testCase.requestingThreadId,
-      });
-      return { message: error.message, name: error.name };
-    }
-    case 'findConflict':
-      return outcome(() =>
-        findCodexSessionOwnerConflict(testCase.records, testCase.bind)
-      );
-    case 'sanitize':
-      return outcome(() => sanitizeCodexSessionOwnership(testCase.records));
-    default:
-      return { threw: true, message: 'unknown ownership fn ' + String(testCase.fn) };
-  }
-}
-
-// --- Lease epoch registry -----------------------------------------------------------
-
-function handleLease(testCase) {
-  switch (testCase.fn) {
-    case 'readLeaseEpoch':
-      return outcome(() => readLeaseEpoch(testCase.value));
-    case 'envelope':
-      return outcome(() => leaseEpochEnvelope(testCase.held ?? undefined));
-    case 'isFenced':
-      return outcome(() =>
-        isFencedClaim(testCase.held ?? undefined, testCase.control ?? undefined)
-      );
-    case 'scenario': {
-      const registry = createLeaseEpochRegistry();
-      const results = (testCase.actions ?? []).map((action) => {
-        switch (action.fn) {
-          case 'adopt':
-            return outcome(() => registry.adopt(action.threadId, action.epoch));
-          case 'current':
-            return outcome(() => registry.current(action.threadId));
-          case 'release':
-            return outcome(() => registry.release(action.threadId));
-          case 'snapshot':
-            return outcome(() => registry.snapshot());
-          default:
-            return { threw: true, message: 'unknown lease fn ' + String(action.fn) };
-        }
-      });
-      return { results };
-    }
-    default:
-      return { threw: true, message: 'unknown lease fn ' + String(testCase.fn) };
-  }
-}
-
-// --- Registry store paths + scripted lifecycles --------------------------------------
-
-function handleRegistryPaths(testCase) {
-  process.env.LINZUMI_SESSION_REGISTRY_DIR = testCase.envDir ?? '';
-  const result = {
-    dir: outcome(() => runnerThreadSessionRegistryDir()),
-    path: outcome(() => runnerThreadSessionRegistryPath(testCase.runnerId)),
-  };
-  delete process.env.LINZUMI_SESSION_REGISTRY_DIR;
-  return result;
-}
-
-function handleRegistryScenario(testCase) {
-  const dir = scratch();
-  const path = join(dir, 'registry.json');
-  if (testCase.initialContents !== undefined) {
-    writeFileSync(path, testCase.initialContents, 'utf8');
-  }
-  const events = [];
-  const log = collectingLog(events, dir);
-  // spec/commander-recovery-rules.md rules 01/05 and projection fence:
-  // construction failure is an observable refusal, not an empty store.
-  let store;
-  const startup = outcome(() => {
-    store = createRunnerThreadSessionRegistryStore(path, log);
-    return 'ready';
-  });
-  const results = startup.threw ? [] : (testCase.actions ?? []).map((action) => {
-    switch (action.fn) {
-      case 'upsert':
-        return outcome(() => store.upsert(action.record));
-      case 'remove':
-        return outcome(() => store.remove(action.threadId));
-      case 'rebind':
-        return outcome(() =>
-          store.rebindCodexThread(
-            action.threadId,
-            action.newHarnessSessionId,
-            action.nowMs ?? undefined
-          )
-        );
-      case 'list':
-        return outcome(() => store.list());
-      case 'reload': {
-        // Simulated restart: a fresh store re-reads (and re-sanitizes) the file.
-        store = createRunnerThreadSessionRegistryStore(path, log);
-        return { defined: false };
-      }
-      default:
-        return { threw: true, message: 'unknown registry fn ' + String(action.fn) };
-    }
-  });
-  return substitute(
-    { startup, results, events, files: snapshotFiles(dir) },
-    dir,
-    dirPlaceholder
-  );
-}
-
-// --- Rehydration orchestrator ---------------------------------------------------------
-
-async function handleRehydrate(testCase) {
-  const events = [];
-  const log = collectingLog(events, '\\u0000never');
-  const retired = [];
-  const attachCalls = [];
-  const attachScript = testCase.attach ?? {};
-  const unfinishedScript = testCase.unfinished ?? {};
-  const summary = await rehydrateThreadSessions({
-    records: testCase.records,
-    nowMs: testCase.nowMs,
-    maxAgeMs: testCase.maxAgeMs ?? defaultThreadSessionRehydrationMaxAgeMs,
-    pendingDurableRowCount: (record) =>
-      (testCase.pendingRows ?? {})[record.kandanThreadId] ?? 0,
-    ...(testCase.useUnfinished === true
-      ? {
-          hasUnfinishedWork: (record) => {
-            const value = unfinishedScript[record.kandanThreadId];
-            if (value === 'throw') {
-              throw new Error('scripted unfinished probe failure');
-            }
-            return value === true;
-          },
-        }
-      : {}),
-    attach: async (record) => {
-      attachCalls.push(record.kandanThreadId);
-      const value = attachScript[record.kandanThreadId] ?? 'failed';
-      if (value === 'throw') {
-        throw new Error('scripted attach failure');
-      }
-      return value;
-    },
-    retire: (record) => {
-      retired.push(record.kandanThreadId);
-      return { outcome: 'removed' };
-    },
-    log,
-  });
-  return { summary, retired, attachCalls, events };
-}
-
-// --- Re-announce selection --------------------------------------------------------------
-
-function handleReannounce(testCase) {
-  const input = testCase.records.map((record) => ({ ...record }));
-  const entries = reannounceableThreadSessions(
-    input,
-    testCase.nowMs,
-    testCase.maxAgeMs ?? defaultThreadSessionRehydrationMaxAgeMs,
-    testCase.cap ?? reannounceThreadSessionCap
-  );
-  return {
-    entries,
-    // The input must never be mutated (the filter-copies contract).
-    inputUnchanged:
-      JSON.stringify(input) === JSON.stringify(testCase.records),
-    defaults: {
-      maxAgeMs: defaultThreadSessionRehydrationMaxAgeMs,
-      cap: reannounceThreadSessionCap,
-    },
-  };
-}
-
-// --- Reconciler lock -----------------------------------------------------------------
-
-function handleLockMessages(testCase) {
-  const running = new ReconcilerLockTimeoutError(
-    testCase.threadId,
-    testCase.timeoutMs
-  );
-  const queued = new ReconcilerLockQueuedTimeoutError({
-    threadId: testCase.threadId,
-    timeoutMs: testCase.timeoutMs,
-    queuedForMs: testCase.queuedForMs,
-    blockedSectionAgeMs: testCase.blockedSectionAgeMs ?? undefined,
-  });
-  return {
-    running: { name: running.name, message: running.message },
-    queued: {
-      name: queued.name,
-      message: queued.message,
-      // The subclass relationship existing catches rely on.
-      isTimeoutSubclass: queued instanceof ReconcilerLockTimeoutError,
-    },
-  };
-}
-
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-async function handleLockScenario(testCase) {
-  const lock = createThreadReconcilerLock();
-  const started = [];
-  const settledOrder = [];
-  const callers = (testCase.sections ?? []).map((section) => {
-    const caller = lock
-      .runExclusive(
-        section.threadId,
-        async () => {
-          started.push(section.id);
-          if (section.sleepMs !== undefined) {
-            await sleep(section.sleepMs);
-          }
-          if (section.fail === true) {
-            throw new Error('scripted section failure ' + section.id);
-          }
-          return section.id;
-        },
-        section.deadlineMs ?? undefined
-      )
-      .then(
-        (value) => ({ id: section.id, outcome: 'completed', value }),
-        (error) => ({
-          id: section.id,
-          outcome:
-            error instanceof ReconcilerLockQueuedTimeoutError
-              ? 'queued_timeout'
-              : error instanceof ReconcilerLockTimeoutError
-                ? 'section_timeout'
-                : 'failed',
-          message:
-            error instanceof ReconcilerLockQueuedTimeoutError ||
-            error instanceof ReconcilerLockTimeoutError
-              ? undefined
-              : error.message,
-        })
-      )
-      .then((result) => {
-        settledOrder.push(result.id);
-        return result;
-      });
-    return caller;
-  });
-  const results = await Promise.all(callers);
-  // Let any background sections settle so zombie runs (there must be none)
-  // are observable.
-  await sleep(testCase.settleMs ?? 150);
-  return {
-    results,
-    started,
-    settledOrder,
-    busyAfter: (testCase.sections ?? []).some((section) =>
-      lock.isBusy(section.threadId)
-    ),
-    activeThreadCountAfter: lock.activeThreadCount(),
-  };
-}
-
-// --- Generation pins -------------------------------------------------------------------
-
-function handlePins(testCase) {
-  if (testCase.fn === 'disposition') {
-    const pinned = new Set(testCase.pinned ?? []);
-    return outcome(() =>
-      generationControlDisposition({
-        role: testCase.role,
-        threadId: testCase.threadId ?? undefined,
-        isPinned: (threadId) => pinned.has(threadId),
-      })
-    );
-  }
-  const registry = createGenerationPinRegistry();
-  const results = (testCase.actions ?? []).map((action) => {
-    switch (action.fn) {
-      case 'pin':
-        return outcome(() => registry.pin(action.threadId));
-      case 'release':
-        return outcome(() => registry.release(action.threadId));
-      case 'isPinned':
-        return outcome(() => registry.isPinned(action.threadId));
-      case 'replaceAll':
-        return outcome(() => registry.replaceAll(action.threadIds));
-      case 'clear':
-        return outcome(() => registry.clear());
-      case 'snapshot':
-        return outcome(() => registry.snapshot());
-      case 'size':
-        return outcome(() => registry.size());
-      default:
-        return { threw: true, message: 'unknown pins fn ' + String(action.fn) };
-    }
-  });
-  return { results };
-}
-
-// --- Thread-worker liveness ---------------------------------------------------------------
-
-// A genuinely-dead pid: spawnSync returns only after the child exits, so
-// the pid no longer maps to a live process (the TS unit tests' technique).
-let cachedDeadPid;
-function deadPid() {
-  if (cachedDeadPid === undefined) {
-    const result = spawnSync(process.execPath, ['-e', '0']);
-    cachedDeadPid = result.pid;
-  }
-  return cachedDeadPid;
-}
-
-function resolvePid(spec) {
-  if (spec === 'live') return process.pid;
-  if (spec === 'dead') return deadPid();
-  return undefined;
-}
-
-function fakeCodexClient(isClosed) {
-  return {
-    request: async () => ({ jsonrpc: '2.0', id: 1, result: {} }),
-    notify: () => undefined,
-    onNotification: () => undefined,
-    onRequest: () => undefined,
-    onClose: () => undefined,
-    isClosed: () => isClosed === true,
-    close: () => undefined,
-  };
-}
-
-function handleWorkerLiveness(testCase) {
-  if (testCase.fn === 'processIsAlive') {
-    return outcome(() => processIsAlive(resolvePid(testCase.pid)));
-  }
-  const entry =
-    testCase.entry.kind === 'starting'
-      ? { kind: 'starting', promise: new Promise(() => undefined) }
-      : {
-          kind: 'running',
-          handle: {
-            kandanThreadId: testCase.entry.threadId ?? 'thread-1',
-            codex: fakeCodexClient(testCase.entry.ipcClosed),
-            close: async () => undefined,
-            ...(testCase.entry.sessionClosed === undefined
-              ? {}
-              : { sessionClosed: () => testCase.entry.sessionClosed === true }),
-            ...(testCase.entry.pid === undefined
-              ? {}
-              : { processPid: resolvePid(testCase.entry.pid) }),
-          },
-        };
-  return outcome(() => threadRunnerEntryLiveness(entry));
-}
-
-// --- Dispatch --------------------------------------------------------------------------
-
-async function handle(testCase) {
-  switch (testCase.op) {
-    case 'ownership':
-      return handleOwnership(testCase);
-    case 'lease':
-      return handleLease(testCase);
-    case 'registryPaths':
-      return handleRegistryPaths(testCase);
-    case 'registryScenario':
-      return handleRegistryScenario(testCase);
-    case 'rehydrate':
-      return await handleRehydrate(testCase);
-    case 'reannounce':
-      return handleReannounce(testCase);
-    case 'lockMessages':
-      return handleLockMessages(testCase);
-    case 'lockScenario':
-      return await handleLockScenario(testCase);
-    case 'pins':
-      return handlePins(testCase);
-    case 'workerLiveness':
-      return handleWorkerLiveness(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));
-}
-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
-// (the hello-project scaffold's inlined logo), so the asset must sit next
-// to the emitted oracle - the build-auth-parity-oracle precedent.
-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: 'session-registry-parity-driver.ts',
-    loader: 'ts',
-  },
-  bundle: true,
-  // Spec: plans/2026-09-09-ts-native-account-continuation.md. Match the
-  // production/auth-oracle ESM bridge for reachable CJS runtime dependencies;
-  // the distinct banner binding cannot collide with bundled createRequire.
-  banner: {
-    js: "import { createRequire as __sessionRegistryOracleCreateRequire } from 'node:module';\nconst require = __sessionRegistryOracleCreateRequire(import.meta.url);",
-  },
-  platform: 'node',
-  target: 'node20',
-  format: 'esm',
-  outfile: join(
-    packageRoot,
-    '.differential/session-registry-parity-oracle.mjs'
-  ),
-  minify: false,
-  sourcemap: false,
-  legalComments: 'none',
-  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
-});