peaks-loop 4.0.0-beta.8 → 4.0.1

package/dist/cli/commands/cron-scheduler-commands.js

@@ -0,0 +1,284 @@
+/**
+ * `peaks cron scheduler start|stop|status|run-once` — slice 2026-07-29 Part 15.
+ *
+ * Companion CLI to Part 14 (peaks cron init/list/run). The
+ * scheduler is a long-running background daemon that wakes up
+ * once per minute, reads `.peaks/cron/schedule.json`, and runs
+ * any due tasks via detached execSync (so a misbehaving task
+ * cannot block the scheduler). Best-effort persistence via
+ * `.peaks/cron/scheduler.pid` (advisory — operators can `kill
+ * $(cat scheduler.pid)` if a stale entry lingers).
+ *
+ * Why a separate `peaks-cron-scheduler` CLI (not a peaks
+ * subcommand) — long-running daemons that are spawned from a
+ * `peaks ...` invocation confuse a future "which peaks version
+ * is running" check. A dedicated binary name keeps the
+ * scheduler's startup visible to operators.
+ *
+ * Windows: the scheduler writes its pid to a file. To run as
+ * a real Windows service, the operator wires NSSM (or
+ * node-windows) to call `peaks-cron-scheduler start` on
+ * service start. Future slice: ship an NSSM install recipe
+ * in the operator docs.
+ *
+ * POSIX: same pid-file pattern; an init.d / systemd unit
+ * file would call `peaks-cron-scheduler start` and rely on
+ * the scheduler to write its own pid. Or just run from
+ * `nohup peaks-cron-scheduler start &` if you don't need
+ * restart-on-crash.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { fail, getErrorMessage, ok } from 'peaks-loop-shared/result';
+import { addJsonOption, printResult } from '../cli-helpers.js';
+import { findProjectRoot } from '../../services/config/config-safety.js';
+import { readSchedule, listDueTasks, runTask } from './cron-commands.js';
+const SCHEDULER_TICK_MS = 60_000; // 1 minute
+const PID_FILENAME = 'scheduler.pid';
+function schedulerPidPath(projectRoot) {
+    return join(projectRoot, '.peaks', 'cron', PID_FILENAME);
+}
+function readSchedulerPid(projectRoot) {
+    const p = schedulerPidPath(projectRoot);
+    if (!existsSync(p))
+        return null;
+    const raw = readFileSync(p, 'utf8').trim();
+    const pid = Number.parseInt(raw, 10);
+    if (!Number.isFinite(pid) || pid <= 0)
+        return null;
+    return pid;
+}
+function isPidAlive(pid) {
+    try {
+        // `process.kill(pid, 0)` does not actually kill; it just
+        // checks if the process exists. ESRCH means no such pid;
+        // EPERM means it exists but we don't have permission to
+        // signal it (still alive).
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        return code === 'EPERM';
+    }
+}
+function findSchedulerEntryPoint() {
+    // The peaks-cron-scheduler.js entry shim lives in bin/ (not
+    // dist/, so the pnpm build does not overwrite it). It forwards
+    // to dist/cli/commands/cron-scheduler-commands.js with
+    // PEAKS_CRON_SCHEDULER_DAEMON=1 set; the CLI detects the env
+    // and runs runSchedulerLoop directly.
+    const here = dirname(fileURLToPath(import.meta.url));
+    // dist/cli/commands/cron-scheduler-commands.js → bin/peaks-cron-scheduler.js
+    return resolve(here, '..', '..', '..', 'bin', 'peaks-cron-scheduler.js');
+}
+export function registerCronSchedulerCommand(program, io) {
+    const cmd = program
+        .command('cron-scheduler')
+        .description('Long-running background scheduler for peaks cron tasks (Part 15).');
+    addJsonOption(cmd.command('start')
+        .description('Spawn the scheduler as a detached background process. Idempotent: refuses to start when an alive pid already exists.')
+        .option('--project <path>', 'project root (default: findProjectRoot(cwd))')).action((options) => {
+        try {
+            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+            const pidFile = schedulerPidPath(projectRoot);
+            const existing = readSchedulerPid(projectRoot);
+            if (existing !== null && isPidAlive(existing)) {
+                printResult(io, ok('cron-scheduler.start', { projectRoot, started: false, alreadyRunning: true, existingPid: existing }, [], [
+                    `Scheduler already running at pid ${existing}; not starting a second one.`,
+                    'Use `peaks cron-scheduler stop` first if you need to restart.'
+                ]), options.json);
+                return;
+            }
+            // Spawn detached via `peaks-cron-scheduler.js` — the
+            // child runs `runSchedulerLoop` (60s setInterval + due-task
+            // runner). The detached flag + stdio:ignore puts the
+            // scheduler in its own process group (POSIX) / detaches
+            // from the console (Windows). PEAKS_CRON_SCHEDULER_DAEMON
+            // env is the canonical "I'm the long-running child" signal.
+            const entry = findSchedulerEntryPoint();
+            const child = spawn(process.execPath, [entry, '--project', projectRoot], {
+                cwd: projectRoot,
+                stdio: 'ignore',
+                detached: true,
+                windowsHide: true,
+                env: { ...process.env, PEAKS_CRON_SCHEDULER: '1', PEAKS_CRON_SCHEDULER_DAEMON: '1' }
+            });
+            child.unref();
+            if (typeof child.pid !== 'number') {
+                throw new Error('spawn returned no pid');
+            }
+            writeFileSync(pidFile, String(child.pid), 'utf8');
+            printResult(io, ok('cron-scheduler.start', { projectRoot, started: true, pid: child.pid, pidFile }, [], [
+                `Scheduler started at pid ${child.pid}; logs go to .peaks/cron/scheduler.log.`,
+                'Use `peaks cron-scheduler status` to confirm it is alive; `stop` to terminate.'
+            ]), options.json);
+        }
+        catch (err) {
+            printResult(io, fail('cron-scheduler.start', 'SCHEDULER_START_FAILED', getErrorMessage(err), { projectRoot: options.project }, [
+                'Verify the peaks-cron-scheduler.js entry point is on disk.',
+                'Check that the .peaks/cron/ directory is writable.'
+            ]), options.json);
+            process.exitCode = 1;
+        }
+    });
+    addJsonOption(cmd.command('stop')
+        .description('Send SIGTERM to the scheduler pid (best-effort; removes the pid file either way).')
+        .option('--project <path>', 'project root (default: findProjectRoot(cwd))')).action((options) => {
+        try {
+            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+            const pid = readSchedulerPid(projectRoot);
+            if (pid === null) {
+                printResult(io, ok('cron-scheduler.stop', { projectRoot, stopped: false, reason: 'no-pid-file' }, [], ['No scheduler pid file found; nothing to stop.']), options.json);
+                return;
+            }
+            let signalSent = false;
+            if (isPidAlive(pid)) {
+                try {
+                    process.kill(pid, 'SIGTERM');
+                    signalSent = true;
+                }
+                catch {
+                    signalSent = false;
+                }
+            }
+            const pidFile = schedulerPidPath(projectRoot);
+            try {
+                unlinkSync(pidFile);
+            }
+            catch { /* best-effort */ }
+            printResult(io, ok('cron-scheduler.stop', { projectRoot, stopped: signalSent, pid, pidFile }, [], [
+                signalSent
+                    ? `Sent SIGTERM to pid ${pid}; pid file removed.`
+                    : `pid ${pid} was not alive; pid file removed.`
+            ]), options.json);
+        }
+        catch (err) {
+            printResult(io, fail('cron-scheduler.stop', 'SCHEDULER_STOP_FAILED', getErrorMessage(err), { projectRoot: options.project }, [
+                'Verify the pid file is readable / the process is yours.'
+            ]), options.json);
+            process.exitCode = 1;
+        }
+    });
+    addJsonOption(cmd.command('status')
+        .description('Report whether the scheduler is alive + when it last ran a task.')
+        .option('--project <path>', 'project root (default: findProjectRoot(cwd))')).action((options) => {
+        try {
+            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+            const pid = readSchedulerPid(projectRoot);
+            const alive = pid !== null && isPidAlive(pid);
+            let schedule;
+            try {
+                schedule = readSchedule(projectRoot);
+            }
+            catch (err) {
+                schedule = { version: 1, entries: [] };
+            }
+            const due = alive ? listDueTasks(projectRoot) : [];
+            printResult(io, ok('cron-scheduler.status', { projectRoot, pid, alive, scheduleEntries: schedule.entries.length, dueTaskCount: due.length }, [], [alive
+                    ? `Scheduler alive at pid ${pid}; ${due.length} task(s) due now.`
+                    : 'Scheduler is NOT running. Use `peaks cron-scheduler start` to spawn.']), options.json);
+        }
+        catch (err) {
+            printResult(io, fail('cron-scheduler.status', 'SCHEDULER_STATUS_FAILED', getErrorMessage(err), { projectRoot: options.project }, [
+                'Verify the .peaks/cron/ directory exists.'
+            ]), options.json);
+            process.exitCode = 1;
+        }
+    });
+    addJsonOption(cmd.command('run-once')
+        .description('Synchronous foreground one-shot: run every currently-due task and exit. Useful for manual cron substitute.')
+        .option('--project <path>', 'project root (default: findProjectRoot(cwd))')).action((options) => {
+        try {
+            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+            const due = listDueTasks(projectRoot);
+            const records = due.map((t) => runTask(projectRoot, t));
+            printResult(io, ok('cron-scheduler.run-once', { projectRoot, ran: records.length, records }, [], [
+                `${records.length} due task(s) ran; ${records.filter((r) => r.exitCode === 0).length} succeeded.`
+            ]), options.json);
+            if (records.some((r) => r.exitCode !== 0))
+                process.exitCode = 1;
+        }
+        catch (err) {
+            printResult(io, fail('cron-scheduler.run-once', 'SCHEDULER_RUN_ONCE_FAILED', getErrorMessage(err), { projectRoot: options.project }, [
+                "If schedule.json is missing, run 'peaks cron init' first."
+            ]), options.json);
+            process.exitCode = 1;
+        }
+    });
+}
+/**
+ * Standalone scheduler entry point (the process the CLI spawns).
+ * Runs a setInterval tick + reads schedule + runs due tasks.
+ * Exits cleanly on SIGTERM.
+ *
+ * Exported as `runSchedulerLoop` so the dedicated
+ * `peaks-cron-scheduler.js` entry shim can call it; the
+ * command-side `registerCronSchedulerCommand` only uses
+ * start/stop/status, not the loop.
+ */
+export async function runSchedulerLoop(args) {
+    const tickMs = args.tickMs ?? SCHEDULER_TICK_MS;
+    // Idempotency: refuse to start a second loop in the same
+    // process (the start CLI is expected to be a fresh spawn).
+    if (process.__peaksCronScheduler) {
+        throw new Error('scheduler loop already running in this process');
+    }
+    process.__peaksCronScheduler = true;
+    const tick = () => {
+        try {
+            const due = listDueTasks(args.projectRoot);
+            for (const task of due) {
+                runTask(args.projectRoot, task);
+            }
+        }
+        catch (err) {
+            process.stderr.write(`[cron-scheduler] tick error: ${getErrorMessage(err)}\n`);
+        }
+    };
+    // First tick on entry (don't wait the full interval
+    // for the first run after a start).
+    tick();
+    const handle = setInterval(tick, tickMs);
+    // Wait for the abort signal (POSIX) or the platform
+    // equivalent. We don't use Node's process.on('SIGTERM')
+    // for portability — the parent process kills us via
+    // `process.kill(pid, 'SIGTERM')` and the event loop
+    // exits naturally if the interval is the only thing
+    // keeping the loop alive. We clearInterval on exit.
+    await new Promise((resolve) => {
+        const onAbort = () => {
+            clearInterval(handle);
+            resolve();
+        };
+        if (args.signal) {
+            args.signal.addEventListener('abort', onAbort, { once: true });
+        }
+        else {
+            // POSIX: SIGTERM. Windows: kill the process directly.
+            process.on('SIGTERM', onAbort);
+            process.on('SIGINT', onAbort);
+        }
+    });
+    process.exit(0);
+}
+// Standalone entry shim. When this file is run directly via
+// `node peaks-cron-scheduler.js`, the loop starts; when it is
+// imported (e.g. by the CLI), the export is used but the
+// loop is not started.
+if (process.env.PEAKS_CRON_SCHEDULER_DAEMON === '1') {
+    // Spawned by `peaks cron-scheduler start` as the long-running
+    // detached child. Run the loop until SIGTERM. Gated on the
+    // env var (not argv[1]) because on Windows a forked node
+    // process inherits the parent's argv[1] (which is bin/peaks.js).
+    const projectRoot = (() => {
+        const idx = process.argv.indexOf('--project');
+        return idx >= 0 ? process.argv[idx + 1] : findProjectRoot(process.cwd()) ?? process.cwd();
+    })();
+    runSchedulerLoop({ projectRoot }).catch((err) => {
+        process.stderr.write(`[cron-scheduler] fatal: ${getErrorMessage(err)}\n`);
+        process.exit(1);
+    });
+}

