@monoes/monomindcli 2.9.22 → 2.9.24

package/dist/src/commands/doctor-project-checks.js

@@ -2,13 +2,13 @@
  * Doctor — project/monomind health checks
  * Config, memory, API keys, MCP, monograph, helpers, routing, gates, gitignore, worker metrics
  */
-import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, copyFileSync, writeFileSync, appendFileSync, rmSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { execSync } from 'child_process';
-import { homedir } from 'os';
-import { MAX_DOCTOR_PKG_BYTES, MAX_DOCTOR_CONFIG_BYTES, MAX_DOCTOR_GITIGNORE_BYTES, MAX_DOCTOR_HELPER_BYTES, } from './doctor-env-checks.js';
+import { execSync } from 'node:child_process';
+import { appendFileSync, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { DOCTOR_TRACKED_HELPERS } from '../init/helpers-generator.js';
+import { MAX_DOCTOR_CONFIG_BYTES, MAX_DOCTOR_GITIGNORE_BYTES, MAX_DOCTOR_HELPER_BYTES, MAX_DOCTOR_PKG_BYTES, } from './doctor-env-checks.js';
 export async function checkConfigFile() {
     const jsonPaths = ['.monomind/config.json', 'monomind.config.json', '.monomind.json'];
     for (const configPath of jsonPaths) {
@@ -18,7 +18,12 @@ export async function checkConfigFile() {
                 return { name: 'Config File', status: 'pass', message: `Found: ${configPath}` };
             }
             catch {
-                return { name: 'Config File', status: 'fail', message: `Invalid JSON: ${configPath}`, fix: 'Fix JSON syntax in config file' };
+                return {
+                    name: 'Config File',
+                    status: 'fail',
+                    message: `Invalid JSON: ${configPath}`,
+                    fix: 'Fix JSON syntax in config file',
+                };
             }
         }
     }
@@ -27,7 +32,12 @@ export async function checkConfigFile() {
         if (existsSync(configPath))
             return { name: 'Config File', status: 'pass', message: `Found: ${configPath}` };
     }
-    return { name: 'Config File', status: 'warn', message: 'No config file (using defaults)', fix: 'monomind config init' };
+    return {
+        name: 'Config File',
+        status: 'warn',
+        message: 'No config file (using defaults)',
+        fix: 'monomind config init',
+    };
 }
 export async function checkMemoryDatabase() {
     const dbPaths = ['.monomind/memory.db', '.swarm/memory.db', 'data/memory.db'];
@@ -42,7 +52,12 @@ export async function checkMemoryDatabase() {
             }
         }
     }
-    return { name: 'Memory Database', status: 'warn', message: 'Not initialized', fix: 'monomind memory configure --backend hybrid' };
+    return {
+        name: 'Memory Database',
+        status: 'warn',
+        message: 'Not initialized',
+        fix: 'monomind memory configure --backend hybrid',
+    };
 }
 /** Memory knowledge graph (cognee port): entities/relations/rules distilled
  * from sessions and org runs. Informational — an empty graph on a fresh
@@ -55,16 +70,31 @@ export async function checkMemoryKnowledgeGraph() {
         const project = await kg.kgStats();
         const orgDb = join(process.cwd(), '.monomind', 'org-memory');
         const org = existsSync(orgDb) ? await kg.kgStats({ dbPath: orgDb }) : null;
-        await bridge.shutdownBridge().catch(() => { });
+        await bridge.shutdownBridge().catch(() => {
+            /* best effort */
+        });
         const total = project.nodes + (org?.nodes ?? 0);
         const fmt = (s) => `${s.nodes}n/${s.edges}e/${s.rules}r`;
         if (total === 0) {
-            return { name, status: 'warn', message: 'Empty — sessions/org runs have not distilled knowledge yet', fix: 'org runs call org_learn automatically; sessions use memory_kg_ingest' };
+            return {
+                name,
+                status: 'warn',
+                message: 'Empty — sessions/org runs have not distilled knowledge yet',
+                fix: 'org runs call org_learn automatically; sessions use memory_kg_ingest',
+            };
         }
