@linzumi/cli 1.0.272 → 1.0.273

package/scripts/build-core-dispatch-input-queue-parity-oracle.mjs

@@ -1,225 +0,0 @@
-// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
-// (M3 cluster 10, commander core / dispatch input queue).
-// Relationship: Builds the TS-side PARITY ORACLE for the per-session
-// dispatch input queue of the ReScript commander port, the sibling of
-// build-pipeline-parity-oracle.mjs (cluster 9, which owns the two recovery
-// watchdog primitives this queue's predicates feed). The oracle bundles the
-// REAL runner.ts exports - createClaudeCodeInputQueue (the streaming-input
-// FIFO with the single-live-turn park/release discipline, the #2589 honest
-// enqueue disposition, the #2590 steer-application tracking, and the
-// BLOCKER A dispatch-confirm watermark seam), claudeCodeTurnStallThresholdMs
-// (the LINZUMI_CLAUDE_TURN_STALL_MS env resolution), and
-// claudeCodeDispatchTerminalFailureReason (the kill-respawn-retry ladder's
-// byte-frozen terminal copy) - behind the cluster 1/2 one-shot BATCH driver
-// (a JSON array of cases on stdin, a JSON array of results on stdout).
-//
-// Byte parity: every trace event (dispatches with their payload bytes,
-// predicate refusals, park positions, watermark commits, steer outcomes and
-// applied resolutions, closed-input errors) is normalized by THIS driver
-// with pinned key order, and delivered message payloads ride the TS message
-// objects VERBATIM (their own key insertion order), so the ReScript side
-// must reproduce field presence AND insertion order exactly.
-//
-// Determinism: the queue owns no timers and no clock - its only
-// nondeterminism is promise scheduling, which the driver serializes by
-// draining the microtask queue after every op (pull resolutions and steer
-// `applied` resolutions land in trace order deterministically). Scripted
-// deps: the isLiveSteerAllowed predicate is a mutable flag flipped via ops;
-// the delivery/wait/watermark callbacks append trace events.
-//
-// Import-time side effects: runner.ts transitively reads
-// src/assets/linzumi-logo.svg relative to the bundle at import time
-// (helloLinzumiProject.ts), so the asset is copied next to the bundle -
-// the build-harness-codex-parity-oracle.mjs convention. Externals match
-// the existing oracles (ws/undici/blessed/claude-agent-sdk stay external;
-// none of them is touched at import time on this driver's paths).
-//
-// 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 {
-  claudeCodeDispatchTerminalFailureReason,
-  claudeCodeTurnStallThresholdMs,
-  createClaudeCodeInputQueue,
-} from './src/runner';
-
-// Deterministic promise settlement: every queue-internal resolution is
-// synchronous, so a bounded microtask drain after each op flushes every
-// pending .then into the trace in resolution order.
-async function drainMicrotasks() {
-  for (let tick = 0; tick < 8; tick += 1) {
-    await Promise.resolve();
-  }
-}
-
-async function runInputQueueCase(caseInput) {
-  const trace = [];
-  let liveSteerAllowed = true;
-  let steerCount = 0;
-  let pullCount = 0;
-  const queue = createClaudeCodeInputQueue({
-    content: caseInput.content,
-    sourceSeq: caseInput.sourceSeq ?? undefined,
-    onInputDelivered: () => trace.push({ t: 'inputDelivered' }),
-    isLiveSteerAllowed:
-      caseInput.liveSteerMode === 'scripted' ? () => liveSteerAllowed : undefined,
-    onInputWait: (currentSourceSeq) =>
-      trace.push({ t: 'inputWait', seq: currentSourceSeq ?? null }),
-    onSourceSeqDelivered: (sourceSeq) => trace.push({ t: 'watermark', seq: sourceSeq }),
-  });
-  const iterator = queue.messages[Symbol.asyncIterator]();
-  for (const op of caseInput.ops ?? []) {
-    if (op.op === 'enqueue') {
-      try {
-        const disposition = queue.enqueue({
-          content: op.content,
-          sourceSeq: op.sourceSeq ?? undefined,
-        });
-        trace.push({
-          t: 'enqueue',
-          result:
-            disposition.disposition === 'parked'
-              ? { disposition: 'parked', queuePosition: disposition.queuePosition }
-              : { disposition: 'delivered' },
-        });
-      } catch (error) {
-        trace.push({
-          t: 'enqueue',
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    } else if (op.op === 'enqueueSteer') {
-      steerCount += 1;
-      const steerId = steerCount;
-      try {
-        const outcome = queue.enqueueSteer(op.content);
-        trace.push({ t: 'steer', steerId, steered: outcome.steered });
-        void outcome.applied.then((applied) =>
-          trace.push({ t: 'steerApplied', steerId, applied })
-        );
-      } catch (error) {
-        trace.push({
-          t: 'steer',
-          steerId,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    } else if (op.op === 'next') {
-      pullCount += 1;
-      const pullId = pullCount;
-      trace.push({ t: 'pullStart', pullId });
-      void iterator.next().then((result) =>
-        trace.push(
-          result.done === true
-            ? { t: 'pulled', pullId, done: true }
-            : { t: 'pulled', pullId, done: false, message: result.value }
-        )
-      );
-    } else if (op.op === 'completeTurn') {
-      trace.push({ t: 'completeTurn', completed: queue.completeTurn() ?? null });
-    } else if (op.op === 'currentSourceSeq') {
-      trace.push({ t: 'currentSourceSeq', seq: queue.currentSourceSeq() ?? null });
-    } else if (op.op === 'close') {
-      queue.close();
-      trace.push({ t: 'closed' });
-    } else if (op.op === 'drainUndelivered') {
-      trace.push({
-        t: 'drained',
-        followUps: queue.drainUndeliveredFollowUps().map((followUp) => ({
-          message: followUp.message,
-          sourceSeq: followUp.sourceSeq ?? null,
-        })),
-      });
-    } else if (op.op === 'setLiveSteerAllowed') {
-      liveSteerAllowed = op.value === true;
-    }
-    await drainMicrotasks();
-  }
-  await drainMicrotasks();
-  return { trace };
-}
-
-async function runCase(input) {
-  switch (input.kind) {
-    case 'constants':
-      return {
-        claudeCodeDispatchTerminalFailureReason,
-      };
-    case 'turnStallThresholdMs':
-      return claudeCodeTurnStallThresholdMs(input.env ?? {});
-    case 'inputQueueRun':
-      return runInputQueueCase(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-dispatch-input-queue-parity-oracle.mjs');
-
-await mkdir(outDir, { recursive: true });
-// runner.ts transitively reads this asset relative to the bundle at import
-// time (helloLinzumiProject.ts readFileSync), so it must exist next to the
-// oracle bundle.
-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-dispatch-input-queue-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 __coreDispatchInputQueueOracleCreateRequire } from 'node:module';\nconst require = __coreDispatchInputQueueOracleCreateRequire(import.meta.url);",
-  },
-  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');

package/scripts/build-core-fate-ladder-parity-oracle.mjs

@@ -1,350 +0,0 @@
-// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
-// (M3 cluster 10, commander core).
-// Relationship: Builds the TS-side PARITY ORACLE for the fate-ladder policy
-// engine of the ReScript commander port, the sibling of
-// build-pipeline-parity-oracle.mjs (cluster 9). The oracle bundles the REAL
-// TS module (src/fateLadder.ts - the F2/D51/D53 policy engine: the policy
-// table, the budget env resolution, the run/history record, the one
-// decision entry point, the hold-dispatch commit, the visible-reason
-// strings, the F4 wire receipts, and the rate-limit reset capture) behind
-// the cluster 1/2 one-shot BATCH driver (a JSON array of cases on stdin, a
-// JSON array of results on stdout).
-//
-// Byte parity: fateLadderWireHistory receipts are returned PRE-STRINGIFIED
-// (the TS object's own key insertion order rides JSON.stringify), and every
-// decision/run is serialized through one canonical shape both sides
-// reproduce field-for-field. Determinism: clocks and budgets are injected
-// per case op, the breaker gate is scripted per decide op (its calls are
-// traced so the consult discipline is pinned too) - nothing here reads wall
-// time or process.env except through case inputs.
-//
-// SECRETS: the oracle only ever sees the conformance suite's synthetic
-// payloads. The output is a local test artifact (.differential/ is
-// gitignored, never published) and stays unminified for debuggability.
-import { mkdir, readFile, writeFile } 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 providerSlasPath = join(
-  packageRoot,
-  'src',
-  'fateLadderProviderSlas.json'
-);
-const generatedProviderSlasPath = join(
-  packageRoot,
-  '..',
-  'linzumi-cli-rescript',
-  'src',
-  'generated',
-  'CommanderFateLadderProviderSlas.res'
-);
-
-function positiveFiniteNumber(value, label) {
-  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
-    throw new Error(`invalid provider fate SLA ${label}: ${String(value)}`);
-  }
-  return value;
-}
-
-const providerSlas = JSON.parse(await readFile(providerSlasPath, 'utf8'));
-const defaultMaxLadderMs = positiveFiniteNumber(
-  providerSlas?.default?.maxLadderMs,
-  'default.maxLadderMs'
-);
-const waferMaxLadderMs = positiveFiniteNumber(
-  providerSlas?.wafer?.maxLadderMs,
-  'wafer.maxLadderMs'
-);
-const generatedProviderSlas = `// GENERATED from packages/linzumi-cli/src/fateLadderProviderSlas.json by
-// packages/linzumi-cli/scripts/build-core-fate-ladder-parity-oracle.mjs.
-// Do not edit this file by hand.
-// Spec: plans/2026-08-07-wafer-provider-aware-fate-budget.spec.md
-
-let defaultMaxLadderMs = ${defaultMaxLadderMs}.
-let waferMaxLadderMs = ${waferMaxLadderMs}.
-
-let maxLadderMsForModelProvider = (modelProvider: option<string>): float =>
-  switch modelProvider {
-  | Some("wafer") => waferMaxLadderMs
-  | Some(_) | None => defaultMaxLadderMs
-  }
-`;
-
-if (process.argv.includes('--write-provider-slas')) {
-  await writeFile(generatedProviderSlasPath, generatedProviderSlas, 'utf8');
-} else {
-  const trackedProviderSlas = await readFile(generatedProviderSlasPath, 'utf8');
-  if (trackedProviderSlas !== generatedProviderSlas) {
-    throw new Error(
-      'generated CommanderFateLadderProviderSlas.res is stale; run build-core-fate-ladder-parity-oracle.mjs --write-provider-slas'
-    );
-  }
-}
-
-if (process.argv.includes('--check-provider-slas-only')) {
-  process.stdout.write(generatedProviderSlasPath + '\n');
-  process.exit(0);
-}
-
-// PARITY SCOPE (owner ruling 2026-07-18, failover becomes a user-decision
-// capability): the compared surface is the SHARED F2 recovery engine only.
-// The TS-only frozen failover rung (flag-OFF forever, superseded) is
-// excluded: no failover constants, no failover flag case, no failover
-// decide input/grant, no commitFailover op, no per-entry failover
-// sub-object, and the rung vocabulary is filtered to the shared members -
-// the ReScript commander has no automatic failover surface to compare.
-const driverSource = `
-import {
-  appendFateLadderEntry,
-  commitFateLadderHoldDispatch,
-  commitRouteOutageHoldOutcome,
-  createFateLadderRun,
-  decideFateLadderStep,
-  defaultFateLadderBudgets,
-  fateLadderBudgets,
-  fateLadderPolicies,
-  fateLadderRungs,
-  fateLadderWireHistory,
-  freshSessionResumeReason,
-  inPlaceResumeMaxAttempts,
-  maxFateLadderHistoryEntries,
-  rateLimitHoldReason,
-  rateLimitHoldReasonPrefix,
-  rateLimitResetAtMsFromNotification,
-  redispatchAfterLocalFailureReason,
-  workerRebuildRetryReason,
-} from './src/fateLadder';
-
-// Canonical run/decision serialization shared (by construction) with the
-// ReScript conformance: fixed key order, option fields as null.
-function runJson(run) {
-  return {
-    fate: run.fate,
-    startedAtMs: run.startedAtMs,
-    rungCursor: run.rungCursor,
-    cursorAttempts: run.cursorAttempts,
-    recoveryRungsAttempted: run.recoveryRungsAttempted,
-    holdCommitted: run.holdCommitted,
-    holdDispatched: run.holdDispatched,
-    historyTruncated: run.historyTruncated,
-    entries: run.entries.map((entry) => ({
-      rung: entry.rung,
-      outcome: entry.outcome,
-      atMs: entry.atMs,
-      detail: entry.detail === undefined ? null : entry.detail,
-      resetAtMs: entry.resetAtMs === undefined ? null : entry.resetAtMs,
-    })),
-  };
-}
-
-function decisionJson(decision) {
-  switch (decision.kind) {
-    case 'stand':
-      return { kind: 'stand', cause: decision.cause };
-    case 'execute_rung':
-      return { kind: 'execute_rung', rung: decision.rung, run: runJson(decision.run) };
-    case 'hold_until_reset':
-      return {
-        kind: 'hold_until_reset',
-        resetAtMs: decision.resetAtMs,
-        run: runJson(decision.run),
-      };
-    case 'route_outage_hold':
-      return {
-        kind: 'route_outage_hold',
-        deadlineAtMs: decision.deadlineAtMs,
-        run: runJson(decision.run),
-      };
-    case 'breaker_hold':
-      return { kind: 'breaker_hold', reason: decision.reason, run: runJson(decision.run) };
-    case 'red':
-      return { kind: 'red', cause: decision.cause, run: runJson(decision.run) };
-    default:
-      return { kind: 'unknown' };
-  }
-}
-
-function budgetsOf(raw) {
-  return raw === undefined
-    ? defaultFateLadderBudgets
-    : {
-        maxRecoveryRungs: raw.maxRecoveryRungs,
-        maxLadderMs: raw.maxLadderMs,
-        maxRateLimitHoldMs: raw.maxRateLimitHoldMs,
-      };
-}
-
-// One scripted per-turn schedule: ops drive the pure engine exactly the way
-// the session layer would (decide -> store returned run -> dispatch), with
-// the breaker verdict scripted per decide op and every gate call traced.
-function runScheduleCase(caseInput) {
-  let current = undefined;
-  const steps = [];
-  for (const op of caseInput.ops ?? []) {
-    if (op.op === 'decide') {
-      const breakerCalls = [];
-      const scripted = op.breaker ?? { action: 'proceed' };
-      const gate = (fate, nowMs) => {
-        breakerCalls.push({ fate, nowMs });
-        if (scripted.action === 'hold') {
-          return { action: 'hold', reason: scripted.reason ?? 'scripted_hold' };
-        }
-        if (scripted.action === 'canary') {
-          return { action: 'canary' };
-        }
-        return { action: 'proceed' };
-      };
-      const decision = decideFateLadderStep({
-        fate: op.fate ?? undefined,
-        run: current,
-        nowMs: op.nowMs,
-        budgets: budgetsOf(op.budgets),
-        breaker: gate,
-        grants: {
-          inPlaceResume: op.grants?.inPlaceResume === true,
-          redispatch: op.grants?.redispatch === true,
-          workerRebuild: op.grants?.workerRebuild === true,
-        },
-        rateLimitResetAtMs: op.resetAtMs ?? undefined,
-        // route_outage (2026-07-24 duration form): the server-owned hold
-        // ceiling DURATION the schedule may script; absent = pre-hold
-        // server / valve off (the honest red).
-        routeOutageHoldCeilingMs: op.routeOutageCeilingMs ?? undefined,
-      });
-      if (decision.kind !== 'stand') {
-        current = decision.run;
-      }
-      steps.push({ decision: decisionJson(decision), breakerCalls });
-    } else if (op.op === 'commitHoldDispatch') {
-      if (current === undefined) {
-        steps.push({ skipped: true });
-      } else {
-        current = commitFateLadderHoldDispatch(current, op.nowMs);
-        steps.push({ run: runJson(current) });
-      }
-    } else if (op.op === 'commitRouteOutageHoldOutcome') {
-      // Route-outage hold outcome commit (2026-07-23): the session-layer
-      // twin op (dispatch on the route-recovered snapshot / ceiling
-      // exhaustion).
-      if (current === undefined) {
-        steps.push({ skipped: true });
-      } else {
-        current = commitRouteOutageHoldOutcome(current, {
-          outcome: op.outcome,
-          atMs: op.nowMs,
-          detail: op.detail ?? undefined,
-        });
-        steps.push({ run: runJson(current) });
-      }
-    } else if (op.op === 'append') {
-      if (current === undefined) {
-        steps.push({ skipped: true });
-      } else {
-        current = appendFateLadderEntry(current, {
-          rung: op.entry.rung,
-          outcome: op.entry.outcome,
-          atMs: op.entry.atMs,
-          detail: op.entry.detail ?? undefined,
-          resetAtMs: op.entry.resetAtMs ?? undefined,
-        });
-        steps.push({ run: runJson(current) });
-      }
-    } else if (op.op === 'seed') {
-      current = createFateLadderRun(op.fate, op.nowMs);
-      steps.push({ run: runJson(current) });
-    } else if (op.op === 'wire') {
-      steps.push({
-        wire: JSON.stringify(fateLadderWireHistory(current, op.fate, budgetsOf(op.budgets))),
-      });
-    } else if (op.op === 'reset') {
-      current = undefined;
-      steps.push({ reset: true });
-    } else {
-      steps.push({ error: 'unknown op ' + String(op.op) });
-    }
-  }
-  return { steps };
-}
-
-function runCase(input) {
-  switch (input.kind) {
-    case 'constants':
-      return {
-        // The shared recovery vocabulary only: the TS-only frozen
-        // cross_harness_failover member is excluded by name (2026-07-18
-        // ruling) - the ReScript engine's fateLadderRungs is the filtered
-        // array by construction.
-        fateLadderRungs: fateLadderRungs.filter(
-          (rung) => rung !== 'cross_harness_failover'
-        ),
-        inPlaceResumeMaxAttempts,
-        fateLadderPolicies,
-        defaultFateLadderBudgets,
-        maxFateLadderHistoryEntries,
-        redispatchAfterLocalFailureReason,
-        workerRebuildRetryReason,
-        freshSessionResumeReason,
-        rateLimitHoldReasonPrefix,
-      };
-    case 'budgets':
-      return fateLadderBudgets(input.env ?? {}, input.modelProvider);
-    case 'holdReason':
-      return rateLimitHoldReason(input.resetAtMs);
-    case 'resetFromNotification':
-      return rateLimitResetAtMsFromNotification(input.params) ?? null;
-    case 'scheduleRun':
-      return runScheduleCase(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(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-fate-ladder-parity-oracle.mjs');
-
-await mkdir(outDir, { recursive: true });
-
-await build({
-  stdin: {
-    contents: driverSource,
-    resolveDir: packageRoot,
-    sourcefile: 'core-fate-ladder-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');