session-orchestrator 3.16.0

package/scripts/autopilot.mjs

@@ -0,0 +1,383 @@
+#!/usr/bin/env node
+/**
+ * autopilot.mjs — Phase C-5 headless CLI driver for the /autopilot loop.
+ *
+ * Issue #302 (Phase C-5). Wires real implementations of the four injectable
+ * seams defined by `runLoop` in `scripts/lib/autopilot.mjs` and lets the user
+ * run the autopilot loop unattended from the CLI.
+ *
+ * Usage:
+ *   node scripts/autopilot.mjs --headless [options]
+ *
+ * Flags:
+ *   --headless                  Required. Activates headless mode.
+ *   --max-sessions=N            Max iterations (1..50, default 5).
+ *   --max-hours=H               Max wall-clock hours (0.5..24.0, default 4.0).
+ *   --confidence-threshold=0.X  Mode confidence gate (0.0..1.0, default 0.85).
+ *   --dry-run                   Emit a single record without spawning sessions.
+ *   --verbose                   Pipe child process stdio (instead of inherit).
+ *
+ * Exit codes:
+ *   0 — clean termination (max-sessions-reached, max-hours-exceeded, or fallback-to-manual).
+ *   1 — uncaught error.
+ *   2 — kill_switch=failed-wave, or missing --headless flag.
+ *
+ * References:
+ *   scripts/lib/autopilot.mjs   — runLoop, parseFlags, writeAutopilotJsonl
+ *   scripts/lib/build-live-signals.mjs — buildLiveSignals
+ *   scripts/lib/mode-selector.mjs      — selectMode
+ *   scripts/lib/resource-probe.mjs     — probe, evaluate
+ *   scripts/lib/session-registry.mjs   — detectPeers
+ *   scripts/lib/session-schema.mjs     — normalizeSession
+ *   "/autopilot Loop Command (Phase C)" (#277/#271; archived in the private Meta-Vault)
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { spawnSync, spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+
+import {
+  runLoop,
+  parseFlags,
+  KILL_SWITCHES,
+} from './lib/autopilot.mjs';
+import { buildLiveSignals } from './lib/build-live-signals.mjs';
+import { surfaceTopN, decayOptsFromConfig } from './lib/learnings/surface.mjs';
+import { selectMode } from './lib/mode-selector.mjs';
+import { probe, evaluate } from './lib/resource-probe.mjs';
+import { detectPeers } from './lib/session-registry.mjs';
+import { normalizeSession } from './lib/session-schema.mjs';
+
+// ---------------------------------------------------------------------------
+// CLI-level flag extraction
+// ---------------------------------------------------------------------------
+
+const argv = process.argv.slice(2);
+
+const hasHeadless = argv.includes('--headless');
+const hasVerbose = argv.includes('--verbose');
+
+if (!hasHeadless) {
+  process.stderr.write('autopilot: headless mode requires --headless flag\n');
+  process.exit(2);
+}
+
+// Strip CLI-only flags before forwarding to parseFlags (which ignores unknown
+// flags, but being explicit avoids confusion with future parseFlags additions).
+const flagsForParse = argv.filter(
+  (a) => a !== '--headless' && a !== '--verbose'
+);
+
+const { maxSessions, maxHours, confidenceThreshold, dryRun } = parseFlags(flagsForParse);
+
+// ---------------------------------------------------------------------------
+// Session Config (parsed once, shared by thresholds + decay readers)
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse Session Config once by spawning `node scripts/parse-config.mjs`.
+ * Returns the parsed config object, or `null` if the spawn fails / yields
+ * no usable stdout. Callers fall back to their own defaults on `null`.
+ *
+ * @returns {object|null}
+ */
+function loadConfig() {
+  try {
+    const scriptPath = resolve(
+      new URL('.', import.meta.url).pathname,
+      'parse-config.mjs'
+    );
+    const result = spawnSync(
+      process.execPath,
+      [scriptPath],
+      { encoding: 'utf8', timeout: 10_000 }
+    );
+    if (result.status !== 0 || !result.stdout) return null;
+    return JSON.parse(result.stdout);
+  } catch {
+    return null;
+  }
+}
+
+const config = loadConfig();
+
+// ---------------------------------------------------------------------------
+// Resource-thresholds from Session Config
+// ---------------------------------------------------------------------------
+
+/**
+ * Read the `resource-thresholds` block from the parsed Session Config. Falls
+ * back to the resource-probe defaults if the field is absent or config is null.
+ *
+ * @returns {object} thresholds object consumable by evaluate()
+ */
+function loadResourceThresholds() {
+  // Probe defaults (mirrors resource-probe hard-coded values)
+  const DEFAULTS = {
+    'ram-free-min-gb': 2.0,
+    'ram-free-critical-gb': 0.5,
+    'cpu-load-max-pct': 85,
+    'concurrent-sessions-warn': 3,
+  };
+
+  const rt = config && config['resource-thresholds'];
+  if (rt && typeof rt === 'object') {
+    return { ...DEFAULTS, ...rt };
+  }
+  return DEFAULTS;
+}
+
+const thresholds = loadResourceThresholds();
+
+// ---------------------------------------------------------------------------
+// Learnings loader — top-15 active learnings from learnings.jsonl
+// ---------------------------------------------------------------------------
+//
+// Delegates to scripts/lib/learnings/surface.mjs (`surfaceTopN`). Same filter
+// semantics as the original inline implementation: confidence > 0.3 AND
+// (no expires_at OR expires_at > now), sorted by effectiveScore DESC (#670
+// time-decay), then created_at DESC, then sliced to n=15. The `evolve.decay`
+// Session Config block is threaded through `decayOptsFromConfig` so the
+// documented decay knobs (decay-enabled / decay-half-life-days /
+// decay-floor-factor) actually take effect here (#670). Errors swallowed → [].
+
+const surfacedLearnings = await surfaceTopN(
+  resolve('.orchestrator/metrics/learnings.jsonl'),
+  15,
+  { decay: decayOptsFromConfig(config && config['evolve.decay']) }
+);
+
+// ---------------------------------------------------------------------------
+// Branch detection for autopilot_run_id construction
+// ---------------------------------------------------------------------------
+
+function detectBranch() {
+  try {
+    const result = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+      encoding: 'utf8',
+      timeout: 5_000,
+    });
+    if (result.status === 0 && result.stdout) {
+      return result.stdout.trim() || null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+const branch = detectBranch();
+
+// ---------------------------------------------------------------------------
+// sessions.jsonl helpers for sessionRunner
+// ---------------------------------------------------------------------------
+
+const SESSIONS_JSONL_PATH = resolve('.orchestrator/metrics/sessions.jsonl');
+
+/**
+ * Count the number of non-empty lines in sessions.jsonl. Returns 0 if missing.
+ * @returns {number}
+ */
+function countSessionLines() {
+  if (!existsSync(SESSIONS_JSONL_PATH)) return 0;
+  try {
+    const raw = readFileSync(SESSIONS_JSONL_PATH, 'utf8');
+    return raw.split('\n').filter((l) => l.trim().length > 0).length;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Read the last non-empty line from sessions.jsonl, parse it, run it through
+ * normalizeSession, and project to the sessionRunner return shape.
+ *
+ * @returns {{session_id: string, agent_summary?: object, effectiveness?: object}}
+ */
+function readTailSession() {
+  const raw = readFileSync(SESSIONS_JSONL_PATH, 'utf8');
+  const lines = raw.split('\n').filter((l) => l.trim().length > 0);
+  if (lines.length === 0) {
+    throw new Error('sessions.jsonl is empty after session completed');
+  }
+  const parsed = JSON.parse(lines[lines.length - 1]);
+  const normalized = normalizeSession(parsed);
+  return {
+    session_id: normalized.session_id,
+    agent_summary: normalized.agent_summary,
+    effectiveness: normalized.effectiveness,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Shared resource snapshot (updated by peerCounter on every iteration)
+// ---------------------------------------------------------------------------
+
+/** @type {object|null} */
+let cachedProbeSnapshot = null;
+
+// ---------------------------------------------------------------------------
+// DI seam implementations
+// ---------------------------------------------------------------------------
+
+/**
+ * modeSelector — invoked before each iteration.
+ * Signals are assembled once (surfacedLearnings surfaced before the loop),
+ * but buildLiveSignals is called per-iteration to get fresh STATE.md / sessions.
+ *
+ * @returns {Promise<{mode: string, confidence: number, rationale?: string, alternatives?: object[]}>}
+ */
+async function modeSelector() {
+  const signals = await buildLiveSignals({
+    learnings: surfacedLearnings,
+    backlogLimit: 50,
+  });
+  return selectMode(signals);
+}
+
+/**
+ * sessionRunner — spawns `claude` with the recommended mode and awaits exit.
+ * Verifies that a new sessions.jsonl record was appended before returning.
+ *
+ * @param {{mode: string, autopilotRunId: string}} args
+ * @returns {Promise<{session_id: string, agent_summary?: object, effectiveness?: object}>}
+ */
+async function sessionRunner({ mode, autopilotRunId }) {
+  const preCount = countSessionLines();
+
+  await new Promise((res, rej) => {
+    const childStdio = hasVerbose
+      ? ['ignore', 'pipe', 'pipe']
+      : ['ignore', 'inherit', 'inherit'];
+
+    const child = spawn(
+      'claude',
+      ['-p', `/session ${mode}`],
+      {
+        env: { ...process.env, AUTOPILOT_RUN_ID: autopilotRunId },
+        stdio: childStdio,
+        cwd: process.cwd(),
+      }
+    );
+
+    if (hasVerbose) {
+      child.stdout.pipe(process.stdout);
+      child.stderr.pipe(process.stderr);
+    }
+
+    child.on('error', (err) => rej(err));
+    child.on('close', (code) => {
+      if (code !== 0) {
+        rej(new Error(`claude exit ${code}`));
+      } else {
+        res(undefined);
+      }
+    });
+  });
+
+  const postCount = countSessionLines();
+  if (postCount === preCount) {
+    throw new Error('no session record appended');
+  }
+
+  return readTailSession();
+}
+
+/**
+ * resourceEvaluator — returns the latest cached probe verdict.
+ * The cached snapshot is refreshed by peerCounter before each iteration.
+ * Falls back to probing inline if the cache is null (first iteration safety).
+ *
+ * @returns {{verdict: string, reasons: string[], recommended_agents_per_wave_cap: number|null}}
+ */
+function resourceEvaluator() {
+  if (cachedProbeSnapshot === null) {
+    // Synchronous fallback is not possible since probe() is async.
+    // Return a conservative 'warn' so the loop does not mis-gate on missing data.
+    // The real snapshot will be available after peerCounter runs on the next call.
+    return { verdict: 'warn', reasons: ['probe not yet available'], recommended_agents_per_wave_cap: null };
+  }
+  return evaluate(cachedProbeSnapshot, thresholds);
+}
+
+/**
+ * peerCounter — refreshes the resource snapshot AND returns the peer count.
+ * Using this combined approach lets resourceEvaluator remain synchronous as
+ * required by the runLoop contract.
+ *
+ * @param {string} autopilotRunId — self-id to exclude from peer list.
+ * @returns {Promise<number>}
+ */
+async function makePeerCounter(autopilotRunId) {
+  return async () => {
+    const [peers, snapshot] = await Promise.all([
+      detectPeers({ sessionId: autopilotRunId, freshnessMin: 15 }),
+      probe(),
+    ]);
+    cachedProbeSnapshot = snapshot;
+    return peers.length;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// AbortController for SIGINT
+// ---------------------------------------------------------------------------
+
+const controller = new AbortController();
+process.on('SIGINT', () => {
+  controller.abort();
+});
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  // Build the autopilotRunId via runLoop's defaultRunId (driven by branch opt).
+  // We don't construct it ourselves — runLoop builds it from branch + timestamp.
+  // We need it for peerCounter BEFORE runLoop starts. So we replicate the
+  // defaultRunId logic here to derive the same id. However, runLoop accepts
+  // an explicit `runId` override, so we just pre-compute one and pass it in.
+  const now = Date.now();
+  function pad2(n) { return n < 10 ? `0${n}` : String(n); }
+  const d = new Date(now);
+  const ymd = `${d.getUTCFullYear()}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())}`;
+  const hhmm = `${pad2(d.getUTCHours())}${pad2(d.getUTCMinutes())}`;
+  const safeBranch = (branch ?? 'unknown').replace(/[^A-Za-z0-9._-]+/g, '-');
+  const autopilotRunId = `${safeBranch}-${ymd}-${hhmm}-autopilot`;
+
+  const peerCounter = await makePeerCounter(autopilotRunId);
+
+  const state = await runLoop({
+    maxSessions,
+    maxHours,
+    confidenceThreshold,
+    dryRun,
+    modeSelector,
+    sessionRunner,
+    resourceEvaluator,
+    peerCounter,
+    abortSignal: controller.signal,
+    runId: autopilotRunId,
+    branch: branch ?? undefined,
+  });
+
+  const sessionIds = state.sessions.join(', ') || '(none)';
+  const summary =
+    `${state.autopilot_run_id} ` +
+    `kill_switch=${state.kill_switch ?? 'none'} ` +
+    `iterations=${state.iterations_completed} ` +
+    `sessions=[${sessionIds}] ` +
+    `duration=${state.duration_seconds}s`;
+  process.stdout.write(summary + '\n');
+
+  if (state.kill_switch === KILL_SWITCHES.FAILED_WAVE) {
+    process.exit(2);
+  }
+  process.exit(0);
+}
+
+main().catch((err) => {
+  process.stderr.write(`autopilot: fatal error: ${err?.message ?? String(err)}\n`);
+  process.exit(1);
+});

package/scripts/backfill-abandoned-sessions.mjs

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+/**
+ * backfill-abandoned-sessions.mjs — one-time historical migration CLI (#724 C1).
+ *
+ * Scans `.orchestrator/metrics/events.jsonl` for every distinct
+ * `orchestrator.session.started` UUID that has no counterpart in
+ * `.orchestrator/metrics/sessions.jsonl`, bridges each to its semantic id via
+ * `orchestrator.session.lock.acquired` where available, and synthesizes a
+ * `status: 'abandoned'` stub through the shared backfill core
+ * (`scripts/lib/session-close-backfill.mjs`).
+ *
+ * SAFETY: `--dry-run` is the DEFAULT — nothing is written unless `--apply` is
+ * passed. Dry-run is idempotent (creates no marker files, appends nothing) so
+ * you can safely preview counts, then apply once against a copy or the live
+ * store at the operator's discretion.
+ *
+ *   node scripts/backfill-abandoned-sessions.mjs [--dry-run|--apply] [--json]
+ *                                                [--repo-root PATH]
+ *                                                [--assume-dead-before ISO]
+ *
+ * DEAD-BY-AGE RELAXATION (#731): every CLI run happens FROM an active
+ * session, so `.orchestrator/session.lock` is ALWAYS live at run-time — the
+ * foreign-live-lock guard in the shared core (session-close-backfill.mjs)
+ * would otherwise block every historical candidate unconditionally. This CLI
+ * therefore ALWAYS passes `relaxDeadByAge: true`, so a candidate whose last
+ * known event is older than the lock's own default TTL
+ * (`session-lock.mjs` `DEFAULT_TTL_HOURS`) bypasses the current lock. The
+ * optional `--assume-dead-before <ISO>` flag additionally bypasses the guard
+ * for any candidate whose last known event predates the given cutoff,
+ * regardless of the TTL window. This relaxation is scoped to THIS CLI only —
+ * `hooks/on-session-end.mjs` never passes it (see the comment there).
+ *
+ * Exit codes (cli-design.md):
+ *   0 — completed (dry-run or apply)
+ *   1 — user/input error (bad args, invalid --assume-dead-before)
+ *   2 — system error (unreadable events file, etc.)
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { fileURLToPath } from 'node:url';
+
+import { backfillAbandonedSession } from './lib/session-close-backfill.mjs';
+import { SO_PROJECT_DIR } from './lib/platform.mjs';
+
+const LOCK_ACQUIRED = 'orchestrator.session.lock.acquired';
+const SESSION_STARTED = 'orchestrator.session.started';
+
+/** Read a JSONL file into parsed objects; missing → []; malformed lines skipped. */
+function readJsonl(filePath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split('\n')) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      out.push(JSON.parse(t));
+    } catch {
+      /* skip malformed */
+    }
+  }
+  return out;
+}
+
+/**
+ * Enumerate distinct sessions worth evaluating: every unique
+ * session.started UUID, each bridged to its semantic id via lock.acquired
+ * where one exists. Preserves first-seen order.
+ *
+ * @param {{ repoRoot: string }} args
+ * @returns {Array<{ sessionId: string, semanticSessionId: string|null }>}
+ */
+export function planSessions({ repoRoot }) {
+  const events = readJsonl(path.join(repoRoot, '.orchestrator', 'metrics', 'events.jsonl'));
+
+  const semanticByUuid = new Map();
+  for (const ev of events) {
+    if (
+      ev.event === LOCK_ACQUIRED &&
+      typeof ev.session_id === 'string' &&
+      typeof ev.semantic_session_id === 'string'
+    ) {
+      semanticByUuid.set(ev.session_id, ev.semantic_session_id);
+    }
+  }
+
+  const seen = new Set();
+  const plan = [];
+  for (const ev of events) {
+    if (ev.event !== SESSION_STARTED || typeof ev.session_id !== 'string') continue;
+    if (seen.has(ev.session_id)) continue;
+    seen.add(ev.session_id);
+    plan.push({ sessionId: ev.session_id, semanticSessionId: semanticByUuid.get(ev.session_id) ?? null });
+  }
+  return plan;
+}
+
+/**
+ * Run the migration over every planned session.
+ *
+ * `relaxDeadByAge: true` is ALWAYS passed to the shared core (#731) — see the
+ * module docblock for why. `assumeDeadBeforeMs` is forwarded as-is (null when
+ * `--assume-dead-before` was not given).
+ *
+ * @param {{ repoRoot: string, apply: boolean, assumeDeadBeforeMs?: number|null }} args
+ * @returns {Promise<object>} aggregate summary
+ */
+export async function runMigration({ repoRoot, apply, assumeDeadBeforeMs = null }) {
+  const plan = planSessions({ repoRoot });
+  const summary = {
+    repoRoot,
+    mode: apply ? 'apply' : 'dry-run',
+    total: plan.length,
+    backfilled: 0,
+    would_backfill: 0,
+    dead_by_age: 0,
+    errors: 0,
+    skipped: {},
+  };
+
+  // Dry-run has no incremental sessions.jsonl write, so two started-UUIDs that
+  // bridge to the SAME semantic id (a session that cleared/compacted mid-run)
+  // would both report 'would-backfill' and over-count. Track projected ids
+  // here so the dry-run total matches what --apply actually writes.
+  const projected = new Set();
+
+  for (const item of plan) {
+    const res = await backfillAbandonedSession({
+      repoRoot,
+      sessionId: item.sessionId,
+      semanticSessionId: item.semanticSessionId,
+      dryRun: !apply,
+      relaxDeadByAge: true,
+      assumeDeadBeforeMs,
+    });
+    switch (res.action) {
+      case 'backfilled':
+        summary.backfilled += 1;
+        if (res.deadByAge) summary.dead_by_age += 1;
+        break;
+      case 'would-backfill':
+        if (projected.has(res.sessionId)) {
+          summary.skipped['skipped-already-recorded'] =
+            (summary.skipped['skipped-already-recorded'] ?? 0) + 1;
+        } else {
+          projected.add(res.sessionId);
+          summary.would_backfill += 1;
+          if (res.deadByAge) summary.dead_by_age += 1;
+        }
+        break;
+      case 'error':
+        summary.errors += 1;
+        break;
+      default:
+        summary.skipped[res.action] = (summary.skipped[res.action] ?? 0) + 1;
+    }
+  }
+  return summary;
+}
+
+function renderHuman(summary) {
+  const lines = [];
+  lines.push(`Backfill abandoned sessions — ${summary.mode}`);
+  lines.push(`  repo:            ${summary.repoRoot}`);
+  lines.push(`  sessions seen:   ${summary.total}`);
+  if (summary.mode === 'apply') {
+    lines.push(`  backfilled:      ${summary.backfilled}`);
+  } else {
+    lines.push(`  would backfill:  ${summary.would_backfill}`);
+  }
+  if (summary.dead_by_age > 0) {
+    lines.push(`  dead-by-age:     ${summary.dead_by_age} (relaxed past a live foreign session.lock)`);
+  }
+  lines.push(`  errors:          ${summary.errors}`);
+  const skips = Object.entries(summary.skipped);
+  if (skips.length > 0) {
+    lines.push('  skipped:');
+    for (const [reason, n] of skips) lines.push(`    ${reason}: ${n}`);
+  }
+  return lines.join('\n') + '\n';
+}
+
+async function main() {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: process.argv.slice(2),
+      options: {
+        apply: { type: 'boolean', default: false },
+        'dry-run': { type: 'boolean', default: false },
+        json: { type: 'boolean', default: false },
+        'repo-root': { type: 'string' },
+        'assume-dead-before': { type: 'string' },
+        help: { type: 'boolean', short: 'h', default: false },
+      },
+      allowPositionals: false,
+    });
+  } catch (err) {
+    process.stderr.write(`backfill-abandoned-sessions: ${err.message}\n`);
+    process.exit(1);
+  }
+
+  const { values } = parsed;
+
+  if (values.help) {
+    process.stdout.write(
+      'Usage: node scripts/backfill-abandoned-sessions.mjs [--dry-run|--apply] [--json]\n' +
+        '                                                     [--repo-root PATH]\n' +
+        '                                                     [--assume-dead-before ISO]\n' +
+        '  --dry-run             preview only (DEFAULT — nothing is written)\n' +
+        '  --apply               synthesize + append abandoned-session stubs\n' +
+        '  --json                emit the summary as JSON to stdout\n' +
+        '  --repo-root           override the project root (default: resolved SO_PROJECT_DIR)\n' +
+        '  --assume-dead-before  ISO-8601 cutoff; a candidate whose last known event\n' +
+        '                        predates it bypasses a live foreign session.lock\n' +
+        'Exit codes: 0 ok, 1 arg error, 2 system error\n'
+    );
+    process.exit(0);
+  }
+
+  // --apply is an explicit opt-in; absent it (or with --dry-run) we never write.
+  const apply = values.apply === true && values['dry-run'] !== true;
+  const repoRoot = values['repo-root'] || SO_PROJECT_DIR;
+
+  let assumeDeadBeforeMs = null;
+  if (typeof values['assume-dead-before'] === 'string' && values['assume-dead-before'].length > 0) {
+    const ms = Date.parse(values['assume-dead-before']);
+    if (Number.isNaN(ms)) {
+      process.stderr.write(
+        `backfill-abandoned-sessions: --assume-dead-before is not a valid ISO-8601 timestamp: "${values['assume-dead-before']}"\n`
+      );
+      process.exit(1);
+    }
+    assumeDeadBeforeMs = ms;
+  }
+
+  let summary;
+  try {
+    summary = await runMigration({ repoRoot, apply, assumeDeadBeforeMs });
+  } catch (err) {
+    process.stderr.write(`backfill-abandoned-sessions: ${err?.message ?? String(err)}\n`);
+    process.exit(2);
+  }
+
+  if (values.json) {
+    process.stdout.write(JSON.stringify(summary) + '\n');
+  } else {
+    process.stdout.write(renderHuman(summary));
+  }
+  process.exit(0);
+}
+
+const isDirectRun = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isDirectRun) {
+  main().catch((err) => {
+    process.stderr.write(`backfill-abandoned-sessions: unexpected error: ${err?.stack ?? err}\n`);
+    process.exit(2);
+  });
+}