package/dist/cli/commands/dashboard-commands.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+import type { ProgramIO } from '../cli-helpers.js';
+/** Registers the top-level `peaks dashboard` command tree. */
+export declare function registerDashboardCommands(program: Command, io: ProgramIO): void;

package/dist/cli/commands/dashboard-commands.js

@@ -0,0 +1,10 @@
+import { registerDashboardLongRunCommand } from './dashboard-long-run.js';
+import { registerDashboardSummaryCommand } from './dashboard-summary.js';
+/** Registers the top-level `peaks dashboard` command tree. */
+export function registerDashboardCommands(program, io) {
+    const dashboard = program
+        .command('dashboard')
+        .description('peaks dashboard surface (24h long-run view etc.)');
+    registerDashboardLongRunCommand(dashboard, io);
+    registerDashboardSummaryCommand(dashboard, io);
+}

package/dist/cli/commands/dashboard-long-run.d.ts

@@ -0,0 +1,25 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+type ParseResult = {
+    ok: true;
+    ms: number;
+} | {
+    ok: false;
+    error: string;
+};
+declare function parseSince(raw: string | undefined): ParseResult;
+type Boundary = {
+    key: 'empty' | 'cap' | 'valid';
+    message: string;
+};
+declare function boundaryLabel(raw: string): Boundary;
+export declare function registerDashboardLongRunCommand(dashboard: Command, io: ProgramIO): void;
+export declare const DASHBOARD_LONG_RUN_CONSTANTS: {
+    readonly WINDOW_CAP_HOURS: 24;
+    readonly WINDOW_CAP_MS: number;
+};
+export declare const __test__: {
+    parseSince: typeof parseSince;
+    boundaryLabel: typeof boundaryLabel;
+};
+export {};

