@winspan/claude-forge 8.54.4 → 9.2.0

package/dist/core/diagnostics/checks.js

@@ -0,0 +1,765 @@
+/**
+ * cf doctor — 9-check diagnostic engine (spec 1a41b43a).
+ *
+ * Pure module: CLI (`cf doctor`) and Web (`GET /api/diagnostics`) both consume
+ * `runChecks()` here, avoiding child_process spawns and circular deps between
+ * `src/cli/` and `src/web/`.
+ *
+ * Each check returns a `CheckResult` describing pass/warn/fail status, a
+ * short human message, optional details, and a fix hint. The set of checks
+ * automatically fixable by `cf fix` is enumerated in `FIXABLE_COMMANDS`.
+ *
+ * Marker schema (spec 1, frozen): `readSystemMarker()` / `readProjectMarker()`
+ * from `./markers.js` — DO NOT modify.
+ *
+ * @see docs/design/2026-06-01/1030-cf-doctor-diagnostic-spec.md
+ */
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import os from 'node:os';
+import { FORGE_PATHS } from '../constants.js';
+import { readProjectMarker } from './markers.js';
+import { getDaemonSelfStatus } from './daemon-status.js';
+import { check10_staleDecisions, check11_staleSpecs, check12_orphanEvents, } from './entropy-checks.js';
+/**
+ * Whitelist of checks `cf fix` can auto-apply. Any check NOT in this map is
+ * considered manual-only (we do not synthesize new commands at runtime).
+ *
+ * Tests guarantee that every key here corresponds to a real check id, so the
+ * registry stays in sync.
+ */
+export const FIXABLE_COMMANDS = {
+    1: 'cf daemon ensure-running',
+    3: 'cf daemon install',
+    4: 'cf init',
+    5: 'cf project init --skip-knowledge',
+    6: 'cf knowledge init',
+};
+function defaultReadFile(p) {
+    try {
+        return fs.readFileSync(p, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function defaultKill0(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function check1_daemonProcess(deps) {
+    const readPid = deps?.readPid ?? defaultReadFile;
+    const kill0 = deps?.kill0 ?? defaultKill0;
+    const pidFile = deps?.pidFile ?? FORGE_PATHS.daemonPid();
+    // spec 8cbecdb4 / OQ #3: in self-mode (Web /api/diagnostics) the report
+    // runs inside the daemon process — pidfile probe is unreliable. Defer to
+    // the shared helper which uses process.pid + heartbeat freshness.
+    if (deps?.selfMode) {
+        const s = getDaemonSelfStatus();
+        if (s.status === 'stale') {
+            return {
+                id: 1,
+                name: 'daemon-process',
+                status: 'warn',
+                message: `Daemon PID ${s.pid} alive but heartbeat is stale`,
+                fix_hint: 'cf daemon ensure-running',
+                fixable_by: 'cf fix',
+            };
+        }
+        return {
+            id: 1,
+            name: 'daemon-process',
+            status: 'pass',
+            message: `Daemon running (PID ${s.pid})`,
+        };
+    }
+    const raw = readPid(pidFile);
+    if (raw == null) {
+        return {
+            id: 1,
+            name: 'daemon-process',
+            status: 'fail',
+            message: 'Daemon PID file missing — daemon is not running',
+            fix_hint: 'cf daemon ensure-running',
+            fixable_by: 'cf fix',
+        };
+    }
+    const pid = parseInt(raw.trim(), 10);
+    if (Number.isNaN(pid) || !kill0(pid)) {
+        return {
+            id: 1,
+            name: 'daemon-process',
+            status: 'fail',
+            message: `Daemon PID ${raw.trim()} is stale or process is dead`,
+            fix_hint: 'cf daemon ensure-running',
+            fixable_by: 'cf fix',
+        };
+    }
+    return {
+        id: 1,
+        name: 'daemon-process',
+        status: 'pass',
+        message: `Daemon running (PID ${pid})`,
+    };
+}
+function defaultTryConnect(socketPath, timeoutMs) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const sock = net.createConnection(socketPath);
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            sock.destroy();
+            resolve(false);
+        }, timeoutMs);
+        sock.once('connect', () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            sock.end();
+            resolve(true);
+        });
+        sock.once('error', () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(false);
+        });
+    });
+}
+export async function check2_daemonSocket(deps) {
+    const socketPath = deps?.socketPath ?? FORGE_PATHS.daemonSocket();
+    const tryConnect = deps?.tryConnect ?? defaultTryConnect;
+    if (!fs.existsSync(socketPath)) {
+        return {
+            id: 2,
+            name: 'daemon-socket',
+            status: 'fail',
+            message: 'Daemon socket file does not exist',
+            details: `Expected: ${socketPath}`,
+            fix_hint: 'Start the daemon: cf daemon ensure-running',
+            fixable_by: 'manual',
+        };
+    }
+    const connectable = await tryConnect(socketPath, 5_000);
+    if (!connectable) {
+        return {
+            id: 2,
+            name: 'daemon-socket',
+            status: 'warn',
+            message: 'Socket exists but connect timed out',
+            details: `Socket: ${socketPath}`,
+            fix_hint: 'Restart the daemon: cf daemon ensure-running',
+            fixable_by: 'manual',
+        };
+    }
+    return {
+        id: 2,
+        name: 'daemon-socket',
+        status: 'pass',
+        message: 'Socket connectable',
+    };
+}
+export async function check3_launchdAgent(deps) {
+    const platform = deps?.platform ?? process.platform;
+    if (platform !== 'darwin') {
+        return {
+            id: 3,
+            name: 'launchd-agent',
+            status: 'skip',
+            message: `LaunchAgent check skipped on ${platform} (macOS only)`,
+        };
+    }
+    let getter = deps?.launchdStatus;
+    if (!getter) {
+        // Lazy import to keep non-darwin platforms from loading darwin-only logic.
+        const mod = await import('../../daemon/launchd-installer.js');
+        getter = () => mod.status();
+    }
+    try {
+        const s = getter();
+        if (!s.installed) {
+            return {
+                id: 3,
+                name: 'launchd-agent',
+                status: 'fail',
+                message: 'LaunchAgent plist is not installed',
+                fix_hint: 'cf daemon install',
+                fixable_by: 'cf fix',
+            };
+        }
+        if (!s.loaded) {
+            return {
+                id: 3,
+                name: 'launchd-agent',
+                status: 'fail',
+                message: 'LaunchAgent plist exists but is not loaded',
+                fix_hint: 'cf daemon install',
+                fixable_by: 'cf fix',
+            };
+        }
+        if (s.state && s.state !== 'running' && s.state !== 'waiting') {
+            return {
+                id: 3,
+                name: 'launchd-agent',
+                status: 'warn',
+                message: `LaunchAgent loaded but state=${s.state}`,
+                fix_hint: 'cf daemon install',
+                fixable_by: 'cf fix',
+            };
+        }
+        return {
+            id: 3,
+            name: 'launchd-agent',
+            status: 'pass',
+            message: s.pid != null ? `LaunchAgent loaded (PID ${s.pid})` : 'LaunchAgent loaded',
+        };
+    }
+    catch (err) {
+        return {
+            id: 3,
+            name: 'launchd-agent',
+            status: 'warn',
+            message: 'LaunchAgent status unavailable',
+            details: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+// ─── Check 4: global hooks injected into ~/.claude/settings.json ──────────
+const REQUIRED_HOOK_NAMES = [
+    'pre-tool-use.sh',
+    'post-tool-use.sh',
+    'user-prompt-submit.sh',
+    'notification.sh',
+    'stop.sh',
+];
+export async function check4_hooksInjected(deps) {
+    const settingsPath = deps?.settingsPath ?? path.join(os.homedir(), '.claude', 'settings.json');
+    const readFile = deps?.readFile ?? defaultReadFile;
+    const raw = readFile(settingsPath);
+    if (raw == null) {
+        return {
+            id: 4,
+            name: 'hooks-injected',
+            status: 'fail',
+            message: '~/.claude/settings.json not found — hooks not injected',
+            fix_hint: 'cf init',
+            fixable_by: 'cf fix',
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return {
+            id: 4,
+            name: 'hooks-injected',
+            status: 'fail',
+            message: '~/.claude/settings.json is invalid JSON',
+            fix_hint: 'cf init',
+            fixable_by: 'cf fix',
+        };
+    }
+    const hooksBlock = parsed.hooks;
+    if (!hooksBlock || typeof hooksBlock !== 'object') {
+        return {
+            id: 4,
+            name: 'hooks-injected',
+            status: 'fail',
+            message: 'No hooks block found in settings.json',
+            fix_hint: 'cf init',
+            fixable_by: 'cf fix',
+        };
+    }
+    // Count distinct forge hook scripts referenced.
+    const flatCommands = JSON.stringify(hooksBlock);
+    const present = REQUIRED_HOOK_NAMES.filter((name) => flatCommands.includes(name));
+    if (present.length === 0) {
+        return {
+            id: 4,
+            name: 'hooks-injected',
+            status: 'fail',
+            message: 'No forge hooks present in settings.json',
+            fix_hint: 'cf init',
+            fixable_by: 'cf fix',
+        };
+    }
+    if (present.length < REQUIRED_HOOK_NAMES.length) {
+        return {
+            id: 4,
+            name: 'hooks-injected',
+            status: 'warn',
+            message: `Only ${present.length}/${REQUIRED_HOOK_NAMES.length} forge hooks present`,
+            details: `Missing: ${REQUIRED_HOOK_NAMES.filter((n) => !present.includes(n)).join(', ')}`,
+            fix_hint: 'cf init',
+            fixable_by: 'cf fix',
+        };
+    }
+    return {
+        id: 4,
+        name: 'hooks-injected',
+        status: 'pass',
+        message: `All ${REQUIRED_HOOK_NAMES.length} forge hooks injected`,
+    };
+}
+// ─── Check 5: project CLAUDE.md exists + has forge marker ─────────────────
+const FORGE_MARKERS = ['Claude Forge', 'claude-forge', 'forge-resume-body'];
+export async function check5_projectClaudemd(opts) {
+    // spec e5b845c4: explicit null = "no project context" (Web fresh install) →
+    // SKIP instead of FAILing against the daemon's cwd. undefined keeps the CLI
+    // behaviour (defaults to process.cwd()).
+    if (opts && opts.cwd === null) {
+        return {
+            id: 5,
+            name: 'project-claudemd',
+            status: 'skip',
+            message: 'No project context — open Claude Code in a project to enable this check',
+        };
+    }
+    const cwd = opts?.cwd ?? process.cwd();
+    const claudemd = path.join(cwd, 'CLAUDE.md');
+    if (!fs.existsSync(claudemd)) {
+        return {
+            id: 5,
+            name: 'project-claudemd',
+            status: 'fail',
+            message: 'CLAUDE.md missing in this project',
+            fix_hint: 'cf project init --skip-knowledge',
+            fixable_by: 'cf fix',
+        };
+    }
+    let content = '';
+    try {
+        content = fs.readFileSync(claudemd, 'utf-8');
+    }
+    catch (err) {
+        return {
+            id: 5,
+            name: 'project-claudemd',
+            status: 'fail',
+            message: 'CLAUDE.md exists but is unreadable',
+            details: err instanceof Error ? err.message : String(err),
+            fix_hint: 'cf project init --skip-knowledge',
+            fixable_by: 'cf fix',
+        };
+    }
+    const hasMarker = FORGE_MARKERS.some((m) => content.includes(m));
+    if (!hasMarker) {
+        return {
+            id: 5,
+            name: 'project-claudemd',
+            status: 'warn',
+            message: 'CLAUDE.md exists but no forge marker found',
+            fix_hint: 'cf project init --skip-knowledge',
+            fixable_by: 'cf fix',
+        };
+    }
+    return {
+        id: 5,
+        name: 'project-claudemd',
+        status: 'pass',
+        message: 'CLAUDE.md present with forge marker',
+    };
+}
+// ─── Check 6: .forge-knowledge/ skeleton complete ─────────────────────────
+export async function check6_projectKnowledge(opts) {
+    // spec e5b845c4: explicit null = "no project context" (Web fresh install) →
+    // SKIP. See check5_projectClaudemd for the same contract.
+    if (opts && opts.cwd === null) {
+        return {
+            id: 6,
+            name: 'project-knowledge',
+            status: 'skip',
+            message: 'No project context — open Claude Code in a project to enable this check',
+        };
+    }
+    const cwd = opts?.cwd ?? process.cwd();
+    const kbDir = path.join(cwd, '.forge-knowledge');
+    if (!fs.existsSync(kbDir)) {
+        return {
+            id: 6,
+            name: 'project-knowledge',
+            status: 'fail',
+            message: '.forge-knowledge/ directory missing',
+            fix_hint: 'cf knowledge init',
+            fixable_by: 'cf fix',
+        };
+    }
+    const meta = path.join(kbDir, '.meta.json');
+    const overview = path.join(kbDir, 'overview.md');
+    const missing = [];
+    if (!fs.existsSync(meta))
+        missing.push('.meta.json');
+    if (!fs.existsSync(overview))
+        missing.push('overview.md');
+    if (missing.length > 0) {
+        return {
+            id: 6,
+            name: 'project-knowledge',
+            status: 'warn',
+            message: '.forge-knowledge/ skeleton incomplete',
+            details: `Missing: ${missing.join(', ')}`,
+            fix_hint: 'cf knowledge init',
+            fixable_by: 'cf fix',
+        };
+    }
+    // Cross-check with project marker if present (spec 1 contract).
+    const marker = readProjectMarker(cwd);
+    if (marker && marker.steps.knowledge !== 'ok') {
+        return {
+            id: 6,
+            name: 'project-knowledge',
+            status: 'warn',
+            message: `Project marker reports knowledge step = ${marker.steps.knowledge}`,
+            fix_hint: 'cf knowledge init',
+            fixable_by: 'cf fix',
+        };
+    }
+    return {
+        id: 6,
+        name: 'project-knowledge',
+        status: 'pass',
+        message: '.forge-knowledge/ healthy',
+    };
+}
+export async function check7_dbIntegrity(deps) {
+    const dbPath = deps?.dbPath ?? FORGE_PATHS.database();
+    if (!fs.existsSync(dbPath)) {
+        return {
+            id: 7,
+            name: 'db-integrity',
+            status: 'fail',
+            message: 'SQLite database file does not exist',
+            details: `Expected: ${dbPath}`,
+            fix_hint: 'Start the daemon to initialize the DB: cf daemon ensure-running',
+            fixable_by: 'manual',
+        };
+    }
+    let DB;
+    try {
+        if (deps?.load) {
+            DB = await deps.load();
+        }
+        else {
+            const mod = await import('better-sqlite3');
+            DB = mod.default;
+        }
+    }
+    catch (err) {
+        return {
+            id: 7,
+            name: 'db-integrity',
+            status: 'fail',
+            message: 'Could not load better-sqlite3 driver',
+            details: err instanceof Error ? err.message : String(err),
+            fixable_by: 'manual',
+        };
+    }
+    try {
+        const db = new DB(dbPath, { readonly: true });
+        try {
+            const row = db.pragma('integrity_check', { simple: true });
+            const sizeMb = Math.round(fs.statSync(dbPath).size / (1024 * 1024));
+            if (row !== 'ok') {
+                return {
+                    id: 7,
+                    name: 'db-integrity',
+                    status: 'fail',
+                    message: `SQLite integrity_check returned: ${row}`,
+                    fix_hint: 'Backup DB then run `cf init` to rebuild',
+                    fixable_by: 'manual',
+                };
+            }
+            if (sizeMb > 500) {
+                return {
+                    id: 7,
+                    name: 'db-integrity',
+                    status: 'warn',
+                    message: `Integrity OK but DB is large (${sizeMb} MB)`,
+                    fix_hint: 'Run storage vacuum or rotate archives',
+                    fixable_by: 'manual',
+                };
+            }
+            return {
+                id: 7,
+                name: 'db-integrity',
+                status: 'pass',
+                message: `SQLite integrity_check: ok (size: ${sizeMb} MB)`,
+            };
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (err) {
+        return {
+            id: 7,
+            name: 'db-integrity',
+            status: 'fail',
+            message: 'SQLite integrity check threw',
+            details: err instanceof Error ? err.message : String(err),
+            fix_hint: 'Backup DB then run `cf init` to rebuild',
+            fixable_by: 'manual',
+        };
+    }
+}
+// ─── Check 8: config.yaml has no deprecated sections ──────────────────────
+const DEPRECATED_KEYS = ['ai', 'skill_matching', 'distill'];
+export async function check8_configYaml(deps) {
+    const configPath = deps?.configPath ?? FORGE_PATHS.config();
+    const readFile = deps?.readFile ?? defaultReadFile;
+    const raw = readFile(configPath);
+    if (raw == null) {
+        return {
+            id: 8,
+            name: 'config-yaml',
+            status: 'pass',
+            message: 'No config.yaml on disk (defaults in effect)',
+        };
+    }
+    // Light-touch parse: look for top-level deprecated keys via line regex.
+    // Avoids pulling in yaml just to detect a handful of keys.
+    const found = [];
+    for (const key of DEPRECATED_KEYS) {
+        const re = new RegExp(`^${key}\\s*:`, 'm');
+        if (re.test(raw))
+            found.push(key);
+    }
+    // Quick YAML syntax probe: require either empty or '---' / 'key:' at root.
+    // If the file has no `:` at all, the user wrote freeform text by mistake.
+    if (raw.trim().length > 0 && !/:/m.test(raw)) {
+        return {
+            id: 8,
+            name: 'config-yaml',
+            status: 'fail',
+            message: 'config.yaml does not look like YAML (no key: value)',
+            fix_hint: 'Restore from backup or delete to use defaults',
+            fixable_by: 'manual',
+        };
+    }
+    if (found.length === 0) {
+        return {
+            id: 8,
+            name: 'config-yaml',
+            status: 'pass',
+            message: 'No deprecated keys in config.yaml',
+        };
+    }
+    return {
+        id: 8,
+        name: 'config-yaml',
+        status: 'warn',
+        message: `Deprecated keys present (silently ignored): ${found.join(', ')}`,
+        fix_hint: `Remove the ${found.join(' / ')} block from ${configPath}`,
+        fixable_by: 'manual',
+    };
+}
+export async function check9_recentActivity(deps) {
+    const dbPath = deps?.dbPath ?? FORGE_PATHS.database();
+    const now = deps?.now ?? Date.now;
+    if (!fs.existsSync(dbPath)) {
+        return {
+            id: 9,
+            name: 'recent-activity',
+            status: 'fail',
+            message: 'DB not present — no activity to read',
+            fix_hint: 'Start daemon and use Claude Code to generate events',
+            fixable_by: 'manual',
+        };
+    }
+    let DB;
+    try {
+        if (deps?.load) {
+            DB = await deps.load();
+        }
+        else {
+            const mod = await import('better-sqlite3');
+            DB = mod.default;
+        }
+    }
+    catch (err) {
+        return {
+            id: 9,
+            name: 'recent-activity',
+            status: 'warn',
+            message: 'Could not load DB driver to read activity',
+            details: err instanceof Error ? err.message : String(err),
+            fixable_by: 'manual',
+        };
+    }
+    const cutoffMs = now() - 7 * 24 * 60 * 60 * 1000;
+    const cutoffIso = new Date(cutoffMs).toISOString();
+    try {
+        const db = new DB(dbPath, { readonly: true });
+        try {
+            const eventsCount = countRecent(db, 'events', 'timestamp', cutoffIso);
+            // routing_events 用 `ts` INTEGER (unix millis), 不是 `timestamp` TEXT
+            const routingCount = countRecentMs(db, 'routing_events', 'ts', cutoffMs);
+            if (eventsCount === 0 && routingCount === 0) {
+                return {
+                    id: 9,
+                    name: 'recent-activity',
+                    status: 'fail',
+                    message: 'No events or routing entries in last 7 days',
+                    fix_hint: 'Verify daemon is receiving hooks and Claude Code is active',
+                    fixable_by: 'manual',
+                };
+            }
+            if (eventsCount > 0 && routingCount === 0) {
+                return {
+                    id: 9,
+                    name: 'recent-activity',
+                    status: 'warn',
+                    message: `events=${eventsCount}, routing_events=0 (last 7d)`,
+                    details: 'No routing events — agent delegation may be misconfigured',
+                    fixable_by: 'manual',
+                };
+            }
+            return {
+                id: 9,
+                name: 'recent-activity',
+                status: 'pass',
+                message: `events=${eventsCount}, routing_events=${routingCount} (last 7d)`,
+            };
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (err) {
+        return {
+            id: 9,
+            name: 'recent-activity',
+            status: 'warn',
+            message: 'Activity query failed',
+            details: err instanceof Error ? err.message : String(err),
+            fixable_by: 'manual',
+        };
+    }
+}
+function countRecent(db, table, tsCol, cutoffIso) {
+    try {
+        const stmt = db.prepare(`SELECT COUNT(*) AS n FROM ${table} WHERE ${tsCol} >= ?`);
+        const row = stmt.get(cutoffIso);
+        return row?.n ?? 0;
+    }
+    catch {
+        // Table may not exist on a fresh DB.
+        return 0;
+    }
+}
+function countRecentMs(db, table, tsCol, cutoffMs) {
+    try {
+        const stmt = db.prepare(`SELECT COUNT(*) AS n FROM ${table} WHERE ${tsCol} >= ?`);
+        const row = stmt.get(cutoffMs);
+        return row?.n ?? 0;
+    }
+    catch {
+        return 0;
+    }
+}
+// ─── Aggregator ───────────────────────────────────────────────────────────
+const ALL_CHECKS = [
+    { id: 1, fn: async (o) => check1_daemonProcess({ selfMode: o?.selfMode ?? false }) },
+    { id: 2, fn: async () => check2_daemonSocket() },
+    { id: 3, fn: async (o) => check3_launchdAgent({ platform: o?.platform ?? process.platform }) },
+    { id: 4, fn: async () => check4_hooksInjected() },
+    { id: 5, fn: async (o) => check5_projectClaudemd({ cwd: o?.cwd }) },
+    { id: 6, fn: async (o) => check6_projectKnowledge({ cwd: o?.cwd }) },
+    { id: 7, fn: async () => check7_dbIntegrity() },
+    { id: 8, fn: async () => check8_configYaml() },
+    { id: 9, fn: async () => check9_recentActivity() },
+    // Entropy checks 10–12 (spec f3dc1397). Warn-only, never fixable by `cf fix`
+    // (intentionally absent from FIXABLE_COMMANDS so cleanup stays manual).
+    // For project-scoped check 11, route `cwd` through as docsRoot so it scans
+    // the active project's docs/design (Web fresh-install passes null → cwd()).
+    { id: 10, fn: async () => check10_staleDecisions() },
+    {
+        id: 11,
+        fn: async (o) => check11_staleSpecs({ docsRoot: o?.cwd ?? undefined }),
+    },
+    { id: 12, fn: async () => check12_orphanEvents() },
+];
+export async function runChecks(opts) {
+    const filter = opts?.ids;
+    const checks = filter && filter.length > 0
+        ? ALL_CHECKS.filter((c) => filter.includes(c.id))
+        : ALL_CHECKS;
+    const results = [];
+    for (const c of checks) {
+        try {
+            // Per-check 10s soft timeout so a hung check doesn't stall the report.
+            const result = await withTimeout(c.fn(opts), 10_000, () => ({
+                id: c.id,
+                name: `check-${c.id}`,
+                status: 'warn',
+                message: 'Check timed out (>10s)',
+            }));
+            results.push(result);
+        }
+        catch (err) {
+            results.push({
+                id: c.id,
+                name: `check-${c.id}`,
+                status: 'fail',
+                message: 'Check threw',
+                details: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return results;
+}
+export function summarize(checks) {
+    const out = { pass: 0, warn: 0, fail: 0, skip: 0, fixable: 0 };
+    for (const c of checks) {
+        out[c.status]++;
+        if (c.fixable_by === 'cf fix' && c.status !== 'pass' && c.status !== 'skip') {
+            out.fixable++;
+        }
+    }
+    return out;
+}
+export async function runDoctorReport(opts) {
+    const checks = await runChecks(opts);
+    return {
+        summary: summarize(checks),
+        checks,
+        generated_at: new Date().toISOString(),
+    };
+}
+// ─── helpers ─────────────────────────────────────────────────────────────
+function withTimeout(p, ms, onTimeout) {
+    return new Promise((resolve, reject) => {
+        let done = false;
+        const timer = setTimeout(() => {
+            if (done)
+                return;
+            done = true;
+            resolve(onTimeout());
+        }, ms);
+        p.then((val) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            resolve(val);
+        }, (err) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+//# sourceMappingURL=checks.js.map