monomind 2.7.4 → 2.7.6

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/hooks-routing-commands.js

@@ -5,7 +5,6 @@
  */
 import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import { storeCommand } from './transfer-store.js';
 // Route subcommand
 export const routeCommand = {
     name: 'route',
@@ -639,36 +638,23 @@ export const transferFromProjectCommand = {
 // Parent transfer command combining all transfer methods
 export const transferCommand = {
     name: 'transfer',
-    description: 'Transfer patterns via IPFS-based decentralized registry',
-    subcommands: [storeCommand, transferFromProjectCommand],
+    description: 'Transfer learned patterns from another local project',
+    subcommands: [transferFromProjectCommand],
     examples: [
-        { command: 'monomind hooks transfer store list', description: 'List patterns from registry' },
-        { command: 'monomind hooks transfer store search -q routing', description: 'Search patterns' },
-        { command: 'monomind hooks transfer store download -p seraphine-genesis', description: 'Download pattern' },
-        { command: 'monomind hooks transfer store publish', description: 'Publish pattern to registry' },
-        { command: 'monomind hooks transfer from-project -s ../other-project', description: 'Transfer from project' },
+        { command: 'monomind hooks transfer from-project -s ../other-project', description: 'Transfer all patterns from another checkout' },
+        { command: 'monomind hooks transfer from-project -s ../prod --filter security -m 0.9', description: 'Transfer only high-confidence security patterns' },
     ],
     action: async () => {
         output.writeln();
-        output.writeln(output.bold('Pattern Transfer System'));
-        output.writeln(output.dim('Decentralized pattern sharing via IPFS'));
+        output.writeln(output.bold('Pattern Transfer'));
+        output.writeln(output.dim('Copy learned patterns between local project checkouts'));
         output.writeln();
         output.writeln('Subcommands:');
         output.printList([
-            `${output.highlight('store')}        - Pattern marketplace (list, search, download, publish)`,
-            `${output.highlight('from-project')} - Transfer patterns from another project`,
+            `${output.highlight('from-project')} - Transfer patterns from another project directory`,
         ]);
         output.writeln();
-        output.writeln(output.bold('IPFS-Based Features:'));
-        output.printList([
-            'Decentralized registry via IPNS for discoverability',
-            'Content-addressed storage for integrity',
-            'Ed25519 signatures for verification',
-            'Anonymization levels: minimal, standard, strict, paranoid',
-            'Trust levels: unverified, community, verified, official',
-        ]);
-        output.writeln();
-        output.writeln('Run "monomind hooks transfer <subcommand> --help" for details');
+        output.writeln('Run "monomind hooks transfer from-project --help" for options');
         return { success: true };
     }
 };

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/performance.js

@@ -23,6 +23,13 @@ const benchmarkCommand = {
         const suiteRaw = ctx.flags.suite || 'all';
         const VALID_SUITES = new Set(['all', 'wasm', 'neural', 'memory', 'search']);
         const suite = VALID_SUITES.has(suiteRaw) ? suiteRaw : 'all';
+        // Falling back is fine; doing it silently is not. `--suite quick` used to
+        // print "Running all benchmarks" and produce a full run, so the user's
+        // explicit choice was discarded with no indication it had been ignored.
+        if (suiteRaw !== suite) {
+            output.writeln(output.warning(`Unknown benchmark suite "${suiteRaw}" — running "all" instead. ` +
+                `Valid suites: ${[...VALID_SUITES].join(', ')}.`));
+        }
         const MAX_ITERATIONS = 10_000;
         const MAX_WARMUP = 500;
         const iterationsRaw = parseInt(ctx.flags.iterations || '100', 10);

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/index.js

@@ -156,42 +156,38 @@ export class CLI {
             let subcommandArgs = positional;
             // Process command path (e.g., ['hooks', 'worker', 'list'])
             // Note: When parser includes subcommand in commandPath, positional already excludes it
+            //
+            // Resolution walks as deep as the tree goes. It previously unrolled
+            // exactly two levels of nesting, so a four-segment invocation silently
+            // resolved to its grandparent and ran that command's action — which for
+            // a group command means printing help instead of doing anything. No
+            // error, no hint. `hooks transfer store list` failed exactly this way,
+            // making the whole pattern-store subtree unreachable without anyone
+            // noticing. This mirrors the loop showHelp() already used (see below),
+            // so `--help` and dispatch now agree on the target at any depth.
+            const findChild = (parent, segment) => parent.subcommands?.find(sc => sc.name === segment || sc.aliases?.includes(segment));
             if (commandPath.length > 1 && command.subcommands) {
-                const subcommandName = commandPath[1];
-                const subcommand = command.subcommands.find(sc => sc.name === subcommandName || sc.aliases?.includes(subcommandName));
-                if (subcommand) {
-                    targetCommand = subcommand;
-                    // Parser already extracted subcommand from positional, so use as-is
-                    subcommandArgs = positional;
-                    // Check for nested subcommand (level 2)
-                    if (commandPath.length > 2 && subcommand.subcommands) {
-                        const nestedName = commandPath[2];
-                        const nestedSubcommand = subcommand.subcommands.find(sc => sc.name === nestedName || sc.aliases?.includes(nestedName));
-                        if (nestedSubcommand) {
-                            targetCommand = nestedSubcommand;
-                            // Parser already extracted nested subcommand too
-                            subcommandArgs = positional;
-                        }
-                    }
+                // Parser already lifted the subcommand names out of positional, so
+                // descend using commandPath and leave the remaining args untouched.
+                for (const segment of commandPath.slice(1)) {
+                    const next = findChild(targetCommand, segment);
+                    if (!next)
+                        break;
+                    targetCommand = next;
                 }
+                subcommandArgs = positional;
             }
             else if (positional.length > 0 && command.subcommands) {
-                // Check if first positional is a subcommand
-                const subcommandName = positional[0];
-                const subcommand = command.subcommands.find(sc => sc.name === subcommandName || sc.aliases?.includes(subcommandName));
-                if (subcommand) {
-                    targetCommand = subcommand;
-                    subcommandArgs = positional.slice(1);
-                    // Check for nested subcommand (level 2 from positional)
-                    if (subcommandArgs.length > 0 && subcommand.subcommands) {
-                        const nestedName = subcommandArgs[0];
-                        const nestedSubcommand = subcommand.subcommands.find(sc => sc.name === nestedName || sc.aliases?.includes(nestedName));
-                        if (nestedSubcommand) {
-                            targetCommand = nestedSubcommand;
-                            subcommandArgs = subcommandArgs.slice(1);
-                        }
-                    }
+                // Subcommand names are still in positional — consume each one we match.
+                let consumed = 0;
+                while (consumed < subcommandArgs.length) {
+                    const next = findChild(targetCommand, subcommandArgs[consumed]);
+                    if (!next)
+                        break;
+                    targetCommand = next;
+                    consumed++;
                 }
+                subcommandArgs = subcommandArgs.slice(consumed);
             }
             // Validate flags
             const validationErrors = this.parser.validateFlags(flags, targetCommand);

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,
@@ -126,6 +124,24 @@ export async function callMCPTool(toolName, input = {}, context) {
     if (isToolDisabled(toolName)) {
         throw new MCPClientError(`MCP tool '${toolName}' is disabled. Re-enable with: mcp toggle --enable ${toolName}`, toolName);
     }
+    // Enforce the `required` contract each tool advertises in its inputSchema.
+    // 120 of the ~254 tools declare required params, but nothing used to check
+    // them: handlers were invoked with whatever arrived, so a missing argument
+    // surfaced as whatever the handler happened to hit first — e.g.
+    // `monograph_agent_record` leaked a raw `SqliteError: NOT NULL constraint
+    // failed: agent_interactions.session_id` instead of naming the parameter.
+    // This is the single choke point for both the stdio server and the
+    // in-process CLI path, so validating here covers every tool at once.
+    //
+    // Only missing/undefined/null is rejected — empty strings and 0 are left
+    // alone, since some tools legitimately accept them.
+    const required = tool.inputSchema?.required;
+    if (Array.isArray(required) && required.length > 0) {
+        const missing = required.filter(key => input[key] === undefined || input[key] === null);
+        if (missing.length > 0) {
+            throw new MCPClientError(`MCP tool '${toolName}' missing required parameter${missing.length > 1 ? 's' : ''}: ${missing.join(', ')}`, toolName);
+        }
+    }
     try {
         const result = await tool.handler(input, context);
         return result;

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',
@@ -353,11 +353,14 @@ export const agentTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', enum: ['status', 'scale', 'drain'], description: 'Pool action' },
+                action: { type: 'string', enum: ['status', 'scale', 'drain'], description: 'Pool action (default: status)' },
                 targetSize: { type: 'number', description: 'Target pool size (for scale action)' },
                 agentType: { type: 'string', description: 'Agent type filter' },
             },
-            required: ['action'],
+            // `action` is deliberately NOT required: the handler defaults it to
+            // 'status', and the CLI `agent pool` command relies on that default.
+            // It was previously declared required, which nothing enforced — once
+            // required params became enforced, that false contract broke the CLI.
         },
         handler: async (input) => {
             const action = input.action || 'status'; // Default to status

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

@@ -147,7 +147,7 @@ const autopilotProgress = {
 };
 const autopilotLearn = {
     name: 'autopilot_learn',
-    description: 'Discover success patterns from past task completions. Requires memory backend for full functionality.',
+    description: 'Report success patterns from the optional agentic-flow learning module. That module is not a declared dependency and is absent in normal installs, so this returns available:false with an empty pattern list — no pattern discovery occurs.',
     category: 'autopilot',
     inputSchema: { type: 'object', properties: {} },
     handler: async () => {
@@ -197,7 +197,7 @@ const autopilotHistory = {
 };
 const autopilotPredict = {
     name: 'autopilot_predict',
-    description: 'Predict the optimal next action based on current state and learned patterns.',
+    description: 'Suggest the next action by returning the first incomplete discovered task with a fixed 0.5 confidence — a heuristic over local task files, not ML prediction. The optional agentic-flow learning module that would refine this is not a declared dependency and is absent in normal installs.',
     category: 'autopilot',
     inputSchema: { type: 'object', properties: {} },
     handler: async () => {

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',
@@ -483,7 +484,7 @@ export const embeddingsTools = [
     },
     {
         name: 'embeddings_neural',
-        description: 'Embedding substrate operations (drift, memory physics, coherence)',
+        description: 'Report and adjust pattern-store statistics (drift, consolidate, adapt) from intelligence.ts. Reads real counters — but its "init" action only persists a config blob (sona, flashAttention, ewcPlusPlus, memoryPhysics, swarmCoordination…) for which no implementing code exists anywhere; those flags are stored and echoed back, never acted on. There is no neural substrate and no "memory physics".',
         category: 'embeddings',
         inputSchema: {
             type: 'object',
@@ -501,7 +502,7 @@ export const embeddingsTools = [
                 },
                 decayRate: {
                     type: 'number',
-                    description: 'Memory decay rate (hippocampal dynamics)',
+                    description: 'Decay rate applied to stored pattern confidence (plain exponential decay — the "hippocampal dynamics" framing this once carried described nothing in the code)',
                     default: 0.01,
                 },
             },
@@ -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: ['coordinator', 'mesh-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,10 +194,17 @@ 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)',
+        description: 'Write worker agent records into the agent store and register their ids on the hive state file (combines agent_spawn + hive-mind_join). Creates bookkeeping entries only — no process, thread, or agent is started. Real concurrency comes from Claude Code\'s Task tool.',
         category: 'hive-mind',
         inputSchema: {
             type: 'object',
@@ -278,7 +285,7 @@ export const hiveMindTools = [
     },
     {
         name: 'hive-mind_init',
-        description: 'Initialize the hive-mind collective',
+        description: 'Create the hive state file recording topology, consensus strategy, and an empty worker list. Writes JSON state only — nothing is started, and no collective process exists. Note "gossip" and "crdt" strategies are rejected: they are not implemented.',
         category: 'hive-mind',
         inputSchema: {
             type: 'object',
@@ -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',
@@ -925,7 +932,7 @@ export const hiveMindTools = [
     },
     {
         name: 'hive-mind_broadcast',
-        description: 'Broadcast message to all workers',
+        description: 'Append a message to a shared array on the hive state file (capped at 100 entries). This is a noticeboard, not message delivery — there are no live listeners, and a worker only sees it if something later reads that state. The reported recipient count is just the number of ids in the worker list.',
         category: 'hive-mind',
         inputSchema: {
             type: 'object',
@@ -1048,7 +1055,7 @@ export const hiveMindTools = [
     },
     {
         name: 'hive-mind_memory',
-        description: 'Access hive shared memory',
+        description: 'Read or write a shared JSON blob on the hive state file. Plain key/value bookkeeping in a single local file — not a distributed or replicated store.',
         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/hooks-intelligence.js

@@ -671,7 +671,7 @@ export const hooksIntelligenceStats = {
 // Intelligence learn hook
 export const hooksIntelligenceLearn = {
     name: 'hooks_intelligence_learn',
-    description: 'Force immediate SONA learning cycle with EWC++ consolidation',
+    description: 'Run a consolidation pass over the local keyword-pattern store: time-decay confidence weighting, pruning, and an EWC++-style quadratic penalty derived from squared embedding magnitudes. There are no gradients and no model — no ML training occurs.',
     inputSchema: {
         type: 'object',
         properties: {