moflo 4.9.12 → 4.9.14

package/dist/src/cli/commands/doctor-checks-runtime.js

@@ -0,0 +1,170 @@
+/**
+ * Quick runtime environment checks for `flo doctor`:
+ * Node.js, npm, Claude Code CLI, git, disk space, TypeScript build tool.
+ *
+ * These checks call external binaries via the shared `runCommand` helper that
+ * inherits the full process env (critical on Windows where PATH may not be
+ * inherited properly across child shells).
+ */
+import { execSync, exec } from 'child_process';
+import { promisify } from 'util';
+import { errorDetail } from '../shared/utils/error-detail.js';
+import { output } from '../output.js';
+const execAsync = promisify(exec);
+/**
+ * Execute command asynchronously with proper environment inheritance.
+ * Critical for Windows where PATH may not be inherited properly.
+ */
+export async function runCommand(command, timeoutMs = 5000) {
+    const opts = {
+        encoding: 'utf8',
+        timeout: timeoutMs,
+        shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/sh',
+        env: { ...process.env },
+        windowsHide: true,
+    };
+    const { stdout } = await execAsync(command, opts);
+    const out = stdout.trim();
+    // Windows parallel exec occasionally returns empty stdout under shell contention — retry once serially
+    if (!out && process.platform === 'win32') {
+        const retry = await execAsync(command, opts);
+        return retry.stdout.trim();
+    }
+    return out;
+}
+export async function checkNodeVersion() {
+    const requiredMajor = 20;
+    const version = process.version;
+    const major = parseInt(version.slice(1).split('.')[0], 10);
+    if (major >= requiredMajor) {
+        return { name: 'Node.js Version', status: 'pass', message: `${version} (>= ${requiredMajor} required)` };
+    }
+    else if (major >= 18) {
+        return { name: 'Node.js Version', status: 'warn', message: `${version} (>= ${requiredMajor} recommended)`, fix: 'nvm install 20 && nvm use 20' };
+    }
+    return { name: 'Node.js Version', status: 'fail', message: `${version} (>= ${requiredMajor} required)`, fix: 'nvm install 20 && nvm use 20' };
+}
+export async function checkNpmVersion() {
+    try {
+        const version = await runCommand('npm --version');
+        const major = parseInt(version.split('.')[0], 10);
+        if (major >= 9) {
+            return { name: 'npm Version', status: 'pass', message: `v${version}` };
+        }
+        return { name: 'npm Version', status: 'warn', message: `v${version} (>= 9 recommended)`, fix: 'npm install -g npm@latest' };
+    }
+    catch {
+        return { name: 'npm Version', status: 'fail', message: 'npm not found', fix: 'Install Node.js from https://nodejs.org' };
+    }
+}
+export async function checkGit() {
+    try {
+        const version = await runCommand('git --version');
+        return { name: 'Git', status: 'pass', message: version.replace('git version ', 'v') };
+    }
+    catch (e) {
+        return { name: 'Git', status: 'warn', message: `Not installed (${errorDetail(e, { firstLineOnly: true })})`, fix: 'Install git from https://git-scm.com' };
+    }
+}
+export async function checkGitRepo() {
+    try {
+        await runCommand('git rev-parse --git-dir');
+        return { name: 'Git Repository', status: 'pass', message: 'In a git repository' };
+    }
+    catch (e) {
+        return { name: 'Git Repository', status: 'warn', message: `Not a git repository (${errorDetail(e, { firstLineOnly: true })})`, fix: 'git init' };
+    }
+}
+export async function checkDiskSpace() {
+    try {
+        if (process.platform === 'win32') {
+            try {
+                const driveLetter = process.cwd().match(/^([A-Z]):/i)?.[1]?.toUpperCase() || 'C';
+                const psOutput = await runCommand(`powershell -NoProfile -Command "Get-PSDrive ${driveLetter} | Select-Object -ExpandProperty Free; Get-PSDrive ${driveLetter} | Select-Object -ExpandProperty Used"`);
+                const vals = psOutput.split(/\r?\n/).filter(l => l.trim());
+                const freeBytes = parseInt(vals[0] || '0', 10);
+                const usedBytes = parseInt(vals[1] || '0', 10);
+                const totalBytes = freeBytes + usedBytes || 1;
+                const freeGB = (freeBytes / (1024 ** 3)).toFixed(1);
+                const usePercent = Math.round(((totalBytes - freeBytes) / totalBytes) * 100);
+                if (usePercent > 90) {
+                    return { name: 'Disk Space', status: 'fail', message: `${freeGB}G available (${usePercent}% used)`, fix: 'Free up disk space' };
+                }
+                if (usePercent > 80) {
+                    return { name: 'Disk Space', status: 'warn', message: `${freeGB}G available (${usePercent}% used)` };
+                }
+                return { name: 'Disk Space', status: 'pass', message: `${freeGB}G available` };
+            }
+            catch {
+                return { name: 'Disk Space', status: 'pass', message: 'Check skipped (PowerShell unavailable)' };
+            }
+        }
+        // Use df -Ph for POSIX mode (guarantees single-line output even with long device names)
+        const output_str = await runCommand('df -Ph . | tail -1');
+        const parts = output_str.split(/\s+/);
+        const available = parts[3];
+        const usePercent = parseInt(parts[4]?.replace('%', '') || '0', 10);
+        if (isNaN(usePercent)) {
+            return { name: 'Disk Space', status: 'warn', message: `${available || 'unknown'} available (unable to parse usage)` };
+        }
+        if (usePercent > 90) {
+            return { name: 'Disk Space', status: 'fail', message: `${available} available (${usePercent}% used)`, fix: 'Free up disk space' };
+        }
+        if (usePercent > 80) {
+            return { name: 'Disk Space', status: 'warn', message: `${available} available (${usePercent}% used)` };
+        }
+        return { name: 'Disk Space', status: 'pass', message: `${available} available` };
+    }
+    catch (e) {
+        return { name: 'Disk Space', status: 'warn', message: `Unable to check: ${errorDetail(e, { firstLineOnly: true })}` };
+    }
+}
+export async function checkBuildTools() {
+    try {
+        const tscVersion = await runCommand('npx tsc --version', 10000); // tsc can be slow
+        if (!tscVersion || tscVersion.includes('not found')) {
+            return { name: 'TypeScript', status: 'warn', message: 'Not installed locally', fix: 'npm install -D typescript' };
+        }
+        return { name: 'TypeScript', status: 'pass', message: tscVersion.replace('Version ', 'v') };
+    }
+    catch (e) {
+        return { name: 'TypeScript', status: 'warn', message: `Not installed locally (${errorDetail(e, { firstLineOnly: true })})`, fix: 'npm install -D typescript' };
+    }
+}
+export async function checkClaudeCode() {
+    try {
+        const version = await runCommand('claude --version');
+        const versionMatch = version.match(/v?(\d+\.\d+\.\d+)/);
+        const versionStr = versionMatch ? `v${versionMatch[1]}` : version;
+        return { name: 'Claude Code CLI', status: 'pass', message: versionStr };
+    }
+    catch (e) {
+        return {
+            name: 'Claude Code CLI',
+            status: 'warn',
+            message: `Not installed (${errorDetail(e, { firstLineOnly: true })})`,
+            fix: 'npm install -g @anthropic-ai/claude-code',
+        };
+    }
+}
+export async function installClaudeCode() {
+    try {
+        output.writeln();
+        output.writeln(output.bold('Installing Claude Code CLI...'));
+        execSync('npm install -g @anthropic-ai/claude-code', {
+            encoding: 'utf8',
+            stdio: 'inherit',
+            windowsHide: true,
+        });
+        output.writeln(output.success('Claude Code CLI installed successfully!'));
+        return true;
+    }
+    catch (error) {
+        output.writeln(output.error('Failed to install Claude Code CLI'));
+        if (error instanceof Error) {
+            output.writeln(output.dim(error.message));
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=doctor-checks-runtime.js.map

package/dist/src/cli/commands/doctor-fixes.js

@@ -0,0 +1,165 @@
+/**
+ * Auto-fix dispatch for `flo doctor --fix`.
+ *
+ * Maps each named HealthCheck to a programmatic fix function (preferred over
+ * shell-out where possible). Falls back to running the check's `fix` string
+ * if it looks like an `npx`/`npm`/`claude` command.
+ */
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { output } from '../output.js';
+import { errorDetail } from '../shared/utils/error-detail.js';
+import { repairHookWiring } from '../services/hook-wiring.js';
+import { findZombieProcesses } from './doctor-zombies.js';
+import { installClaudeCode, runCommand } from './doctor-checks-runtime.js';
+/** Run a shell command as a fix action. Returns true on exit code 0. */
+async function runFixCommand(cmd) {
+    try {
+        await runCommand(cmd, 30_000);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Fix missing hook wiring in settings.json by patching in entries for any
+ * REQUIRED_HOOK_WIRING patterns that aren't present. Delegates to shared
+ * repairHookWiring() to stay DRY with the upgrade path.
+ */
+async function fixGateHealthHooks() {
+    const settingsPath = join(process.cwd(), '.claude', 'settings.json');
+    if (!existsSync(settingsPath))
+        return false;
+    try {
+        const raw = readFileSync(settingsPath, 'utf8');
+        const settings = JSON.parse(raw);
+        const { repaired } = repairHookWiring(settings);
+        if (repaired.length === 0)
+            return true; // nothing to fix
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Execute the fix for a failed/warned health check.
+ * Returns true if the fix succeeded (re-check should pass).
+ */
+export async function autoFixCheck(check) {
+    if (!check.fix)
+        return false;
+    // Map checks to programmatic fixes (not just shell commands)
+    const fixActions = {
+        'Memory Database': async () => {
+            try {
+                const swarmDir = join(process.cwd(), '.swarm');
+                if (!existsSync(swarmDir))
+                    mkdirSync(swarmDir, { recursive: true });
+                const { initializeMemoryDatabase } = await import('../memory/memory-initializer.js');
+                const result = await initializeMemoryDatabase({ force: true, verbose: false });
+                return result.success;
+            }
+            catch {
+                return runFixCommand('npx moflo memory init --force');
+            }
+        },
+        'Embeddings': async () => {
+            try {
+                const swarmDir = join(process.cwd(), '.swarm');
+                if (!existsSync(swarmDir))
+                    mkdirSync(swarmDir, { recursive: true });
+                const dbPath = join(swarmDir, 'memory.db');
+                if (!existsSync(dbPath)) {
+                    const { initializeMemoryDatabase } = await import('../memory/memory-initializer.js');
+                    await initializeMemoryDatabase({ force: true, verbose: false });
+                }
+                return runFixCommand('npx moflo embeddings init --force');
+            }
+            catch {
+                return runFixCommand('npx moflo memory init --force');
+            }
+        },
+        'Config File': async () => {
+            try {
+                const cfDir = join(process.cwd(), '.moflo');
+                if (!existsSync(cfDir))
+                    mkdirSync(cfDir, { recursive: true });
+                return runFixCommand('npx moflo config init');
+            }
+            catch {
+                return false;
+            }
+        },
+        'Daemon Status': async () => {
+            const lockFile = join(process.cwd(), '.moflo', 'daemon.lock');
+            const pidFile = join(process.cwd(), '.moflo', 'daemon.pid');
+            try {
+                if (existsSync(lockFile))
+                    unlinkSync(lockFile);
+                if (existsSync(pidFile))
+                    unlinkSync(pidFile);
+            }
+            catch { /* best effort */ }
+            return runFixCommand('npx moflo daemon start');
+        },
+        'MCP Servers': async () => {
+            return runFixCommand('claude mcp add moflo -- npx -y moflo mcp start');
+        },
+        'Claude Code CLI': async () => {
+            return installClaudeCode();
+        },
+        'Zombie Processes': async () => {
+            const result = await findZombieProcesses(true);
+            return result.killed > 0 || result.details.length === 0;
+        },
+        'Gate Health': async () => {
+            return fixGateHealthHooks();
+        },
+        'Status Line': async () => {
+            const settingsPath = join(process.cwd(), '.claude', 'settings.json');
+            if (!existsSync(settingsPath))
+                return false;
+            try {
+                const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+                if (!settings.statusLine) {
+                    settings.statusLine = {
+                        type: 'command',
+                        command: 'node "$CLAUDE_PROJECT_DIR/.claude/helpers/statusline.cjs" --compact',
+                    };
+                    writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+                }
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+    const fixFn = fixActions[check.name];
+    if (fixFn) {
+        try {
+            output.writeln(output.dim(`  Fixing: ${check.name}...`));
+            const success = await fixFn();
+            if (success) {
+                output.writeln(output.success(`  Fixed: ${check.name}`));
+            }
+            else {
+                output.writeln(output.warning(`  Fix attempted but may need manual action: ${check.fix}`));
+            }
+            return success;
+        }
+        catch (e) {
+            output.writeln(output.warning(`  Fix failed: ${errorDetail(e)}`));
+            return false;
+        }
+    }
+    // Generic: try running the fix command directly if it looks like a shell command
+    if (check.fix.startsWith('npx ') || check.fix.startsWith('npm ') || check.fix.startsWith('claude ')) {
+        return runFixCommand(check.fix);
+    }
+    return false;
+}
+//# sourceMappingURL=doctor-fixes.js.map

package/dist/src/cli/commands/doctor-registry.js

@@ -0,0 +1,109 @@
+/**
+ * Doctor check registry: ordered list and component-name lookup.
+ *
+ * Kept separate from `doctor.ts` so the orchestration file stays small and the
+ * registry can be inspected/extended without re-touching command-action code.
+ */
+import { checkSubagentHealth, checkSpellExecution, checkMcpToolInvocation, checkHookExecution, checkMcpSpellIntegration, checkGateHealth, checkHookBlockDrift, checkMofloDbBridge, } from './doctor-checks-deep.js';
+import { checkEmbeddingHygiene } from './doctor-embedding-hygiene.js';
+import { checkSwarmFunctional, checkHiveMindFunctional, } from './doctor-checks-swarm.js';
+import { checkMemoryAccessFunctional } from './doctor-checks-memory-access.js';
+import { checkBuildTools, checkClaudeCode, checkDiskSpace, checkGit, checkGitRepo, checkNodeVersion, checkNpmVersion, } from './doctor-checks-runtime.js';
+import { checkConfigFile, checkDaemonStatus, checkMcpServers, checkMemoryDatabase, checkMofloYamlCompliance, checkStatusLine, checkTestDirs, } from './doctor-checks-config.js';
+import { checkSpellEngine, checkSandboxTier } from './doctor-checks-platform.js';
+import { checkEmbeddings, checkSemanticQuality, } from './doctor-checks-memory.js';
+import { checkIntelligence } from './doctor-checks-intelligence.js';
+import { checkVersionFreshness } from './doctor-version.js';
+import { checkZombieProcesses } from './doctor-zombies.js';
+/** Order matters — top entries surface first under the spinner. */
+export const allChecks = [
+    checkVersionFreshness,
+    checkNodeVersion,
+    checkNpmVersion,
+    checkClaudeCode,
+    checkGit,
+    checkGitRepo,
+    checkConfigFile,
+    checkMofloYamlCompliance,
+    checkStatusLine,
+    checkDaemonStatus,
+    checkMemoryDatabase,
+    checkEmbeddings,
+    checkEmbeddingHygiene,
+    checkTestDirs,
+    checkMcpServers,
+    checkDiskSpace,
+    checkBuildTools,
+    checkSemanticQuality,
+    checkIntelligence,
+    checkSpellEngine,
+    checkZombieProcesses,
+    checkSubagentHealth,
+    checkSpellExecution,
+    checkMcpToolInvocation,
+    checkMcpSpellIntegration,
+    checkHookExecution,
+    checkGateHealth,
+    checkHookBlockDrift,
+    checkMofloDbBridge,
+    // Issue #818 / epic #798 — coordinator-path tripwires. They share the
+    // singleton coordinator with checkSubagentHealth above and assert by
+    // agent-id (not absolute counts) so they tolerate the parallel batch.
+    checkSwarmFunctional,
+    checkHiveMindFunctional,
+    // Issue #844 — memory_store + memory_search round-trip across subagent,
+    // swarm-agent, and hive-mind contexts.
+    checkMemoryAccessFunctional,
+    checkSandboxTier,
+];
+/** Lookup table for `flo doctor -c <name>`. */
+export const componentMap = {
+    'version': checkVersionFreshness,
+    'freshness': checkVersionFreshness,
+    'node': checkNodeVersion,
+    'npm': checkNpmVersion,
+    'claude': checkClaudeCode,
+    'config': checkConfigFile,
+    'yaml': checkMofloYamlCompliance,
+    'moflo-yaml': checkMofloYamlCompliance,
+    'statusline': checkStatusLine,
+    'status-line': checkStatusLine,
+    'daemon': checkDaemonStatus,
+    'memory': checkMemoryDatabase,
+    'embeddings': checkEmbeddings,
+    'embedding-hygiene': checkEmbeddingHygiene,
+    'hygiene': checkEmbeddingHygiene,
+    'git': checkGit,
+    'mcp': checkMcpServers,
+    'disk': checkDiskSpace,
+    'typescript': checkBuildTools,
+    'tests': checkTestDirs,
+    'semantic': checkSemanticQuality,
+    'quality': checkSemanticQuality,
+    'intelligence': checkIntelligence,
+    'workflows': checkSpellEngine,
+    'workflow': checkSpellEngine,
+    'subagent': checkSubagentHealth,
+    'subagents': checkSubagentHealth,
+    'agents': checkSubagentHealth,
+    'spell-exec': checkSpellExecution,
+    'mcp-tools': checkMcpToolInvocation,
+    'mcp-spell': checkMcpSpellIntegration,
+    'hooks': checkHookExecution,
+    'gates': checkGateHealth,
+    'gate': checkGateHealth,
+    'hook-drift': checkHookBlockDrift,
+    'drift': checkHookBlockDrift,
+    'sandbox': checkSandboxTier,
+    'sandbox-tier': checkSandboxTier,
+    'moflodb': checkMofloDbBridge,
+    'bridge': checkMofloDbBridge,
+    'swarm': checkSwarmFunctional,
+    'swarm-functional': checkSwarmFunctional,
+    'hive': checkHiveMindFunctional,
+    'hive-mind': checkHiveMindFunctional,
+    'hive-mind-functional': checkHiveMindFunctional,
+    'memory-access': checkMemoryAccessFunctional,
+    'memory-functional': checkMemoryAccessFunctional,
+};
+//# sourceMappingURL=doctor-registry.js.map

package/dist/src/cli/commands/doctor-render.js

@@ -0,0 +1,203 @@
+/**
+ * Output rendering helpers for `flo doctor`:
+ * formatted summary, JSON output, auto-fix loop, kill-zombies banner.
+ */
+import { output } from '../output.js';
+import { autoFixCheck } from './doctor-fixes.js';
+import { checkClaudeCode, installClaudeCode } from './doctor-checks-runtime.js';
+import { findZombieProcesses, formatZombieDetail, killTrackedProcesses, } from './doctor-zombies.js';
+export function formatCheck(check) {
+    const icon = check.status === 'pass' ? output.success('✓') :
+        check.status === 'warn' ? output.warning('⚠') :
+            output.error('✗');
+    return `${icon} ${check.name}: ${check.message}`;
+}
+function tally(results) {
+    return {
+        passed: results.filter(r => r.status === 'pass').length,
+        warnings: results.filter(r => r.status === 'warn').length,
+        failed: results.filter(r => r.status === 'fail').length,
+    };
+}
+export async function runKillZombiesBanner() {
+    output.writeln(output.bold('Zombie Process Scan'));
+    output.writeln();
+    const registryKilled = killTrackedProcesses();
+    if (registryKilled > 0) {
+        output.writeln(output.success(`  Killed ${registryKilled} tracked background process(es) from registry`));
+    }
+    // Single OS-level scan + kill — the previous flow scanned twice.
+    const result = await findZombieProcesses(true);
+    const found = result.details.length;
+    if (found === 0) {
+        if (registryKilled === 0) {
+            output.writeln(output.success('  No orphaned moflo processes found'));
+        }
+    }
+    else {
+        output.writeln(output.warning(`  Found ${found} additional orphaned process(es):`));
+        for (const d of result.details) {
+            output.writeln(output.dim(`    ${formatZombieDetail(d)}`));
+        }
+        if (result.killed > 0) {
+            output.writeln(output.success(`  Killed ${result.killed} zombie process(es)`));
+        }
+        if (result.killed < found) {
+            output.writeln(output.warning(`  ${found - result.killed} process(es) could not be killed`));
+        }
+    }
+    output.writeln();
+    output.writeln(output.dim('─'.repeat(50)));
+    output.writeln();
+}
+/**
+ * Issue #818: machine-readable output. Emits a single JSON document with
+ * per-check fields (and any FunctionalCheckDetail entries from the swarm/
+ * hive checks) and exits with the right code. Skips auto-fix entirely —
+ * --json is read-only by intent so CI gates can consume it without
+ * mutating the working tree.
+ */
+export function emitJsonOutput({ results, strict, allowWarnList }) {
+    const { passed, warnings, failed } = tally(results);
+    const allowSet = new Set(allowWarnList);
+    const strictWarningFailures = strict
+        ? results.filter(r => r.status === 'warn' && !allowSet.has(r.name)).map(r => r.name)
+        : [];
+    const exitCode = failed > 0 || strictWarningFailures.length > 0 ? 1 : 0;
+    process.stdout.write(JSON.stringify({
+        summary: { passed, warnings, failed },
+        strict: strict ? { strictMode: true, warningsTriggeringFail: strictWarningFailures } : { strictMode: false },
+        results,
+    }, null, 2) + '\n');
+    return { success: exitCode === 0, exitCode, data: { passed, warnings, failed, results } };
+}
+/** Re-runs Claude Code CLI install + check if --install was passed and the prior result wasn't pass. */
+export async function maybeAutoInstallClaudeCode(results, fixes) {
+    const claudeCodeResult = results.find(r => r.name === 'Claude Code CLI');
+    if (!claudeCodeResult || claudeCodeResult.status === 'pass')
+        return;
+    const installed = await installClaudeCode();
+    if (!installed)
+        return;
+    const newCheck = await checkClaudeCode();
+    const idx = results.findIndex(r => r.name === 'Claude Code CLI');
+    if (idx !== -1) {
+        results[idx] = newCheck;
+        const fixIdx = fixes.findIndex(f => f.startsWith('Claude Code CLI:'));
+        if (fixIdx !== -1 && newCheck.status === 'pass') {
+            fixes.splice(fixIdx, 1);
+        }
+    }
+    output.writeln(formatCheck(newCheck));
+}
+export function renderSummary(results) {
+    const counts = tally(results);
+    output.writeln();
+    output.writeln(output.dim('─'.repeat(50)));
+    output.writeln();
+    const summaryParts = [
+        output.success(`${counts.passed} passed`),
+        counts.warnings > 0 ? output.warning(`${counts.warnings} warnings`) : null,
+        counts.failed > 0 ? output.error(`${counts.failed} failed`) : null,
+    ].filter(Boolean);
+    output.writeln(`Summary: ${summaryParts.join(', ')}`);
+    return counts;
+}
+/** Auto-fix loop, including the post-fix re-run. Mutates `results` and `fixes` in place when fixes succeed. */
+export async function runAutoFix(results, fixes, checksToRun) {
+    if (fixes.length === 0)
+        return;
+    output.writeln();
+    output.writeln(output.bold('Auto-fixing issues...'));
+    output.writeln();
+    const fixableResults = results.filter(r => r.fix && (r.status === 'fail' || r.status === 'warn'));
+    let fixed = 0;
+    const unfixed = [];
+    for (const check of fixableResults) {
+        const success = await autoFixCheck(check);
+        if (success) {
+            fixed++;
+        }
+        else {
+            unfixed.push(`${check.name}: ${check.fix}`);
+        }
+    }
+    if (fixed > 0) {
+        output.writeln();
+        output.writeln(output.success(`Auto-fixed ${fixed} issue${fixed > 1 ? 's' : ''}`));
+    }
+    if (unfixed.length > 0) {
+        output.writeln();
+        output.writeln(output.bold('Manual fixes needed:'));
+        for (const fix of unfixed) {
+            output.writeln(output.dim(`  ${fix}`));
+        }
+    }
+    if (fixed === 0)
+        return;
+    output.writeln();
+    output.writeln(output.dim('Re-checking...'));
+    output.writeln();
+    const reResults = await Promise.allSettled(checksToRun.map(check => check()));
+    let rePassed = 0, reWarnings = 0, reFailed = 0;
+    for (const sr of reResults) {
+        if (sr.status === 'fulfilled') {
+            output.writeln(formatCheck(sr.value));
+            if (sr.value.status === 'pass')
+                rePassed++;
+            else if (sr.value.status === 'warn')
+                reWarnings++;
+            else
+                reFailed++;
+        }
+    }
+    output.writeln();
+    output.writeln(output.dim('─'.repeat(50)));
+    const reSummary = [
+        output.success(`${rePassed} passed`),
+        reWarnings > 0 ? output.warning(`${reWarnings} warnings`) : null,
+        reFailed > 0 ? output.error(`${reFailed} failed`) : null,
+    ].filter(Boolean);
+    output.writeln(`After fix: ${reSummary.join(', ')}`);
+}
+/**
+ * Build the final CommandResult based on pass/warn/fail counts and --strict
+ * mode. Issue #784: in strict mode any non-allowlisted warning fails the run.
+ * Equality (not substring) match — an allowlist entry tolerates exactly that
+ * check, never accidentally suppresses neighboring checks like "Git"
+ * allowlisting "Git Repository".
+ */
+export function finalize({ results, strict, allowWarnList }) {
+    const { passed, warnings, failed } = tally(results);
+    if (failed > 0) {
+        output.writeln();
+        output.writeln(output.error('Some checks failed. Please address the issues above.'));
+        return { success: false, exitCode: 1, data: { passed, warnings, failed, results } };
+    }
+    if (warnings > 0) {
+        if (strict) {
+            const warnResults = results.filter((r) => r.status === 'warn');
+            const allowSet = new Set(allowWarnList);
+            const offending = warnResults.filter((r) => !r.name || !allowSet.has(r.name));
+            if (offending.length > 0) {
+                output.writeln();
+                output.writeln(output.error(`--strict: ${offending.length} warning${offending.length > 1 ? 's' : ''} not allowlisted ` +
+                    `(use --allow-warn "<name>,<name>" to tolerate intentional warnings):`));
+                for (const r of offending) {
+                    output.writeln(output.error(`  ✗ ${r.name}: ${r.message ?? ''}`));
+                }
+                return { success: false, exitCode: 1, data: { passed, warnings, failed, results } };
+            }
+            output.writeln();
+            output.writeln(output.success(`--strict: ${warnResults.length} warning${warnResults.length > 1 ? 's' : ''} all allowlisted (--allow-warn).`));
+            return { success: true, data: { passed, warnings, failed, results } };
+        }
+        output.writeln();
+        output.writeln(output.warning('All checks passed with some warnings.'));
+        return { success: true, data: { passed, warnings, failed, results } };
+    }
+    output.writeln();
+    output.writeln(output.success('All checks passed! System is healthy.'));
+    return { success: true, data: { passed, warnings, failed, results } };
+}
+//# sourceMappingURL=doctor-render.js.map

package/dist/src/cli/commands/doctor-types.js

@@ -0,0 +1,9 @@
+/**
+ * Shared type declarations for the doctor command tree.
+ *
+ * Imported as `import type { HealthCheck } from './doctor-types.js'` so the
+ * import is erased at runtime — keeps the doctor-registry → doctor-checks-*
+ * module graph free of value-level cycles.
+ */
+export {};
+//# sourceMappingURL=doctor-types.js.map