-        return { name, status: 'pass', message: `project ${fmt(project)}${org ? ` · org ${fmt(org)}` : ''}` };
+        return {
+            name,
+            status: 'pass',
+            message: `project ${fmt(project)}${org ? ` · org ${fmt(org)}` : ''}`,
+        };
     }
     catch (err) {
-        return { name, status: 'warn', message: `Check failed: ${err instanceof Error ? err.message : String(err)}` };
+        return {
+            name,
+            status: 'warn',
+            message: `Check failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
     }
 }
 /** Count live (non-tombstoned) ingested documents under a brain root, without
@@ -102,7 +132,9 @@ export async function checkSecondBrainModel() {
         projectDocs ? `${projectDocs} project doc${projectDocs === 1 ? '' : 's'}` : null,
         globalDocs ? `${globalDocs} global doc${globalDocs === 1 ? '' : 's'}` : null,
         !projectDocs && !globalDocs ? 'monograph god-nodes' : null,
-    ].filter(Boolean).join(' · ');
+    ]
+        .filter(Boolean)
+        .join(' · ');
     let entryPath = null;
     try {
         // exports map blocks package.json — resolve the entry file, then walk UP
@@ -113,14 +145,21 @@ export async function checkSecondBrainModel() {
         if (viaEsm)
             entryPath = fileURLToPath(await viaEsm);
     }
-    catch { /* try CJS below */ }
+    catch {
+        /* try CJS below */
+    }
     if (!entryPath) {
         try {
             const { createRequire } = await import('node:module');
             entryPath = createRequire(import.meta.url).resolve('@huggingface/transformers');
         }
         catch {
-            return { name, status: 'warn', message: '@huggingface/transformers not installed — semantic search degraded to keyword matching', fix: 'reinstall monomind (the model dependency is optional and may have failed to build)' };
+            return {
+                name,
+                status: 'warn',
+                message: '@huggingface/transformers not installed — semantic search degraded to keyword matching',
+                fix: 'reinstall monomind (the model dependency is optional and may have failed to build)',
+            };
         }
     }
     // Walk up from the entry file to the package root (the dir named 'transformers').
@@ -129,31 +168,62 @@ export async function checkSecondBrainModel() {
         pkgDir = dirname(pkgDir);
     const modelCache = join(pkgDir, '.cache', 'Xenova');
     if (pkgDir.endsWith('transformers') && existsSync(modelCache)) {
-        return { name, status: 'pass', message: `Local embedding model cached — semantic search active (${indexed})` };
+        return {
+            name,
+            status: 'pass',
+            message: `Local embedding model cached — semantic search active (${indexed})`,
+        };
     }
-    return { name, status: 'warn', message: 'Embedding model not downloaded yet — searches use keyword matching until it is', fix: 'run once while online: monomind doc search -q "warmup" (downloads ~90MB locally, one time)' };
+    return {
+        name,
+        status: 'warn',
+        message: 'Embedding model not downloaded yet — searches use keyword matching until it is',
+        fix: 'run once while online: monomind doc search -q "warmup" (downloads ~90MB locally, one time)',
+    };
 }
 export async function checkApiKeys() {
     const keys = ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY', 'OPENAI_API_KEY'];
-    const found = keys.filter(k => process.env[k]);
-    const inClaudeCode = !!(process.env.CLAUDE_CODE || process.env.CLAUDE_PROJECT_DIR || process.env.MCP_SESSION_ID);
+    const found = keys.filter((k) => process.env[k]);
+    const inClaudeCode = !!(process.env.CLAUDE_CODE ||
+        process.env.CLAUDE_PROJECT_DIR ||
+        process.env.MCP_SESSION_ID);
     let claudeCliAvailable = false;
     try {
-        execSync('claude --version', { encoding: 'utf-8', stdio: 'pipe', timeout: 5000, windowsHide: true });
+        execSync('claude --version', {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            timeout: 5000,
+            windowsHide: true,
+        });
         claudeCliAvailable = true;
     }
-    catch { /* not on PATH */ }
+    catch {
+        /* not on PATH */
+    }
     if (found.includes('ANTHROPIC_API_KEY') || found.includes('CLAUDE_API_KEY')) {
         return { name: 'API Keys', status: 'pass', message: `Found: ${found.join(', ')}` };
     }
     else if (inClaudeCode) {
-        return { name: 'API Keys', status: 'pass', message: 'Claude Code manages auth (no direct API key needed)' };
+        return {
+            name: 'API Keys',
+            status: 'pass',
+            message: 'Claude Code manages auth (no direct API key needed)',
+        };
     }
     else if (claudeCliAvailable) {
-        return { name: 'API Keys', status: 'pass', message: 'Using Claude Code CLI auth (no direct API key needed)' };
+        return {
+            name: 'API Keys',
+            status: 'pass',
+            message: 'Using Claude Code CLI auth (no direct API key needed)',
+        };
     }
     else if (found.length > 0) {
-        return { name: 'API Keys', status: 'warn', message: `Found: ${found.join(', ')} (no Claude key)`, fix: 'export ANTHROPIC_API_KEY=your_key' };
+        return {
+            name: 'API Keys',
+            status: 'warn',
+            message: `Found: ${found.join(', ')} (no Claude key)`,
+            fix: 'export ANTHROPIC_API_KEY=your_key',
+        };
     }
     return {
         name: 'API Keys',
@@ -179,13 +249,29 @@ export async function checkMcpServers() {
                 const count = Object.keys(servers).length;
                 const hasMonomind = 'monomind' in servers || 'monomind_alpha' in servers;
                 if (hasMonomind)
-                    return { name: 'MCP Servers', status: 'pass', message: `${count} servers (monomind configured)` };
-                return { name: 'MCP Servers', status: 'warn', message: `${count} servers (monomind not found)`, fix: 'claude mcp add monomind -- npx -y monomind@latest mcp start' };
+                    return {
+                        name: 'MCP Servers',
+                        status: 'pass',
+                        message: `${count} servers (monomind configured)`,
+                    };
+                return {
+                    name: 'MCP Servers',
+                    status: 'warn',
+                    message: `${count} servers (monomind not found)`,
+                    fix: 'claude mcp add monomind -- npx -y monomind@latest mcp start',
+                };
+            }
+            catch {
+                /* try next */
             }
-            catch { /* try next */ }
         }
     }
-    return { name: 'MCP Servers', status: 'warn', message: 'No MCP config found', fix: 'claude mcp add monomind -- npx -y monomind@latest mcp start' };
+    return {
+        name: 'MCP Servers',
+        status: 'warn',
+        message: 'No MCP config found',
+        fix: 'claude mcp add monomind -- npx -y monomind@latest mcp start',
+    };
 }
 export async function checkMonograph() {
     try {
@@ -195,31 +281,49 @@ export async function checkMonograph() {
         try {
             _globalRoot = execSync('npm root -g', { encoding: 'utf8', timeout: 3000 }).trim();
         }
-        catch { /* no npm */ }
+        catch {
+            /* no npm */
+        }
         const candidates = [
             join(_base, '..', '..', 'node_modules', '@monomind', 'monograph', 'package.json'),
             join(_base, '..', '..', '..', '..', 'node_modules', '@monomind', 'monograph', 'package.json'),
             join(_base, '..', '..', 'node_modules', '@monoes', 'monograph', 'package.json'),
             join(_base, '..', '..', '..', '..', 'node_modules', '@monoes', 'monograph', 'package.json'),
-            ...(_globalRoot ? [
-                join(_globalRoot, '@monomind', 'monograph', 'package.json'),
-                join(_globalRoot, '@monoes', 'monograph', 'package.json'),
-            ] : []),
+            ...(_globalRoot
+                ? [
+                    join(_globalRoot, '@monomind', 'monograph', 'package.json'),
+                    join(_globalRoot, '@monoes', 'monograph', 'package.json'),
+                ]
+                : []),
         ];
-        const found = candidates.find(p => existsSync(p) && statSync(p).size <= MAX_DOCTOR_PKG_BYTES);
+        const found = candidates.find((p) => existsSync(p) && statSync(p).size <= MAX_DOCTOR_PKG_BYTES);
         if (found) {
             try {
                 const pkg = JSON.parse(readFileSync(found, 'utf-8'));
-                return { name: 'Monograph', status: 'pass', message: `v${pkg.version || '?'} available (knowledge graph engine)` };
+                return {
+                    name: 'Monograph',
+                    status: 'pass',
+                    message: `v${pkg.version || '?'} available (knowledge graph engine)`,
+                };
             }
             catch {
                 return { name: 'Monograph', status: 'pass', message: 'available (knowledge graph engine)' };
             }
         }
-        return { name: 'Monograph', status: 'warn', message: 'Package not found (knowledge graph disabled)', fix: 'npm install -g monomind@latest' };
+        return {
+            name: 'Monograph',
+            status: 'warn',
+            message: 'Package not found (knowledge graph disabled)',
+            fix: 'npm install -g monomind@latest',
+        };
     }
     catch {
-        return { name: 'Monograph', status: 'warn', message: 'Package check failed', fix: 'npm install -g monomind@latest' };
+        return {
+            name: 'Monograph',
+            status: 'warn',
+            message: 'Package check failed',
+            fix: 'npm install -g monomind@latest',
+        };
     }
 }
 export async function checkMonographFreshness() {
@@ -230,39 +334,74 @@ export async function checkMonographFreshness() {
         const statsPath = join(cwd, '.monomind', 'graph', 'stats.json');
         const hasDb = existsSync(dbPath);
         if (!hasDb && !existsSync(statsPath)) {
-            return { name: 'Graph freshness', status: 'warn', message: 'No monograph graph built yet', fix: 'mcp__monomind__monograph_build codeOnly:true' };
+            return {
+                name: 'Graph freshness',
+                status: 'warn',
+                message: 'No monograph graph built yet',
+                fix: 'mcp__monomind__monograph_build codeOnly:true',
+            };
         }
         let buildMs = 0;
         if (hasDb) {
             try {
                 buildMs = Math.max(buildMs, statSync(dbPath).mtimeMs);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
         }
         try {
             buildMs = Math.max(buildMs, statSync(lockPath).mtimeMs);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         try {
             buildMs = Math.max(buildMs, statSync(statsPath).mtimeMs);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         if (buildMs === 0)
-            return { name: 'Graph freshness', status: 'warn', message: 'Graph exists but build time unknown' };
+            return {
+                name: 'Graph freshness',
+                status: 'warn',
+                message: 'Graph exists but build time unknown',
+            };
         const buildIso = new Date(buildMs).toISOString();
         let commitsBehind = 0;
         try {
-            const out = execSync(`git rev-list --count --since='${buildIso}' HEAD 2>/dev/null`, { encoding: 'utf8', timeout: 2000, cwd }).trim();
+            const out = execSync(`git rev-list --count --since='${buildIso}' HEAD 2>/dev/null`, {
+                encoding: 'utf8',
+                timeout: 2000,
+                cwd,
+            }).trim();
             commitsBehind = parseInt(out, 10) || 0;
         }
-        catch { /* git unavailable */ }
+        catch {
+            /* git unavailable */
+        }
         const ageMinutes = Math.floor((Date.now() - buildMs) / 60000);
         const ageStr = ageMinutes < 60 ? `${ageMinutes}m ago` : `${Math.floor(ageMinutes / 60)}h ago`;
         if (commitsBehind === 0)
-            return { name: 'Graph freshness', status: 'pass', message: `FRESH — built ${ageStr}, 0 commits behind` };
+            return {
+                name: 'Graph freshness',
+                status: 'pass',
+                message: `FRESH — built ${ageStr}, 0 commits behind`,
+            };
         if (commitsBehind <= 5)
-            return { name: 'Graph freshness', status: 'warn', message: `${commitsBehind} commit(s) behind — built ${ageStr}`, fix: 'mcp__monomind__monograph_build codeOnly:true' };
-        return { name: 'Graph freshness', status: 'fail', message: `STALE — ${commitsBehind} commits behind (built ${ageStr})`, fix: 'mcp__monomind__monograph_build codeOnly:true' };
+            return {
+                name: 'Graph freshness',
+                status: 'warn',
+                message: `${commitsBehind} commit(s) behind — built ${ageStr}`,
+                fix: 'mcp__monomind__monograph_build codeOnly:true',
+            };
+        return {
+            name: 'Graph freshness',
+            status: 'fail',
+            message: `STALE — ${commitsBehind} commits behind (built ${ageStr})`,
+            fix: 'mcp__monomind__monograph_build codeOnly:true',
+        };
     }
     catch {
         return { name: 'Graph freshness', status: 'warn', message: 'Could not check graph freshness' };
@@ -276,23 +415,38 @@ export async function checkMonoesMemory() {
         try {
             _globalRoot = execSync('npm root -g', { encoding: 'utf8', timeout: 3000 }).trim();
         }
-        catch { /* no npm */ }
+        catch {
+            /* no npm */
+        }
         const candidates = [
             join(_base, '..', '..', 'node_modules', '@monoes', 'memory', 'package.json'),
             join(_base, '..', '..', '..', '..', 'node_modules', '@monoes', 'memory', 'package.json'),
             ...(_globalRoot ? [join(_globalRoot, '@monoes', 'memory', 'package.json')] : []),
         ];
-        const found = candidates.find(p => existsSync(p) && statSync(p).size <= MAX_DOCTOR_PKG_BYTES);
+        const found = candidates.find((p) => existsSync(p) && statSync(p).size <= MAX_DOCTOR_PKG_BYTES);
         if (found) {
             try {
                 const pkg = JSON.parse(readFileSync(found, 'utf-8'));
-                return { name: 'Vector Memory', status: 'pass', message: `@monoes/memory v${pkg.version || '?'} (HNSW search enabled)` };
+                return {
+                    name: 'Vector Memory',
+                    status: 'pass',
+                    message: `@monoes/memory v${pkg.version || '?'} (HNSW search enabled)`,
+                };
             }
             catch {
-                return { name: 'Vector Memory', status: 'pass', message: '@monoes/memory available (HNSW search enabled)' };
+                return {
+                    name: 'Vector Memory',
+                    status: 'pass',
+                    message: '@monoes/memory available (HNSW search enabled)',
+                };
             }
         }
-        return { name: 'Vector Memory', status: 'warn', message: '@monoes/memory not installed (vector search disabled)', fix: 'npm install @monoes/memory' };
+        return {
+            name: 'Vector Memory',
+            status: 'warn',
+            message: '@monoes/memory not installed (vector search disabled)',
+            fix: 'npm install @monoes/memory',
+        };
     }
     catch {
         return { name: 'Vector Memory', status: 'warn', message: 'Vector memory check failed' };
@@ -307,12 +461,16 @@ function _resolveBundledHelper(relativePath) {
             if (existsSync(candidate) && statSync(candidate).size <= MAX_DOCTOR_PKG_BYTES) {
                 try {
                     const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
-                    if (pkg.name === '@monomind/cli' || pkg.name === 'monomind' || pkg.name === '@monoes/monomindcli') {
+                    if (pkg.name === '@monomind/cli' ||
+                        pkg.name === 'monomind' ||
+                        pkg.name === '@monoes/monomindcli') {
                         const helperPath = join(dir, relativePath);
                         return existsSync(helperPath) ? helperPath : null;
                     }
                 }
-                catch { /* keep walking */ }
+                catch {
+                    /* keep walking */
+                }
             }
             const parent = dirname(dir);
             if (parent === dir)
@@ -344,7 +502,9 @@ function _allTrackedHelperNames() {
                 names.push(join(sub, f));
             }
         }
-        catch { /* skip */ }
+        catch {
+            /* skip */
+        }
     }
     return names;
 }
@@ -375,7 +535,9 @@ async function _detectStaleHelpers() {
             if (hashLocal !== hashBundled)
                 stale.push(name);
         }
-        catch { /* skip */ }
+        catch {
+            /* skip */
+        }
     }
     return { stale, missing };
 }
@@ -403,15 +565,33 @@ export async function checkHelpersFresh() {
     try {
         const { stale, missing } = await _detectStaleHelpers();
         if (stale.length === 0 && missing.length === 0) {
-            return { name: 'Helper Files', status: 'pass', message: 'Project helpers match bundled version' };
+            return {
+                name: 'Helper Files',
+                status: 'pass',
+                message: 'Project helpers match bundled version',
+            };
         }
         if (stale.length > 0) {
-            return { name: 'Helper Files', status: 'warn', message: `${stale.length} stale helper(s): ${stale.join(', ')}`, fix: 'monomind init upgrade' };
+            return {
+                name: 'Helper Files',
+                status: 'warn',
+                message: `${stale.length} stale helper(s): ${stale.join(', ')}`,
+                fix: 'monomind init upgrade',
+            };
         }
-        return { name: 'Helper Files', status: 'warn', message: `Could not locate bundled copies of: ${missing.join(', ')}`, fix: 'Reinstall monomind or run `monomind init upgrade`' };
+        return {
+            name: 'Helper Files',
+            status: 'warn',
+            message: `Could not locate bundled copies of: ${missing.join(', ')}`,
+            fix: 'Reinstall monomind or run `monomind init upgrade`',
+        };
     }
     catch (e) {
-        return { name: 'Helper Files', status: 'warn', message: `check failed: ${e instanceof Error ? e.message : 'unknown'}` };
+        return {
+            name: 'Helper Files',
+            status: 'warn',
+            message: `check failed: ${e instanceof Error ? e.message : 'unknown'}`,
+        };
     }
 }
 function fmtPct(v) {
@@ -426,7 +606,9 @@ async function routingAccuracyLine() {
         const adhStr = ` | adherence ${fmtPct(adh.adherence)} (n=${adh.sample})`;
         if (acc.accuracy === null)
             return `routing accuracy (last 100): no outcome data yet${adhStr}`;
-        const trend = acc.recentVsPrior === null ? '' : ` trend ${acc.recentVsPrior >= 0 ? '+' : ''}${Math.round(acc.recentVsPrior * 100)}%`;
+        const trend = acc.recentVsPrior === null
+            ? ''
+            : ` trend ${acc.recentVsPrior >= 0 ? '+' : ''}${Math.round(acc.recentVsPrior * 100)}%`;
         return `routing accuracy (last ${acc.window}): ${fmtPct(acc.accuracy)} [native ${fmtPct(acc.byMode.native)} / js ${fmtPct(acc.byMode.js)}]${trend}${adhStr}`;
     }
     catch (e) {
@@ -441,32 +623,49 @@ function routingFeedbackFallback() {
         const p = join(process.cwd(), '.monomind', 'routing-feedback.jsonl');
         if (!existsSync(p) || statSync(p).size > 512 * 1024)
             return null;
-        const records = readFileSync(p, 'utf-8').trim().split('\n').filter(Boolean).map(l => {
+        const records = readFileSync(p, 'utf-8')
+            .trim()
+            .split('\n')
+            .filter(Boolean)
+            .map((l) => {
             try {
                 return JSON.parse(l);
             }
             catch {
                 return null;
             }
-        }).filter((r) => r !== null);
+        })
+            .filter((r) => r !== null);
         if (records.length === 0)
             return null;
-        const sessions = new Set(records.map(r => r.sessionId).filter(Boolean));
+        const sessions = new Set(records.map((r) => r.sessionId).filter(Boolean));
         const byAgent = new Map();
         for (const r of records) {
             const a = typeof r.suggestedAgent === 'string' ? r.suggestedAgent : 'unknown';
             byAgent.set(a, (byAgent.get(a) ?? 0) + 1);
         }
-        const top = [...byAgent.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([a, n]) => `${a}=${n}`).join(', ');
-        const flags = records.map(r => r.intelligenceFeedback).filter((v) => typeof v === 'boolean');
+        const top = [...byAgent.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 3)
+            .map(([a, n]) => `${a}=${n}`)
+            .join(', ');
+        const flags = records
+            .map((r) => r.intelligenceFeedback)
+            .filter((v) => typeof v === 'boolean');
         const trueCount = flags.filter(Boolean).length;
         const base = `routing feedback (fallback): ${records.length} decisions across ${sessions.size} sessions; top agents: ${top}`;
         if (flags.length > 0 && trueCount === flags.length) {
-            return { message: `${base}; success flag is degenerate (100% true — sessionSuccess heuristic never records failure)`, degenerate: true };
+            return {
+                message: `${base}; success flag is degenerate (100% true — sessionSuccess heuristic never records failure)`,
+                degenerate: true,
+            };
         }
         if (flags.length === 0)
             return { message: `${base}; no evidence-based success flags yet`, degenerate: true };
-        return { message: `${base}; success rate ${Math.round((trueCount / flags.length) * 100)}% (n=${flags.length})`, degenerate: false };
+        return {
+            message: `${base}; success rate ${Math.round((trueCount / flags.length) * 100)}% (n=${flags.length})`,
+            degenerate: false,
+        };
     }
     catch (e) {
         if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
@@ -480,12 +679,20 @@ export async function checkMonoesIntegration() {
         if (line.startsWith('routing accuracy (last 100): no outcome data yet')) {
             const fb = routingFeedbackFallback();
             if (fb)
-                return { name: 'Routing Learning', status: fb.degenerate ? 'warn' : 'pass', message: fb.message };
+                return {
+                    name: 'Routing Learning',
+                    status: fb.degenerate ? 'warn' : 'pass',
+                    message: fb.message,
+                };
         }
         return { name: 'Routing Learning', status: 'pass', message: line };
     }
     catch (err) {
-        return { name: 'Routing Learning', status: 'warn', message: `Could not compute routing accuracy: ${err instanceof Error ? err.message : String(err)}` };
+        return {
+            name: 'Routing Learning',
+            status: 'warn',
+            message: `Could not compute routing accuracy: ${err instanceof Error ? err.message : String(err)}`,
+        };
     }
 }
 const REQUIRED_GITIGNORE_PATTERNS = [
@@ -501,14 +708,16 @@ const REQUIRED_GITIGNORE_PATTERNS = [
     { pattern: 'data/mastermind-*.json', reason: 'mastermind session data' },
     { pattern: 'data/mastermind-*.jsonl', reason: 'mastermind event logs' },
     { pattern: '**/.claude-flow/', reason: 'claude-flow runtime data with paths' },
-    { pattern: '.hive-mind/', reason: 'hive-mind state with session info' },
-    { pattern: '.swarm/', reason: 'swarm state files' },
+    { pattern: '.monomind/monoswarm/', reason: 'monoswarm state files' },
 ];
 /** Strip the parts that don't change what a pattern matches, so `**​/.monomind/`,
  *  `.monomind/` and `.monomind` all compare equal. A gitignore pattern with no
  *  leading slash already matches at every depth, so `**​/` is redundant. */
 function normalizeGitignorePattern(p) {
-    return p.replace(/^\/+/, '').replace(/^\*\*\//, '').replace(/\/+$/, '');
+    return p
+        .replace(/^\/+/, '')
+        .replace(/^\*\*\//, '')
+        .replace(/\/+$/, '');
 }
 /** True when ignoring `line` already protects everything `required` covers.
  *  Beyond exact matches this understands directory containment: a repo with a
@@ -533,17 +742,34 @@ export async function checkGitignoreCoverage() {
         // writes a literal backslash-n (sh/bash echo does not interpret escapes
         // without -e) — one junk line matching nothing. `--fix` now writes the file
         // directly, so point at that rather than at a command to copy-paste.
-        return { name: 'Gitignore Coverage', status: 'warn', message: 'No .gitignore found — all monomind runtime paths are unprotected', fix: 'monomind doctor --fix   (creates .gitignore covering .monomind/ and secrets)' };
+        return {
+            name: 'Gitignore Coverage',
+            status: 'warn',
+            message: 'No .gitignore found — all monomind runtime paths are unprotected',
+            fix: 'monomind doctor --fix   (creates .gitignore covering .monomind/ and secrets)',
+        };
     }
     if (statSync(gitignorePath).size > MAX_DOCTOR_GITIGNORE_BYTES) {
         return { name: 'Gitignore Coverage', status: 'warn', message: '.gitignore too large to parse' };
     }
-    const lines = readFileSync(gitignorePath, 'utf-8').split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
-    const missing = REQUIRED_GITIGNORE_PATTERNS.filter(({ pattern }) => !lines.some(l => gitignoreLineCovers(l, pattern)));
+    const lines = readFileSync(gitignorePath, 'utf-8')
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((l) => l && !l.startsWith('#'));
+    const missing = REQUIRED_GITIGNORE_PATTERNS.filter(({ pattern }) => !lines.some((l) => gitignoreLineCovers(l, pattern)));
     if (missing.length === 0)
-        return { name: 'Gitignore Coverage', status: 'pass', message: 'All monomind runtime paths are gitignored' };
-    const missingList = missing.map(m => m.pattern).join(', ');
-    return { name: 'Gitignore Coverage', status: 'warn', message: `${missing.length} runtime path(s) not in .gitignore: ${missingList}`, fix: 'monomind doctor --fix   (appends the missing entries)' };
+        return {
+            name: 'Gitignore Coverage',
+            status: 'pass',
+            message: 'All monomind runtime paths are gitignored',
+        };
+    const missingList = missing.map((m) => m.pattern).join(', ');
+    return {
+        name: 'Gitignore Coverage',
+        status: 'warn',
+        message: `${missing.length} runtime path(s) not in .gitignore: ${missingList}`,
+        fix: 'monomind doctor --fix   (appends the missing entries)',
+    };
 }
 /** Patterns written by `doctor --fix` when there is no .gitignore at all.
  *  Covers monomind runtime state plus the standard secrets files, since a repo
@@ -552,8 +778,7 @@ const GITIGNORE_FIX_PATTERNS = [
     '# monomind runtime state',
     '.monomind/',
     '**/.monomind/',
-    '.hive-mind/',
-    '.swarm/',
+    '.monomind/monoswarm/',
     '**/.claude-flow/',
     'data/sessions/',
     'data/mastermind-*.json',
@@ -576,16 +801,17 @@ export async function fixGitignoreCoverage() {
     const gitignorePath = join(process.cwd(), '.gitignore');
     try {
         if (!existsSync(gitignorePath)) {
-            writeFileSync(gitignorePath, GITIGNORE_FIX_PATTERNS.join('\n') + '\n', 'utf-8');
+            writeFileSync(gitignorePath, `${GITIGNORE_FIX_PATTERNS.join('\n')}\n`, 'utf-8');
             return true;
         }
         if (statSync(gitignorePath).size > MAX_DOCTOR_GITIGNORE_BYTES)
             return false;
         const existing = readFileSync(gitignorePath, 'utf-8');
-        const lines = existing.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
-        const missing = REQUIRED_GITIGNORE_PATTERNS
-            .map(m => m.pattern)
-            .filter(pattern => !lines.some(l => gitignoreLineCovers(l, pattern)));
+        const lines = existing
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l && !l.startsWith('#'));
+        const missing = REQUIRED_GITIGNORE_PATTERNS.map((m) => m.pattern).filter((pattern) => !lines.some((l) => gitignoreLineCovers(l, pattern)));
         if (missing.length === 0)
             return false;
         const prefix = existing.endsWith('\n') || existing === '' ? '' : '\n';
@@ -609,7 +835,12 @@ export async function checkAgentRegistry() {
         const registry = buildUnifiedRegistry(roots, join(outDir, 'registry.json'));
         const entries = registry.agents;
         if (entries.length === 0) {
-            return { name: 'Agent Registry', status: 'warn', message: 'No agents found under .claude/agents', fix: 'monomind init  (installs agent definitions)' };
+            return {
+                name: 'Agent Registry',
+                status: 'warn',
+                message: 'No agents found under .claude/agents',
+                fix: 'monomind init  (installs agent definitions)',
+            };
         }
         let missingSlug = 0, missingName = 0, missingDescription = 0;
         for (const agent of entries) {
@@ -622,13 +853,19 @@ export async function checkAgentRegistry() {
         }
         const total = missingSlug + missingName + missingDescription;
         if (total === 0) {
-            return { name: 'Agent Registry', status: 'pass', message: `${entries.length} agent(s), all metadata complete` };
+            return {
+                name: 'Agent Registry',
+                status: 'pass',
+                message: `${entries.length} agent(s), all metadata complete`,
+            };
         }
         const parts = [
             missingSlug > 0 ? `${missingSlug} missing slug` : null,
             missingName > 0 ? `${missingName} missing name` : null,
             missingDescription > 0 ? `${missingDescription} missing description` : null,
-        ].filter(Boolean).join(', ');
+        ]
+            .filter(Boolean)
+            .join(', ');
         return {
             name: 'Agent Registry',
             status: 'warn',
@@ -637,21 +874,39 @@ export async function checkAgentRegistry() {
         };
     }
     catch {
-        return { name: 'Agent Registry', status: 'warn', message: 'Could not build/parse agent registry' };
+        return {
+            name: 'Agent Registry',
+            status: 'warn',
+            message: 'Could not build/parse agent registry',
+        };
     }
 }
 export async function checkGuidanceGates() {
     const settingsPath = join(process.cwd(), '.claude', 'settings.json');
     const gatesHandlerPath = join(process.cwd(), '.claude', 'helpers', 'handlers', 'gates-handler.cjs');
     if (!existsSync(gatesHandlerPath)) {
-        return { name: 'Guidance Gates', status: 'warn', message: 'gates-handler.cjs not found — enforcement gates not installed', fix: 'monomind init  (then monomind guidance setup)' };
+        return {
+            name: 'Guidance Gates',
+            status: 'warn',
+            message: 'gates-handler.cjs not found — enforcement gates not installed',
+            fix: 'monomind init  (then monomind guidance setup)',
+        };
     }
     if (!existsSync(settingsPath)) {
-        return { name: 'Guidance Gates', status: 'warn', message: 'gates-handler.cjs present but .claude/settings.json missing', fix: 'monomind guidance setup' };
+        return {
+            name: 'Guidance Gates',
+            status: 'warn',
+            message: 'gates-handler.cjs present but .claude/settings.json missing',
+            fix: 'monomind guidance setup',
+        };
     }
     try {
         if (statSync(settingsPath).size > MAX_DOCTOR_CONFIG_BYTES) {
-            return { name: 'Guidance Gates', status: 'warn', message: 'settings.json too large to parse' };
+            return {
+                name: 'Guidance Gates',
+                status: 'warn',
+                message: 'settings.json too large to parse',
+            };
         }
         const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
         const preToolUse = settings?.hooks?.PreToolUse ?? [];
@@ -662,18 +917,42 @@ export async function checkGuidanceGates() {
         // INACTIVE the moment it did, telling users their secrets gate was off
         // while it was demonstrably blocking secrets, and sending them to
         // `guidance setup`, which would then add a duplicate entry.
-        const hasPreWrite = preToolUse.some(e => /\bWrite\b/.test(e.matcher ?? '') && e.hooks.some(h => h.command?.includes('pre-write')));
-        const hasPreBash = preToolUse.some(e => e.matcher === 'Bash' && e.hooks.some(h => h.command?.includes('pre-bash')));
+        const hasPreWrite = preToolUse.some((e) => /\bWrite\b/.test(e.matcher ?? '') && e.hooks.some((h) => h.command?.includes('pre-write')));
+        const hasPreBash = preToolUse.some((e) => e.matcher === 'Bash' && e.hooks.some((h) => h.command?.includes('pre-bash')));
         if (!hasPreWrite && !hasPreBash)
-            return { name: 'Guidance Gates', status: 'warn', message: 'gates-handler.cjs present but no gates registered', fix: 'monomind guidance setup' };
+            return {
+                name: 'Guidance Gates',
+                status: 'warn',
+                message: 'gates-handler.cjs present but no gates registered',
+                fix: 'monomind guidance setup',
+            };
         if (!hasPreWrite)
-            return { name: 'Guidance Gates', status: 'warn', message: 'pre-write hook not registered — secrets gate inactive', fix: 'monomind guidance setup' };
+            return {
+                name: 'Guidance Gates',
+                status: 'warn',
+                message: 'pre-write hook not registered — secrets gate inactive',
+                fix: 'monomind guidance setup',
+            };
         if (!hasPreBash)
-            return { name: 'Guidance Gates', status: 'warn', message: 'pre-bash hook not registered — destructive-ops gate inactive', fix: 'monomind guidance setup' };
-        return { name: 'Guidance Gates', status: 'pass', message: 'destructive-ops (pre-bash) + secrets (pre-write) gates active' };
+            return {
+                name: 'Guidance Gates',
+                status: 'warn',
+                message: 'pre-bash hook not registered — destructive-ops gate inactive',
+                fix: 'monomind guidance setup',
+            };
+        return {
+            name: 'Guidance Gates',
+            status: 'pass',
+            message: 'destructive-ops (pre-bash) + secrets (pre-write) gates active',
+        };
     }
     catch {
-        return { name: 'Guidance Gates', status: 'warn', message: 'Could not parse .claude/settings.json', fix: 'monomind guidance setup --force' };
+        return {
+            name: 'Guidance Gates',
+            status: 'warn',
+            message: 'Could not parse .claude/settings.json',
+            fix: 'monomind guidance setup --force',
+        };
     }
 }
 // Workers refresh at session start when output is >6h old — allow a grace
@@ -702,11 +981,19 @@ function readMetricsJSON(name) {
 export async function checkMetricsFreshness() {
     const metricsDir = join(process.cwd(), '.monomind', 'metrics');
     const knownOutputs = [
-        'codebase-map.json', 'security-audit.json', 'performance.json',
-        'consolidation.json', 'ddd-progress.json',
+        'codebase-map.json',
+        'security-audit.json',
+        'performance.json',
+        'consolidation.json',
+        'ddd-progress.json',
     ];
     if (!existsSync(metricsDir)) {
-        return { name: 'Worker Metrics', status: 'warn', message: 'No .monomind/metrics — workers have not run yet (they run at session start)', fix: 'monomind hooks worker run map' };
+        return {
+            name: 'Worker Metrics',
+            status: 'warn',
+            message: 'No .monomind/metrics — workers have not run yet (they run at session start)',
+            fix: 'monomind hooks worker run map',
+        };
     }
     const now = Date.now();
     const fresh = [];
@@ -722,19 +1009,30 @@ export async function checkMetricsFreshness() {
             else
                 stale.push(name);
         }
-        catch { /* skip unreadable */ }
+        catch {
+            /* skip unreadable */
+        }
     }
     if (fresh.length === 0 && stale.length === 0) {
-        return { name: 'Worker Metrics', status: 'warn', message: 'No worker output files found yet (they run at session start)', fix: 'monomind hooks worker run map' };
+        return {
+            name: 'Worker Metrics',
+            status: 'warn',
+            message: 'No worker output files found yet (they run at session start)',
+            fix: 'monomind hooks worker run map',
+        };
     }
     if (stale.length === 0) {
-        return { name: 'Worker Metrics', status: 'pass', message: `${fresh.length} metrics file(s) fresh (<12h)` };
+        return {
+            name: 'Worker Metrics',
+            status: 'pass',
+            message: `${fresh.length} metrics file(s) fresh (<12h)`,
+        };
     }
     return {
         name: 'Worker Metrics',
         status: 'warn',
         message: `${stale.length} stale (>12h): ${stale.join(', ')}${fresh.length > 0 ? ` — ${fresh.length} fresh` : ''}`,
-        fix: 'monomind hooks worker run <name>  # map, audit, optimize, consolidate, ddd',
+        fix: 'monomind hooks worker run <name>  # map, audit, consolidate, ddd',
     };
 }
 /**
@@ -743,12 +1041,18 @@ export async function checkMetricsFreshness() {
 export async function checkSecurityAuditFindings() {
     const audit = readMetricsJSON('security-audit.json');
     if (!audit) {
-        return { name: 'Security Audit', status: 'warn', message: 'No security-audit.json yet', fix: 'monomind hooks worker run audit' };
+        return {
+            name: 'Security Audit',
+            status: 'warn',
+            message: 'No security-audit.json yet',
+            fix: 'monomind hooks worker run audit',
+        };
     }
     const riskLevel = (audit.riskLevel || 'low').toLowerCase();
     const recommendations = audit.recommendations || [];
     const priorityTargets = audit.priorityScanTargets || [];
-    const criticalCount = recommendations.length + (riskLevel === 'high' || riskLevel === 'critical' ? priorityTargets.length : 0);
+    const criticalCount = recommendations.length +
+        (riskLevel === 'high' || riskLevel === 'critical' ? priorityTargets.length : 0);
     if (riskLevel === 'critical' || riskLevel === 'high') {
         return {
             name: 'Security Audit',
@@ -758,7 +1062,11 @@ export async function checkSecurityAuditFindings() {
         };
     }
     if (recommendations.length > 0) {
-        return { name: 'Security Audit', status: 'warn', message: `risk=${riskLevel}, ${recommendations.length} recommendation(s)` };
+        return {
+            name: 'Security Audit',
+            status: 'warn',
+            message: `risk=${riskLevel}, ${recommendations.length} recommendation(s)`,
+        };
     }
     return { name: 'Security Audit', status: 'pass', message: `risk=${riskLevel}, no open findings` };
 }
@@ -786,7 +1094,11 @@ export async function checkMemoryProficiency() {
         return { name: 'Memory Proficiency', status: 'pass', message: msg };
     }
     catch {
-        return { name: 'Memory Proficiency', status: 'warn', message: 'Could not load intelligence module' };
+        return {
+            name: 'Memory Proficiency',
+            status: 'warn',
+            message: 'Could not load intelligence module',
+        };
     }
 }
 /** AppleDouble sidecars (`._name`) under `.claude/`.
@@ -808,7 +1120,10 @@ export async function checkAppleDoubleSidecars() {
     const found = findAppleDoubleSidecars(process.cwd());
     if (found.length === 0)
         return { name, status: 'pass', message: 'None under .claude/' };
-    const shown = found.slice(0, 3).map(p => p.replace(process.cwd() + '/', '')).join(', ');
+    const shown = found
+        .slice(0, 3)
+        .map((p) => p.replace(`${process.cwd()}/`, ''))
+        .join(', ');
     return {
         name,
         status: 'warn',
@@ -860,8 +1175,55 @@ export function fixAppleDoubleSidecars(cwd) {
             rmSync(f, { force: true });
             removed++;
         }
-        catch { /* best effort */ }
+        catch {
+            /* best effort */
+        }
     }
     return removed;
 }
+/** Second Brain document ingestion: whether the "documents" capability is
+ * active for this project. Read directly from capabilities.json rather than
+ * re-running the directory scan — doctor should report on what's actually
+ * activated, not re-detect. */
+function isDocumentsCapabilityActive(cwd) {
+    try {
+        const capsPath = join(cwd, '.monomind', 'capabilities.json');
+        if (!existsSync(capsPath))
+            return false;
+        const parsed = JSON.parse(readFileSync(capsPath, 'utf8'));
+        return Array.isArray(parsed.active) && parsed.active.includes('documents');
+    }
+    catch {
+        return false;
+    }
+}
+/** Per-extractor health for Second Brain document ingestion (MEM-8/MEM-9):
+ * one check per format family (PDF, DOCX, XLSX/XLS/ODS, PPTX/ODT/ODP/EPUB,
+ * legacy DOC/PPT/Pages) instead of a single blanket "documents" check, so
+ * `doctor` can report exactly which formats are functional vs broken.
+ * No-op (empty array) when the documents capability isn't active — nothing
+ * to report if this project doesn't ingest documents. */
+export async function checkDocumentExtractors() {
+    if (!isDocumentsCapabilityActive(process.cwd()))
+        return [];
+    try {
+        const { documentsCapability } = await import('../capabilities/cap-documents.js');
+        const checks = (await documentsCapability.healthChecks?.()) ?? [];
+        return checks.map((c) => ({
+            name: c.name,
+            status: c.status,
+            message: c.message,
+            fix: c.hint ?? c.fix,
+        }));
+    }
+    catch (err) {
+        return [
+            {
+                name: 'Document Extractors',
+                status: 'warn',
+                message: `Check failed: ${err instanceof Error ? err.message : String(err)}`,
+            },
+        ];
+    }
+}
 //# sourceMappingURL=doctor-project-checks.js.map