monomind 1.16.2 → 1.16.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.16.2",
+  "version": "1.16.4",
   "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) {
@@ -550,7 +554,6 @@ async function checkMonoesMemory() {
         return { name: 'Vector Memory', status: 'warn', message: 'Vector memory check failed' };
     }
 }
-// Check agentic-flow v1 integration (filesystem-based to avoid slow WASM/DB init)
 // Resolve the path to the bundled (npm-installed) copy of a helper file.
 // Walks up from this module's location to find the package root, then joins
 // the relative path. Returns null if not found.
@@ -635,49 +638,6 @@ async function checkHelpersFresh() {
         return { name: 'Helper Files', status: 'warn', message: `check failed: ${e instanceof Error ? e.message : 'unknown'}` };
     }
 }
-async function checkAgenticFlow() {
-    try {
-        // Walk common node_modules paths to find agentic-flow/package.json
-        const candidates = [
-            join(process.cwd(), 'node_modules', 'agentic-flow', 'package.json'),
-            join(process.cwd(), '..', 'node_modules', 'agentic-flow', 'package.json'),
-        ];
-        let pkgJsonPath = null;
-        for (const p of candidates) {
-            if (existsSync(p)) {
-                pkgJsonPath = p;
-                break;
-            }
-        }
-        if (!pkgJsonPath) {
-            return {
-                name: 'agentic-flow',
-                status: 'warn',
-                message: 'Not installed (optional — embeddings/routing will use fallbacks)',
-                fix: 'npm install agentic-flow@latest'
-            };
-        }
-        if (statSync(pkgJsonPath).size > MAX_DOCTOR_PKG_BYTES) {
-            return { name: 'agentic-flow', status: 'warn', message: 'package.json too large to parse' };
-        }
-        const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
-        const version = pkg.version || 'unknown';
-        const exports = pkg.exports || {};
-        const features = [
-            exports['./reasoningbank'] ? 'ReasoningBank' : null,
-            exports['./router'] ? 'Router' : null,
-            exports['./transport/quic'] ? 'QUIC' : null,
-        ].filter(Boolean);
-        return {
-            name: 'agentic-flow',
-            status: 'pass',
-            message: `v${version}${features.length ? ' (' + features.join(', ') + ')' : ' (installed)'}`
-        };
-    }
-    catch {
-        return { name: 'agentic-flow', status: 'warn', message: 'Check failed' };
-    }
-}
 // Check @monoes native acceleration integration (sona/router/attention/learning-wasm)
 // Format a 0..1 accuracy as a whole-percent string, or 'n/a' when null.
 function fmtPct(v) {
@@ -876,7 +836,7 @@ export const doctorCommand = {
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, graph-freshness, memory-pkg, helpers, agentic-flow, monoes, gates, gitignore)',
+            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, graph-freshness, memory-pkg, helpers, monoes, gates, gitignore)',
             type: 'string'
         },
         {
@@ -922,7 +882,6 @@ export const doctorCommand = {
             checkMonographFreshness,
             checkMonoesMemory,
             checkHelpersFresh,
-            checkAgenticFlow,
             checkMonoesIntegration,
             checkGuidanceGates,
             checkGitignoreCoverage,
@@ -945,7 +904,6 @@ export const doctorCommand = {
             'graph-freshness': checkMonographFreshness,
             'memory-pkg': checkMonoesMemory,
             'helpers': checkHelpersFresh,
-            'agentic-flow': checkAgenticFlow,
             'monoes': checkMonoesIntegration,
             'gates': checkGuidanceGates,
             'gitignore': checkGitignoreCoverage,

package/packages/@monomind/cli/dist/src/commands/hooks-coverage-commands.js

@@ -880,7 +880,7 @@ export const statuslineCommand = {
             try {
                 const psCmd = isWindows
                     ? 'tasklist /FI "IMAGENAME eq node.exe" 2>NUL | findstr /I /C:"node" >NUL && echo 1 || echo 0'
-                    : 'ps aux 2>/dev/null | grep -c agentic-flow || echo "0"';
+                    : 'ps aux 2>/dev/null | grep -c "mcp.*start" || echo "0"';
                 const ps = execSync(psCmd, { encoding: 'utf-8' });
                 const raw = parseInt(ps.trim());
                 activeAgents = Math.max(0, isWindows ? raw : raw - 1);

package/packages/@monomind/cli/dist/src/commands/hooks-extended-commands.js

@@ -5,10 +5,10 @@
  */
 import { output } from '../output.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-// Token Optimizer command - integrates agentic-flow Agent Booster
+// Token Optimizer command
 export const tokenOptimizeCommand = {
     name: 'token-optimize',
-    description: 'Token optimization via agentic-flow Agent Booster (30-50% savings)',
+    description: 'Token optimization via memory-based context retrieval (30-50% savings)',
     options: [
         { name: 'query', short: 'q', type: 'string', description: 'Query for compact context retrieval' },
         { name: 'agents', short: 'A', type: 'number', description: 'Agent count for optimal config', default: '6' },
@@ -25,7 +25,7 @@ export const tokenOptimizeCommand = {
         const agentCount = parseInt(ctx.flags['agents'] || '6', 10);
         const showReport = ctx.flags['report'];
         const showStats = ctx.flags['stats'];
-        const spinner = output.createSpinner({ text: 'Checking agentic-flow integration...', spinner: 'dots' });
+        const spinner = output.createSpinner({ text: 'Checking memory integration...', spinner: 'dots' });
         spinner.start();
         // Inline TokenOptimizer (self-contained, no external imports)
         const stats = {
@@ -35,26 +35,8 @@ export const tokenOptimizeCommand = {
             cacheMisses: 0,
             memoriesRetrieved: 0,
         };
-        let agenticFlowAvailable = false;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let reasoningBank = null;
         try {
-            // Check if agentic-flow v1 is available
-            const rb = await import('agentic-flow/reasoningbank').catch(() => null);
-            if (rb) {
-                agenticFlowAvailable = true;
-                if (typeof rb.retrieveMemories === 'function') {
-                    reasoningBank = rb;
-                }
-            }
-            else {
-                // Legacy check for older agentic-flow
-                const af = await import('agentic-flow').catch(() => null);
-                if (af)
-                    agenticFlowAvailable = true;
-            }
-            const versionLabel = agenticFlowAvailable ? `agentic-flow v1 detected (ReasoningBank: ${reasoningBank ? 'active' : 'unavailable'})` : 'agentic-flow not available (using fallbacks)';
-            spinner.succeed(versionLabel);
+            spinner.succeed('Memory-based token optimization active');
             output.writeln();
             // Anti-drift config (hardcoded optimal values from research)
             const config = {
@@ -69,27 +51,9 @@ export const tokenOptimizeCommand = {
                 `Batch Size: ${config.batchSize}\n` +
                 `Cache: ${config.cacheSizeMB}MB\n` +
                 `Success Rate: ${(config.expectedSuccessRate * 100)}%`);
-            // If query provided, get compact context via ReasoningBank
-            if (query && reasoningBank) {
-                output.writeln();
-                output.printInfo(`Retrieving compact context for: "${query}"`);
-                const memories = await reasoningBank.retrieveMemories(query, { k: 5 });
-                const compactPrompt = reasoningBank.formatMemoriesForPrompt ? reasoningBank.formatMemoriesForPrompt(memories) : '';
-                // Estimate based on actual query vs compact prompt size difference
-                const queryTokenEstimate = Math.ceil((query?.length || 0) / 4);
-                const used = Math.ceil((compactPrompt?.length || 0) / 4);
-                const tokensSaved = Math.max(0, queryTokenEstimate - used);
-                stats.totalTokensSaved += tokensSaved;
-                stats.memoriesRetrieved += Array.isArray(memories) ? memories.length : 0;
-                output.writeln(`  Memories found: ${Array.isArray(memories) ? memories.length : 0}`);
-                output.writeln(`  Tokens saved: ${output.success(String(tokensSaved))}`);
-                if (compactPrompt) {
-                    output.writeln(`  Compact prompt (${compactPrompt.length} chars)`);
-                }
-            }
-            else if (query) {
+            if (query) {
                 output.writeln();
-                output.printInfo('ReasoningBank not available - query skipped');
+                output.printInfo(`Context retrieval for: "${query}" — use monomind memory search`);
             }
             // Simulate some token savings for demo
             stats.totalTokensSaved += 200;
@@ -112,7 +76,6 @@ export const tokenOptimizeCommand = {
                         { metric: 'Cache Hit Rate', value: `${hitRate}%` },
                         { metric: 'Memories Retrieved', value: String(stats.memoriesRetrieved) },
                         { metric: 'Est. Monthly Savings', value: `$${savings}` },
-                        { metric: 'Agentic-Flow Active', value: agenticFlowAvailable ? '✓' : '✗' },
                     ],
                 });
             }
@@ -131,9 +94,9 @@ export const tokenOptimizeCommand = {
 | Cache Hit Rate | ${hitRate}% |
 | Memories Retrieved | ${stats.memoriesRetrieved} |
 | Est. Monthly Savings | $${savings} |
-| Agentic-Flow Active | ${agenticFlowAvailable ? '✓' : '✗'} |`);
+| Memories Retrieved | ${stats.memoriesRetrieved} |`);
             }
-            return { success: true, data: { config, stats: { ...stats, agenticFlowAvailable } } };
+            return { success: true, data: { config, stats } };
         }
         catch (error) {
             spinner.fail('TokenOptimizer failed');

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

@@ -757,9 +757,9 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
         if (!fs.existsSync(activityPath)) {
             const activity = {
                 timestamp: new Date().toISOString(),
-                processes: { agentic_flow: 0, mcp_server: 0, estimated_agents: 0 },
+                processes: { mcp_server: 0, estimated_agents: 0 },
                 swarm: { active: false, agent_count: 0, coordination_active: false },
-                integration: { agentic_flow_active: false, mcp_active: false },
+                integration: { mcp_active: false },
                 _initialized: true
             };
             atomicWriteFile(activityPath, JSON.stringify(activity, null, 2));
@@ -1582,7 +1582,6 @@ async function writeInitialMetrics(targetDir, options, result) {
         const activity = {
             timestamp: new Date().toISOString(),
             processes: {
-                agentic_flow: 0,
                 mcp_server: 0,
                 estimated_agents: 0
             },
@@ -1592,7 +1591,6 @@ async function writeInitialMetrics(targetDir, options, result) {
                 coordination_active: false
             },
             integration: {
-                agentic_flow_active: false,
                 mcp_active: false
             },
             _initialized: true
@@ -1977,7 +1975,6 @@ npx monomind@latest hive-mind consensus --propose "task"
 ### Integrated Packages
 | Package | Version | Purpose |
 |---------|---------|---------|
-| agentic-flow | 3.0.0-alpha.1 | Core coordination + ReasoningBank + Router |
 | @lancedb/lancedb | latest | Vector database (ANN search) |
 
 ### Optional Integrations

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/mcp-tools/neural-tools.d.ts

@@ -4,8 +4,8 @@
  * V2 Compatibility - Neural network and ML tools
  *
  * ✅ HYBRID Implementation:
- * - Uses agentic-flow/reasoningbank for REAL ML embeddings when available
- * - Falls back to deterministic hash-based embeddings when ML model not installed
+ * - Uses monovector ONNX embeddings when available
+ * - Falls back to deterministic hash-based embeddings otherwise
  * - Pattern storage and search with cosine similarity (real math in all tiers)
  * - Training stores patterns as searchable embeddings (not simulated)
  *

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

@@ -4,8 +4,8 @@
  * V2 Compatibility - Neural network and ML tools
  *
  * ✅ HYBRID Implementation:
- * - Uses agentic-flow/reasoningbank for REAL ML embeddings when available
- * - Falls back to deterministic hash-based embeddings when ML model not installed
+ * - Uses monovector ONNX embeddings when available
+ * - Falls back to deterministic hash-based embeddings otherwise
  * - Pattern storage and search with cosine similarity (real math in all tiers)
  * - Training stores patterns as searchable embeddings (not simulated)
  *
@@ -16,19 +16,28 @@ import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync, statSyn
 import { join } from 'node:path';
 const MAX_NEURAL_STORE_BYTES = 50 * 1024 * 1024; // 50 MB
 const NEURAL_RESERVED_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
-// Try to import real embeddings — agentic-flow v1 ReasoningBank when available,
-// otherwise the deterministic hash fallback below.
+// Embeddings via monovector ONNX when available; deterministic hash fallback otherwise.
 let realEmbeddings = null;
 let embeddingServiceName = 'none';
 try {
-    const rb = await import('agentic-flow/reasoningbank').catch(() => null);
-    if (rb?.computeEmbedding) {
-        realEmbeddings = { embed: async (text) => Array.from(await rb.computeEmbedding(text)) };
-        embeddingServiceName = 'agentic-flow/reasoningbank';
+    const monovector = await import('monovector').catch(() => null);
+    if (monovector?.getOptimizedOnnxEmbedder) {
+        await monovector.initOnnxEmbedder?.();
+        const onnxEmb = monovector.getOptimizedOnnxEmbedder();
+        if (onnxEmb?.embed) {
+            const probe = await onnxEmb.embed('test');
+            const hasNonZero = ArrayBuffer.isView(probe) || Array.isArray(probe)
+                ? [...probe].some((v) => v !== 0)
+                : false;
+            if (probe && probe.length > 0 && hasNonZero) {
+                realEmbeddings = { embed: async (text) => Array.from(await onnxEmb.embed(text)) };
+                embeddingServiceName = 'monovector/onnx';
+            }
+        }
     }
 }
 catch {
-    // No embedding provider available, will use fallback
+    // No ONNX embedding provider available, will use hash fallback
 }
 // Storage paths
 const STORAGE_DIR = '.monomind';

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

@@ -76,25 +76,6 @@ export async function loadEmbeddingModel(options) {
                 loadTime: Date.now() - startTime
             };
         }
-        // Fallback: Check for agentic-flow ReasoningBank embeddings (v1)
-        const reasoningBank = await import('agentic-flow/reasoningbank').catch(() => null);
-        if (reasoningBank?.computeEmbedding) {
-            if (verbose) {
-                console.log('Loading agentic-flow ReasoningBank embedding model...');
-            }
-            embeddingModelState = {
-                loaded: true,
-                model: { embed: reasoningBank.computeEmbedding },
-                tokenizer: null,
-                dimensions: 768
-            };
-            return {
-                success: true,
-                dimensions: 768,
-                modelName: 'agentic-flow/reasoningbank',
-                loadTime: Date.now() - startTime
-            };
-        }
         // Fallback: Check for monovector ONNX embedder (bundled MiniLM-L6-v2 since v0.2.15)
         // v0.2.16: LoRA B=0 fix makes AdaptiveEmbedder safe (identity when untrained)
         // Note: isReady() returns false until first embed() call (lazy init), so we
@@ -108,7 +89,8 @@ export async function loadEmbeddingModel(options) {
                 if (onnxEmb?.embed) {
                     // Probe embed to trigger lazy ONNX init and verify it works
                     const probe = await onnxEmb.embed('test');
-                    if (probe && probe.length > 0 && (Array.isArray(probe) ? probe.some((v) => v !== 0) : true)) {
+                    const probeArr = ArrayBuffer.isView(probe) ? Array.from(probe) : (Array.isArray(probe) ? probe : []);
+                    if (probe && probe.length > 0 && probeArr.some((v) => v !== 0)) {
                         if (verbose) {
                             console.log(`Loading monovector ONNX embedder (all-MiniLM-L6-v2, ${probe.length}d)...`);
                         }
@@ -131,25 +113,6 @@ export async function loadEmbeddingModel(options) {
                 // monovector ONNX init failed, continue to next fallback
             }
         }
-        // Legacy fallback: Check for agentic-flow core embeddings
-        const agenticFlow = await import('agentic-flow').catch(() => null);
-        if (agenticFlow && agenticFlow.embeddings) {
-            if (verbose) {
-                console.log('Loading agentic-flow embedding model...');
-            }
-            embeddingModelState = {
-                loaded: true,
-                model: agenticFlow.embeddings,
-                tokenizer: null,
-                dimensions: 768
-            };
-            return {
-                success: true,
-                dimensions: 768,
-                modelName: 'agentic-flow',
-                loadTime: Date.now() - startTime
-            };
-        }
         // No ONNX model available - use fallback
         embeddingModelState = {
             loaded: true,

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-initializer.js

@@ -65,8 +65,6 @@ INSERT OR REPLACE INTO metadata (key, value) VALUES
 
 -- Create default vector index configuration
 -- Dimensions match BRIDGE_EMBEDDING_DIMS=384 (Xenova/all-MiniLM-L6-v2).
--- 768 was a legacy value from the agentic-flow era; 384 is the actual
--- embedding size used by memory-bridge.ts and LanceDB.
 INSERT OR IGNORE INTO vector_indexes (id, name, dimensions) VALUES
   ('default', 'default', 384),
   ('patterns', 'patterns', 384);

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.4",
   "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",
@@ -94,7 +94,6 @@
   "optionalDependencies": {
     "sql.js": "^1.14.1",
     "@monoes/memory": "^1.0.0",
-    "agentic-flow": "^3.0.0-alpha.1",
     "@huggingface/transformers": "^3.8.1",
     "monofence-ai": "*",
     "@monomind/hooks": "*",