monomind 2.7.4 → 2.7.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "2.7.4",
+  "version": "2.7.5",
   "description": "Open-source CLI extension for Claude Code. Adds an MCP server with a codebase knowledge graph, persistent memory, multi-agent coordination, and reusable slash commands. MIT licensed, runs locally, no data leaves your machine.",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/bin/cli.js

@@ -287,7 +287,23 @@ if (isMCPMode) {
   const isDaemonChild = cliArgs.includes('--foreground-worker-internal');
   cli.run().then(() => {
     if (!isDaemonChild) {
-      process.exit(process.exitCode ?? 0);
+      // Prefer a natural exit over process.exit(). Any command that touched
+      // embeddings has onnxruntime-node's thread pool loaded in-process (via
+      // memory-bridge -> @huggingface/transformers), and forcing exit out from
+      // under it aborts the process:
+      //   libc++abi: terminating due to uncaught exception of type
+      //   std::__1::system_error: mutex lock failed: Invalid argument
+      // — an exit code of 134 on `doctor`, `memory store`, `memory search`,
+      // etc., despite the command itself having succeeded. Disposing the
+      // pipeline first does NOT help; only letting the loop drain does.
+      //
+      // So: publish the exit code and let node exit on its own once the loop
+      // empties. The unref'd timer below still fires if something lingers
+      // (it does not itself hold the process open), preserving the original
+      // guarantee that the CLI never hangs forever on a stray handle.
+      process.exitCode = process.exitCode ?? 0;
+      const FORCE_EXIT_MS = 5000;
+      setTimeout(() => process.exit(process.exitCode ?? 0), FORCE_EXIT_MS).unref();
     }
     // Daemon child: let the event loop stay alive on its own ref'd interval.
   }).catch((error) => {

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

@@ -23,6 +23,9 @@ export declare function fixStaleHelpers(): Promise<boolean>;
 export declare function checkHelpersFresh(): Promise<HealthCheck>;
 export declare function checkMonoesIntegration(): Promise<HealthCheck>;
 export declare function checkGitignoreCoverage(): Promise<HealthCheck>;
+/** Creates or appends the missing gitignore entries. Returns true if it wrote.
+ *  Append-only and idempotent: never rewrites lines the user already has. */
+export declare function fixGitignoreCoverage(): Promise<boolean>;
 export declare function checkAgentRegistry(): Promise<HealthCheck>;
 export declare function checkGuidanceGates(): Promise<HealthCheck>;
 /**

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

@@ -2,7 +2,7 @@
  * Doctor — project/monomind health checks
  * Config, memory, API keys, MCP, monograph, helpers, routing, gates, gitignore, worker metrics
  */
-import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, copyFileSync } from 'fs';
+import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, copyFileSync, writeFileSync, appendFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { execSync } from 'child_process';
@@ -476,24 +476,97 @@ const REQUIRED_GITIGNORE_PATTERNS = [
     { pattern: '.hive-mind/', reason: 'hive-mind state with session info' },
     { pattern: '.swarm/', reason: 'swarm 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(/\/+$/, '');
+}
+/** True when ignoring `line` already protects everything `required` covers.
+ *  Beyond exact matches this understands directory containment: a repo with a
+ *  blanket `.monomind/` is fully covered for `.monomind/sessions/`,
+ *  `.monomind/*.json` and friends, and should not be nagged to add each one. */
+function gitignoreLineCovers(line, required) {
+    const l = normalizeGitignorePattern(line);
+    const r = normalizeGitignorePattern(required);
+    if (!l)
+        return false;
+    if (l === r)
+        return true;
+    // A bare directory entry covers every path beneath it, but only when the
+    // entry itself is literal — `.monomind/*.json` must not be treated as an
+    // ancestor of `.monomind/sessions`.
+    return !l.includes('*') && r.startsWith(`${l}/`);
+}
 export async function checkGitignoreCoverage() {
     const gitignorePath = join(process.cwd(), '.gitignore');
     if (!existsSync(gitignorePath)) {
-        return { name: 'Gitignore Coverage', status: 'warn', message: 'No .gitignore found — all monomind runtime paths are unprotected', fix: 'echo ".monomind/\\n**/.monomind/" >> .gitignore' };
+        // The old hint was `echo ".monomind/\n**/.monomind/" >> .gitignore`, which
+        // 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)' };
     }
     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 }) => {
-        const base = pattern.replace(/\*\*\//g, '').replace(/\*/g, '');
-        return !lines.some(l => l === pattern || l === pattern.replace(/\/$/, '') ||
-            (l.includes('**') && base && l.replace(/\*\*\//g, '').replace(/\*/g, '') === base));
-    });
+    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: `printf "${missing.map(m => m.pattern).join('\\n')}\\n" >> .gitignore` };
+    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
+ *  with no .gitignore has nothing protecting those either. */
+const GITIGNORE_FIX_PATTERNS = [
+    '# monomind runtime state',
+    '.monomind/',
+    '**/.monomind/',
+    '.hive-mind/',
+    '.swarm/',
+    '**/.claude-flow/',
+    'data/sessions/',
+    'data/mastermind-*.json',
+    'data/mastermind-*.jsonl',
+    '',
+    '# secrets / local env',
+    '.env',
+    '.env.*',
+    '!.env.example',
+    '*.pem',
+    '*.key',
+    '',
+    '# dependencies / build output',
+    'node_modules/',
+    'dist/',
+];
+/** Creates or appends the missing gitignore entries. Returns true if it wrote.
+ *  Append-only and idempotent: never rewrites lines the user already has. */
+export async function fixGitignoreCoverage() {
+    const gitignorePath = join(process.cwd(), '.gitignore');
+    try {
+        if (!existsSync(gitignorePath)) {
+            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)));
+        if (missing.length === 0)
+            return false;
+        const prefix = existing.endsWith('\n') || existing === '' ? '' : '\n';
+        appendFileSync(gitignorePath, `${prefix}\n# monomind runtime state\n${missing.join('\n')}\n`, 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 export async function checkAgentRegistry() {
     try {

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, checkMemoryDatabase, checkApiKeys, checkMcpServers, checkMonograph, checkMonographFreshness, checkMonoesMemory, checkHelpersFresh, fixStaleHelpers, checkMonoesIntegration, checkGuidanceGates, checkGitignoreCoverage, checkAgentRegistry, checkMemoryProficiency, checkMetricsFreshness, checkSecurityAuditFindings, checkSecondBrainModel, checkMemoryKnowledgeGraph, } from './doctor-project-checks.js';
+import { checkConfigFile, checkMemoryDatabase, checkApiKeys, checkMcpServers, checkMonograph, checkMonographFreshness, checkMonoesMemory, checkHelpersFresh, fixStaleHelpers, checkMonoesIntegration, checkGuidanceGates, checkGitignoreCoverage, fixGitignoreCoverage, checkAgentRegistry, checkMemoryProficiency, checkMetricsFreshness, checkSecurityAuditFindings, checkSecondBrainModel, checkMemoryKnowledgeGraph, } from './doctor-project-checks.js';
 import { checkMonoesTools, fixMonoesTools } from './doctor-monoes-checks.js';
 function formatCheck(check) {
     const icon = check.status === 'pass' ? output.success('✓') :
@@ -19,7 +19,7 @@ export const doctorCommand = {
     name: 'doctor',
     description: 'System diagnostics and health checks',
     options: [
-        { name: 'fix', short: 'f', description: 'Apply local fixes (helper files, monoes tool shims) and show fix commands for the rest', type: 'boolean', default: false },
+        { name: 'fix', short: 'f', description: 'Apply local fixes (helper files, monoes tool shims, .gitignore entries) and show fix commands for the rest', type: 'boolean', default: false },
         { name: 'install', short: 'i', description: 'Auto-install missing dependencies (Claude Code CLI)', type: 'boolean', default: false },
         {
             name: 'component', short: 'c',
@@ -160,6 +160,20 @@ export const doctorCommand = {
                     output.writeln(formatCheck(newCheck));
                 }
             }
+            const gitignoreResult = results.find(r => r.name === 'Gitignore Coverage');
+            if (gitignoreResult && gitignoreResult.status !== 'pass') {
+                if (await fixGitignoreCoverage()) {
+                    const newCheck = await checkGitignoreCoverage();
+                    const idx = results.findIndex(r => r.name === 'Gitignore Coverage');
+                    if (idx !== -1) {
+                        results[idx] = newCheck;
+                        const fixIdx = fixes.findIndex(f => f.startsWith('Gitignore Coverage:'));
+                        if (fixIdx !== -1 && newCheck.status === 'pass')
+                            fixes.splice(fixIdx, 1);
+                    }
+                    output.writeln(formatCheck(newCheck));
+                }
+            }
             const helpersResult = results.find(r => r.name === 'Helper Files');
             if (helpersResult && helpersResult.status !== 'pass') {
                 if (await fixStaleHelpers()) {

package/packages/@monomind/cli/dist/src/commands/memory-crud.js

@@ -241,7 +241,7 @@ export const searchCommand = {
         },
         {
             name: 'build-hnsw',
-            description: 'Build/rebuild pure-JS HNSW index before searching',
+            description: 'Build/rebuild the pure-JS HNSW fallback index. Only used when the SQLite bridge is unavailable (e.g. better-sqlite3 native binary failed to load) — has no effect on the search that follows when the bridge is active, which is the common case',
             type: 'boolean',
             default: false
         }
@@ -249,7 +249,7 @@ export const searchCommand = {
     examples: [
         { command: 'monomind memory search -q "authentication patterns"', description: 'Semantic search' },
         { command: 'monomind memory search -q "JWT" -t keyword', description: 'Keyword search' },
-        { command: 'monomind memory search -q "test" --build-hnsw', description: 'Build HNSW index and search' }
+        { command: 'monomind memory search -q "test" --build-hnsw', description: 'Build the sql.js-fallback HNSW index (no-op unless the SQLite bridge is down)' }
     ],
     action: async (ctx) => {
         const query = ctx.flags.query || ctx.args[0];
@@ -262,9 +262,14 @@ export const searchCommand = {
             output.printError('Query is required. Use --query or -q');
             return { success: false, exitCode: 1 };
         }
-        // Build/rebuild HNSW index if requested
+        // Build/rebuild the sql.js-fallback HNSW index if requested. This index is only
+        // consulted when the SQLite bridge is unavailable — check that first so the
+        // message reflects what will actually happen in the search below, not what
+        // would happen if this were the only backend.
         if (buildHnsw) {
-            output.printInfo('Building HNSW index...');
+            const { isBridgeAvailable } = await import('../memory/memory-bridge.js');
+            const bridgeUp = await isBridgeAvailable().catch(() => false);
+            output.printInfo('Building HNSW fallback index...');
             try {
                 const { getHNSWIndex, getHNSWStatus } = await import('../memory/memory-initializer.js');
                 const startTime = Date.now();
@@ -274,7 +279,12 @@ export const searchCommand = {
                     const status = getHNSWStatus();
                     output.printSuccess(`HNSW index built (${status.entryCount} vectors, ${buildTime}ms)`);
                     output.writeln(output.dim(`  Dimensions: ${status.dimensions}, Metric: cosine`));
-                    output.writeln(output.dim(`  Complexity: O(log n) vs O(n) linear scan`));
+                    if (bridgeUp) {
+                        output.writeln(output.dim('  Note: the SQLite bridge is active, so the search below uses its brute-force cosine search, not this index. This index only kicks in if the bridge becomes unavailable.'));
+                    }
+                    else {
+                        output.writeln(output.dim('  SQLite bridge is unavailable — the search below will use this index (O(log n) vs O(n) linear scan).'));
+                    }
                 }
                 else {
                     output.printWarning('HNSW index not available');

package/packages/@monomind/cli/dist/src/commands/security-misc.js

@@ -9,15 +9,20 @@ export const auditCommand = {
     name: 'audit',
     description: 'Security audit logging and compliance',
     options: [
-        { name: 'action', short: 'a', type: 'string', description: 'Action: log, list, export, clear', default: 'list' },
+        { name: 'action', short: 'a', type: 'string', description: 'Action: list (only supported value — log/export/clear are not implemented)', default: 'list' },
         { name: 'limit', short: 'l', type: 'number', description: 'Number of entries to show', default: '20' },
         { name: 'filter', short: 'f', type: 'string', description: 'Filter by event type' },
     ],
     examples: [
         { command: 'monomind security audit --action list', description: 'List audit logs' },
-        { command: 'monomind security audit -a export', description: 'Export audit trail' },
     ],
     action: async (ctx) => {
+        const requestedAction = ctx.flags.action || 'list';
+        if (requestedAction !== 'list') {
+            output.writeln();
+            output.writeln(output.error(`security audit --action ${requestedAction} is not implemented — only "list" is supported.`));
+            return { success: false, message: `Unsupported action: ${requestedAction}`, exitCode: 1 };
+        }
         output.writeln();
         output.writeln(output.bold('Security Audit Log'));
         output.writeln(output.dim('─'.repeat(60)));

package/packages/@monomind/cli/dist/src/init/helpers-generator.js

@@ -1283,6 +1283,11 @@ export const HELPER_FILES = {
     'statusline.cjs': { forceSync: true, doctorTracked: true },
     'graphify-freshen.cjs': { forceSync: true, doctorTracked: true },
     'router.cjs': { forceSync: true, doctorTracked: true, generate: generateAgentRouter },
+    // Regenerates skill-registry.json (which router.cjs's matchSkills reads) from
+    // the live .claude/commands + .claude/skills trees. No fallback generator:
+    // if it can't be copied there is nothing to regenerate the registry with, and
+    // router.cjs degrades to its built-in FALLBACK_SKILLS rather than breaking.
+    'build-skill-registry.cjs': { forceSync: true, doctorTracked: true },
     'memory.cjs': { generate: generateMemoryHelper },
     'session.cjs': { generate: generateSessionManager },
     'pre-commit': { generate: generatePreCommitHook },

package/packages/@monomind/cli/dist/src/mcp-client.js

@@ -41,7 +41,6 @@ const CATEGORY_LOADERS = {
     neural: async () => (await import('./mcp-tools/neural-tools.js')).neuralTools,
     performance: async () => (await import('./mcp-tools/performance-tools.js')).performanceTools,
     github: async () => (await import('./mcp-tools/github-tools.js')).githubTools,
-    daa: async () => (await import('./mcp-tools/daa-tools.js')).daaTools,
     browser: async () => (await import('./mcp-tools/browser-tools.js')).browserTools,
     guidance: async () => (await import('./mcp-tools/guidance-tools.js')).guidanceTools,
     autopilot: async () => (await import('./mcp-tools/autopilot-tools.js')).autopilotTools,
@@ -49,7 +48,6 @@ const CATEGORY_LOADERS = {
     graphify: async () => (await import('./mcp-tools/graphify-tools.js')).graphifyTools,
     coverage: async () => (await import('./monovector/coverage-tools.js')).coverageRouterTools,
     quality: async () => (await import('./mcp-tools/quality-tools.js')).qualityTools,
-    coherence: async () => (await import('./mcp-tools/coherence-tools.js')).coherenceTools,
     knowledge: async () => (await import('./mcp-tools/knowledge-tools.js')).knowledgeTools,
     // system-tools.ts also exports tools with mcp_ and config_ prefixes
     mcp: async () => (await import('./mcp-tools/system-tools.js')).systemTools,

package/packages/@monomind/cli/dist/src/mcp-tools/agent-tools.js

@@ -121,7 +121,7 @@ async function determineAgentModel(agentType, config, task) {
 export const agentTools = [
     {
         name: 'agent_spawn',
-        description: 'Spawn a new agent with intelligent model selection',
+        description: 'Register a new agent record (type, model preference, status) in the persistent agent store. This creates a database entry, not a running agent — use Claude Code\'s Task tool to actually execute work.',
         category: 'agent',
         inputSchema: {
             type: 'object',

package/packages/@monomind/cli/dist/src/mcp-tools/embeddings-tools.d.ts

@@ -5,5 +5,7 @@
  * Implements ADR-024: Embeddings MCP Tools
  */
 import type { MCPTool } from './types.js';
+/** Ungated — internal/test use only. MCP clients get `embeddingsTools` below. */
+export declare const allEmbeddingsTools: MCPTool[];
 export declare const embeddingsTools: MCPTool[];
 //# sourceMappingURL=embeddings-tools.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/embeddings-tools.js

@@ -128,7 +128,8 @@ function poincareDistance(a, b, curvature) {
     const delta = 2 * diffSq / (denom + 1e-15);
     return (1 / Math.sqrt(c)) * Math.acosh(1 + delta);
 }
-export const embeddingsTools = [
+/** Ungated — internal/test use only. MCP clients get `embeddingsTools` below. */
+export const allEmbeddingsTools = [
     {
         name: 'embeddings_init',
         description: 'Initialize the ONNX embedding subsystem with hyperbolic support',
@@ -845,4 +846,13 @@ export const embeddingsTools = [
         },
     },
 ];
+// embeddings_neural's `init` action persists a config blob (sona/flashAttention/
+// ewcPlusPlus/etc.) with no implementing code anywhere for those flags — gated
+// behind MONOMIND_MCP_SPECULATIVE=1. The other 6 tools in this file
+// (embeddings_init/generate/compare/search/hyperbolic/status) do real work
+// and stay visible by default.
+const SPECULATIVE = process.env['MONOMIND_MCP_SPECULATIVE'] === '1';
+export const embeddingsTools = SPECULATIVE
+    ? allEmbeddingsTools
+    : allEmbeddingsTools.filter(t => t.name !== 'embeddings_neural');
 //# sourceMappingURL=embeddings-tools.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/guidance-tools.js

@@ -70,7 +70,7 @@ const CAPABILITY_CATALOG = {
         description: 'Multi-agent coordination with topology-aware communication and consensus.',
         tools: ['swarm_init', 'swarm_status', 'swarm_spawn', 'swarm_terminate', 'swarm_topology', 'swarm_metrics'],
         commands: ['swarm init', 'swarm status', 'swarm spawn', 'swarm terminate'],
-        agents: ['hierarchical-coordinator', 'mesh-coordinator', 'adaptive-coordinator', 'queen-coordinator', 'collective-intelligence-coordinator'],
+        agents: ['mesh-coordinator', 'queen-coordinator', 'collective-intelligence-coordinator'],
         skills: ['swarm-orchestration', 'swarm-advanced', 'monomind-swarm'],
         whenToUse: 'When a task requires multiple agents working together (3+ files, features, refactoring).',
     },
@@ -79,8 +79,8 @@ const CAPABILITY_CATALOG = {
         description: 'Persistent memory with ANN vector search, SQLite storage, and embeddings.',
         tools: ['memory_store', 'memory_retrieve', 'memory_search', 'memory_list', 'memory_delete', 'memory_init', 'memory_export', 'memory_import', 'memory_stats', 'memory_compact', 'memory_namespace'],
         commands: ['memory store', 'memory retrieve', 'memory search', 'memory list', 'memory delete', 'memory init'],
-        agents: ['swarm-memory-manager', 'v1-memory-specialist'],
-        skills: ['v1-memory-unification', 'memory-advanced', 'memory-vector-search', 'memory-patterns', 'memory-learning'],
+        agents: ['swarm-memory-manager'],
+        skills: ['memory-advanced', 'memory-vector-search', 'memory-patterns', 'memory-learning'],
         whenToUse: 'When you need to persist, search, or retrieve knowledge across sessions.',
     },
     'intelligence-learning': {
@@ -88,7 +88,7 @@ const CAPABILITY_CATALOG = {
         description: 'Pattern storage and cosine-similarity search (SONA/ReasoningBank) backed by real embeddings.',
         tools: ['neural_train', 'neural_predict', 'neural_status', 'neural_patterns', 'neural_optimize'],
         commands: [],
-        agents: ['sona-learning-optimizer', 'safla-neural'],
+        agents: [],
         skills: ['reasoningbank-intelligence', 'memory-reasoningbank'],
         whenToUse: 'When optimizing agent routing, training patterns from outcomes, or adaptive learning.',
     },
@@ -112,7 +112,7 @@ const CAPABILITY_CATALOG = {
         description: 'Queen-led Byzantine fault-tolerant distributed consensus with multiple strategies.',
         tools: ['hive_mind_init', 'hive_mind_status', 'hive_mind_propose', 'hive_mind_vote', 'hive_mind_consensus', 'hive_mind_metrics'],
         commands: ['hive-mind init', 'hive-mind status', 'hive-mind consensus', 'hive-mind sessions', 'hive-mind spawn', 'hive-mind stop'],
-        agents: ['byzantine-coordinator', 'raft-manager', 'gossip-coordinator', 'crdt-synchronizer', 'quorum-manager'],
+        agents: ['crdt-synchronizer', 'quorum-manager'],
         skills: ['hive-mind-advanced'],
         whenToUse: 'When multiple agents need to reach agreement on decisions using BFT, Raft, or CRDT.',
     },
@@ -121,8 +121,8 @@ const CAPABILITY_CATALOG = {
         description: 'Security scanning, CVE remediation, input validation, claims-based authorization.',
         tools: ['security_scan', 'security_audit', 'security_cve', 'security_threats', 'security_validate', 'security_report', 'claims_check', 'claims_grant', 'claims_revoke', 'claims_list'],
         commands: ['security scan', 'security audit', 'security cve', 'security threats', 'claims check', 'claims grant'],
-        agents: ['v1-security-architect'],
-        skills: ['v1-security-overhaul'],
+        agents: ['security-manager'],
+        skills: [],
         whenToUse: 'When auditing code for vulnerabilities, managing permissions, or security reviews.',
     },
     'performance': {
@@ -130,8 +130,8 @@ const CAPABILITY_CATALOG = {
         description: 'Benchmarking, profiling, metrics collection, and optimization recommendations.',
         tools: ['performance_benchmark', 'performance_profile', 'performance_metrics', 'performance_optimize', 'performance_report'],
         commands: ['performance benchmark', 'performance profile', 'performance metrics', 'performance optimize', 'performance report'],
-        agents: ['v1-performance-engineer'],
-        skills: ['v1-performance-optimization', 'performance-analysis'],
+        agents: [],
+        skills: ['performance-analysis'],
         whenToUse: 'When measuring, profiling, or optimizing system performance.',
     },
     'github-integration': {
@@ -139,7 +139,7 @@ const CAPABILITY_CATALOG = {
         description: 'PR management, code review, issue tracking, release automation, multi-repo coordination.',
         tools: ['github_pr_manage', 'github_code_review', 'github_issue_track', 'github_repo_analyze', 'github_sync_coord', 'github_metrics'],
         commands: [],
-        agents: ['pr-manager', 'code-review-swarm', 'issue-tracker', 'release-manager', 'repo-architect', 'workflow-automation', 'multi-repo-swarm', 'project-board-sync', 'swarm-pr', 'swarm-issue', 'sync-coordinator', 'github-modes', 'release-swarm'],
+        agents: ['pr-manager', 'code-review-swarm', 'issue-tracker', 'release-manager', 'repo-architect', 'workflow-automation', 'multi-repo-swarm', 'project-board-sync', 'swarm-pr', 'swarm-issue', 'sync-coordinator', 'github-modes'],
         skills: ['github-release-management', 'github-workflow-automation', 'github-code-review', 'github-project-management', 'github-multi-repo'],
         whenToUse: 'When working with GitHub repos, PRs, issues, releases, or CI/CD pipelines.',
     },
@@ -166,7 +166,7 @@ const CAPABILITY_CATALOG = {
         description: 'AST analysis, diff classification, coverage routing, dependency graph analysis.',
         tools: ['analyze_diff', 'analyze_coverage', 'analyze_graph'],
         commands: [],
-        agents: ['code-analyzer'],
+        agents: [],
         skills: ['verification-quality'],
         whenToUse: 'When analyzing code quality, diffs, coverage gaps, or dependency graphs.',
     },
@@ -208,7 +208,7 @@ const WORKFLOW_TEMPLATES = {
     },
     refactor: {
         steps: ['Analyze code structure', 'Plan refactor approach', 'Implement changes', 'Verify no regressions'],
-        agents: ['code-analyzer', 'coder', 'reviewer'],
+        agents: ['coder', 'reviewer'],
         topology: 'hierarchical',
     },
     testing: {
@@ -218,17 +218,17 @@ const WORKFLOW_TEMPLATES = {
     },
     security: {
         steps: ['Run security scan', 'Triage findings', 'Fix vulnerabilities', 'Verify remediations'],
-        agents: ['v1-security-architect', 'coder', 'reviewer'],
+        agents: ['security-manager', 'coder', 'reviewer'],
         topology: 'hierarchical',
     },
     performance: {
         steps: ['Run benchmarks', 'Profile bottlenecks', 'Implement optimizations', 'Re-benchmark'],
-        agents: ['v1-performance-engineer', 'coder'],
+        agents: ['coder'],
         topology: 'hierarchical',
     },
     memory: {
         steps: ['Initialize memory store', 'Store/retrieve patterns', 'Search with HNSW', 'Compact and optimize'],
-        agents: ['v1-memory-specialist'],
+        agents: ['swarm-memory-manager'],
         topology: 'hierarchical',
     },
     'github-pr': {
@@ -243,12 +243,12 @@ const WORKFLOW_TEMPLATES = {
     },
     swarm: {
         steps: ['Initialize swarm topology', 'Spawn specialized agents', 'Coordinate via memory', 'Collect and synthesize results'],
-        agents: ['hierarchical-coordinator', 'coder', 'tester', 'reviewer'],
+        agents: ['mesh-coordinator', 'coder', 'tester', 'reviewer'],
         topology: 'hierarchical',
     },
     learning: {
         steps: ['Pretrain on codebase', 'Record trajectories', 'Compute rewards', 'Distill learning', 'Consolidate (EWC++)'],
-        agents: ['sona-learning-optimizer'],
+        agents: [],
         topology: 'hierarchical',
     },
     automation: {

package/packages/@monomind/cli/dist/src/mcp-tools/hive-mind-tools.d.ts

@@ -11,5 +11,7 @@
  * The names are kept for CLI/API compatibility.
  */
 import { type MCPTool } from './types.js';
+/** Ungated — internal/test use only. MCP clients get `hiveMindTools` below. */
+export declare const allHiveMindTools: MCPTool[];
 export declare const hiveMindTools: MCPTool[];
 //# sourceMappingURL=hive-mind-tools.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/hive-mind-tools.js

@@ -194,7 +194,14 @@ function saveAgentStore(store) {
     writeAgentStore(tmp, JSON.stringify(store, null, 2), 'utf-8');
     renameSync(tmp, dest);
 }
-export const hiveMindTools = [
+// Every hive-mind_* tool operates on a single JSON state file in one process —
+// "consensus"/"spawn"/"broadcast" etc. are vote-threshold bookkeeping and
+// record-keeping, not real distributed coordination (see CLAUDE.md's Hive-Mind
+// Consensus section and hive-mind_consensus's own description). Only status/join
+// are legitimate no-drama primitives (read state / register into it) and stay
+// visible by default; everything else is gated behind MONOMIND_MCP_SPECULATIVE=1.
+/** Ungated — internal/test use only. MCP clients get `hiveMindTools` below. */
+export const allHiveMindTools = [
     {
         name: 'hive-mind_spawn',
         description: 'Spawn workers and automatically join them to the hive-mind (combines agent/spawn + hive-mind/join)',
@@ -536,7 +543,7 @@ export const hiveMindTools = [
     },
     {
         name: 'hive-mind_consensus',
-        description: 'Propose or vote on consensus with BFT, Raft, or Quorum strategies',
+        description: 'Propose or vote on a threshold-based decision, single-process only. "bft"/"raft"/"quorum" are vote-count thresholds (2f+1 / majority / configurable preset) over one JSON state file — NOT real distributed consensus protocols (no leader election, log replication, or network model). Names kept for CLI/API compatibility.',
         category: 'hive-mind',
         inputSchema: {
             type: 'object',
@@ -1222,4 +1229,9 @@ export const hiveMindTools = [
         },
     },
 ];
+const SPECULATIVE = process.env['MONOMIND_MCP_SPECULATIVE'] === '1';
+const CORE_HIVE_MIND_NAMES = new Set(['hive-mind_status', 'hive-mind_join']);
+export const hiveMindTools = SPECULATIVE
+    ? allHiveMindTools
+    : allHiveMindTools.filter(t => CORE_HIVE_MIND_NAMES.has(t.name));
 //# sourceMappingURL=hive-mind-tools.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/index.d.ts

@@ -26,7 +26,6 @@ export { autopilotTools } from './autopilot-tools.js';
 export { graphifyTools } from './graphify-tools.js';
 export { monographTools } from './monograph-tools.js';
 export { terminalTools } from './terminal-tools.js';
-export { daaTools } from './daa-tools.js';
 export { browserTools } from './browser-tools.js';
 export { knowledgeTools } from './knowledge-tools.js';
 //# sourceMappingURL=index.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/index.js

@@ -26,7 +26,6 @@ export { autopilotTools } from './autopilot-tools.js';
 export { graphifyTools } from './graphify-tools.js';
 export { monographTools } from './monograph-tools.js';
 export { terminalTools } from './terminal-tools.js';
-export { daaTools } from './daa-tools.js';
 export { browserTools } from './browser-tools.js';
 export { knowledgeTools } from './knowledge-tools.js';
 //# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/monograph-tools.js

@@ -6,7 +6,7 @@
  */
 import { join, resolve, sep } from 'path';
 import { execSync } from 'child_process';
-import { statSync } from 'fs';
+import { statSync, readdirSync, existsSync } from 'fs';
 import { randomUUID } from 'crypto';
 import { getProjectCwd } from './types.js';
 let _cachedDbPath;
@@ -2108,7 +2108,6 @@ const monographDeadCodeTool = {
     },
 };
 function findStaleDist(repoPath) {
-    const { readdirSync, existsSync } = require('fs');
     const distSrc = join(repoPath, 'dist', 'src');
     const src = join(repoPath, 'src');
     // Scan a single package for stale dist artifacts

package/packages/@monomind/cli/dist/src/mcp-tools/neural-tools.js

@@ -201,7 +201,7 @@ export const neuralTools = [
     },
     {
         name: 'neural_patterns',
-        description: 'Get or manage neural patterns',
+        description: 'List, inspect, or delete entries in the stored pattern set (CRUD over the embedding-backed pattern store — no model or network involved)',
         category: 'neural',
         inputSchema: {
             type: 'object',

package/packages/@monomind/cli/dist/src/mcp-tools/swarm-tools.js

@@ -56,7 +56,7 @@ const VALID_TOPOLOGIES = new Set([
 export const swarmTools = [
     {
         name: 'swarm_init',
-        description: 'Initialize a swarm with persistent state tracking',
+        description: 'Record a swarm topology/strategy in persistent state. This writes a JSON state file — it does not start any process, thread, or agent. Actual concurrent work only happens when the caller separately dispatches subagents with Claude Code\'s Task tool.',
         category: 'swarm',
         inputSchema: {
             type: 'object',
@@ -193,7 +193,7 @@ export const swarmTools = [
     },
     {
         name: 'swarm_scale',
-        description: 'Scale a swarm to a target agent count by spawning or terminating agents',
+        description: 'Adjust the number of agent records in a swarm\'s persistent state to a target count. Adds or removes bookkeeping entries only — no process is started or stopped.',
         category: 'swarm',
         inputSchema: {
             type: 'object',

package/packages/@monomind/cli/dist/src/mcp-tools/transfer-tools.d.ts

@@ -9,6 +9,8 @@ import type { MCPTool } from './types.js';
 /**
  * Transfer MCP tools for pattern export, import, anonymization, and sharing
  */
+/** Ungated — internal/test use only. MCP clients get `transferTools` below. */
+export declare const allTransferTools: MCPTool[];
 export declare const transferTools: MCPTool[];
 export default transferTools;
 //# sourceMappingURL=transfer-tools.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/transfer-tools.js

@@ -37,7 +37,8 @@ async function getPatternStore() {
 /**
  * Transfer MCP tools for pattern export, import, anonymization, and sharing
  */
-export const transferTools = [
+/** Ungated — internal/test use only. MCP clients get `transferTools` below. */
+export const allTransferTools = [
     // ═══════════════════════════════════════════════════════════════
     // ANONYMIZATION TOOLS
     // ═══════════════════════════════════════════════════════════════
@@ -275,5 +276,14 @@ export const transferTools = [
         },
     },
 ];
+// The IPFS pattern-registry tools (ipfs-resolve, store-*) have zero test
+// coverage and no evidence of production use — gated behind
+// MONOMIND_MCP_SPECULATIVE=1. transfer_detect-pii is an unrelated, real PII
+// scanner bundled in this file and stays visible by default.
+const SPECULATIVE = process.env['MONOMIND_MCP_SPECULATIVE'] === '1';
+const CORE_TRANSFER_NAMES = new Set(['transfer_detect-pii']);
+export const transferTools = SPECULATIVE
+    ? allTransferTools
+    : allTransferTools.filter(t => CORE_TRANSFER_NAMES.has(t.name));
 export default transferTools;
 //# sourceMappingURL=transfer-tools.js.map