monomind 1.16.2 → 1.16.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.16.2",
+  "version": "1.16.3",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

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

@@ -213,7 +213,11 @@ async function startBackgroundDaemon(projectRoot, quiet, maxCpuLoad, minFreeMemo
     const __dirname = dirname(__filename);
     // dist/src/commands -> dist/src -> dist -> package root -> bin/cli.js
     const cliPath = resolve(join(__dirname, '..', '..', '..', 'bin', 'cli.js'));
-    validatePath(cliPath, 'CLI path');
+    // monolean: CLI may be in global npm install (different drive on Windows) — only
+    // check for injection, not directory containment
+    if (cliPath.includes('\0') || /[;&|`$<>]/.test(cliPath)) {
+        throw new Error('CLI path contains invalid characters');
+    }
     // Verify CLI path exists
     if (!fs.existsSync(cliPath)) {
         output.printError(`CLI not found at: ${cliPath}`);

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

@@ -186,7 +186,11 @@ async function checkMcpServers() {
     const mcpConfigPaths = [
         join(homedir(), '.claude/claude_desktop_config.json'),
         join(homedir(), '.config/claude/mcp.json'),
-        '.mcp.json'
+        '.mcp.json',
+        // Claude Code local/project scope stores MCP servers in settings files
+        '.claude/settings.json',
+        '.claude/settings.local.json',
+        join(homedir(), '.claude/settings.json'),
     ];
     for (const configPath of mcpConfigPaths) {
         if (existsSync(configPath) && statSync(configPath).size <= MAX_DOCTOR_CONFIG_BYTES) {

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

@@ -159,7 +159,7 @@ const IS_WINDOWS = process.platform === 'win32';
  */
 function hookCmd(script, subcommand) {
     if (IS_WINDOWS) {
-        return `cmd /c node %CLAUDE_PROJECT_DIR%/${script} ${subcommand}`.trim();
+        return `cmd /c node "%CLAUDE_PROJECT_DIR%/${script}" ${subcommand}`.trim();
     }
     // Use sh -c to ensure $CLAUDE_PROJECT_DIR is expanded by a real shell,
     // even if Claude Code doesn't invoke hooks through a shell on macOS.
@@ -180,13 +180,13 @@ function captureHandlerCmd(subcommand) {
     // capture-handler does not use sh -c wrapper — it reads stdin directly
     const dir = IS_WINDOWS ? '%CLAUDE_PROJECT_DIR%' : '${CLAUDE_PROJECT_DIR:-.}';
     return IS_WINDOWS
-        ? `node ${dir}/.claude/helpers/handlers/capture-handler.cjs ${subcommand}`
+        ? `node "${dir}/.claude/helpers/handlers/capture-handler.cjs" ${subcommand}`
         : `node "${dir}/.claude/helpers/handlers/capture-handler.cjs" ${subcommand}`;
 }
 /** Shorthand for standalone CJS helper scripts (no subcommand) */
 function standaloneHelperCmd(script) {
     if (IS_WINDOWS) {
-        return `cmd /c node %CLAUDE_PROJECT_DIR%/.claude/helpers/${script}`;
+        return `cmd /c node "%CLAUDE_PROJECT_DIR%/.claude/helpers/${script}"`;
     }
     // eslint-disable-next-line no-template-curly-in-string
     const dir = '${CLAUDE_PROJECT_DIR:-.}';
@@ -200,8 +200,14 @@ function generateStatusLineConfig(_options) {
     // Claude Code pipes JSON session data to the script via stdin.
     // Valid fields: type, command, padding (optional).
     // The script runs after each assistant message (debounced 300ms).
-    // NOTE: statusline must NOT use `cmd /c` — Claude Code manages its stdin
-    // directly for statusline commands, and `cmd /c` blocks stdin forwarding.
+    // NOTE: statusline must NOT use `cmd /c` on Windows either — Claude Code
+    // manages stdin directly for statusline commands; wrappers block forwarding.
+    if (IS_WINDOWS) {
+        return {
+            type: 'command',
+            command: 'node "%CLAUDE_PROJECT_DIR%/.claude/helpers/statusline.cjs"',
+        };
+    }
     // eslint-disable-next-line no-template-curly-in-string
     const dir = '${CLAUDE_PROJECT_DIR:-.}';
     return {

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

@@ -70,17 +70,22 @@ function getVersion() {
       }
     } catch { /* ignore */ }
   }
-  // 2. Fallback: npm global prefix
+  // 2. Fallback: npm global prefix (lib/node_modules on POSIX, node_modules on Windows)
   try {
     const { execSync } = require('child_process');
     const prefix = execSync('npm config get prefix', { encoding: 'utf-8', timeout: 2000 }).trim();
-    const globalPkgPath = path.join(prefix, 'lib', 'node_modules', 'monomind', 'package.json');
-    const globalPkgStat = safeStat(globalPkgPath);
-    if (!globalPkgStat || globalPkgStat.size > 1024 * 1024) throw new Error('too large');
-    const pkg = JSON.parse(fs.readFileSync(globalPkgPath, 'utf-8'));
-    if (pkg.version) return \`v\${pkg.version}\`;
+    const candidates = [
+      path.join(prefix, 'lib', 'node_modules', 'monomind', 'package.json'),
+      path.join(prefix, 'node_modules', 'monomind', 'package.json'),
+    ];
+    for (const globalPkgPath of candidates) {
+      const globalPkgStat = safeStat(globalPkgPath);
+      if (!globalPkgStat || globalPkgStat.size > 1024 * 1024) continue;
+      const pkg = JSON.parse(fs.readFileSync(globalPkgPath, 'utf-8'));
+      if (pkg.version) return \`v\${pkg.version}\`;
+    }
   } catch { /* ignore */ }
-  return 'v1.0.6';
+  return 'v?';
 }
 const VERSION = getVersion();
 

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

@@ -657,7 +657,7 @@ export class MCPServerManager extends EventEmitter {
         }
         // Dynamically import the MCP server package
         // FIX for issue #942: Use proper package import instead of broken relative path
-        // @ts-expect-error — @monomind/mcp is an optional peer resolved at runtime
+        // @ts-ignore — @monomind/mcp is an optional peer resolved at runtime
         const { createMCPServer } = await import('@monomind/mcp');
         const logger = {
             debug: (msg, data) => this.emit('log', { level: 'debug', msg, data }),

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

@@ -182,10 +182,11 @@ export const daaTools = [
             try {
                 const bridge = await import('../memory/memory-bridge.js');
                 await bridge.bridgeRecordFeedback({
-                    taskId: `adapt-${agentId}-${agent.metrics.adaptations}`,
-                    success: performanceScore >= 0.5,
-                    quality: performanceScore,
-                    agent: agentId,
+                    taskType: agentId,
+                    action: `adapt-${agentId}-${agent.metrics.adaptations}`,
+                    outcome: performanceScore >= 0.5 ? 'success' : 'failure',
+                    confidence: performanceScore,
+                    metadata: { agentId, adaptations: agent.metrics.adaptations },
                 });
                 _storedIn = 'lancedb';
             }

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

@@ -354,7 +354,7 @@ export const hooksPatternStore = {
         let reasoningResult = null;
         try {
             const bridge = await import('../memory/memory-bridge.js');
-            reasoningResult = await bridge.bridgeStorePattern({ pattern, type, confidence, metadata: metadata });
+            reasoningResult = await bridge.bridgeStorePattern({ pattern, taskType: type, confidence });
         }
         catch {
             // Bridge not available
@@ -379,20 +379,20 @@ export const hooksPatternStore = {
             }
         }
         const success = reasoningResult?.success || storeResult.success;
-        const controller = reasoningResult?.controller || (storeResult.success ? 'bridge-store' : 'none');
+        const controller = reasoningResult?.success ? 'lancedb' : (storeResult.success ? 'bridge-store' : 'none');
         return {
-            patternId: reasoningResult?.patternId || storeResult.id || patternId,
+            patternId: reasoningResult?.id || storeResult.id || patternId,
             pattern,
             type,
             confidence,
             indexed: success,
-            hnswIndexed: success && (!!storeResult.embedding || controller === 'reasoningBank'),
+            hnswIndexed: success && (!!storeResult.embedding || controller === 'lancedb'),
             embedding: storeResult.embedding,
             timestamp,
             controller,
-            implementation: controller === 'reasoningBank' ? 'reasoning-bank-controller' : (storeResult.success ? 'real-hnsw-indexed' : 'memory-only'),
-            note: controller === 'reasoningBank'
-                ? 'Pattern stored via ReasoningBank controller with HNSW indexing'
+            implementation: controller === 'lancedb' ? 'lancedb-controller' : (storeResult.success ? 'real-hnsw-indexed' : 'memory-only'),
+            note: controller === 'lancedb'
+                ? 'Pattern stored via lancedb bridge with HNSW indexing'
                 : (storeResult.success ? 'Pattern stored with vector embedding for semantic search' : (storeResult.error || 'Store function unavailable')),
         };
     },
@@ -428,20 +428,22 @@ export const hooksPatternSearch = {
         // Phase 3: Try ReasoningBank search via bridge first
         try {
             const bridge = await import('../memory/memory-bridge.js');
-            const rbResult = await bridge.bridgeSearchPatterns({ query, topK, minConfidence });
-            if (rbResult && rbResult.results.length > 0) {
+            const rbResult = await bridge.bridgeSearchPatterns({ query, limit: topK });
+            if (rbResult && rbResult.patterns.length > 0) {
                 return {
                     query,
-                    results: rbResult.results.map(r => ({
+                    results: rbResult.patterns
+                        .filter((r) => r.score >= minConfidence)
+                        .map((r) => ({
                         patternId: r.id,
-                        pattern: r.content,
+                        pattern: r.pattern,
                         similarity: r.score,
                         confidence: r.score,
                         namespace,
                     })),
                     searchTimeMs: 0,
-                    backend: rbResult.controller,
-                    note: `Results from ${rbResult.controller} controller`,
+                    backend: 'lancedb',
+                    note: 'Results from lancedb bridge',
                 };
             }
         }

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

@@ -91,13 +91,10 @@ export const hooksPostEdit = {
         try {
             const bridge = await import('../memory/memory-bridge.js');
             feedbackResult = await bridge.bridgeRecordFeedback({
-                taskId: `edit-${filePath}-${Date.now()}`,
-                success,
-                quality: success ? 0.85 : 0.3,
-                agent,
-                // B1.2: give the SONA embedder real semantics (the edited file) instead of
-                // the opaque task ID.
-                task: `edit ${filePath}`,
+                taskType: agent ?? 'coder',
+                action: `edit ${filePath}`,
+                outcome: success ? 'success' : 'failure',
+                confidence: success ? 0.85 : 0.3,
             });
         }
         catch {
@@ -111,8 +108,8 @@ export const hooksPostEdit = {
             learningUpdate: success ? 'pattern_reinforced' : 'pattern_adjusted',
             feedback: feedbackResult ? {
                 recorded: feedbackResult.success,
-                controller: feedbackResult.controller,
-                updates: feedbackResult.updated,
+                controller: feedbackResult.success ? 'lancedb' : 'unavailable',
+                updates: feedbackResult.success ? 1 : 0,
             } : { recorded: false, controller: 'unavailable', updates: 0 },
         };
     },
@@ -259,51 +256,56 @@ export const hooksRoute = {
         if (useSemanticRouter) {
             try {
                 const bridge = await import('../memory/memory-bridge.js');
-                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 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(), {
-                        routeId,
-                        ts: Date.now(),
-                        task,
-                        recommendedAgent: agents[0],
-                        routingMethod: memoryMethod,
-                        confidence: memoryConfidence,
-                        learningMode: 'js',
-                    });
-                    return {
-                        routeId,
-                        task,
-                        routing: {
-                            method: memoryMethod,
-                            backend: memoryRoute.controller,
-                            latencyMs: 0,
-                            throughput: 'N/A',
-                        },
-                        matchedPattern: memoryRoute.route,
-                        semanticMatches: [{ pattern: memoryRoute.route, score: memoryRoute.confidence }],
-                        primaryAgent: {
-                            type: agents[0],
-                            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((memoryRoute.confidence - (0.1 * (i + 1))) * 100) / 100,
-                            reason: `Alternative from ${memoryRoute.controller}`,
-                        })),
-                        estimatedMetrics: {
-                            successProbability: Math.round(memoryRoute.confidence * 100) / 100,
-                            estimatedDuration: complexity === 'high' ? '2-4 hours' : complexity === 'medium' ? '30-60 min' : '10-30 min',
-                            complexity,
-                        },
-                        swarmRecommendation: agents.length > 2 ? { topology: 'hierarchical', agents, coordination: 'queen-led' } : null,
-                    };
+                const memoryRoute = await bridge.bridgeRouteTask({ task });
+                if (memoryRoute && memoryRoute.routes && memoryRoute.routes.length > 0) {
+                    const topRoute = memoryRoute.routes[0];
+                    const routeConfidence = topRoute.confidence ?? 0;
+                    if (routeConfidence > 0.5) {
+                        const agents = memoryRoute.routes.map((r) => r.agentType);
+                        const complexity = task.length > 200 ? 'high' : task.length < 50 ? 'low' : 'medium';
+                        const memoryMethod = 'memory-lancedb';
+                        const memoryConfidence = Math.round(routeConfidence * 100) / 100;
+                        const matchedPattern = topRoute.pattern ?? task.slice(0, 60);
+                        // Record the route recommendation so post-task can join the actual outcome
+                        const routeId = randomUUID();
+                        await recordRoute(getRouteOutcomesBaseDir(), {
+                            routeId,
+                            ts: Date.now(),
+                            task,
+                            recommendedAgent: agents[0],
+                            routingMethod: memoryMethod,
+                            confidence: memoryConfidence,
+                            learningMode: 'js',
+                        });
+                        return {
+                            routeId,
+                            task,
+                            routing: {
+                                method: memoryMethod,
+                                backend: 'lancedb',
+                                latencyMs: 0,
+                                throughput: 'N/A',
+                            },
+                            matchedPattern,
+                            semanticMatches: [{ pattern: matchedPattern, score: routeConfidence }],
+                            primaryAgent: {
+                                type: agents[0],
+                                confidence: memoryConfidence,
+                                reason: `memory:lancedb: "${matchedPattern}" (${Math.round(routeConfidence * 100)}%)`,
+                            },
+                            alternativeAgents: agents.slice(1).map((agent, i) => ({
+                                type: agent,
+                                confidence: Math.round((routeConfidence - (0.1 * (i + 1))) * 100) / 100,
+                                reason: 'Alternative from lancedb',
+                            })),
+                            estimatedMetrics: {
+                                successProbability: memoryConfidence,
+                                estimatedDuration: complexity === 'high' ? '2-4 hours' : complexity === 'medium' ? '30-60 min' : '10-30 min',
+                                complexity,
+                            },
+                            swarmRecommendation: agents.length > 2 ? { topology: 'hierarchical', agents, coordination: 'queen-led' } : null,
+                        };
+                    }
                 }
             }
             catch {
@@ -682,17 +684,11 @@ export const hooksPostTask = {
         try {
             const bridge = await import('../memory/memory-bridge.js');
             feedbackResult = await bridge.bridgeRecordFeedback({
-                taskId,
-                success,
-                quality,
-                agent,
-                // B1.2: thread the real task description into the SONA trajectory so the
-                // embedder encodes meaning, not the opaque task ID.
-                task: cappedPostTask || undefined,
-                // B1.3: only feed the SONA LoRA update when the outcome is actually known.
-                outcomeKnown,
-                duration: params.duration || undefined,
-                patterns: params.patterns || undefined,
+                taskType: agent ?? 'task',
+                action: cappedPostTask?.slice(0, 80) ?? taskId,
+                outcome: success ? 'success' : (outcomeKnown ? 'failure' : 'partial'),
+                confidence: quality,
+                metadata: { taskId, duration: params.duration || undefined, patterns: params.patterns || undefined },
             });
         }
         catch {
@@ -705,7 +701,7 @@ export const hooksPostTask = {
                 sourceId: taskId,
                 targetId: `outcome-${taskId}`,
                 relation: success ? 'succeeded' : 'failed',
-                weight: quality,
+                strength: quality,
             });
         }
         catch {
@@ -830,17 +826,17 @@ export const hooksPostTask = {
             successSource,
             duration,
             learningUpdates: {
-                patternsUpdated: feedbackResult?.updated || (success ? 2 : 1),
+                patternsUpdated: feedbackResult?.success ? (success ? 2 : 1) : 0,
                 newPatterns: success ? 1 : 0,
                 trajectoryId: `traj-${Date.now()}`,
-                controller: feedbackResult?.controller || 'none',
+                controller: feedbackResult?.success ? 'lancedb' : 'none',
                 outcomePersisted,
             },
             quality,
             feedback: feedbackResult ? {
                 recorded: feedbackResult.success,
-                controller: feedbackResult.controller,
-                updates: feedbackResult.updated,
+                controller: feedbackResult.success ? 'lancedb' : 'unavailable',
+                updates: feedbackResult.success ? 1 : 0,
             } : { recorded: false, controller: 'unavailable', updates: 0 },
             marReflection,
             timestamp: new Date().toISOString(),
@@ -1261,12 +1257,12 @@ export const hooksSessionStart = {
             const bridge = await import('../memory/memory-bridge.js');
             const result = await bridge.bridgeSessionStart({
                 sessionId,
-                context: restoreLatest ? 'restore previous session patterns' : 'new session',
+                metadata: { context: restoreLatest ? 'restore previous session patterns' : 'new session' },
             });
             if (result) {
                 sessionMemory = {
-                    controller: result.controller,
-                    restoredPatterns: result.restoredPatterns,
+                    controller: result.success ? 'lancedb' : 'none',
+                    restoredPatterns: 0,
                 };
             }
         }
@@ -1351,13 +1347,12 @@ export const hooksSessionEnd = {
             const result = await bridge.bridgeSessionEnd({
                 sessionId,
                 summary: saveState ? 'Session ended with state saved' : 'Session ended',
-                tasksCompleted: taskCount,
-                patternsLearned: patternCount,
+                metrics: { tasksCompleted: taskCount, patternsLearned: patternCount },
             });
             if (result) {
                 sessionPersistence = {
-                    controller: result.controller,
-                    persisted: result.persisted,
+                    controller: result.success ? 'lancedb' : 'none',
+                    persisted: result.success,
                 };
             }
         }

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

@@ -94,9 +94,9 @@ export const memoryControllers = {
                 return { available: false, controllers: [], error: 'Memory bridge not available — @monomind/memory not installed or missing controller-registry. Use memory_store/memory_search tools instead.' };
             return {
                 available: true,
-                controllers,
-                total: controllers.length,
-                active: controllers.filter((c) => c.enabled).length,
+                controllers: controllers.controllers,
+                total: controllers.controllers.length,
+                active: controllers.active.length,
             };
         }
         catch (error) {
@@ -125,7 +125,7 @@ export const memoryPatternStore = {
             const bridge = await getBridge();
             const result = await bridge.bridgeStorePattern({
                 pattern,
-                type: validateString(params.type, 'type', 200) ?? 'general',
+                taskType: validateString(params.type, 'type', 200) ?? 'general',
                 confidence: validateScore(params.confidence, 0.8),
             });
             return result ?? { success: false, error: 'Memory bridge not available. Use memory_store/memory_search instead.' };
@@ -154,12 +154,17 @@ export const memoryPatternSearch = {
             if (!query)
                 return { results: [], error: 'query is required (non-empty string, max 10KB)' };
             const bridge = await getBridge();
+            const minConfidence = validateScore(params.minConfidence, 0.3);
             const result = await bridge.bridgeSearchPatterns({
                 query,
-                topK: validatePositiveInt(params.topK, 5, MAX_TOP_K),
-                minConfidence: validateScore(params.minConfidence, 0.3),
+                limit: validatePositiveInt(params.topK, 5, MAX_TOP_K),
             });
-            return result ?? { results: [], controller: 'unavailable' };
+            if (!result)
+                return { results: [], controller: 'unavailable' };
+            return {
+                ...result,
+                patterns: result.patterns.filter((p) => p.score >= minConfidence),
+            };
         }
         catch (error) {
             return { results: [], error: sanitizeError(error) };
@@ -187,10 +192,11 @@ export const memoryFeedback = {
                 return { success: false, error: 'taskId is required (non-empty string, max 500 chars)' };
             const bridge = await getBridge();
             const result = await bridge.bridgeRecordFeedback({
-                taskId,
-                success: params.success === true,
-                quality: validateScore(params.quality, 0.85),
-                agent: validateString(params.agent, 'agent', 200) ?? undefined,
+                taskType: validateString(params.agent, 'agent', 200) ?? 'task',
+                action: taskId,
+                outcome: params.success === true ? 'success' : 'failure',
+                confidence: validateScore(params.quality, 0.85),
+                metadata: { taskId },
             });
             return result ?? { success: false, error: 'Memory bridge not available. Use memory_store/memory_search instead.' };
         }
@@ -229,7 +235,7 @@ export const memoryCausalEdge = {
                 sourceId,
                 targetId,
                 relation,
-                weight: typeof params.weight === 'number' ? validateScore(params.weight, 0.5) : undefined,
+                strength: typeof params.weight === 'number' ? validateScore(params.weight, 0.5) : undefined,
             });
             return result ?? { success: false, error: 'Memory bridge not available. Use memory_store/memory_search instead.' };
         }
@@ -256,10 +262,7 @@ export const memoryRoute = {
             if (!task)
                 return { route: 'general', confidence: 0.5, agents: ['coder'], controller: 'error', error: 'task is required (non-empty string)' };
             const bridge = await getBridge();
-            const result = await bridge.bridgeRouteTask({
-                task,
-                context: validateString(params.context, 'context', 10_000) ?? undefined,
-            });
+            const result = await bridge.bridgeRouteTask({ task });
             return result ?? { route: 'general', confidence: 0.5, agents: ['coder'], controller: 'fallback' };
         }
         catch (error) {
@@ -287,7 +290,7 @@ export const memorySessionStart = {
             const bridge = await getBridge();
             const result = await bridge.bridgeSessionStart({
                 sessionId,
-                context: validateString(params.context, 'context', 10_000) ?? undefined,
+                metadata: { context: validateString(params.context, 'context', 10_000) ?? undefined },
             });
             return result ?? { success: false, error: 'Memory bridge not available. Use memory_store/memory_search instead.' };
         }
@@ -318,7 +321,7 @@ export const memorySessionEnd = {
             const result = await bridge.bridgeSessionEnd({
                 sessionId,
                 summary: validateString(params.summary, 'summary', 50_000) ?? undefined,
-                tasksCompleted: validatePositiveInt(params.tasksCompleted, 0, 10_000),
+                metrics: { tasksCompleted: validatePositiveInt(params.tasksCompleted, 0, 10_000) },
             });
             return result ?? { success: false, error: 'Memory bridge not available. Use memory_store/memory_search instead.' };
         }

package/packages/@monomind/cli/dist/src/memory/hnsw-operations.js

@@ -85,13 +85,6 @@ function saveHNSWMetadata() {
  * Add entry to HNSW index (with automatic persistence)
  */
 export async function addToHNSWIndex(id, embedding, entry) {
-    // ADR-053: Try LanceDB memory bridge first
-    const bridge = await getBridge();
-    if (bridge) {
-        const bridgeResult = await bridge.bridgeAddToHNSW(id, embedding, entry);
-        if (bridgeResult === true)
-            return true;
-    }
     const index = await getHNSWIndex({ dimensions: embedding.length });
     if (!index)
         return false;
@@ -115,13 +108,6 @@ export async function addToHNSWIndex(id, embedding, entry) {
  * Returns results sorted by similarity (highest first)
  */
 export async function searchHNSWIndex(queryEmbedding, options) {
-    // ADR-053: Try LanceDB memory bridge first
-    const bridge = await getBridge();
-    if (bridge) {
-        const bridgeResult = await bridge.bridgeSearchHNSW(queryEmbedding, options);
-        if (bridgeResult)
-            return bridgeResult;
-    }
     const index = await getHNSWIndex({ dimensions: queryEmbedding.length });
     if (!index)
         return null;

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

@@ -320,7 +320,7 @@ export async function deleteEntry(options) {
             if (bridgeResult.deleted) {
                 rebuildSearchIndex();
             }
-            return bridgeResult;
+            return { ...bridgeResult, key: options.key, namespace: options.namespace ?? 'default', remainingEntries: 0 };
         }
     }
     // Fallback: raw sql.js

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

@@ -166,7 +166,16 @@ export async function listEntries(options) {
     if (bridge) {
         const bridgeResult = await bridge.bridgeListEntries(options);
         if (bridgeResult)
-            return bridgeResult;
+            return {
+                success: bridgeResult.success,
+                total: bridgeResult.total,
+                error: bridgeResult.error,
+                entries: bridgeResult.entries.map((e) => ({
+                    id: e.id, key: e.key, namespace: e.namespace,
+                    size: typeof e.content === 'string' ? e.content.length : 0,
+                    accessCount: e.accessCount, createdAt: e.createdAt, updatedAt: e.updatedAt, hasEmbedding: e.hasEmbedding,
+                })),
+            };
     }
     // Fallback: raw sql.js
     const { namespace, limit = 20, offset = 0, dbPath: customPath } = options;

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.16.2",
+  "version": "1.16.3",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",