package/dist/cli/commands/dashboard-long-run.js

@@ -0,0 +1,122 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
+import { read24hState } from '../../services/24h-mode/index.js';
+import { getErrorMessage } from '../cli-helpers.js';
+const SINCE_PATTERN = /^(\d+)([smhd])$/i;
+const WINDOW_CAP_HOURS = 24;
+const WINDOW_CAP_MS = WINDOW_CAP_HOURS * 60 * 60 * 1000;
+function parseSince(raw) {
+    if (!raw)
+        return { ok: false, error: '--since is required (e.g. 24h, 8h, 30m)' };
+    const match = SINCE_PATTERN.exec(raw);
+    if (!match)
+        return { ok: false, error: `--since must match <n><s|m|h|d> (got ${raw})` };
+    const value = Number(match[1]);
+    if (!Number.isFinite(value) || value < 0)
+        return { ok: false, error: `--since must be a non-negative integer (got ${raw})` };
+    const unit = (match[2] ?? 'h').toLowerCase();
+    const multiplier = unit === 'd' ? 86_400_000 : unit === 'h' ? 3_600_000 : unit === 'm' ? 60_000 : 1_000;
+    return { ok: true, ms: Math.min(WINDOW_CAP_MS, value * multiplier) };
+}
+function readSlices(projectRoot, sessionId) {
+    const path = join(projectRoot, '.peaks', '_runtime', sessionId, 'metrics', 'slices.jsonl');
+    if (!existsSync(path))
+        return 0;
+    try {
+        return readFileSync(path, 'utf8').split('\n').filter((line) => line.trim().length > 0).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function readLastCheckpointAgeMs(snapshot) {
+    if (!snapshot.lastCheckpointAt)
+        return null;
+    const ts = Date.parse(snapshot.lastCheckpointAt);
+    return Number.isFinite(ts) ? Math.max(0, Date.now() - ts) : null;
+}
+function boundaryLabel(raw) {
+    if (raw === '0h' || raw === '0m' || raw === '0s' || raw === '0d') {
+        return { key: 'empty', message: 'since=0 produces an empty window' };
+    }
+    const match = SINCE_PATTERN.exec(raw);
+    if (!match)
+        return { key: 'valid', message: 'unparseable' };
+    const value = Number(match[1]);
+    const unit = (match[2] ?? 'h').toLowerCase();
+    const multiplier = unit === 'd' ? 86_400_000 : unit === 'h' ? 3_600_000 : unit === 'm' ? 60_000 : 1_000;
+    if (value * multiplier > WINDOW_CAP_MS) {
+        return { key: 'cap', message: 'since>24h is capped to the 24h window' };
+    }
+    return { key: 'valid', message: 'within window' };
+}
+export function registerDashboardLongRunCommand(dashboard, io) {
+    dashboard
+        .command('long-run')
+        .description('24h long-run indicator dashboard (read-only) for the active 24h state')
+        .option('--since <duration>', 'time window (e.g. 24h, 8h, 30m); capped at 24h')
+        .option('--project <path>', 'project root (defaults to current directory)')
+        .option('--session-id <sessionId>', 'explicit session id')
+        .option('--json', 'emit machine-readable JSON')
+        .action(async (options) => {
+        const projectRoot = resolveCanonicalProjectRoot(options.project ?? process.cwd());
+        const parsed = parseSince(options.since);
+        if (!parsed.ok) {
+            io.stdout((options.json === true
+                ? JSON.stringify({ ok: false, code: 'INVALID_SINCE', message: parsed.error })
+                : `${parsed.error}\n`) + '\n');
+            process.exitCode = 1;
+            return;
+        }
+        const sid = options.sessionId ?? (await (async () => {
+            const { getSessionIdCanonical } = await import('../../services/session/session-manager.js');
+            return getSessionIdCanonical(projectRoot);
+        })());
+        if (!sid) {
+            io.stdout((options.json === true
+                ? JSON.stringify({ ok: false, code: 'NO_ACTIVE_SESSION', message: 'no --session-id and no canonical binding' })
+                : 'NO_ACTIVE_SESSION: no --session-id and no canonical binding\n'));
+            process.exitCode = 1;
+            return;
+        }
+        const boundary = boundaryLabel(options.since ?? '');
+        try {
+            const snapshot = read24hState(projectRoot, sid);
+            const sliceCount = readSlices(projectRoot, sid);
+            const checkpointAgeMs = readLastCheckpointAgeMs(snapshot);
+            const checkpointFrequency = snapshot.checkpoints > 0 && snapshot.enteredAt
+                ? Math.max(1, Math.round((Date.now() - Date.parse(snapshot.enteredAt)) / snapshot.checkpoints / 60_000))
+                : null;
+            const indicators = {
+                dispatchCount: sliceCount,
+                autoCompactCount: snapshot.autoCompactCount,
+                monotonicTriggerCount: snapshot.monotonicGuards,
+                subAgentFailureCount: Object.values(snapshot.attempts).reduce((a, b) => a + b, 0),
+                checkpointFrequency
+            };
+            const payload = {
+                ok: true,
+                data: {
+                    sessionId: sid,
+                    since: options.since ?? null,
+                    sinceMs: parsed.ms,
+                    sinceCapped: parsed.ms === WINDOW_CAP_MS && boundary.key === 'cap',
+                    boundary: boundary.key,
+                    snapshot: { state: snapshot.state, enteredAt: snapshot.enteredAt, lastCheckpointAt: snapshot.lastCheckpointAt },
+                    indicators,
+                    checkpointAgeMs
+                }
+            };
+            io.stdout((options.json === true ? JSON.stringify(payload) : JSON.stringify(payload.data, null, 2)) + '\n');
+        }
+        catch (error) {
+            io.stdout((options.json === true
+                ? JSON.stringify({ ok: false, code: 'LONG_RUN_READ_FAILED', message: getErrorMessage(error) })
+                : `LONG_RUN_READ_FAILED: ${getErrorMessage(error)}\n`) + '\n');
+            process.exitCode = 1;
+        }
+    });
+}
+export const DASHBOARD_LONG_RUN_CONSTANTS = { WINDOW_CAP_HOURS, WINDOW_CAP_MS };
+export const __test__ = { parseSince, boundaryLabel };

package/dist/cli/commands/dashboard-summary.d.ts

@@ -0,0 +1,12 @@
+/**
+ * rid-030 F-direction: `peaks dashboard summary --since <duration>`.
+ *
+ * Read-only 5-metric surface derived from raw observability events
+ * (cycle / token / dispatch / compact / monotonic-trigger). Distinct
+ * from `peaks dashboard long-run` (which reads 24h-state indicators);
+ * the two commands answer different questions and intentionally
+ * coexist.
+ */
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerDashboardSummaryCommand(dashboard: Command, io: ProgramIO): void;

package/dist/cli/commands/dashboard-summary.js

@@ -0,0 +1,58 @@
+import { resolveCanonicalProjectRoot } from '../../services/config/config-service.js';
+import { aggregateDashboardMetrics } from '../../services/observability/aggregation.js';
+import { getErrorMessage } from '../cli-helpers.js';
+import { __test__ as longRunTest } from './dashboard-long-run.js';
+const { parseSince } = longRunTest;
+export function registerDashboardSummaryCommand(dashboard, io) {
+    dashboard
+        .command('summary')
+        .description('Read-only 24h dashboard summary (5 metric classes from observability events)')
+        .option('--since <duration>', 'time window (e.g. 24h, 8h, 30m); defaults to 24h', '24h')
+        .option('--project <path>', 'project root (defaults to current directory)')
+        .option('--session-id <sessionId>', 'explicit session id (defaults to canonical binding)')
+        .option('--json', 'emit machine-readable JSON', false)
+        .action(async (options) => {
+        const projectRoot = resolveCanonicalProjectRoot(options.project ?? process.cwd());
+        const parsed = parseSince(options.since ?? '24h');
+        if (!parsed.ok) {
+            io.stdout((options.json === true
+                ? JSON.stringify({ ok: false, code: 'INVALID_SINCE', message: parsed.error })
+                : `${parsed.error}\n`) + '\n');
+            process.exitCode = 1;
+            return;
+        }
+        const since = new Date(Date.now() - parsed.ms);
+        let sid = options.sessionId ?? null;
+        if (!sid) {
+            const { getSessionIdCanonical } = await import('../../services/session/session-manager.js');
+            sid = await getSessionIdCanonical(projectRoot);
+        }
+        if (!sid) {
+            io.stdout((options.json === true
+                ? JSON.stringify({ ok: false, code: 'NO_ACTIVE_SESSION', message: 'no --session-id and no canonical binding' })
+                : 'NO_ACTIVE_SESSION: no --session-id and no canonical binding\n'));
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const metrics = aggregateDashboardMetrics(projectRoot, sid, since);
+            const payload = {
+                ok: true,
+                data: {
+                    sessionId: sid,
+                    since: options.since ?? '24h',
+                    sinceMs: parsed.ms,
+                    windowStart: since.toISOString(),
+                    metrics
+                }
+            };
+            io.stdout((options.json === true ? JSON.stringify(payload) : JSON.stringify(payload.data, null, 2)) + '\n');
+        }
+        catch (error) {
+            io.stdout((options.json === true
+                ? JSON.stringify({ ok: false, code: 'SUMMARY_READ_FAILED', message: getErrorMessage(error) })
+                : `SUMMARY_READ_FAILED: ${getErrorMessage(error)}\n`) + '\n');
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/cli/commands/dispatch-commands.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerDispatchCommand(parent: Command, io: ProgramIO): void;