monomind 1.15.6 → 1.16.0

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

@@ -32,8 +32,6 @@ import { githubTools } from './mcp-tools/github-tools.js';
 import { daaTools } from './mcp-tools/daa-tools.js';
 import { coordinationTools } from './mcp-tools/coordination-tools.js';
 import { browserTools } from './mcp-tools/browser-tools.js';
-// Phase 6: AgentDB v1 controller tools
-import { agentdbTools } from './mcp-tools/agentdb-tools.js';
 import { guidanceTools } from './mcp-tools/guidance-tools.js';
 import { autopilotTools } from './mcp-tools/autopilot-tools.js';
 // Knowledge graph tools (graphify — deprecated shims + monograph native)
@@ -51,10 +49,7 @@ import { coherenceTools } from './mcp-tools/coherence-tools.js';
  * Maps tool names to their handler functions
  */
 const TOOL_REGISTRY = new Map();
-// Register all tools — refuse silent overrides so a future plugin/IPFS-loaded
-// tool cannot shadow a built-in handler (e.g. `agent_spawn`, `memory_store`)
-// without an explicit override flag. Logical-name collision is a real concern
-// when the plugin system goes live.
+// Register all tools — refuse silent overrides without an explicit override flag.
 function registerTools(tools, options = {}) {
     for (const tool of tools) {
         if (TOOL_REGISTRY.has(tool.name) && !options.override) {
@@ -89,8 +84,6 @@ registerTools([
     ...daaTools,
     ...coordinationTools,
     ...browserTools,
-    // Phase 6: AgentDB v1 controller tools
-    ...agentdbTools,
     // Guidance & discovery tools
     ...guidanceTools,
     // Autopilot persistent completion tools

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 AgentDB for full functionality.',
+    description: 'Discover success patterns from past task completions. Requires memory backend for full functionality.',
     category: 'autopilot',
     inputSchema: { type: 'object', properties: {} },
     handler: async () => {
@@ -159,12 +159,12 @@ const autopilotLearn = {
             ]);
             return ok({ metrics, patterns });
         }
-        return ok({ available: false, reason: 'AgentDB/AutopilotLearning not initialized', patterns: [] });
+        return ok({ available: false, reason: 'memory backend/AutopilotLearning not initialized', patterns: [] });
     },
 };
 const autopilotHistory = {
     name: 'autopilot_history',
-    description: 'Search past completion episodes by keyword. Requires AgentDB.',
+    description: 'Search past completion episodes by keyword. Requires memory backend.',
     category: 'autopilot',
     inputSchema: {
         type: 'object',

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

@@ -121,7 +121,7 @@ export const daaTools = [
             }
             store.agents[id] = agent;
             saveDAAStore(store);
-            // Store agent in AgentDB for searchable agent registry
+            // Store agent in memory backend for searchable agent registry
             try {
                 const bridge = await import('../memory/memory-bridge.js');
                 await bridge.bridgeStoreEntry({
@@ -131,7 +131,7 @@ export const daaTools = [
                     tags: [agent.type, agent.cognitivePattern],
                 });
             }
-            catch { /* AgentDB not available */ }
+            catch { /* memory backend unavailable */ }
             return {
                 success: true,
                 agent: {
@@ -177,7 +177,7 @@ export const daaTools = [
             agent.lastActivity = new Date().toISOString();
             agent.status = 'active';
             saveDAAStore(store);
-            // Store adaptation feedback in AgentDB for pattern learning (backward compat: JSON store above)
+            // Store adaptation feedback in memory backend for pattern learning (backward compat: JSON store above)
             let _storedIn = 'json-store';
             try {
                 const bridge = await import('../memory/memory-bridge.js');
@@ -187,9 +187,9 @@ export const daaTools = [
                     quality: performanceScore,
                     agent: agentId,
                 });
-                _storedIn = 'agentdb';
+                _storedIn = 'lancedb';
             }
-            catch { /* AgentDB not available */ }
+            catch { /* memory backend unavailable */ }
             return {
                 success: true,
                 agentId,
@@ -283,7 +283,7 @@ export const daaTools = [
             }
             workflow.status = 'running';
             saveDAAStore(store);
-            // Store workflow state in AgentDB for tracking
+            // Store workflow state in memory backend for tracking
             try {
                 const bridge = await import('../memory/memory-bridge.js');
                 await bridge.bridgeStoreEntry({
@@ -296,7 +296,7 @@ export const daaTools = [
                     namespace: 'daa-workflows',
                 });
             }
-            catch { /* AgentDB not available */ }
+            catch { /* memory backend unavailable */ }
             return {
                 success: true,
                 workflowId,
@@ -325,7 +325,7 @@ export const daaTools = [
             const store = loadDAAStore();
             const sourceId = input.sourceAgentId;
             // Cap targetIds to prevent a large array from inflating the JSON store
-            // entry and the AgentDB tags blob.  100 target agents is already very
+            // entry and the memory backend tags blob.  100 target agents is already very
             // generous for any realistic swarm configuration.
             const MAX_TARGET_IDS = 100;
             const MAX_TARGET_ID_LEN = 256;
@@ -344,7 +344,7 @@ export const daaTools = [
                 targetAgents: targetIds,
                 timestamp: new Date().toISOString(),
             };
-            // Primary: store in AgentDB for vector-searchable knowledge
+            // Primary: store in memory backend for vector-searchable knowledge
             let _storedIn = 'json-store';
             try {
                 const bridge = await import('../memory/memory-bridge.js');
@@ -354,9 +354,9 @@ export const daaTools = [
                     namespace: 'daa-knowledge',
                     tags: [domain, sourceId, ...targetIds],
                 });
-                _storedIn = 'agentdb';
+                _storedIn = 'lancedb';
             }
-            catch { /* AgentDB not available */ }
+            catch { /* memory backend unavailable */ }
             // Backward compat: always persist in JSON store (cap at 1000 entries)
             if (Object.keys(store.knowledge).length >= 1000) {
                 const oldest = Object.keys(store.knowledge)[0];
@@ -373,8 +373,8 @@ export const daaTools = [
                 domain,
                 sharedAt: knowledgeEntry.timestamp,
                 _storedIn,
-                _note: _storedIn === 'agentdb'
-                    ? 'Knowledge stored in AgentDB (vector-searchable) and JSON store. Target agents can retrieve via daa_learning_status or memory search.'
+                _note: _storedIn === 'lancedb'
+                    ? 'Knowledge stored in memory backend (vector-searchable) and JSON store. Target agents can retrieve via daa_learning_status or memory search.'
                     : 'Knowledge stored in shared JSON registry. Target agents can retrieve via daa_learning_status. No cross-agent memory transfer occurs.',
             };
         },

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

@@ -76,11 +76,11 @@ const CAPABILITY_CATALOG = {
     },
     'memory-knowledge': {
         name: 'Memory & Knowledge',
-        description: 'Persistent memory with HNSW vector search, AgentDB storage, and embeddings.',
+        description: 'Persistent memory with ANN vector search, LanceDB 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', 'agentdb-advanced', 'agentdb-vector-search', 'agentdb-memory-patterns', 'agentdb-learning'],
+        skills: ['v1-memory-unification', 'memory-advanced', 'memory-vector-search', 'memory-patterns', 'memory-learning'],
         whenToUse: 'When you need to persist, search, or retrieve knowledge across sessions.',
     },
     'intelligence-learning': {
@@ -89,7 +89,7 @@ const CAPABILITY_CATALOG = {
         tools: ['neural_train', 'neural_predict', 'neural_status', 'neural_patterns', 'neural_optimize'],
         commands: ['neural train', 'neural predict', 'neural status', 'neural patterns', 'neural optimize'],
         agents: ['sona-learning-optimizer', 'safla-neural'],
-        skills: ['reasoningbank-intelligence', 'reasoningbank-agentdb'],
+        skills: ['reasoningbank-intelligence', 'memory-reasoningbank'],
         whenToUse: 'When optimizing agent routing, training patterns from outcomes, or adaptive learning.',
     },
     'hooks-automation': {
@@ -158,7 +158,7 @@ const CAPABILITY_CATALOG = {
         tools: ['embeddings_embed', 'embeddings_batch', 'embeddings_search', 'embeddings_init'],
         commands: ['embeddings embed', 'embeddings batch', 'embeddings search', 'embeddings init'],
         agents: [],
-        skills: ['agentdb-vector-search', 'agentdb-optimization'],
+        skills: ['memory-vector-search', 'memory-optimization'],
         whenToUse: 'When you need semantic search, document embedding, or vector similarity operations.',
     },
     'code-analysis': {

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

@@ -675,7 +675,7 @@ export const hiveMindTools = [
                     state.consensus.pending = state.consensus.pending.filter(p => p.proposalId !== proposal.proposalId);
                 }
                 saveHiveState(state);
-                // Persist consensus result in AgentDB for searchable history
+                // Persist consensus result for searchable history
                 if (resolved) {
                     try {
                         const bridge = await import('../memory/memory-bridge.js');
@@ -693,7 +693,7 @@ export const hiveMindTools = [
                             tags: [proposal.type, proposalStrategy || 'raft', proposal.status],
                         });
                     }
-                    catch { /* AgentDB not available — JSON store is primary */ }
+                    catch { /* LanceDB not available — JSON store is primary */ }
                     // Persist consensus audit record
                     const sessionSecret = process.env.MONOMIND_SESSION_SECRET;
                     if (!sessionSecret) {
@@ -983,7 +983,7 @@ export const hiveMindTools = [
                 }
                 state.sharedMemory[key] = cappedValue;
                 saveHiveState(state);
-                // Also store in AgentDB for searchable hive memory
+                // Also store for searchable hive memory
                 try {
                     const bridge = await import('../memory/memory-bridge.js');
                     await bridge.bridgeStoreEntry({
@@ -992,7 +992,7 @@ export const hiveMindTools = [
                         namespace: 'hive-memory',
                     });
                 }
-                catch { /* AgentDB not available */ }
+                catch { /* LanceDB not available */ }
                 return {
                     action,
                     key,

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

@@ -735,6 +735,7 @@ export const hooksIntelligenceAttention = {
             results,
             stats: {
                 computeTimeMs,
+                speedup: implementation.startsWith('real-') ? computeTimeMs : null,
                 _stub: implementation === 'none',
                 _note: implementation === 'none' ? 'Pure-JS similarity only; native attention backends are not part of the lean build.' : undefined,
             },

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

@@ -189,7 +189,7 @@ export const hooksPostCommand = {
             command: typeof command === 'string' ? command.slice(0, 200) : String(command).slice(0, 200),
             exitCode,
         });
-        // Persist command outcome via AgentDB
+        // Persist command outcome via memory backend
         let _storedIn = 'none';
         try {
             const bridge = await import('../memory/memory-bridge.js');
@@ -199,10 +199,10 @@ export const hooksPostCommand = {
                 namespace: 'commands',
                 tags: [success ? 'success' : 'error'],
             });
-            _storedIn = 'agentdb';
+            _storedIn = 'lancedb';
         }
         catch {
-            // AgentDB not available — store in JSON
+            // memory backend unavailable — store in JSON
             try {
                 const store = loadMemoryStore();
                 const key = `cmd-${Date.now()}`;
@@ -255,16 +255,16 @@ export const hooksRoute = {
             ? rawContext.slice(0, MAX_ROUTE_CTX_LEN)
             : rawContext;
         const useSemanticRouter = params.useSemanticRouter !== false;
-        // Phase 5: Try AgentDB's SemanticRouter / LearningSystem first
+        // Phase 5: Try memory backend SemanticRouter / LearningSystem first
         if (useSemanticRouter) {
             try {
                 const bridge = await import('../memory/memory-bridge.js');
-                const agentdbRoute = await bridge.bridgeRouteTask({ task, context });
-                if (agentdbRoute && agentdbRoute.confidence > 0.5) {
-                    const agents = agentdbRoute.agents.length > 0 ? agentdbRoute.agents : ['coder', 'researcher'];
+                const memoryRoute = await bridge.bridgeRouteTask({ task, context });
+                if (memoryRoute && memoryRoute.confidence > 0.5) {
+                    const agents = memoryRoute.agents.length > 0 ? memoryRoute.agents : ['coder', 'researcher'];
                     const complexity = task.length > 200 ? 'high' : task.length < 50 ? 'low' : 'medium';
-                    const agentdbMethod = `agentdb-${agentdbRoute.controller}`;
-                    const agentdbConfidence = Math.round(agentdbRoute.confidence * 100) / 100;
+                    const memoryMethod = `memory-${memoryRoute.controller}`;
+                    const memoryConfidence = Math.round(memoryRoute.confidence * 100) / 100;
                     // Record the route recommendation so post-task can join the actual outcome
                     const routeId = randomUUID();
                     await recordRoute(getRouteOutcomesBaseDir(), {
@@ -272,33 +272,33 @@ export const hooksRoute = {
                         ts: Date.now(),
                         task,
                         recommendedAgent: agents[0],
-                        routingMethod: agentdbMethod,
-                        confidence: agentdbConfidence,
+                        routingMethod: memoryMethod,
+                        confidence: memoryConfidence,
                         learningMode: 'js',
                     });
                     return {
                         routeId,
                         task,
                         routing: {
-                            method: agentdbMethod,
-                            backend: agentdbRoute.controller,
+                            method: memoryMethod,
+                            backend: memoryRoute.controller,
                             latencyMs: 0,
                             throughput: 'N/A',
                         },
-                        matchedPattern: agentdbRoute.route,
-                        semanticMatches: [{ pattern: agentdbRoute.route, score: agentdbRoute.confidence }],
+                        matchedPattern: memoryRoute.route,
+                        semanticMatches: [{ pattern: memoryRoute.route, score: memoryRoute.confidence }],
                         primaryAgent: {
                             type: agents[0],
-                            confidence: Math.round(agentdbRoute.confidence * 100) / 100,
-                            reason: `AgentDB ${agentdbRoute.controller}: "${agentdbRoute.route}" (${Math.round(agentdbRoute.confidence * 100)}%)`,
+                            confidence: Math.round(memoryRoute.confidence * 100) / 100,
+                            reason: `memory:${memoryRoute.controller}: "${memoryRoute.route}" (${Math.round(memoryRoute.confidence * 100)}%)`,
                         },
                         alternativeAgents: agents.slice(1).map((agent, i) => ({
                             type: agent,
-                            confidence: Math.round((agentdbRoute.confidence - (0.1 * (i + 1))) * 100) / 100,
-                            reason: `Alternative from ${agentdbRoute.controller}`,
+                            confidence: Math.round((memoryRoute.confidence - (0.1 * (i + 1))) * 100) / 100,
+                            reason: `Alternative from ${memoryRoute.controller}`,
                         })),
                         estimatedMetrics: {
-                            successProbability: Math.round(agentdbRoute.confidence * 100) / 100,
+                            successProbability: Math.round(memoryRoute.confidence * 100) / 100,
                             estimatedDuration: complexity === 'high' ? '2-4 hours' : complexity === 'medium' ? '30-60 min' : '10-30 min',
                             complexity,
                         },
@@ -307,7 +307,7 @@ export const hooksRoute = {
                 }
             }
             catch {
-                // AgentDB router not available — fall through to local routing
+                // memory router not available — fall through to local routing
             }
         }
         // Deterministic keyword routing is the baseline (and only) local path.
@@ -1004,7 +1004,7 @@ export const hooksPretrain = {
         };
         scan(repoPath, 0);
         const elapsed = Math.round(performance.now() - startTime);
-        // Store extracted patterns in AgentDB
+        // Store extracted patterns in memory backend
         let patternsStored = 0;
         try {
             const bridge = await import('../memory/memory-bridge.js');
@@ -1016,7 +1016,7 @@ export const hooksPretrain = {
             });
             patternsStored = patterns.length;
         }
-        catch { /* AgentDB not available */ }
+        catch { /* memory backend unavailable */ }
         // Feed extracted import patterns into the neural training system so
         // pretrain actually trains, not just scans.
         let neuralPatternsLearned = 0;

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

@@ -10,7 +10,6 @@ export { systemTools } from './system-tools.js';
 export { neuralTools } from './neural-tools.js';
 export { performanceTools } from './performance-tools.js';
 export { githubTools } from './github-tools.js';
-export { agentdbTools } from './agentdb-tools.js';
 export { memoryTools } from './memory-tools.js';
 export { configTools } from './config-tools.js';
 export { hooksTools } from './hooks-tools.js';

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

@@ -10,8 +10,6 @@ export { systemTools } from './system-tools.js';
 export { neuralTools } from './neural-tools.js';
 export { performanceTools } from './performance-tools.js';
 export { githubTools } from './github-tools.js';
-// Phase 6: AgentDB v1 controller tools
-export { agentdbTools } from './agentdb-tools.js';
 export { memoryTools } from './memory-tools.js';
 export { configTools } from './config-tools.js';
 export { hooksTools } from './hooks-tools.js';

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

@@ -1,14 +1,30 @@
 /**
- * Memory MCP Tools for CLI - V1 with sql.js/HNSW Backend
+ * Memory MCP Tools — Phase 6 of ADR-053
  *
- * UPGRADED: Now uses the advanced sql.js + HNSW backend for:
- * - 150x-12,500x faster semantic search
- * - Vector embeddings with cosine similarity
- * - Persistent SQLite storage (WASM)
- * - Backward compatible with legacy JSON storage (auto-migrates)
+ * Exposes Memory backend operations as MCP tools.
+ * Provides direct access to ReasoningBank, CausalGraph, SkillLibrary,
+ * AttestationLog, and bridge health through the MCP protocol.
+ *
+ * Security: All handlers validate input types, enforce length bounds,
+ * and sanitize error messages before returning to MCP callers.
  *
  * @module v1/cli/mcp-tools/memory-tools
  */
 import type { MCPTool } from './types.js';
+export declare const memoryHealth: MCPTool;
+export declare const memoryControllers: MCPTool;
+export declare const memoryPatternStore: MCPTool;
+export declare const memoryPatternSearch: MCPTool;
+export declare const memoryFeedback: MCPTool;
+export declare const memoryCausalEdge: MCPTool;
+export declare const memoryRoute: MCPTool;
+export declare const memorySessionStart: MCPTool;
+export declare const memorySessionEnd: MCPTool;
+export declare const memoryHierarchicalStore: MCPTool;
+export declare const memoryHierarchicalRecall: MCPTool;
+export declare const memoryConsolidate: MCPTool;
+export declare const memoryBatch: MCPTool;
+export declare const memoryContextSynthesize: MCPTool;
+export declare const memorySemanticRoute: MCPTool;
 export declare const memoryTools: MCPTool[];
 //# sourceMappingURL=memory-tools.d.ts.map