monomind 1.10.47 → 1.10.55

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

@@ -1,6 +1,6 @@
 /**
  * CLI Update Command
- * Auto-update system for @monoes packages (ADR-025)
+ * Auto-update system for @monomind packages (ADR-025)
  */
 import { output } from '../output.js';
 import { checkForUpdates, getInstalledVersion, DEFAULT_CONFIG, } from '../update/checker.js';
@@ -36,7 +36,7 @@ function formatPriority(priority) {
 // Subcommand: check
 const checkCommand = {
     name: 'check',
-    description: 'Check for available @monoes package updates',
+    description: 'Check for available @monomind package updates',
     options: [
         { name: 'force', description: 'Force check (ignore rate limit)', type: 'boolean' },
         { name: 'json', description: 'Output as JSON', type: 'boolean' },
@@ -58,7 +58,7 @@ const checkCommand = {
                 return { success: true };
             }
             if (results.length === 0) {
-                output.printSuccess('All @monoes packages are up to date!');
+                output.printSuccess('All @monomind packages are up to date!');
                 return { success: true };
             }
             output.writeln();
@@ -103,7 +103,7 @@ const checkCommand = {
 // Subcommand: all
 const allCommand = {
     name: 'all',
-    description: 'Update all @monoes packages',
+    description: 'Update all @monomind packages',
     options: [
         { name: 'dry-run', description: 'Show what would be updated', type: 'boolean' },
         { name: 'include-major', description: 'Include major version updates', type: 'boolean' },
@@ -244,14 +244,14 @@ const clearCacheCommand = {
 // Main update command
 const updateCommand = {
     name: 'update',
-    description: 'Manage @monoes package updates (ADR-025)',
+    description: 'Manage @monomind package updates (ADR-025)',
     subcommands: [checkCommand, allCommand, historyCommand, rollbackCommand, clearCacheCommand],
     async action() {
         // Show help if no subcommand
         output.writeln();
         output.writeln(output.highlight('═══ Update Command ═══'));
         output.writeln();
-        output.writeln('Manage @monoes package updates with auto-update support.');
+        output.writeln('Manage @monomind package updates with auto-update support.');
         output.writeln();
         output.writeln('Subcommands:');
         output.printList([

package/packages/@monomind/cli/dist/src/init/executor.js

@@ -272,6 +272,7 @@ export async function executeInit(options) {
             directories: [],
             files: [],
         },
+        updated: [],
         skipped: [],
         errors: [],
         summary: {
@@ -1489,6 +1490,33 @@ daemon.pid
         atomicWriteFile(gitignorePath, gitignore);
         result.created.files.push('.monomind/.gitignore');
     }
+    // Ensure the project-level .gitignore does NOT blanket-ignore .monomind/
+    // A blanket ignore prevents config, metrics, and knowledge graph from being committed.
+    // We remove any bare `.monomind/` or `**/.monomind/` lines and add specific excludes instead.
+    const projectGitignorePath = path.join(targetDir, '.gitignore');
+    if (fs.existsSync(projectGitignorePath)) {
+        const existing = fs.readFileSync(projectGitignorePath, 'utf-8');
+        const blanketPattern = /^(\*\*\/)?\.monomind\/?\s*$/gm;
+        if (blanketPattern.test(existing)) {
+            const fixed = existing
+                .split('\n')
+                .filter(line => !/^(\*\*\/)?\.monomind\/?\s*$/.test(line))
+                .join('\n');
+            const specificExcludes = [
+                '# monomind runtime — exclude sensitive and machine-specific data',
+                '.monomind/sessions/',
+                '.monomind/security/',
+                '.monomind/*.tmp',
+                '.monomind/*.log',
+                '.monomind/daemon.pid',
+                '.monomind/*.db',
+                '.monomind/*.db-wal',
+                '.monomind/*.db-shm',
+            ].join('\n');
+            atomicWriteFile(projectGitignorePath, fixed.trimEnd() + '\n' + specificExcludes + '\n');
+            result.updated.push('.gitignore (replaced blanket .monomind/ ignore with specific excludes)');
+        }
+    }
     // Write CAPABILITIES.md with full system overview
     await writeCapabilitiesDoc(targetDir, options, result);
 }

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

@@ -860,7 +860,7 @@ function getGraphUsage() {
                     + (d.graph_assist_search || 0) + (d.graph_assist_neighbors || 0);
     const searches = (d.grep_call || 0) + (d.glob_call || 0)
                    + (d.bash_grep_call || 0) + (d.bash_find_call || 0);
-    const total = graphWins + searches;
+    const total = graphWins + searches + (d.preresolve_miss || 0);
     if (total === 0) return null;
     return { graphWins: graphWins, searches: searches, pct: Math.round((graphWins / total) * 100), dollarsSaved: d.dollars_saved || 0 };
   } catch { return null; }

package/packages/@monomind/cli/dist/src/init/types.d.ts

@@ -303,6 +303,7 @@ export interface InitResult {
         directories: string[];
         files: string[];
     };
+    updated: string[];
     skipped: string[];
     errors: string[];
     summary: {

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

@@ -495,6 +495,98 @@ export class MCPServerManager extends EventEmitter {
                         };
                     }
                 }
+                case 'resources/list':
+                    return {
+                        jsonrpc: '2.0',
+                        id: message.id,
+                        result: {
+                            resources: [
+                                {
+                                    uri: 'monograph://repo/processes',
+                                    name: 'Processes',
+                                    description: 'All detected Process nodes with their steps',
+                                    mimeType: 'application/json',
+                                },
+                                {
+                                    uri: 'monograph://repo/communities',
+                                    name: 'Communities',
+                                    description: 'All community clusters with member symbols',
+                                    mimeType: 'application/json',
+                                },
+                                {
+                                    uri: 'monograph://repo/schema',
+                                    name: 'Schema',
+                                    description: 'Graph schema: node labels, edge relations, counts',
+                                    mimeType: 'application/json',
+                                },
+                                {
+                                    uri: 'monograph://repo/graph',
+                                    name: 'Graph',
+                                    description: 'Full graph export (nodes + edges, up to 2000 nodes)',
+                                    mimeType: 'application/json',
+                                },
+                            ],
+                        },
+                    };
+                case 'resources/read': {
+                    const uri = params.uri ?? '';
+                    try {
+                        const { join } = await import('path');
+                        const { openDb, closeDb, getProcessesResource, getCommunitiesResource, getSchemaResource, getGraphResource } = await import('@monoes/monograph');
+                        const projectCwd = process.env['MONOMIND_CWD'] || process.cwd();
+                        const dbPath = join(projectCwd, '.monomind', 'monograph.db');
+                        const resDb = openDb(dbPath);
+                        let data;
+                        try {
+                            switch (uri) {
+                                case 'monograph://repo/processes':
+                                    data = getProcessesResource(resDb);
+                                    break;
+                                case 'monograph://repo/communities':
+                                    data = getCommunitiesResource(resDb);
+                                    break;
+                                case 'monograph://repo/schema':
+                                    data = getSchemaResource(resDb);
+                                    break;
+                                case 'monograph://repo/graph':
+                                    data = getGraphResource(resDb);
+                                    break;
+                                default:
+                                    return {
+                                        jsonrpc: '2.0',
+                                        id: message.id,
+                                        error: { code: -32602, message: `Unknown resource URI: ${uri}` },
+                                    };
+                            }
+                        }
+                        finally {
+                            closeDb(resDb);
+                        }
+                        return {
+                            jsonrpc: '2.0',
+                            id: message.id,
+                            result: {
+                                contents: [
+                                    {
+                                        uri,
+                                        text: JSON.stringify(data),
+                                        mimeType: 'application/json',
+                                    },
+                                ],
+                            },
+                        };
+                    }
+                    catch (err) {
+                        return {
+                            jsonrpc: '2.0',
+                            id: message.id,
+                            error: {
+                                code: -32603,
+                                message: err instanceof Error ? err.message : 'Failed to read resource',
+                            },
+                        };
+                    }
+                }
                 case 'notifications/initialized':
                     // Client notification - no response needed
                     console.error(`[${new Date().toISOString()}] INFO [monomind-mcp] (${sessionId}) Client initialized`);

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

@@ -7,6 +7,51 @@ import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from '
 import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
 import { weightedTally } from '../consensus/vote-signer.js';
+// Module-level QueenCoordinator singleton — persists for the lifetime of the
+// MCP server process so task routing and learning are stateful across calls.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let queenCoordinator = null;
+let queenCoordinatorHiveId = null;
+async function getOrCreateQueenCoordinator(hiveId) {
+    if (queenCoordinator && queenCoordinatorHiveId === hiveId)
+        return queenCoordinator;
+    try {
+        const swarmPkg = await import('@monomind/swarm').catch(() => null);
+        if (!swarmPkg?.createQueenCoordinatorWithNeural)
+            return null;
+        const realSwarm = {
+            getActiveAgents: async () => {
+                try {
+                    const store = loadAgentStore();
+                    return Object.entries(store.agents || {}).map(([id, agent]) => ({
+                        agentId: id,
+                        type: agent.type || 'coder',
+                        status: agent.status || 'active',
+                    }));
+                }
+                catch {
+                    return [];
+                }
+            },
+            spawnAgent: async (config) => {
+                const id = `queen-spawned-${Date.now()}`;
+                return { agentId: id };
+            },
+            terminateAgent: async (_agentId) => { },
+            broadcastMessage: async (_message) => { },
+        };
+        queenCoordinator = await swarmPkg.createQueenCoordinatorWithNeural(realSwarm, {
+            enableLearning: true,
+            patternRetrievalK: 3,
+        });
+        await queenCoordinator.initialize();
+        queenCoordinatorHiveId = hiveId;
+    }
+    catch {
+        queenCoordinator = null;
+    }
+    return queenCoordinator;
+}
 // Storage paths
 const STORAGE_DIR = '.monomind';
 const HIVE_DIR = 'hive-mind';
@@ -241,12 +286,19 @@ export const hiveMindTools = [
                 updatedAt: now,
             };
             saveHiveState(state);
+            // Start QueenCoordinator with neural learning when topology is hierarchical
+            let neuralEnabled = false;
+            if (state.topology === 'hierarchical' || state.topology === 'mesh') {
+                const queen = await getOrCreateQueenCoordinator(hiveId);
+                neuralEnabled = !!queen;
+            }
             return {
                 success: true,
                 hiveId,
                 topology: state.topology,
                 consensus: input.consensus || 'byzantine',
                 queenId,
+                neuralLearning: neuralEnabled ? 'active' : 'unavailable',
                 status: 'initialized',
                 config: {
                     topology: state.topology,

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

@@ -524,6 +524,50 @@ function suggestAgentsForTask(task) {
     // Default fallback
     return { agents: ['coder', 'researcher', 'tester'], confidence: 0.7 };
 }
+/**
+ * V3: Augment agent suggestions with semantic matches from intelligence.ts ReasoningBank.
+ * Returns null when the intelligence system is unavailable or has no relevant patterns.
+ * Kept sync-safe by returning a Promise — callers that need a sync result use the
+ * non-async suggestAgentsForTask above and optionally merge async results.
+ */
+// Canonical set of valid monomind agent type strings.
+// Patterns whose type is not in this set (e.g. 'action', 'observation', 'routing')
+// are structural labels, not agent names, and must be excluded from routing.
+const VALID_AGENT_TYPES = new Set([
+    'coder', 'reviewer', 'tester', 'planner', 'researcher',
+    'architect', 'security-architect', 'security-auditor',
+    'performance-engineer', 'backend-dev', 'mobile-dev',
+    'ml-developer', 'cicd-engineer', 'api-docs', 'system-architect',
+    'code-analyzer', 'devops', 'debugger', 'documenter', 'optimizer',
+]);
+async function suggestAgentsFromIntelligence(task) {
+    try {
+        const intel = await import('../memory/intelligence.js');
+        await intel.initializeIntelligence();
+        const matches = await intel.findSimilarPatterns(task, { k: 5 });
+        if (!matches || matches.length === 0)
+            return null;
+        // Only count patterns whose type is a valid agent name.
+        // Trajectory-derived patterns use type='action'|'observation' etc. — skip those.
+        const agentCounts = {};
+        for (const m of matches) {
+            const agent = m.type ?? '';
+            if (!VALID_AGENT_TYPES.has(agent))
+                continue;
+            agentCounts[agent] = (agentCounts[agent] ?? 0) + (m.similarity ?? m.confidence ?? 0.5);
+        }
+        const sorted = Object.entries(agentCounts).sort((a, b) => b[1] - a[1]);
+        if (sorted.length === 0)
+            return null;
+        // Return top-3 ranked agents so callers can build multi-agent task assignments
+        const topAgents = sorted.slice(0, 3).map(([agent]) => agent);
+        const confidence = Math.min(0.9, sorted[0][1] / matches.length);
+        return { agents: topAgents, confidence };
+    }
+    catch {
+        return null;
+    }
+}
 function assessCommandRisk(command) {
     const warnings = [];
     let level = 0;
@@ -796,7 +840,26 @@ export const hooksRoute = {
         let routingLatencyMs = 0;
         let backendInfo = '';
         const queryText = context ? `${task} ${context}` : task;
-        const queryEmbedding = generateSimpleEmbedding(queryText);
+        // Apply LoRA adaptations from the neural system when available.
+        // This is the path where learned weights actually influence routing:
+        // the query embedding is transformed by the session-trained LoRA before
+        // being compared against the semantic router's pattern embeddings.
+        let queryEmbedding = generateSimpleEmbedding(queryText);
+        try {
+            const neural = await import('@monomind/neural').catch(() => null);
+            if (neural?.createNeuralLearningSystem) {
+                const sys = neural.createNeuralLearningSystem('balanced');
+                await sys.initialize();
+                // applyAdaptations uses the LoRA weights from learned-state.json
+                // (loaded during initialize()) to transform the query embedding.
+                const base = generateSimpleEmbedding(queryText, 768);
+                const adapted = await sys.getSONAManager().applyAdaptations(base);
+                // Down-project to 384 to match the semantic router's expected dimension
+                queryEmbedding = adapted.slice(0, 384);
+                await sys.cleanup();
+            }
+        }
+        catch { /* fall through to hash embedding */ }
         // Try native VectorDb (HNSW-backed)
         if (native && backend === 'native') {
             const routeStart = performance.now();
@@ -843,13 +906,31 @@ export const hooksRoute = {
             matchedPattern = topMatch.intent;
         }
         else {
-            // Fall back to keyword matching
-            const suggestion = suggestAgentsForTask(task);
-            agents = suggestion.agents;
-            confidence = suggestion.confidence;
+            // Keyword fallback is the baseline
+            const keywordSuggestion = suggestAgentsForTask(task);
+            agents = keywordSuggestion.agents;
+            confidence = keywordSuggestion.confidence;
             matchedPattern = 'keyword-fallback';
             routingMethod = 'keyword';
             backendInfo = 'keyword matching';
+            // V3: augment with neural ReasoningBank patterns — merge into agent list
+            // rather than replacing, so keyword precision is preserved while neural
+            // adds learned agents from past sessions.
+            const intelSuggestion = await suggestAgentsFromIntelligence(task).catch(() => null);
+            if (intelSuggestion && intelSuggestion.confidence > 0.5) {
+                // Prepend neural agents (deduped) and boost confidence
+                const existingSet = new Set(agents);
+                const neuralOnly = intelSuggestion.agents.filter(a => !existingSet.has(a));
+                agents = [...intelSuggestion.agents, ...agents.filter(a => !new Set(intelSuggestion.agents).has(a))];
+                const neuralWeight = intelSuggestion.confidence > 0.7 ? 0.65 : 0.5;
+                const keywordWeight = 1 - neuralWeight;
+                confidence = Math.min(0.95, intelSuggestion.confidence * neuralWeight +
+                    confidence * keywordWeight +
+                    (neuralOnly.length > 0 ? 0.03 : 0));
+                matchedPattern = 'neural+keyword';
+                routingMethod = 'neural-augmented';
+                backendInfo = 'intelligence ReasoningBank + keyword matching';
+            }
         }
         // Determine complexity
         const taskLower = task.toLowerCase();
@@ -1438,6 +1519,25 @@ export const hooksPretrain = {
             patternsStored = patterns.length;
         }
         catch { /* AgentDB not available */ }
+        // Feed extracted import patterns into the neural training system so
+        // pretrain actually trains, not just scans.
+        let neuralPatternsLearned = 0;
+        if (patterns.length > 0) {
+            try {
+                const intel = await import('../memory/intelligence.js');
+                await intel.initializeIntelligence({ loraLearningRate: 0.002, maxTrajectorySize: patterns.length });
+                // Record each extracted pattern as an action step
+                for (const pat of patterns.slice(0, 50)) {
+                    await intel.recordStep({ type: 'action', content: pat, metadata: { source: 'pretrain', depth } });
+                }
+                // Record the entire scan as a completed trajectory
+                const steps = patterns.slice(0, 50).map(p => ({ type: 'action', content: p }));
+                await intel.recordTrajectory(steps, 'success');
+                intel.flushPatterns();
+                neuralPatternsLearned = steps.length;
+            }
+            catch { /* intelligence not available */ }
+        }
         return {
             success: true,
             _real: true,
@@ -1449,6 +1549,7 @@ export const hooksPretrain = {
                 totalLines,
                 patternsExtracted: patterns.length,
                 patternsStored,
+                neuralPatternsLearned,
                 fileTypes: Object.entries(extCounts).sort((a, b) => b[1] - a[1]).slice(0, 15).map(([ext, count]) => ({ ext, count })),
             },
         };

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

@@ -7,13 +7,9 @@ export type { MCPTool, MCPToolInputSchema, MCPToolResult } from './types.js';
 export { agentTools } from './agent-tools.js';
 export { swarmTools } from './swarm-tools.js';
 export { systemTools } from './system-tools.js';
-export { terminalTools } from './terminal-tools.js';
 export { neuralTools } from './neural-tools.js';
 export { performanceTools } from './performance-tools.js';
 export { githubTools } from './github-tools.js';
-export { daaTools } from './daa-tools.js';
-export { coordinationTools } from './coordination-tools.js';
-export { browserTools } from './browser-tools.js';
 export { agentdbTools } from './agentdb-tools.js';
 export { memoryTools } from './memory-tools.js';
 export { configTools } from './config-tools.js';
@@ -22,7 +18,6 @@ export { taskTools } from './task-tools.js';
 export { sessionTools } from './session-tools.js';
 export { hiveMindTools } from './hive-mind-tools.js';
 export { workflowTools } from './workflow-tools.js';
-export { coverageRouterTools } from '../ruvector/coverage-tools.js';
 export { analyzeTools } from './analyze-tools.js';
 export { progressTools } from './progress-tools.js';
 export { transferTools } from './transfer-tools.js';

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

@@ -7,13 +7,9 @@ export { agentTools } from './agent-tools.js';
 export { swarmTools } from './swarm-tools.js';
 // V2 Compatibility tools
 export { systemTools } from './system-tools.js';
-export { terminalTools } from './terminal-tools.js';
 export { neuralTools } from './neural-tools.js';
 export { performanceTools } from './performance-tools.js';
 export { githubTools } from './github-tools.js';
-export { daaTools } from './daa-tools.js';
-export { coordinationTools } from './coordination-tools.js';
-export { browserTools } from './browser-tools.js';
 // Phase 6: AgentDB v1 controller tools
 export { agentdbTools } from './agentdb-tools.js';
 export { memoryTools } from './memory-tools.js';
@@ -23,7 +19,6 @@ export { taskTools } from './task-tools.js';
 export { sessionTools } from './session-tools.js';
 export { hiveMindTools } from './hive-mind-tools.js';
 export { workflowTools } from './workflow-tools.js';
-export { coverageRouterTools } from '../ruvector/coverage-tools.js';
 export { analyzeTools } from './analyze-tools.js';
 export { progressTools } from './progress-tools.js';
 export { transferTools } from './transfer-tools.js';