@linzumi/cli 1.0.112 → 1.0.114

package/scripts/build-tui-parity-oracle.mjs

@@ -0,0 +1,577 @@
+// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
+// (M3 cluster 11, the TUI).
+// Relationship: Builds the TS-side PARITY ORACLE for the commander
+// console/TUI port - the deterministic core of the console-reporter module
+// (dashboard state fold, selection machinery, key/chunk parsers, every
+// render surface incl. the TUI table/header-layout models) plus the
+// blessed hardening transforms (terminfo conditional repair, the ACS
+// charset fix, the #2955 screen-registry sweep) and the reporter's
+// teardown/degrade/fail-soft latches. ONE bundle imports the REAL TS
+// module exports behind the one-shot batch driver: a JSON array of cases
+// on stdin, a JSON array of results on stdout. The ReScript package's
+// ConsoleTuiParityConformance drives the SAME inputs through
+// src/tui/CommanderConsole* / CommanderTuiGuards and asserts byte-equal
+// rendered strings, deep-equal state projections, and identical event
+// traces.
+//
+// Determinism: every op is pure given its inputs - clocks arrive as
+// explicit nowMs values, and the reporter-latch ops reset the module
+// latches per case via the exported *ForTest hooks. The teardown/degrade
+// ops route observability through explicit sinks (so the TS default audit
+// sink never fires), and scripted dashboards/streams throw
+// deterministically shaped errors.
+//
+// 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 { 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 {
+  arrowKeysInRawChunk,
+  createRunnerConsoleDashboard,
+  dashboardJobKeyAtTableRow,
+  dashboardNoticeLines,
+  droppedArrowKeysInRawChunk,
+  formatRunnerConsoleEvent,
+  keypressIsEscape,
+  rawInputChunkContainsMouseReport,
+  rawInputChunkSignalsEscape,
+  renderRunnerConsoleDashboard,
+  resolveSelectionAfterRefresh,
+  runnerConsoleDashboardTableModel,
+  runnerConsoleTuiEscapePressed,
+  runnerConsoleTuiHeaderLayout,
+  selectDashboardJobAtVisibleIndex,
+  selectDashboardJobByKey,
+  tableSelectionPageStep,
+  tableSelectionRowIndex,
+  updateRunnerConsoleDashboard,
+  updateRunnerConsoleDashboardMode,
+  createRunnerConsoleDashboardTuiFailSoft,
+  resetRunnerConsoleDashboardTuiConstructionForTest,
+  teardownRunnerConsoleDashboardTuiSafely,
+  degradeRunnerConsoleTuiToHeadless,
+  resetRunnerConsoleTuiDegradeForTest,
+  runnerConsoleTuiDegradedToHeadless,
+  setRunnerConsoleDashboardTuiForTest,
+  runnerConsoleDashboardTuiActiveForTest,
+} from './src/runnerConsoleReporter';
+import { balanceTerminfoConditionals } from './src/blessedTputSetulcShim';
+import {
+  applyBlessedAcsCharsetFix,
+  blessedWouldUseAcsCharset,
+  forceUnicodeBoxDrawingOnTput,
+} from './src/blessedAcsCharsetShim';
+import {
+  constructBlessedScreenGuarded,
+  detachBlessedScreenFromRegistry,
+  sweepStrandedBlessedScreens,
+} from './src/blessedScreenLifecycleGuard';
+import { linzumiCliVersion } from './src/version';
+
+// --- Projections ------------------------------------------------------------------------
+
+const orNull = (value) => (value === undefined ? null : value);
+
+function projectJob(job) {
+  return {
+    key: job.key,
+    createdAtMs: job.createdAtMs,
+    createdOrdinal: job.createdOrdinal,
+    agentProvider: orNull(job.agentProvider),
+    linzumiThreadId: orNull(job.linzumiThreadId),
+    linzumiThreadTitle: orNull(job.linzumiThreadTitle),
+    // The shared agent-session slot: the TS field carries the deprecated
+    // name; the projection uses the canonical key (D44) so both impls
+    // compare on neutral vocabulary.
+    harnessSessionId: orNull(job.codexThreadId),
+    tokenUsage: orNull(job.tokenUsage),
+    lastIncomingPreview: orNull(job.lastIncomingPreview),
+    lastIncomingAtMs: orNull(job.lastIncomingAtMs),
+    lastAssistantPreview: orNull(job.lastAssistantPreview),
+    lastAssistantAtMs: orNull(job.lastAssistantAtMs),
+    latestHarnessEventId: orNull(job.latestCodexEventId),
+    eventType: orNull(job.eventType),
+    creditExhaustion: orNull(job.creditExhaustion),
+    queueDepth: orNull(job.queueDepth),
+    turnId: orNull(job.turnId),
+    updatedAtMs: job.updatedAtMs,
+  };
+}
+
+function projectState(state) {
+  return {
+    jobs: [...state.jobs.entries()].map(([key, job]) => [key, projectJob(job)]),
+    discovery: [...state.discovery.entries()].map(([key, status]) => [
+      key,
+      {
+        key: status.key,
+        phase: status.phase,
+        status: status.status,
+        placesSearched: status.placesSearched,
+        message: orNull(status.message),
+        currentPlace: orNull(status.currentPlace),
+        currentSource: orNull(status.currentSource),
+        lastError: orNull(status.lastError),
+        metadata: orNull(status.metadata),
+        updatedAtMs: status.updatedAtMs,
+      },
+    ]),
+    notices: [...state.notices.entries()].map(([key, notice]) => [
+      key,
+      {
+        key: notice.key,
+        severity: notice.severity,
+        message: notice.message,
+        count: notice.count,
+        updatedAtMs: notice.updatedAtMs,
+      },
+    ]),
+    rawLines: state.rawLines.map((line) => ({
+      jobKey: orNull(line.jobKey),
+      line: line.line,
+    })),
+    nextJobOrdinal: state.nextJobOrdinal,
+    mode:
+      state.mode.type === 'raw_job'
+        ? { type: 'raw_job', jobKey: state.mode.jobKey }
+        : { type: state.mode.type },
+    selectedJobKey: orNull(state.selectedJobKey),
+    selectedJobIndexHint: orNull(state.selectedJobIndexHint),
+    tokenUsage: orNull(state.tokenUsage),
+    rateLimit: orNull(state.rateLimit),
+    creditExhaustion: orNull(state.creditExhaustion),
+    lastUpdateAtMs: orNull(state.lastUpdateAtMs),
+    browserUrl: orNull(state.browserUrl),
+    workspace: orNull(state.workspace),
+    runnerId: orNull(state.runnerId),
+    connectionStale: state.connectionStale,
+    rosterTruncated: state.rosterTruncated,
+  };
+}
+
+function projectTableModel(model) {
+  return {
+    rows: model.rows,
+    rowJobKeys: model.rowJobKeys.map((key) => orNull(key)),
+    selectedJobKey: orNull(model.selectedJobKey),
+    jobKeys: model.jobs.map((job) => job.key),
+    selectionRowIndex: tableSelectionRowIndex(model),
+  };
+}
+
+// --- scenario: the state fold + render surfaces ------------------------------------------
+
+function handleScenario(testCase) {
+  const state = createRunnerConsoleDashboard();
+  const outputs = [];
+  for (const step of testCase.steps) {
+    switch (step.op) {
+      case 'event':
+        updateRunnerConsoleDashboard(state, step.event, step.payload, step.nowMs);
+        outputs.push(null);
+        break;
+      case 'mode_key':
+        updateRunnerConsoleDashboardMode(state, step.key);
+        outputs.push(null);
+        break;
+      case 'select_index':
+        selectDashboardJobAtVisibleIndex(state, step.index);
+        outputs.push(null);
+        break;
+      case 'select_key':
+        selectDashboardJobByKey(state, step.key ?? undefined);
+        outputs.push(null);
+        break;
+      case 'escape_pressed':
+        outputs.push(runnerConsoleTuiEscapePressed(state));
+        break;
+      case 'escape_chunk': {
+        const signals = rawInputChunkSignalsEscape(step.chunk);
+        const changed = signals ? runnerConsoleTuiEscapePressed(state) : false;
+        outputs.push({ signals, changed });
+        break;
+      }
+      case 'render':
+        outputs.push(orNull(renderRunnerConsoleDashboard(state, step.nowMs)));
+        break;
+      case 'table_model':
+        outputs.push(projectTableModel(runnerConsoleDashboardTableModel(state, step.nowMs)));
+        break;
+      case 'header_layout':
+        outputs.push(
+          runnerConsoleTuiHeaderLayout(
+            state,
+            step.jobCount,
+            step.nowMs,
+            step.terminalRows
+          )
+        );
+        break;
+      case 'notice_lines':
+        outputs.push(dashboardNoticeLines(state, step.mode));
+        break;
+      case 'state':
+        outputs.push(projectState(state));
+        break;
+      default:
+        outputs.push({ threw: true, message: 'unknown scenario step ' + String(step.op) });
+        break;
+    }
+  }
+  return outputs;
+}
+
+// --- Reporter-latch ops -------------------------------------------------------------------
+
+function makeSinkCollector() {
+  const events = [];
+  return {
+    events,
+    sinks: {
+      audit: (event, fields) => events.push({ sink: 'audit', event, fields }),
+      log: (event, fields) => events.push({ sink: 'log', event, fields }),
+    },
+  };
+}
+
+function scriptedError(spec) {
+  const error = new Error(spec.message);
+  if (spec.code !== undefined) {
+    error.code = spec.code;
+  }
+  return error;
+}
+
+function handleTeardownScenario(testCase) {
+  resetRunnerConsoleTuiDegradeForTest();
+  setRunnerConsoleDashboardTuiForTest(undefined);
+  const collector = makeSinkCollector();
+  const outputs = [];
+  let stopCalls = 0;
+  let destroyCalls = 0;
+  for (const step of testCase.steps) {
+    switch (step.op) {
+      case 'install': {
+        destroyCalls = 0;
+        stopCalls = 0;
+        const dashboard = {
+          render: () => {},
+          destroy: () => {
+            destroyCalls += 1;
+            if (step.destroyError !== undefined) {
+              throw scriptedError(step.destroyError);
+            }
+          },
+        };
+        setRunnerConsoleDashboardTuiForTest(
+          dashboard,
+          { stdin: step.stdinTty ?? true, stdout: step.stdoutTty ?? true },
+          () => {
+            stopCalls += 1;
+          }
+        );
+        outputs.push(null);
+        break;
+      }
+      case 'teardown': {
+        const outcome = teardownRunnerConsoleDashboardTuiSafely(
+          { trigger: step.trigger },
+          collector.sinks
+        );
+        outputs.push({
+          hadTui: outcome.hadTui,
+          ok: outcome.ok,
+          swallowedErrorCode: orNull(outcome.swallowedErrorCode),
+          active: runnerConsoleDashboardTuiActiveForTest(),
+          stopCalls,
+          destroyCalls,
+        });
+        break;
+      }
+      case 'degrade': {
+        degradeRunnerConsoleTuiToHeadless(
+          { code: step.code ?? undefined, stage: step.stage },
+          collector.sinks
+        );
+        outputs.push({
+          degraded: runnerConsoleTuiDegradedToHeadless(),
+          active: runnerConsoleDashboardTuiActiveForTest(),
+          stopCalls,
+          destroyCalls,
+        });
+        break;
+      }
+      case 'reset_degrade':
+        resetRunnerConsoleTuiDegradeForTest();
+        outputs.push(null);
+        break;
+      default:
+        outputs.push({ threw: true, message: 'unknown teardown step ' + String(step.op) });
+        break;
+    }
+  }
+  return { outputs, events: collector.events };
+}
+
+function handleFailSoftScenario(testCase) {
+  resetRunnerConsoleDashboardTuiConstructionForTest();
+  const collector = makeSinkCollector();
+  const outputs = [];
+  let createCalls = 0;
+  for (const step of testCase.steps) {
+    switch (step.op) {
+      case 'create': {
+        const result = createRunnerConsoleDashboardTuiFailSoft(() => {
+          createCalls += 1;
+          if (step.createError !== undefined) {
+            throw scriptedError(step.createError);
+          }
+          return { render: () => {}, destroy: () => {} };
+        }, collector.sinks);
+        outputs.push({ defined: result !== undefined, createCalls });
+        break;
+      }
+      case 'reset_construction':
+        resetRunnerConsoleDashboardTuiConstructionForTest();
+        outputs.push(null);
+        break;
+      default:
+        outputs.push({ threw: true, message: 'unknown failsoft step ' + String(step.op) });
+        break;
+    }
+  }
+  return {
+    outputs,
+    // The guarded construction wraps the REAL blessed registry; only the
+    // event vocabulary is compared (stack contents are impl-specific), so
+    // project events to sink+event+swept_screens.
+    events: collector.events.map((entry) => ({
+      sink: entry.sink,
+      event: entry.event,
+      swept_screens: orNull(entry.fields.swept_screens),
+    })),
+  };
+}
+
+// --- Blessed-guard ops -----------------------------------------------------------------------
+
+function makeFakeScreen(spec, sweepTrace) {
+  const screen = {};
+  if (spec.hasProgram) {
+    screen.program = {};
+  }
+  screen.destroy = () => {
+    sweepTrace.push('destroy:' + spec.name);
+    if (spec.destroyError !== undefined) {
+      throw scriptedError(spec.destroyError);
+    }
+    // A real complete screen's destroy() detaches itself from the
+    // registry; the scripted double mirrors that so the sweep's
+    // idempotent re-detach is exercised the same way on both impls.
+    if (spec.selfDetach !== false) {
+      const index = spec.registry.instances.indexOf(screen);
+      if (index !== -1) {
+        spec.registry.instances.splice(index, 1);
+        spec.registry.total -= 1;
+        spec.registry.global = spec.registry.instances[0];
+        if (spec.registry.total === 0) {
+          spec.registry.global = null;
+        }
+      }
+    }
+  };
+  return screen;
+}
+
+function projectRegistry(registry, names) {
+  return {
+    instanceNames: registry.instances.map((instance) => names.get(instance) ?? '?'),
+    total: registry.total,
+    global:
+      registry.global === null
+        ? null
+        : registry.global === undefined
+          ? '<undefined>'
+          : (names.get(registry.global) ?? '?'),
+  };
+}
+
+function handleRegistryGuard(testCase) {
+  const collector = makeSinkCollector();
+  const sweepTrace = [];
+  const registry = { instances: [], total: 0, global: null };
+  const names = new Map();
+  const preexisting = [];
+  for (const spec of testCase.preexisting ?? []) {
+    const screen = makeFakeScreen({ ...spec, registry }, sweepTrace);
+    names.set(screen, spec.name);
+    registry.instances.push(screen);
+    registry.total += 1;
+    preexisting.push(screen);
+  }
+  registry.global = registry.instances[0] ?? null;
+  let result;
+  try {
+    result = {
+      returned: constructBlessedScreenGuarded(
+        registry,
+        () => {
+          for (const spec of testCase.constructed ?? []) {
+            const screen = makeFakeScreen({ ...spec, registry }, sweepTrace);
+            names.set(screen, spec.name);
+            registry.instances.push(screen);
+            registry.total += 1;
+          }
+          if (testCase.constructError !== undefined) {
+            throw scriptedError(testCase.constructError);
+          }
+          return 'constructed';
+        },
+        { sinks: collector.sinks, context: { surface: 'parity_case' } }
+      ),
+    };
+  } catch (error) {
+    result = { threw: true, message: error instanceof Error ? error.message : String(error) };
+  }
+  return {
+    result,
+    registry: projectRegistry(registry, names),
+    sweepTrace,
+    events: collector.events,
+  };
+}
+
+function handleRegistryDetach(testCase) {
+  const registry = { instances: [], total: testCase.total ?? 0, global: null };
+  const names = new Map();
+  const screens = [];
+  for (const name of testCase.instances) {
+    const screen = { name };
+    names.set(screen, name);
+    registry.instances.push(screen);
+    screens.push(screen);
+  }
+  registry.global = registry.instances[0] ?? null;
+  const target = screens[testCase.detachIndex];
+  const detached = detachBlessedScreenFromRegistry(
+    registry,
+    target ?? { name: 'unregistered' }
+  );
+  return { detached, registry: projectRegistry(registry, names) };
+}
+
+// --- Dispatch ----------------------------------------------------------------------------------
+
+function handle(testCase) {
+  switch (testCase.op) {
+    case 'version':
+      return linzumiCliVersion;
+    case 'format_line':
+      return orNull(formatRunnerConsoleEvent(testCase.event, testCase.payload));
+    case 'keys':
+      return {
+        escape: rawInputChunkSignalsEscape(testCase.chunk),
+        mouse: rawInputChunkContainsMouseReport(testCase.chunk),
+        arrows: arrowKeysInRawChunk(testCase.chunk),
+        dropped: droppedArrowKeysInRawChunk(testCase.chunk),
+      };
+    case 'keypress_escape':
+      return keypressIsEscape(testCase.key);
+    case 'selection_resolve': {
+      const resolved = resolveSelectionAfterRefresh(
+        testCase.previousKey ?? undefined,
+        testCase.previousIndexHint ?? undefined,
+        testCase.jobKeys
+      );
+      return { key: orNull(resolved.key), index: orNull(resolved.index) };
+    }
+    case 'page_step':
+      return tableSelectionPageStep(testCase.tableHeight);
+    case 'job_key_at_row': {
+      const state = createRunnerConsoleDashboard();
+      for (const step of testCase.events) {
+        updateRunnerConsoleDashboard(state, step.event, step.payload, step.nowMs);
+      }
+      const model = runnerConsoleDashboardTableModel(state, testCase.nowMs);
+      return testCase.rows.map((row) => orNull(dashboardJobKeyAtTableRow(model, row)));
+    }
+    case 'terminfo_balance':
+      return balanceTerminfoConditionals(testCase.cap);
+    case 'acs_would_use':
+      return blessedWouldUseAcsCharset(
+        testCase.tput ?? undefined,
+        testCase.ch,
+        testCase.alreadyInAcsRun ?? false
+      );
+    case 'acs_force': {
+      const tput = testCase.tput ?? undefined;
+      const mutated = forceUnicodeBoxDrawingOnTput(tput);
+      return { mutated, tput: orNull(tput) };
+    }
+    case 'acs_fix': {
+      const screen = testCase.screen ?? undefined;
+      if (screen !== undefined && testCase.shareProgramTput === true) {
+        screen.program = { tput: screen.tput };
+      }
+      applyBlessedAcsCharsetFix(screen);
+      return orNull(screen);
+    }
+    case 'scenario':
+      return handleScenario(testCase);
+    case 'teardown_scenario':
+      return handleTeardownScenario(testCase);
+    case 'failsoft_scenario':
+      return handleFailSoftScenario(testCase);
+    case 'registry_guard':
+      return handleRegistryGuard(testCase);
+    case 'registry_detach':
+      return handleRegistryDetach(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(handle(testCase));
+}
+process.stdout.write(JSON.stringify(results));
+`;
+
+await mkdir(join(packageRoot, '.differential'), { recursive: true });
+
+await build({
+  stdin: {
+    contents: driverSource,
+    resolveDir: packageRoot,
+    sourcefile: 'tui-parity-driver.ts',
+    loader: 'ts',
+  },
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outfile: join(packageRoot, '.differential/tui-parity-oracle.mjs'),
+  minify: false,
+  sourcemap: false,
+  legalComments: 'none',
+  // The console-reporter module imports blessed (and the crash-handler /
+  // logger slice pulls the runtime graph); the runtime externals stay
+  // aligned with the other cluster oracles.
+  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
+});

package/scripts/build.mjs

@@ -1,6 +1,6 @@
 // Spec: plans/2026-05-17-linzumi-cli-node-toolchain-note.md
 // Relationship: Builds the published CLI package with Node-hosted tooling.
-import { copyFile, mkdir, rm } from 'node:fs/promises';
+import { copyFile, mkdir, rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { build } from 'esbuild';
@@ -84,6 +84,45 @@ await build({
   banner,
 });
 
+// F5 cross-harness failover bridge (Workstream F task F5): the runner
+// dynamic-imports ./crossHarnessFailover.mjs relative to its own bundle, so
+// dist ships a self-contained sibling bundle with the compiled ReScript
+// transpiler artifacts (packages/linzumi-cli-rescript, built by `rescript`)
+// resolved at build time. When the artifacts are not built in this checkout
+// the publish must not silently ship a broken rung: emit an HONEST stub
+// whose import succeeds but whose executor refuses loudly - the ladder then
+// terminates red-with-receipts exactly as F2 (the flag's rollback posture) -
+// and warn in the build log.
+try {
+  await build({
+    entryPoints: [join(packageRoot, 'src/crossHarnessFailover.mjs')],
+    bundle: true,
+    platform: 'node',
+    target: 'node20',
+    format: 'esm',
+    outfile: join(packageRoot, 'dist/crossHarnessFailover.mjs'),
+    minify: true,
+    sourcemap: false,
+    legalComments: 'none',
+    banner,
+  });
+} catch (error) {
+  console.warn(
+    '[build] cross-harness failover bridge could not be bundled (are the ' +
+      'linzumi-cli-rescript artifacts built?); shipping the honest refusal ' +
+      `stub instead: ${error instanceof Error ? error.message : String(error)}`
+  );
+  await writeFile(
+    join(packageRoot, 'dist/crossHarnessFailover.mjs'),
+    'export async function transpileAndSeedClaudeSession() {\n' +
+      '  return {\n' +
+      '    ok: false,\n' +
+      "    failure: 'the cross-harness failover transpiler bridge was not bundled into this build',\n" +
+      '  };\n' +
+      '}\n'
+  );
+}
+
 await mkdir(join(packageRoot, 'dist/assets'), { recursive: true });
 await copyFile(
   join(packageRoot, 'src/assets/linzumi-logo.svg'),