@linzumi/cli 1.0.110 → 1.0.112

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

@@ -0,0 +1,219 @@
+// 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,
+  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

@@ -0,0 +1,250 @@
+// 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 } 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 {
+  appendFateLadderEntry,
+  commitFateLadderHoldDispatch,
+  createFateLadderRun,
+  decideFateLadderStep,
+  defaultFateLadderBudgets,
+  fateLadderBudgets,
+  fateLadderPolicies,
+  fateLadderRungs,
+  fateLadderWireHistory,
+  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 '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,
+      });
+      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 === '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 {
+        fateLadderRungs,
+        inPlaceResumeMaxAttempts,
+        fateLadderPolicies,
+        defaultFateLadderBudgets,
+        maxFateLadderHistoryEntries,
+        redispatchAfterLocalFailureReason,
+        workerRebuildRetryReason,
+        rateLimitHoldReasonPrefix,
+      };
+    case 'budgets':
+      return fateLadderBudgets(input.env ?? {});
+    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');