monomind 1.19.0 → 2.0.0

package/packages/@monomind/cli/dist/src/capabilities/index.d.ts

@@ -1,8 +1,6 @@
 export * from './types.js';
 export { scanDirectory, saveFingerprint, loadFingerprint } from './scanner.js';
 export { CapabilityManager } from './manager.js';
-export { EnrichmentPipeline } from './enrichment.js';
-export type { EnrichmentSummary, EnrichmentStatusReport } from './enrichment.js';
 export { FileWatcher } from './watcher.js';
 export { codeCapability } from './cap-code.js';
 export { documentsCapability } from './cap-documents.js';

package/packages/@monomind/cli/dist/src/capabilities/index.js

@@ -1,7 +1,6 @@
 export * from './types.js';
 export { scanDirectory, saveFingerprint, loadFingerprint } from './scanner.js';
 export { CapabilityManager } from './manager.js';
-export { EnrichmentPipeline } from './enrichment.js';
 export { FileWatcher } from './watcher.js';
 export { codeCapability } from './cap-code.js';
 export { documentsCapability } from './cap-documents.js';

package/packages/@monomind/cli/dist/src/commands/agent-lifecycle.js

@@ -6,6 +6,7 @@ import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
+import { writeJsonFileAtomic } from '../utils/json-file.js';
 // ─── Shared utilities ────────────────────────────────────────────────────────
 export function updateSwarmActivityMetrics(agentCountDelta) {
     try {
@@ -18,9 +19,6 @@ export function updateSwarmActivityMetrics(agentCountDelta) {
         if (fs.existsSync(activityPath) && fs.statSync(activityPath).size <= 10 * 1024 * 1024) {
             data = JSON.parse(fs.readFileSync(activityPath, 'utf-8'));
         }
-        else {
-            fs.mkdirSync(metricsDir, { recursive: true });
-        }
         const swarm = data.swarm ?? {};
         const currentCount = Math.max(0, swarm.agent_count || 0);
         const newCount = Math.max(0, currentCount + agentCountDelta);
@@ -29,9 +27,7 @@ export function updateSwarmActivityMetrics(agentCountDelta) {
         swarm.coordination_active = newCount > 0;
         data.swarm = swarm;
         data.timestamp = new Date().toISOString();
-        const tmpPath = activityPath + '.tmp';
-        fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-        fs.renameSync(tmpPath, activityPath);
+        writeJsonFileAtomic(activityPath, data);
     }
     catch {
         // Non-critical — don't fail the command if metrics update fails

package/packages/@monomind/cli/dist/src/commands/analyze.d.ts

@@ -7,16 +7,12 @@
  * - Symbol extraction (functions, classes, variables, types)
  * - Cyclomatic complexity scoring
  * - Diff classification and risk assessment
- * - Graph boundaries using MinCut algorithm
- * - Module communities using Louvain algorithm
- * - Circular dependency detection
  *
  * github.com/monoes/monomind
  */
 import type { Command } from '../types.js';
 type AnalyzerModule = any;
 export declare function getASTAnalyzer(): Promise<AnalyzerModule | null>;
-export declare function getGraphAnalyzer(): Promise<AnalyzerModule | null>;
 /**
  * Write analysis output to a file, constraining the path to the current working
  * directory to prevent path traversal attacks via --output /etc/cron.d/x or

package/packages/@monomind/cli/dist/src/commands/analyze.js

@@ -7,9 +7,6 @@
  * - Symbol extraction (functions, classes, variables, types)
  * - Cyclomatic complexity scoring
  * - Diff classification and risk assessment
- * - Graph boundaries using MinCut algorithm
- * - Module communities using Louvain algorithm
- * - Circular dependency detection
  *
  * github.com/monoes/monomind
  */
@@ -21,16 +18,10 @@ import { diffCommand, codeCommand } from './analyze-diff.js';
 import { astCommand } from './analyze-ast.js';
 import { complexityAstCommand, symbolsCommand } from './analyze-symbols.js';
 import { importsCommand, depsCommand } from './analyze-imports.js';
-import { boundariesCommand, modulesCommand } from './analyze-boundaries.js';
-import { dependenciesCommand, circularCommand } from './analyze-graph.js';
 // AST analyzer module was never shipped — always falls back to the regex path.
 export async function getASTAnalyzer() {
     return null;
 }
-// Graph analyzer module was never shipped — callers handle the null path.
-export async function getGraphAnalyzer() {
-    return null;
-}
 /**
  * Write analysis output to a file, constraining the path to the current working
  * directory to prevent path traversal attacks via --output /etc/cron.d/x or
@@ -154,7 +145,7 @@ export function fallbackAnalyze(code, filePath) {
 // Main analyze command
 export const analyzeCommand = {
     name: 'analyze',
-    description: 'Code analysis, diff classification, graph boundaries, and change risk assessment',
+    description: 'Code analysis, diff classification, and change risk assessment',
     aliases: ['an'],
     subcommands: [
         diffCommand,
@@ -164,10 +155,6 @@ export const analyzeCommand = {
         complexityAstCommand,
         symbolsCommand,
         importsCommand,
-        boundariesCommand,
-        modulesCommand,
-        dependenciesCommand,
-        circularCommand,
     ],
     options: [
         {
@@ -191,10 +178,6 @@ export const analyzeCommand = {
         { command: 'monomind analyze symbols src/ --type function', description: 'Extract all functions' },
         { command: 'monomind analyze imports src/ --external', description: 'List npm dependencies' },
         { command: 'monomind analyze diff --risk', description: 'Analyze diff with risk assessment' },
-        { command: 'monomind analyze boundaries src/', description: 'Find code boundaries using MinCut' },
-        { command: 'monomind analyze modules src/', description: 'Detect module communities with Louvain' },
-        { command: 'monomind analyze dependencies src/ --format dot', description: 'Export dependency graph as DOT' },
-        { command: 'monomind analyze circular src/', description: 'Find circular dependencies' },
         { command: 'monomind analyze deps --security', description: 'Check dependency vulnerabilities' },
     ],
     action: async (_ctx) => {
@@ -212,10 +195,6 @@ export const analyzeCommand = {
         output.writeln(`  ${output.highlight('complexity')}   Analyze cyclomatic and cognitive complexity`);
         output.writeln(`  ${output.highlight('symbols')}      Extract functions, classes, and types`);
         output.writeln(`  ${output.highlight('imports')}      Analyze import dependencies`);
-        output.writeln(`  ${output.highlight('boundaries')}   Find code boundaries using MinCut algorithm`);
-        output.writeln(`  ${output.highlight('modules')}      Detect module communities using Louvain algorithm`);
-        output.writeln(`  ${output.highlight('dependencies')} Build and export full dependency graph`);
-        output.writeln(`  ${output.highlight('circular')}     Detect circular dependencies in codebase`);
         output.writeln();
         output.writeln(output.bold('AST Analysis Examples:'));
         output.writeln();
@@ -225,13 +204,6 @@ export const analyzeCommand = {
         output.writeln(`  ${output.dim('monomind analyze symbols src/ --type fn')}    # Extract functions`);
         output.writeln(`  ${output.dim('monomind analyze imports src/ --external')}   # Only npm imports`);
         output.writeln();
-        output.writeln(output.bold('Graph Analysis Examples:'));
-        output.writeln();
-        output.writeln(`  ${output.dim('monomind analyze boundaries src/')}            # Find natural code boundaries`);
-        output.writeln(`  ${output.dim('monomind analyze modules src/')}               # Detect module communities`);
-        output.writeln(`  ${output.dim('monomind analyze dependencies -f dot src/')}   # Export to DOT format`);
-        output.writeln(`  ${output.dim('monomind analyze circular src/')}              # Find circular deps`);
-        output.writeln();
         output.writeln(output.bold('Diff Analysis Examples:'));
         output.writeln();
         output.writeln(`  ${output.dim('monomind analyze diff --risk')}              # Risk assessment`);

package/packages/@monomind/cli/dist/src/commands/completions.js

@@ -7,9 +7,9 @@
 import { output } from '../output.js';
 // Get all top-level commands for completions
 const TOP_LEVEL_COMMANDS = [
-    'swarm', 'agent', 'task', 'session', 'config', 'memory', 'workflow',
-    'hive-mind', 'hooks', 'daemon', 'security', 'performance',
-    'providers', 'claims', 'embeddings',
+    'swarm', 'agent', 'task', 'session', 'config', 'memory',
+    'hive-mind', 'hooks', 'security', 'performance',
+    'providers', 'embeddings',
     'doctor', 'completions', 'help', 'version'
 ];
 // Swarm subcommands
@@ -85,10 +85,6 @@ _monomind_completions() {
             COMPREPLY=( $(compgen -W "generate search compare collections index providers" -- "\${cur}") )
             return 0
             ;;
-        daemon)
-            COMPREPLY=( $(compgen -W "start stop status trigger enable" -- "\${cur}") )
-            return 0
-            ;;
         providers)
             COMPREPLY=( $(compgen -W "list configure test models usage" -- "\${cur}") )
             return 0
@@ -130,7 +126,6 @@ _monomind() {
         'workflow:Workflow automation'
         'hive-mind:Queen-led consensus coordination'
         'hooks:Self-learning automation hooks'
-        'daemon:Background service management'
         'security:Security scanning and CVE detection'
         'performance:Performance profiling'
         'providers:AI provider management'
@@ -262,15 +257,6 @@ _monomind() {
                         'providers:Embedding providers'
                     )
                     ;;
-                daemon)
-                    subcommands=(
-                        'start:Start daemon'
-                        'stop:Stop daemon'
-                        'status:Daemon status'
-                        'trigger:Trigger event'
-                        'enable:Enable feature'
-                    )
-                    ;;
                 providers)
                     subcommands=(
                         'list:List providers'
@@ -331,9 +317,6 @@ complete -c monomind -n "__fish_seen_subcommand_from claims" -a "list check gran
 # Embeddings subcommands
 complete -c monomind -n "__fish_seen_subcommand_from embeddings" -a "generate search compare collections index providers"
 
-# Daemon subcommands
-complete -c monomind -n "__fish_seen_subcommand_from daemon" -a "start stop status trigger enable"
-
 # Providers subcommands
 complete -c monomind -n "__fish_seen_subcommand_from providers" -a "list configure test models usage"
 `;
@@ -358,9 +341,7 @@ $script:SubCommands = @{
     'hooks' = @('${HOOKS_SUBCOMMANDS.join("', '")}')
     'security' = @('scan', 'cve', 'audit', 'secrets')
     'performance' = @('benchmark', 'profile', 'metrics', 'bottleneck')
-    'claims' = @('list', 'check', 'grant', 'revoke', 'roles', 'policies')
     'embeddings' = @('generate', 'search', 'compare', 'collections', 'index', 'providers')
-    'daemon' = @('start', 'stop', 'status', 'trigger', 'enable')
     'providers' = @('list', 'configure', 'test', 'models', 'usage')
 }
 

package/packages/@monomind/cli/dist/src/commands/config.js

@@ -18,12 +18,6 @@ const initCommand = {
             type: 'boolean',
             default: false
         },
-        {
-            name: 'sparc',
-            description: 'Initialize with SPARC methodology',
-            type: 'boolean',
-            default: false
-        },
         {
             name: 'v1',
             description: 'Initialize v1 configuration',

package/packages/@monomind/cli/dist/src/commands/doctor-project-checks.d.ts

@@ -1,11 +1,10 @@
 /**
  * Doctor — project/monomind health checks
- * Config, daemon, memory, API keys, MCP, monograph, helpers, routing, gates, gitignore
+ * Config, memory, API keys, MCP, monograph, helpers, routing, gates, gitignore, worker metrics
  */
 import type { HealthCheck } from './doctor-env-checks.js';
 export type { HealthCheck };
 export declare function checkConfigFile(): Promise<HealthCheck>;
-export declare function checkDaemonStatus(): Promise<HealthCheck>;
 export declare function checkMemoryDatabase(): Promise<HealthCheck>;
 export declare function checkApiKeys(): Promise<HealthCheck>;
 export declare function checkMcpServers(): Promise<HealthCheck>;
@@ -18,6 +17,17 @@ export declare function checkMonoesIntegration(): Promise<HealthCheck>;
 export declare function checkGitignoreCoverage(): Promise<HealthCheck>;
 export declare function checkAgentRegistry(): Promise<HealthCheck>;
 export declare function checkGuidanceGates(): Promise<HealthCheck>;
+/**
+ * Worker metrics freshness — reports the age of the @monomind/hooks worker
+ * output files (written at session start with a 6h staleness gate, or on
+ * demand via `monomind hooks worker run <name>`), so missing/stale worker
+ * output is visible without digging through .monomind/metrics.
+ */
+export declare function checkMetricsFreshness(): Promise<HealthCheck>;
+/**
+ * Surfaces critical findings from the security-audit worker output.
+ */
+export declare function checkSecurityAuditFindings(): Promise<HealthCheck>;
 /**
  * AutoMem proficiency check — reports memory learning health
  */

package/packages/@monomind/cli/dist/src/commands/doctor-project-checks.js

@@ -1,13 +1,13 @@
 /**
  * Doctor — project/monomind health checks
- * Config, daemon, memory, API keys, MCP, monograph, helpers, routing, gates, gitignore
+ * Config, memory, API keys, MCP, monograph, helpers, routing, gates, gitignore, worker metrics
  */
 import { existsSync, readFileSync, statSync, mkdirSync, copyFileSync } 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_PID_BYTES, MAX_DOCTOR_HELPER_BYTES, } from './doctor-env-checks.js';
+import { MAX_DOCTOR_PKG_BYTES, MAX_DOCTOR_CONFIG_BYTES, MAX_DOCTOR_GITIGNORE_BYTES, MAX_DOCTOR_HELPER_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) {
@@ -28,25 +28,6 @@ export async function checkConfigFile() {
     }
     return { name: 'Config File', status: 'warn', message: 'No config file (using defaults)', fix: 'monomind config init' };
 }
-export async function checkDaemonStatus() {
-    try {
-        const pidFile = '.monomind/daemon.pid';
-        if (existsSync(pidFile) && statSync(pidFile).size <= MAX_DOCTOR_PID_BYTES) {
-            const pid = readFileSync(pidFile, 'utf8').trim();
-            try {
-                process.kill(parseInt(pid, 10), 0);
-                return { name: 'Daemon Status', status: 'pass', message: `Running (PID: ${pid})` };
-            }
-            catch {
-                return { name: 'Daemon Status', status: 'warn', message: 'Stale PID file', fix: 'rm .monomind/daemon.pid && monomind daemon start' };
-            }
-        }
-        return { name: 'Daemon Status', status: 'warn', message: 'Not running', fix: 'monomind daemon start' };
-    }
-    catch {
-        return { name: 'Daemon Status', status: 'warn', message: 'Unable to check', fix: 'monomind daemon status' };
-    }
-}
 export async function checkMemoryDatabase() {
     const dbPaths = ['.monomind/memory.db', '.swarm/memory.db', 'data/memory.db'];
     for (const dbPath of dbPaths) {
@@ -329,9 +310,52 @@ async function routingAccuracyLine() {
         return 'routing accuracy (last 100): no outcome data yet';
     }
 }
+/** Fallback when route-outcomes.jsonl has no data: summarize .monomind/routing-feedback.jsonl honestly. */
+function routingFeedbackFallback() {
+    try {
+        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 => {
+            try {
+                return JSON.parse(l);
+            }
+            catch {
+                return null;
+            }
+        }).filter((r) => r !== null);
+        if (records.length === 0)
+            return null;
+        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 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 };
+        }
+        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 };
+    }
+    catch {
+        return null;
+    }
+}
 export async function checkMonoesIntegration() {
     try {
-        return { name: 'Routing Learning', status: 'pass', message: await routingAccuracyLine() };
+        const line = await routingAccuracyLine();
+        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: 'pass', message: line };
     }
     catch (err) {
         return { name: 'Routing Learning', status: 'warn', message: `Could not compute routing accuracy: ${err instanceof Error ? err.message : String(err)}` };
@@ -445,6 +469,90 @@ export async function checkGuidanceGates() {
         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
+// window beyond that before flagging staleness.
+const METRICS_FRESHNESS_MS = 12 * 60 * 60 * 1000; // 12 hours
+const MAX_DOCTOR_METRICS_BYTES = 5 * 1024 * 1024;
+function readMetricsJSON(name) {
+    try {
+        const p = join(process.cwd(), '.monomind', 'metrics', name);
+        if (!existsSync(p) || statSync(p).size > MAX_DOCTOR_METRICS_BYTES)
+            return null;
+        return JSON.parse(readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Worker metrics freshness — reports the age of the @monomind/hooks worker
+ * output files (written at session start with a 6h staleness gate, or on
+ * demand via `monomind hooks worker run <name>`), so missing/stale worker
+ * output is visible without digging through .monomind/metrics.
+ */
+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',
+    ];
+    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' };
+    }
+    const now = Date.now();
+    const fresh = [];
+    const stale = [];
+    for (const name of knownOutputs) {
+        const p = join(metricsDir, name);
+        if (!existsSync(p))
+            continue;
+        try {
+            const ageMs = now - statSync(p).mtimeMs;
+            if (ageMs <= METRICS_FRESHNESS_MS)
+                fresh.push(name);
+            else
+                stale.push(name);
+        }
+        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' };
+    }
+    if (stale.length === 0) {
+        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',
+    };
+}
+/**
+ * Surfaces critical findings from the security-audit worker output.
+ */
+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' };
+    }
+    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);
+    if (riskLevel === 'critical' || riskLevel === 'high') {
+        return {
+            name: 'Security Audit',
+            status: 'fail',
+            message: `risk=${riskLevel}, ${criticalCount} critical finding(s) — ${priorityTargets.length} priority scan target(s)`,
+            fix: 'Review .monomind/metrics/security-audit.json priorityScanTargets and recommendations',
+        };
+    }
+    if (recommendations.length > 0) {
+        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` };
+}
 /**
  * AutoMem proficiency check — reports memory learning health
  */

package/packages/@monomind/cli/dist/src/commands/doctor.js

@@ -7,7 +7,7 @@
 import * as path from 'path';
 import { output } from '../output.js';
 import { checkNodeVersion, checkNpmVersion, checkGit, checkGitRepo, checkDiskSpace, checkBuildTools, checkVersionFreshness, checkClaudeCode, installClaudeCode, } from './doctor-env-checks.js';
-import { checkConfigFile, checkDaemonStatus, checkMemoryDatabase, checkApiKeys, checkMcpServers, checkMonograph, checkMonographFreshness, checkMonoesMemory, checkHelpersFresh, fixStaleHelpers, checkMonoesIntegration, checkGuidanceGates, checkGitignoreCoverage, checkAgentRegistry, checkMemoryProficiency, } from './doctor-project-checks.js';
+import { checkConfigFile, checkMemoryDatabase, checkApiKeys, checkMcpServers, checkMonograph, checkMonographFreshness, checkMonoesMemory, checkHelpersFresh, fixStaleHelpers, checkMonoesIntegration, checkGuidanceGates, checkGitignoreCoverage, checkAgentRegistry, checkMemoryProficiency, checkMetricsFreshness, checkSecurityAuditFindings, } from './doctor-project-checks.js';
 import { checkMonoesTools, fixMonoesTools } from './doctor-monoes-checks.js';
 function formatCheck(check) {
     const icon = check.status === 'pass' ? output.success('✓') :
@@ -23,7 +23,7 @@ export const doctorCommand = {
         { name: 'install', short: 'i', description: 'Auto-install missing dependencies (Claude Code CLI)', type: 'boolean', default: false },
         {
             name: 'component', short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, graph-freshness, memory-pkg, helpers, monoes, gates, gitignore, registry, monoes-tools)',
+            description: 'Check specific component (version, node, npm, config, memory, api, git, mcp, claude, disk, typescript, monograph, graph-freshness, memory-pkg, helpers, monoes, gates, gitignore, registry, monoes-tools, metrics-freshness, security-audit)',
             type: 'string',
         },
         { name: 'verbose', short: 'v', description: 'Verbose output', type: 'boolean', default: false },
@@ -63,8 +63,8 @@ export const doctorCommand = {
             checkVersionFreshness, checkNodeVersion, checkNpmVersion, checkClaudeCode,
             checkConfigFile, checkMemoryDatabase, checkDiskSpace,
             checkMonograph, checkMonoesMemory, checkHelpersFresh, checkMonoesIntegration,
-            checkGuidanceGates, checkAgentRegistry, checkGit, checkDaemonStatus, checkApiKeys,
-            checkMemoryProficiency,
+            checkGuidanceGates, checkAgentRegistry, checkGit, checkApiKeys,
+            checkMemoryProficiency, checkMetricsFreshness, checkSecurityAuditFindings,
         ];
         const codeOnlyChecks = [
             checkGitRepo, checkMcpServers,
@@ -76,7 +76,7 @@ export const doctorCommand = {
         const componentMap = {
             version: checkVersionFreshness, freshness: checkVersionFreshness,
             node: checkNodeVersion, npm: checkNpmVersion, claude: checkClaudeCode,
-            config: checkConfigFile, daemon: checkDaemonStatus, memory: checkMemoryDatabase,
+            config: checkConfigFile, memory: checkMemoryDatabase,
             api: checkApiKeys, git: checkGit, mcp: checkMcpServers, disk: checkDiskSpace,
             typescript: checkBuildTools, monograph: checkMonograph,
             'graph-freshness': checkMonographFreshness, 'memory-pkg': checkMonoesMemory,
@@ -84,6 +84,7 @@ export const doctorCommand = {
             gates: checkGuidanceGates, gitignore: checkGitignoreCoverage,
             registry: checkAgentRegistry, 'memory-proficiency': checkMemoryProficiency,
             'monoes-tools': checkMonoesTools,
+            'metrics-freshness': checkMetricsFreshness, 'security-audit': checkSecurityAuditFindings,
         };
         const checksToRun = (component && componentMap[component]) ? [componentMap[component]] : allChecks;
         const results = [];

package/packages/@monomind/cli/dist/src/commands/guidance.d.ts

@@ -1,6 +1,10 @@
 /**
  * CLI Guidance Command
- * Guidance Control Plane - compile, retrieve, enforce, optimize
+ *
+ * Wires the enforcement gates (destructive-ops + secrets) into Claude Code hooks.
+ * The gates themselves live in .claude/helpers/handlers/gates-handler.cjs — a
+ * self-contained regex table that runs on every PreToolUse. This command only
+ * registers the hook entries in .claude/settings.json.
  */
 import type { Command } from '../types.js';
 export declare const guidanceCommand: Command;