monomind 1.11.5 → 1.11.7

package/README.md

@@ -342,7 +342,6 @@ The workspace ships 16 `@monomind/*` packages:
 | `@monomind/security` | Input validation, prompt injection detection, CVE remediation, gVisor sandbox |
 | `@monomind/mcp` | MCP server transport (stdio / http / WebSocket) |
 | `@monomind/routing` | Two-stage LLM + keyword agent routing, confidence scoring |
-| `@monomind/embeddings` | Vector embedding generation and management |
 | `@monomind/performance` | Profiling, benchmarking, latency tracking |
 | `@monomind/plugins` | IPFS/Pinata plugin registry, install/create/list |
 | `@monomind/claims` | Claims-based authorization for agent actions |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.11.5",
+  "version": "1.11.7",
   "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",
@@ -51,7 +51,6 @@
     "test": "vitest",
     "test:ui": "vitest --ui",
     "test:security": "vitest run packages/__tests__/security/",
-    "lint": "cd packages/@monomind/cli && npm run lint || true",
     "security:audit": "npm audit --audit-level high",
     "security:fix": "npm audit fix",
     "security:test": "npm run test:security",
@@ -66,10 +65,18 @@
   "overrides": {
     "hono": ">=4.11.4"
   },
+  "pnpm": {
+    "peerDependencyRules": {
+      "allowedVersions": {
+        "tree-sitter": "0.22.4",
+        "marked": "16",
+        "@vitest/coverage-v8": "4.1.8",
+        "vitest": "4.1.4"
+      }
+    }
+  },
   "devDependencies": {
-    "@types/bcrypt": "^5.0.2",
     "@types/node": "^20.0.0",
-    "eslint": "^8.0.0",
     "tsx": "^4.21.0",
     "typescript": "^5.0.0",
     "vitest": "^4.1.4",

package/packages/@monomind/cli/README.md

@@ -342,7 +342,6 @@ The workspace ships 16 `@monomind/*` packages:
 | `@monomind/security` | Input validation, prompt injection detection, CVE remediation, gVisor sandbox |
 | `@monomind/mcp` | MCP server transport (stdio / http / WebSocket) |
 | `@monomind/routing` | Two-stage LLM + keyword agent routing, confidence scoring |
-| `@monomind/embeddings` | Vector embedding generation and management |
 | `@monomind/performance` | Profiling, benchmarking, latency tracking |
 | `@monomind/plugins` | IPFS/Pinata plugin registry, install/create/list |
 | `@monomind/claims` | Claims-based authorization for agent actions |

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

@@ -127,7 +127,14 @@ const spawnCommand = {
         if (!agentType && taskDescription) {
             try {
                 const { RouteLayer, ALL_ROUTES } = await import('@monomind/routing');
-                const layer = new RouteLayer({ routes: ALL_ROUTES });
+                // Delegate low-confidence fallback to a headless Claude Code (Haiku)
+                // agent when `claude` is available — no API key required.
+                const { createClaudeLLMCaller } = await import('../routing/llm-caller.js');
+                const llmCaller = createClaudeLLMCaller({ model: 'haiku' });
+                const layer = new RouteLayer({
+                    routes: ALL_ROUTES,
+                    ...(llmCaller ? { llmFallback: { llmCaller, model: 'haiku' } } : {}),
+                });
                 const routeResult = await layer.route(taskDescription);
                 agentType = routeResult.agentSlug;
                 process.stderr.write(`[route] ${routeResult.method}: "${agentType}" (confidence: ${(routeResult.confidence * 100).toFixed(1)}%)\n`);

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

@@ -32,46 +32,18 @@ const pretrainCommand = {
         const outputFormat = ctx.flags.output || 'text';
         const saveFile = ctx.flags.save;
         const verbose = ctx.flags.verbose === true;
-        try {
-            // Dynamically import benchmark suite
-            const { runPretrainBenchmarkSuite } = await import('../benchmarks/pretrain/index.js');
-            const results = await runPretrainBenchmarkSuite({
-                iterations,
-                warmupIterations: warmup,
-                verbose,
-            });
-            // Output as JSON if requested
-            if (outputFormat === 'json') {
-                output.writeln(JSON.stringify(results, null, 2));
-            }
-            // Save to file if requested
-            if (saveFile) {
-                const resultsDir = join(process.cwd(), '.monomind', 'benchmarks');
-                if (!existsSync(resultsDir)) {
-                    mkdirSync(resultsDir, { recursive: true });
-                }
-                const savePath = saveFile.startsWith('/') ? saveFile : join(resultsDir, saveFile);
-                const saveTmp = savePath + '.tmp';
-                writeFileSync(saveTmp, JSON.stringify(results, null, 2));
-                renameSync(saveTmp, savePath);
-                output.writeln(output.success(`Results saved to ${savePath}`));
-            }
-            const allPassed = results.results.every(r => r.targetMet);
-            return {
-                success: true,
-                message: allPassed
-                    ? 'All benchmark targets met!'
-                    : `${results.results.filter(r => r.targetMet).length}/${results.results.length} targets met`,
-            };
-        }
-        catch (err) {
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            output.writeln(output.error(`Benchmark failed: ${errorMsg}`));
-            return {
-                success: false,
-                message: `Benchmark failed: ${errorMsg}`,
-            };
-        }
+        void iterations;
+        void warmup;
+        void verbose;
+        void outputFormat;
+        void saveFile;
+        output.writeln();
+        output.writeln(output.bold('Pattern-Learning Benchmark'));
+        output.writeln(output.dim('─'.repeat(50)));
+        output.writeln(output.dim('  The native SONA/EWC++/MoE pre-training benchmark was removed in the lean build.'));
+        output.writeln(output.dim('  Use "monomind benchmark neural" to benchmark the active pure-JS intelligence layer.'));
+        output.writeln();
+        return { success: true };
     },
 };
 // ============================================================================
@@ -79,7 +51,7 @@ const pretrainCommand = {
 // ============================================================================
 const neuralCommand = {
     name: 'neural',
-    description: 'Benchmark neural operations (embeddings, WASM, Flash Attention)',
+    description: 'Benchmark neural operations (embeddings, HNSW, cosine similarity)',
     options: [
         { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: '100' },
         { name: 'dimension', short: 'd', type: 'number', description: 'Embedding dimension', default: '384' },
@@ -182,8 +154,8 @@ const neuralCommand = {
                 target: 5.0,
                 met: cosineMean <= 5.0,
             });
-            // 3. Flash Attention Search (if available)
-            spinner.setText('Benchmarking flash attention search...');
+            // 3. Softmax-weighted top-K search (pure-JS)
+            spinner.setText('Benchmarking softmax top-K search...');
             const flashTimes = [];
             try {
                 const memory = await import('../memory/memory-initializer.js');
@@ -196,13 +168,13 @@ const neuralCommand = {
                 }
             }
             catch {
-                // Flash attention not available
+                // not available
             }
             if (flashTimes.length > 0) {
                 const flashMean = flashTimes.reduce((a, b) => a + b, 0) / flashTimes.length;
                 const flashSorted = [...flashTimes].sort((a, b) => a - b);
                 results.push({
-                    name: 'Flash Attention Search',
+                    name: 'Softmax Top-K Search',
                     mean: flashMean,
                     p95: percentile(flashSorted, 95),
                     p99: percentile(flashSorted, 99),

package/packages/@monomind/cli/dist/src/commands/index.d.ts

@@ -21,7 +21,6 @@ export { mcpCommand } from './mcp.js';
 export { hooksCommand } from './hooks.js';
 export { daemonCommand } from './daemon.js';
 export { doctorCommand } from './doctor.js';
-export { embeddingsCommand } from './embeddings.js';
 export { neuralCommand } from './neural.js';
 export { performanceCommand } from './performance.js';
 export { securityCommand } from './security.js';
@@ -46,7 +45,6 @@ export declare function getProvidersCommand(): Promise<Command | undefined>;
 export declare function getPluginsCommand(): Promise<Command | undefined>;
 export declare function getDeploymentCommand(): Promise<Command | undefined>;
 export declare function getClaimsCommand(): Promise<Command | undefined>;
-export declare function getEmbeddingsCommand(): Promise<Command | undefined>;
 export declare function getCompletionsCommand(): Promise<Command | undefined>;
 export declare function getAnalyzeCommand(): Promise<Command | undefined>;
 export declare function getRouteCommand(): Promise<Command | undefined>;

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

@@ -39,7 +39,6 @@ const commandLoaders = {
     plugins: () => import('./plugins.js'),
     deployment: () => import('./deployment.js'),
     claims: () => import('./claims.js'),
-    embeddings: () => import('./embeddings.js'),
     // P0 Commands
     completions: () => import('./completions.js'),
     doctor: () => import('./doctor.js'),
@@ -114,7 +113,6 @@ import { mcpCommand } from './mcp.js';
 import { hooksCommand } from './hooks.js';
 import { daemonCommand } from './daemon.js';
 import { doctorCommand } from './doctor.js';
-import { embeddingsCommand } from './embeddings.js';
 import { neuralCommand } from './neural.js';
 import { performanceCommand } from './performance.js';
 import { securityCommand } from './security.js';
@@ -157,7 +155,6 @@ loadedCommands.set('mcp', mcpCommand);
 loadedCommands.set('hooks', hooksCommand);
 loadedCommands.set('daemon', daemonCommand);
 loadedCommands.set('doctor', doctorCommand);
-loadedCommands.set('embeddings', embeddingsCommand);
 loadedCommands.set('neural', neuralCommand);
 loadedCommands.set('performance', performanceCommand);
 loadedCommands.set('security', securityCommand);
@@ -188,7 +185,6 @@ export { mcpCommand } from './mcp.js';
 export { hooksCommand } from './hooks.js';
 export { daemonCommand } from './daemon.js';
 export { doctorCommand } from './doctor.js';
-export { embeddingsCommand } from './embeddings.js';
 export { neuralCommand } from './neural.js';
 export { performanceCommand } from './performance.js';
 export { securityCommand } from './security.js';
@@ -214,7 +210,6 @@ export async function getProvidersCommand() { return loadCommand('providers'); }
 export async function getPluginsCommand() { return loadCommand('plugins'); }
 export async function getDeploymentCommand() { return loadCommand('deployment'); }
 export async function getClaimsCommand() { return loadCommand('claims'); }
-export async function getEmbeddingsCommand() { return loadCommand('embeddings'); }
 export async function getCompletionsCommand() { return loadCommand('completions'); }
 export async function getAnalyzeCommand() { return loadCommand('analyze'); }
 export async function getRouteCommand() { return loadCommand('route'); }
@@ -243,7 +238,6 @@ export const commands = [
     hooksCommand,
     daemonCommand,
     doctorCommand,
-    embeddingsCommand,
     neuralCommand,
     performanceCommand,
     securityCommand,
@@ -275,7 +269,6 @@ export const commandsByCategory = {
         neuralCommand,
         securityCommand,
         performanceCommand,
-        embeddingsCommand,
         hiveMindCommand,
         monovectorCommand,
         guidanceCommand,

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

@@ -278,7 +278,7 @@ const searchCommand = {
             // At @monoes/monograph@1.1.0, semanticSearch is not exported. Import from compat.
             // With no embeddings at 1.1.0, --mode semantic and --mode hybrid both degrade to BM25
             // (the RRF block merges bm25 with a sem list that is itself BM25 — harmless).
-            const { semanticSearch } = await import('../mcp-tools/monograph-compat.js');
+            const { hybridSearch: semanticSearch } = await import('@monoes/monograph');
             const db = openDb(dbPath);
             let results = [];
             const K = 60;

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

@@ -705,7 +705,7 @@ const rateCommand = {
         { name: 'rating', short: 'r', type: 'number', description: 'Rating (1-5)', required: true },
     ],
     examples: [
-        { command: 'monomind plugins rate -n @monomind/embeddings -r 5', description: 'Rate 5 stars' },
+        { command: 'monomind plugins rate -n my-plugin -r 5', description: 'Rate 5 stars' },
         { command: 'monomind plugins rate -n my-plugin -r 4', description: 'Rate 4 stars' },
     ],
     action: async (ctx) => {
@@ -780,7 +780,6 @@ export const pluginsCommand = {
         output.writeln(output.bold('Official Plugins:'));
         output.printList([
             '@monomind/security            - Security scanning and CVE detection',
-            '@monomind/embeddings          - Vector embeddings with hyperbolic support',
             '@monomind/claims              - Claims-based authorization',
             '@monomind/performance         - Performance profiling and benchmarks',
             '@monomind/plugin-gastown-bridge - Gas Town orchestrator integration (WASM-accelerated)',

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

@@ -11,7 +11,7 @@
  * github.com/nokhodian/monomind
  */
 import { output } from '../output.js';
-import { createKeywordRouter, isMonovectorAvailable, } from '../monovector/index.js';
+import { createKeywordRouter, } from '../monovector/index.js';
 /**
  * Available agent types for routing
  */
@@ -86,7 +86,7 @@ const routeTaskCommand = {
     ],
     examples: [
         { command: 'monomind route task "implement authentication"', description: 'Route task to best agent' },
-        { command: 'monomind route task "write unit tests" --q-learning', description: 'Use Q-Learning routing' },
+        { command: 'monomind route task "write unit tests" --q-learning', description: 'Use keyword-based routing' },
         { command: 'monomind route task "review code" --agent reviewer', description: 'Force specific agent' },
     ],
     action: async (ctx) => {
@@ -103,7 +103,7 @@ const routeTaskCommand = {
         spinner.start();
         try {
             if (forceAgent) {
-                // Bypass Q-Learning, use specified agent
+                // Use specified agent directly
                 const agent = getAgentType(forceAgent) ||
                     AGENT_TYPES.find(a => a.name.toLowerCase() === forceAgent.toLowerCase());
                 if (!agent) {
@@ -134,7 +134,7 @@ const routeTaskCommand = {
                 }
                 return { success: true, data: { agentId: agent.id, agentName: agent.name } };
             }
-            // Use Q-Learning routing
+            // Use keyword-based routing
             const router = await getRouter();
             const result = await router.route(taskDescription, useExploration);
             const agent = getAgentType(result.route) || AGENT_TYPES[0];
@@ -177,7 +177,7 @@ const routeTaskCommand = {
                     ``,
                     `Description: ${agent.description}`,
                     `Capabilities: ${capabilities.join(', ')}`,
-                ].join('\n'), 'Q-Learning Routing');
+                ].join('\n'), 'Keyword Routing');
                 if (alternatives.length > 0) {
                     output.writeln();
                     output.writeln(output.bold('Alternatives:'));
@@ -263,7 +263,7 @@ const listAgentsCommand = {
 // ============================================================================
 const statsCommand = {
     name: 'stats',
-    description: 'Show Q-Learning router statistics',
+    description: 'Show keyword router statistics',
     options: [
         {
             name: 'json',
@@ -281,18 +281,12 @@ const statsCommand = {
         try {
             const router = await getRouter();
             const stats = router.getStats();
-            const monovectorAvailable = await isMonovectorAvailable();
-            const monovectorStatus = {
-                available: monovectorAvailable,
-                wasmAccelerated: stats.useNative === 1,
-                backend: stats.useNative === 1 ? 'monovector-native' : 'fallback',
-            };
             if (jsonOutput) {
-                output.printJson({ stats, monovector: monovectorStatus });
+                output.printJson({ stats, backend: 'keyword-routing-js' });
             }
             else {
                 output.writeln();
-                output.writeln(output.bold('Q-Learning Router Statistics'));
+                output.writeln(output.bold('Keyword Router Statistics'));
                 output.writeln();
                 output.printTable({
                     columns: [
@@ -301,22 +295,13 @@ const statsCommand = {
                     ],
                     data: [
                         { metric: 'Update Count', value: String(stats.updateCount) },
-                        { metric: 'Q-Table Size', value: String(stats.qTableSize) },
+                        { metric: 'Pattern Count', value: String(stats.qTableSize) },
                         { metric: 'Step Count', value: String(stats.stepCount) },
-                        { metric: 'Epsilon', value: stats.epsilon.toFixed(4) },
-                        { metric: 'Avg TD Error', value: stats.avgTDError.toFixed(4) },
-                        { metric: 'Native Backend', value: stats.useNative === 1 ? 'Yes' : 'No' },
+                        { metric: 'Backend', value: 'keyword-routing (JS)' },
                     ],
                 });
-                output.writeln();
-                output.writeln(output.bold('MonoVector Status'));
-                output.printList([
-                    `Available: ${monovectorStatus.available ? output.success('Yes') : output.warning('No (using fallback)')}`,
-                    `WASM Accelerated: ${monovectorStatus.wasmAccelerated ? output.success('Yes') : 'No'}`,
-                    `Backend: ${monovectorStatus.backend}`,
-                ]);
             }
-            return { success: true, data: { stats, monovector: monovectorStatus } };
+            return { success: true, data: { stats } };
         }
         catch (error) {
             output.printError(error instanceof Error ? error.message : String(error));
@@ -406,7 +391,7 @@ const feedbackCommand = {
 // ============================================================================
 const resetCommand = {
     name: 'reset',
-    description: 'Reset the Q-Learning router state',
+    description: 'Reset the keyword router state',
     options: [
         {
             name: 'force',
@@ -430,7 +415,7 @@ const resetCommand = {
         try {
             const router = await getRouter();
             router.reset();
-            output.printSuccess('Q-Learning router state has been reset');
+            output.printSuccess('Keyword router state has been reset');
             return { success: true };
         }
         catch (error) {
@@ -802,7 +787,15 @@ const semanticRouteCommand = {
         spinner.start();
         try {
             const { RouteLayer, ALL_ROUTES } = await import('@monomind/routing');
-            const layer = new RouteLayer({ routes: ALL_ROUTES, debug });
+            // Delegate low-confidence fallback to a headless Claude Code (Haiku)
+            // agent when `claude` is available — no API key required.
+            const { createClaudeLLMCaller } = await import('../routing/llm-caller.js');
+            const llmCaller = createClaudeLLMCaller({ model: 'haiku' });
+            const layer = new RouteLayer({
+                routes: ALL_ROUTES,
+                debug,
+                ...(llmCaller ? { llmFallback: { llmCaller, model: 'haiku' } } : {}),
+            });
             const result = await layer.route(taskDescription);
             spinner.succeed(`Routed to ${result.agentSlug}`);
             if (jsonOutput) {
@@ -854,7 +847,7 @@ const semanticRouteCommand = {
 // ============================================================================
 export const routeCommand = {
     name: 'route',
-    description: 'Intelligent task-to-agent routing using Q-Learning',
+    description: 'Intelligent task-to-agent routing using keyword matching',
     subcommands: [
         routeTaskCommand,
         semanticRouteCommand,
@@ -870,7 +863,7 @@ export const routeCommand = {
         {
             name: 'q-learning',
             short: 'q',
-            description: 'Use Q-Learning for agent selection',
+            description: 'Use keyword-based agent selection',
             type: 'boolean',
             default: true,
         },
@@ -883,7 +876,7 @@ export const routeCommand = {
     ],
     examples: [
         { command: 'monomind route "implement feature"', description: 'Route task to best agent' },
-        { command: 'monomind route "write tests" --q-learning', description: 'Use Q-Learning routing' },
+        { command: 'monomind route "write tests" --q-learning', description: 'Use keyword-based routing' },
         { command: 'monomind route --agent coder "fix bug"', description: 'Force specific agent' },
         { command: 'monomind route list-agents', description: 'List available agents' },
         { command: 'monomind route stats', description: 'Show routing statistics' },
@@ -923,12 +916,10 @@ export const routeCommand = {
             'Provides confidence scores and alternatives',
         ]);
         output.writeln();
-        // Show quick status
-        const monovectorAvailable = await isMonovectorAvailable();
         output.writeln(output.bold('Backend Status:'));
         output.printList([
-            `MonoVector: ${monovectorAvailable ? output.success('Available') : output.warning('Fallback mode')}`,
-            `Backend: ${monovectorAvailable ? 'monovector-native' : 'JavaScript fallback'}`,
+            `Routing: ${output.success('keyword-based (JS)')}`,
+            `Learning: trajectory recording + outcome correlation`,
         ]);
         output.writeln();
         output.writeln(output.dim('Run "monomind route <subcommand> --help" for more info'));

package/packages/@monomind/cli/dist/src/index.js

@@ -490,32 +490,12 @@ export class CLI {
             }
         }
         catch { /* optional */ }
-        // Task 01-03: SemanticRouteLayer + LLMFallbackRouting + KeywordRouting
-        try {
-            const { RouteLayer, ALL_ROUTES } = await import('@monomind/routing');
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const routerConfig = { routes: ALL_ROUTES, enableKeywordFilter: true };
-            // Task 02: LLMFallback — wire Anthropic Haiku when API key is present
-            if (process.env.ANTHROPIC_API_KEY) {
-                const { default: Anthropic } = await import('@anthropic-ai/sdk');
-                const anthropic = new Anthropic();
-                routerConfig.llmFallback = {
-                    llmCaller: async (prompt) => {
-                        const msg = await anthropic.messages.create({
-                            model: 'claude-haiku-4-5-20251001',
-                            max_tokens: 100,
-                            messages: [{ role: 'user', content: prompt }],
-                        });
-                        return msg.content[0].type === 'text' ? msg.content[0].text : '';
-                    },
-                };
-            }
-            const routeLayer = new RouteLayer(routerConfig);
-            await routeLayer.initialize();
-            // Expose for router.cjs via process global (router.cjs already checks __monomindRouteLayer)
-            process.__monomindRouteLayer = routeLayer;
-        }
-        catch { /* optional — @monomind/routing may not be installed */ }
+        // NOTE: Semantic routing (@monomind/routing) is constructed on-demand by
+        // its consumers — `monomind route` and `monomind agent --task` (see
+        // commands/route.ts and commands/agent.ts). It is intentionally NOT
+        // eagerly initialized here: building all route centroids and probing for
+        // the `claude` CLI on every CLI startup would regress the <500ms startup
+        // budget for zero benefit (nothing reads a process-global route layer).
     }
     /**
      * Handle errors

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

@@ -533,7 +533,7 @@ export class MCPServerManager extends EventEmitter {
                     try {
                         const { join } = await import('path');
                         const { openDb, closeDb } = await import('@monoes/monograph');
-                        const { getProcessesResource, getCommunitiesResource, getSchemaResource, getGraphResource } = await import('./mcp-tools/monograph-compat.js');
+                        const { getProcessesResource, getCommunitiesResource, getSchemaResource, getGraphResource } = await import('@monoes/monograph');
                         const projectCwd = process.env['MONOMIND_CWD'] || process.cwd();
                         const dbPath = join(projectCwd, '.monomind', 'monograph.db');
                         const resDb = openDb(dbPath);

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

@@ -50,10 +50,6 @@ export declare const OPTIONAL_PACKAGES: {
         readonly description: "AI manipulation defense (prompt injection, PII detection)";
         readonly tools: readonly ["aidefence_scan", "aidefence_analyze", "aidefence_stats", "aidefence_learn"];
     };
-    readonly '@monomind/embeddings': {
-        readonly description: "Vector embeddings with ONNX support";
-        readonly tools: readonly ["embeddings_generate", "embeddings_search", "embeddings_batch"];
-    };
     readonly 'onnxruntime-node': {
         readonly description: "ONNX runtime for neural network inference";
         readonly tools: readonly ["neural_*"];
@@ -69,10 +65,6 @@ declare const _default: {
             readonly description: "AI manipulation defense (prompt injection, PII detection)";
             readonly tools: readonly ["aidefence_scan", "aidefence_analyze", "aidefence_stats", "aidefence_learn"];
         };
-        readonly '@monomind/embeddings': {
-            readonly description: "Vector embeddings with ONNX support";
-            readonly tools: readonly ["embeddings_generate", "embeddings_search", "embeddings_batch"];
-        };
         readonly 'onnxruntime-node': {
             readonly description: "ONNX runtime for neural network inference";
             readonly tools: readonly ["neural_*"];

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

@@ -110,10 +110,6 @@ export const OPTIONAL_PACKAGES = {
         description: 'AI manipulation defense (prompt injection, PII detection)',
         tools: ['aidefence_scan', 'aidefence_analyze', 'aidefence_stats', 'aidefence_learn'],
     },
-    '@monomind/embeddings': {
-        description: 'Vector embeddings with ONNX support',
-        tools: ['embeddings_generate', 'embeddings_search', 'embeddings_batch'],
-    },
     'onnxruntime-node': {
         description: 'ONNX runtime for neural network inference',
         tools: ['neural_*'],

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

@@ -5,7 +5,6 @@
 import { mkdirSync, writeFileSync, renameSync, existsSync, readFileSync, statSync, unlinkSync, readdirSync } from 'fs';
 import { dirname, join, resolve, sep } from 'path';
 import { getProjectCwd } from './types.js';
-import { getCapabilities } from '../monovector/capabilities.js';
 import { randomUUID } from 'node:crypto';
 import { recordRoute, joinOutcome, joinLatestUnresolved } from '../monovector/route-outcomes.js';
 import { recordCommand, deriveRecentSuccess } from '../monovector/command-outcomes.js';
@@ -706,8 +705,6 @@ export const hooksRoute = {
                     const agentdbConfidence = Math.round(agentdbRoute.confidence * 100) / 100;
                     // Record the route recommendation so post-task can join the actual outcome
                     const routeId = randomUUID();
-                    const caps = await getCapabilities();
-                    const learningMode = (caps.sona || caps.router === 'native' || caps.attention) ? 'native' : 'js';
                     await recordRoute(getRouteOutcomesBaseDir(), {
                         routeId,
                         ts: Date.now(),
@@ -715,7 +712,7 @@ export const hooksRoute = {
                         recommendedAgent: agents[0],
                         routingMethod: agentdbMethod,
                         confidence: agentdbConfidence,
-                        learningMode,
+                        learningMode: 'js',
                     });
                     return {
                         routeId,
@@ -797,8 +794,6 @@ export const hooksRoute = {
         const primaryConfidence = Math.round(confidence * 100) / 100;
         // Record the route recommendation so post-task can join the actual outcome
         const routeId = randomUUID();
-        const caps = await getCapabilities();
-        const learningMode = (caps.sona || caps.router === 'native' || caps.attention) ? 'native' : 'js';
         await recordRoute(getRouteOutcomesBaseDir(), {
             routeId,
             ts: Date.now(),
@@ -806,7 +801,7 @@ export const hooksRoute = {
             recommendedAgent: agents[0],
             routingMethod,
             confidence: primaryConfidence,
-            learningMode,
+            learningMode: 'js',
         });
         return {
             routeId,