monomind 1.11.4 → 1.11.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.11.4",
+  "version": "1.11.6",
   "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/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/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) {
@@ -854,7 +839,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 +855,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 +868,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 +908,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/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,

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

@@ -18,7 +18,7 @@ import { homedir } from 'os';
 import { execSync } from 'child_process';
 import { createServer } from 'http';
 import { performance } from 'perf_hooks';
-import { openDb, closeDb, ftsSearch, getNode, getNodesForFile, getEdgesForSource, getEdgesForTarget, countNodes, countEdges, snapshotFromDb, toHtml, MonographError, } from '@monoes/monograph';
+import { openDb, closeDb, ftsSearch, getNode, getNodesForFile, getEdgesForSource, getEdgesForTarget, countNodes, countEdges, snapshotFromDb, toHtml, } from '@monoes/monograph';
 // ─── Tier 1: Fully implementable from primitives ───────────────────────────────
 // 1. hybridQuery
 // BM25-only at monograph@1.1.0 (no vector storage). score = -rank (descending, .toFixed-safe).
@@ -878,7 +878,7 @@ export async function installSkillsForPlatform(repoPath, communities, opts) {
 }
 // 18. runEmbed — embeddings unsupported at 1.1.0; throws so handler catches gracefully
 export async function runEmbed(_db, _opts) {
-    throw new MonographError('Embeddings are not supported in @monoes/monograph@1.1.0 — upgrade to a version with native vector storage, or install @huggingface/transformers and a compat build.');
+    throw new Error('Embeddings are not supported in @monoes/monograph@1.1.0 — no vector storage in this schema version.');
 }
 // ─── Groups (Tier 2) ──────────────────────────────────────────────────────────
 // Helper: read group config (groups.json or group.yaml)

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

@@ -416,8 +416,7 @@ export declare function bridgeContextSynthesize(params: {
 }): Promise<any>;
 /**
  * Route via SemanticRouter.
- * Available since agentdb 3.0.0-alpha.10 — uses @monoes/router for
- * semantic matching with keyword fallback.
+ * Available since agentdb 3.0.0-alpha.10 — semantic matching with keyword fallback.
  */
 export declare function bridgeSemanticRoute(params: {
     input: string;

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

@@ -1671,8 +1671,7 @@ export async function bridgeContextSynthesize(params) {
 }
 /**
  * Route via SemanticRouter.
- * Available since agentdb 3.0.0-alpha.10 — uses @monoes/router for
- * semantic matching with keyword fallback.
+ * Available since agentdb 3.0.0-alpha.10 — semantic matching with keyword fallback.
  */
 export async function bridgeSemanticRoute(params) {
     const registry = await getRegistry();

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

@@ -378,121 +378,13 @@ export async function getHNSWIndex(options) {
     }
     hnswInitializing = true;
     try {
-        // Lean teardown: the native @monoes/core HNSW backend (WASM VectorDb) has been
-        // removed. Callers of getHNSWIndex() already treat a null return as "no native
-        // index — use the pure-JS / brute-force fallback", so we short-circuit here.
-        const monovectorModule = await import('@monoes/core').catch(() => null);
-        if (!monovectorModule) {
-            hnswInitializing = false;
-            return null; // HNSW not available — pure-JS fallback path
-        }
-        // ESM returns { default: { VectorDb, ... } }, CJS returns { VectorDb, ... }
-        const monovectorCore = monovectorModule.default || monovectorModule;
-        if (!monovectorCore?.VectorDb) {
-            hnswInitializing = false;
-            return null; // VectorDb not found
-        }
-        const { VectorDb } = monovectorCore;
-        // Persistent storage paths — resolve to absolute to survive CWD changes
-        const swarmDir = path.resolve(process.cwd(), '.swarm');
-        if (!fs.existsSync(swarmDir)) {
-            fs.mkdirSync(swarmDir, { recursive: true });
-        }
-        const hnswPath = path.join(swarmDir, 'hnsw.index');
-        const metadataPath = path.join(swarmDir, 'hnsw.metadata.json');
-        const dbPath = options?.dbPath ? path.resolve(options.dbPath) : path.join(swarmDir, 'memory.db');
-        // Create HNSW index with persistent storage
-        // @monoes/core uses string enum for distanceMetric: 'Cosine', 'Euclidean', 'DotProduct', 'Manhattan'
-        const db = new VectorDb({
-            dimensions,
-            distanceMetric: 'Cosine',
-            storagePath: hnswPath // Persistent storage!
-        });
-        // Load metadata (entry info) if exists
-        const entries = new Map();
-        if (fs.existsSync(metadataPath)) {
-            try {
-                const metadataJson = fs.readFileSync(metadataPath, 'utf-8');
-                const metadata = JSON.parse(metadataJson);
-                for (const [key, value] of metadata) {
-                    entries.set(key, value);
-                }
-            }
-            catch {
-                // Metadata load failed, will rebuild
-            }
-        }
-        hnswIndex = {
-            db,
-            entries,
-            dimensions,
-            initialized: false
-        };
-        // Check if index already has data (from persistent storage)
-        const existingLen = await db.len();
-        if (existingLen > 0 && entries.size > 0) {
-            // Index loaded from disk, skip SQLite sync
-            hnswIndex.initialized = true;
-            hnswInitializing = false;
-            return hnswIndex;
-        }
-        if (fs.existsSync(dbPath)) {
-            try {
-                // Reject symlinks and oversized DB files. Without this a symlink at the
-                // dbPath pointing at /dev/zero or a 100GB sparse file would OOM the CLI
-                // on the next memory operation.
-                const stat = fs.lstatSync(dbPath);
-                if (stat.isSymbolicLink() || stat.size > 256 * 1024 * 1024) {
-                    return null;
-                }
-                const initSqlJs = (await import('sql.js')).default;
-                const SQL = await initSqlJs();
-                const fileBuffer = fs.readFileSync(dbPath);
-                const sqlDb = new SQL.Database(fileBuffer);
-                // Load all entries with embeddings
-                const result = sqlDb.exec(`
-          SELECT id, key, namespace, content, embedding
-          FROM memory_entries
-          WHERE status = 'active' AND embedding IS NOT NULL
-          LIMIT 10000
-        `);
-                if (result[0]?.values) {
-                    for (const row of result[0].values) {
-                        const [id, key, ns, content, embeddingJson] = row;
-                        if (embeddingJson) {
-                            try {
-                                const embedding = safeParseEmbeddingLocal(embeddingJson);
-                                if (!embedding)
-                                    continue;
-                                const vector = new Float32Array(embedding);
-                                await db.insert({
-                                    id: String(id),
-                                    vector
-                                });
-                                hnswIndex.entries.set(String(id), {
-                                    id: String(id),
-                                    key: key || String(id),
-                                    namespace: ns || 'default',
-                                    content: content || ''
-                                });
-                            }
-                            catch {
-                                // Skip invalid embeddings
-                            }
-                        }
-                    }
-                }
-                sqlDb.close();
-            }
-            catch {
-                // SQLite load failed, start with empty index
-            }
-        }
-        // initialized = true even on empty DB — absence of vectors is a valid ready state,
-        // not a failure. The concurrent-waiter null-check at line ~395 relies on this.
-        hnswIndex.initialized = true;
+        // Native @monoes/core HNSW (WASM VectorDb) was removed in the lean teardown.
+        // This function is kept for callers that check its return value — all callers
+        // already handle null by falling back to the pure-JS / brute-force path.
+        // The AgentDB bridge (memory-bridge.ts) provides HNSW via agentdb instead.
+        // Native backend removed — return null so callers use the pure-JS fallback.
         hnswInitializing = false;
-        return hnswIndex;
+        return null;
     }
     catch {
         hnswInitializing = false;
@@ -576,7 +468,7 @@ export async function searchHNSWIndex(queryEmbedding, options) {
                 continue;
             }
             // Convert cosine distance to similarity score (1 - distance)
-            // Cosine distance from @monoes/core: 0 = identical, 2 = opposite
+            // Cosine distance convention: 0 = identical, 2 = opposite
             const score = 1 - (result.score / 2);
             filtered.push({
                 id: entry.id.substring(0, 12),
@@ -1329,6 +1221,48 @@ export async function loadEmbeddingModel(options) {
         }
     }
     try {
+        // Tier 0: @monomind/embeddings — bundles @xenova/transformers as a hard dep, so it
+        // resolves from the CLI even when a bare `import('@xenova/transformers')` does NOT
+        // (the CLI doesn't declare @xenova directly). Without this, the chain below falls
+        // straight through to the hash fallback and "semantic" search is lexical-only.
+        const embPkg = await import('@monomind/embeddings').catch(() => null);
+        if (embPkg && typeof embPkg.createEmbeddingService === 'function') {
+            try {
+                const service = embPkg.createEmbeddingService({
+                    provider: 'transformers',
+                    model: 'Xenova/all-MiniLM-L6-v2',
+                    normalization: 'l2',
+                    enableCache: true,
+                });
+                // Probe triggers the (lazy) model load and verifies real vectors come back.
+                const probe = await service.embed('probe');
+                const probeVec = probe?.embedding;
+                const dims = (probeVec && probeVec.length) || 384;
+                if (probeVec && dims > 1) {
+                    if (verbose) {
+                        console.log(`Loaded @monomind/embeddings (Transformers MiniLM-L6, ${dims}d)...`);
+                    }
+                    embeddingModelState = {
+                        loaded: true,
+                        // Match generateEmbedding's consumer: a callable returning a plain number[]
+                        // (it accepts either `{ data }` or an Array.isArray(...) result).
+                        model: async (text) => Array.from((await service.embed(String(text))).embedding),
+                        tokenizer: null,
+                        dimensions: dims,
+                    };
+                    return {
+                        success: true,
+                        dimensions: dims,
+                        modelName: '@monomind/embeddings (transformers/MiniLM-L6)',
+                        loadTime: Date.now() - startTime,
+                    };
+                }
+            }
+            catch {
+                // Embeddings package present but model load failed (offline / download error);
+                // fall through to the remaining providers and ultimately the hash fallback.
+            }
+        }
         // Try to import @xenova/transformers for ONNX embeddings
         const transformers = await import('@xenova/transformers').catch(() => null);
         if (transformers) {

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

@@ -1,9 +1,7 @@
 /**
  * MonoVector Integration Module for Monomind CLI (lean)
  *
- * After the SONA / native / WASM teardown this module provides only the
- * lightweight surface:
- * - Capability probing: getCapabilities() — stubbed, always reports JS-only
+ * After the SONA / native / WASM teardown this module provides:
  * - Initialization state: createInitState()
  * - Keyword-based task routing: createKeywordRouter()
  * - Route recommendation→outcome records: recordRoute(), joinOutcome(), accuracy
@@ -11,7 +9,6 @@
  *
  * @module @monomind/cli/monovector
  */
-export { getCapabilities, getCachedCapabilities, resetCapabilitiesCache, refreshCapabilities, type MonoesCapabilities } from './capabilities.js';
 export { createInitState, type InitState, type InitStatus } from './init-state.js';
 export { recordRoute, joinOutcome, joinLatestUnresolved, readOutcomes, computeRoutingAccuracy, computeAdherence, type RouteOutcomeRecord, type RoutingAccuracy, } from './route-outcomes.js';
 export { DiffClassifier, createDiffClassifier, analyzeDiff, analyzeDiffSync, assessFileRisk, assessOverallRisk, classifyDiff, suggestReviewers, getGitDiffNumstat, getGitDiffNumstatAsync, clearDiffCache, clearAllDiffCaches, type DiffClassification, type DiffHunk, type DiffChange, type FileDiff, type DiffAnalysis, type DiffClassifierConfig, type DiffFile, type RiskLevel, type FileRisk, type OverallRisk, type DiffAnalysisResult, } from './diff-classifier.js';
@@ -54,8 +51,4 @@ export interface KeywordRouterConfig {
     discountFactor?: number;
 }
 export declare function createKeywordRouter(_config?: KeywordRouterConfig): KeywordRouter;
-/** @deprecated Use (await getCapabilities()).sona */
-export declare function isMonovectorAvailable(): Promise<boolean>;
-/** @deprecated Use (await getCapabilities()).learningWasm */
-export declare function isWasmBackendAvailable(): Promise<boolean>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,9 +1,7 @@
 /**
  * MonoVector Integration Module for Monomind CLI (lean)
  *
- * After the SONA / native / WASM teardown this module provides only the
- * lightweight surface:
- * - Capability probing: getCapabilities() — stubbed, always reports JS-only
+ * After the SONA / native / WASM teardown this module provides:
  * - Initialization state: createInitState()
  * - Keyword-based task routing: createKeywordRouter()
  * - Route recommendation→outcome records: recordRoute(), joinOutcome(), accuracy
@@ -11,8 +9,6 @@
  *
  * @module @monomind/cli/monovector
  */
-import { getCapabilities } from './capabilities.js';
-export { getCapabilities, getCachedCapabilities, resetCapabilitiesCache, refreshCapabilities } from './capabilities.js';
 export { createInitState } from './init-state.js';
 export { recordRoute, joinOutcome, joinLatestUnresolved, readOutcomes, computeRoutingAccuracy, computeAdherence, } from './route-outcomes.js';
 export { DiffClassifier, createDiffClassifier, analyzeDiff, analyzeDiffSync, assessFileRisk, assessOverallRisk, classifyDiff, suggestReviewers, getGitDiffNumstat, getGitDiffNumstatAsync, clearDiffCache, clearAllDiffCaches, } from './diff-classifier.js';
@@ -56,12 +52,4 @@ export function createKeywordRouter(_config) {
         import() { },
     };
 }
-/** @deprecated Use (await getCapabilities()).sona */
-export async function isMonovectorAvailable() {
-    return (await getCapabilities()).sona;
-}
-/** @deprecated Use (await getCapabilities()).learningWasm */
-export async function isWasmBackendAvailable() {
-    return (await getCapabilities()).learningWasm;
-}
 //# sourceMappingURL=index.js.map

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.11.4",
+  "version": "1.11.6",
   "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",
@@ -68,7 +68,6 @@
     "dist",
     "bin",
     ".claude",
-    "bundled-graph",
     "scripts",
     "README.md"
   ],

package/scripts/build-monovector.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 set -e
 REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-PACKAGES=(learning-wasm exotic-wasm attention-wasm gnn-wasm ruvllm-wasm rvagent-wasm)
+PACKAGES=(learning-wasm exotic-wasm attention-wasm gnn-wasm)
 for pkg in "${PACKAGES[@]}"; do
   echo "Building @monovector/$pkg..."
   (cd "$REPO_ROOT/packages/@monoes/$pkg" && npm run build)

package/scripts/publish-monovector.sh

@@ -6,7 +6,7 @@
 set -e
 REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 
-PACKAGES=(learning-wasm exotic-wasm attention-wasm gnn-wasm ruvllm-wasm rvagent-wasm)
+PACKAGES=(learning-wasm exotic-wasm attention-wasm gnn-wasm)
 
 for pkg in "${PACKAGES[@]}"; do
   PKG_DIR="$REPO_ROOT/packages/@monoes/$pkg/pkg"

package/scripts/verify-appliance.sh

@@ -423,24 +423,7 @@ if should_run "rvf"; then
   rm -rf "$RVF_DIR"
 fi
 
-# ── 27. Local Model Inference (ruvLLM from RuVector) ──────────
-if should_run "ruvllm"; then
-  section 27 "Local Model Inference (ruvLLM / RuVector)"
-  if [ "${SKIP_MODELS:-0}" = "1" ]; then
-    check_skip "ruvllm: model load" "SKIP_MODELS=1"
-    check_skip "ruvllm: tokenize" "SKIP_MODELS=1"
-    check_skip "ruvllm: generate" "SKIP_MODELS=1"
-    check_skip "ruvllm: stream" "SKIP_MODELS=1"
-  elif command -v monomind-ruvllm >/dev/null 2>&1; then
-    check_warn "ruvllm: engine available" monomind-ruvllm --version
-    check_warn "ruvllm: model list" monomind-ruvllm models list
-    check_warn "ruvllm: tokenize" monomind-ruvllm tokenize --text "Hello world"
-    check_warn "ruvllm: generate" monomind-ruvllm generate --prompt "2+2=" --max-tokens 10
-  else
-    check_skip "ruvllm: engine" "monomind-ruvllm not installed (future: ADR-058 Phase 3)"
-    check_skip "ruvllm: inference" "monomind-ruvllm not installed"
-  fi
-fi
+# Section 27 (local model inference) was removed — native LLM module not in lean build
 
 # ── 28. API Key Vault ─────────────────────────────────────────
 if should_run "vault"; then

package/packages/@monomind/cli/bundled-graph/dist/src/build.js

@@ -1,73 +0,0 @@
-import Graph from 'graphology';
-// Mirrors upstream graphify's _normalize_id: lowercase + collapse non-alphanumeric to underscores.
-function normalizeId(s) {
-    return s.replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '').toLowerCase();
-}
-/**
- * Build a graphology Graph from extracted nodes and edges.
- * Deduplicates nodes by id, merges parallel edges with higher weight.
- */
-export function buildGraph(extraction) {
-    const graph = new Graph({ type: 'directed', multi: false });
-    // Add all nodes — merge attributes if already present (dedup by id)
-    for (const node of extraction.nodes) {
-        if (!graph.hasNode(node.id)) {
-            graph.addNode(node.id, { ...node });
-        }
-        else {
-            graph.mergeNodeAttributes(node.id, { ...node });
-        }
-    }
-    // Build normalized ID lookup to remap mismatched edge endpoints before stubbing.
-    const normToId = new Map();
-    graph.forEachNode((id) => {
-        normToId.set(normalizeId(id), id);
-    });
-    // Add edges — skip self-loops, remap via normalization, stub only true externals
-    for (const edge of extraction.edges) {
-        let src = edge.source;
-        let tgt = edge.target;
-        if (!graph.hasNode(src)) {
-            const remapped = normToId.get(normalizeId(src));
-            if (remapped) {
-                src = remapped;
-            }
-            else {
-                graph.addNode(src, { id: src, label: src, fileType: 'unknown', sourceFile: '' });
-                normToId.set(normalizeId(src), src);
-            }
-        }
-        if (!graph.hasNode(tgt)) {
-            const remapped = normToId.get(normalizeId(tgt));
-            if (remapped) {
-                tgt = remapped;
-            }
-            else {
-                graph.addNode(tgt, { id: tgt, label: tgt, fileType: 'unknown', sourceFile: '' });
-                normToId.set(normalizeId(tgt), tgt);
-            }
-        }
-        if (src === tgt)
-            continue;
-        try {
-            graph.addEdge(src, tgt, {
-                relation: edge.relation,
-                confidence: edge.confidence,
-                confidenceScore: edge.confidenceScore,
-                weight: edge.weight ?? 1,
-                sourceFile: edge.sourceFile,
-                sourceLocation: edge.sourceLocation,
-            });
-        }
-        catch {
-            // Edge already exists — bump its weight
-            const existing = graph.edge(src, tgt);
-            if (existing) {
-                const prev = graph.getEdgeAttribute(existing, 'weight') ?? 1;
-                graph.setEdgeAttribute(existing, 'weight', prev + 1);
-            }
-        }
-    }
-    return graph;
-}
-//# sourceMappingURL=build.js.map

package/packages/@monomind/cli/bundled-graph/dist/src/cluster.js

@@ -1,120 +0,0 @@
-import Graph from 'graphology';
-export async function detectCommunities(graph) {
-    let louvainFn = null;
-    try {
-        const mod = await import('graphology-communities-louvain');
-        louvainFn = mod.default;
-    }
-    catch { /* louvain not available */ }
-    if (louvainFn) {
-        try {
-            const assignment = louvainFn(graph);
-            for (const [nodeId, communityId] of Object.entries(assignment)) {
-                graph.setNodeAttribute(nodeId, 'community', communityId);
-            }
-            const communities = {};
-            for (const [nodeId, communityId] of Object.entries(assignment)) {
-                if (!communities[communityId])
-                    communities[communityId] = [];
-                communities[communityId].push(nodeId);
-            }
-            return splitOversizedCommunities(graph, communities, 0.25, louvainFn);
-        }
-        catch { /* fall through */ }
-    }
-    return splitOversizedCommunities(graph, fallbackCluster(graph), 0.25, louvainFn);
-}
-function fallbackCluster(graph) {
-    const dirMap = new Map();
-    let nextId = 0;
-    const communities = {};
-    graph.forEachNode((id, attrs) => {
-        const file = attrs.sourceFile || '';
-        const parts = file.split('/');
-        const dir = parts.length > 1 ? parts.slice(0, -1).join('/') : 'root';
-        if (!dirMap.has(dir))
-            dirMap.set(dir, nextId++);
-        const cid = dirMap.get(dir);
-        graph.setNodeAttribute(id, 'community', cid);
-        if (!communities[cid])
-            communities[cid] = [];
-        communities[cid].push(id);
-    });
-    return communities;
-}
-export function cohesionScore(graph, communityNodes) {
-    const memberSet = new Set(communityNodes);
-    let totalEdges = 0;
-    let internalEdges = 0;
-    graph.forEachEdge((_edge, _attrs, source, target) => {
-        const srcIn = memberSet.has(source);
-        const tgtIn = memberSet.has(target);
-        if (srcIn || tgtIn) {
-            totalEdges++;
-            if (srcIn && tgtIn)
-                internalEdges++;
-        }
-    });
-    return totalEdges === 0 ? 1.0 : internalEdges / totalEdges;
-}
-export function splitOversizedCommunities(graph, communities, threshold = 0.25, louvainFn = null) {
-    const maxSize = threshold * graph.order;
-    const allIds = Object.keys(communities).map(Number);
-    let nextId = allIds.length > 0 ? Math.max(...allIds) + 1 : 0;
-    for (const [cidStr, members] of Object.entries(communities)) {
-        if (members.length <= maxSize)
-            continue;
-        const cid = Number(cidStr);
-        // Attempt topology-based second pass via Louvain on the community subgraph
-        if (louvainFn && members.length >= 10) {
-            try {
-                const memberSet = new Set(members);
-                const subG = new Graph({ type: 'undirected', multi: false });
-                for (const nodeId of members)
-                    subG.addNode(nodeId);
-                graph.forEachEdge((_e, _a, source, target) => {
-                    if (memberSet.has(source) && memberSet.has(target) && source !== target && !subG.hasEdge(source, target))
-                        subG.addEdge(source, target);
-                });
-                const subAssignment = louvainFn(subG);
-                const subCommunityCount = new Set(Object.values(subAssignment)).size;
-                if (subCommunityCount > 1 && subCommunityCount <= Math.ceil(members.length / 2)) {
-                    const subIdMap = new Map();
-                    const newSubIds = {};
-                    for (const [nodeId, localId] of Object.entries(subAssignment)) {
-                        if (!subIdMap.has(localId))
-                            subIdMap.set(localId, nextId++);
-                        const globalId = subIdMap.get(localId);
-                        graph.setNodeAttribute(nodeId, 'community', globalId);
-                        if (!newSubIds[globalId])
-                            newSubIds[globalId] = [];
-                        newSubIds[globalId].push(nodeId);
-                    }
-                    delete communities[cid];
-                    Object.assign(communities, newSubIds);
-                    continue;
-                }
-            }
-            catch { /* fall through to directory heuristic */ }
-        }
-        // Directory heuristic fallback
-        const subMap = new Map();
-        const newSubIds = {};
-        for (const nodeId of members) {
-            const file = graph.getNodeAttribute(nodeId, 'sourceFile') || '';
-            const parts = file.split('/');
-            const parentDir = parts.length > 1 ? parts[parts.length - 2] : 'root';
-            if (!subMap.has(parentDir))
-                subMap.set(parentDir, nextId++);
-            const subId = subMap.get(parentDir);
-            graph.setNodeAttribute(nodeId, 'community', subId);
-            if (!newSubIds[subId])
-                newSubIds[subId] = [];
-            newSubIds[subId].push(nodeId);
-        }
-        delete communities[cid];
-        Object.assign(communities, newSubIds);
-    }
-    return communities;
-}
-//# sourceMappingURL=cluster.js.map

package/packages/@monomind/cli/bundled-graph/package.json

@@ -1,57 +0,0 @@
-{
-  "name": "@monomind/graph",
-  "version": "1.4.0",
-  "type": "module",
-  "description": "Knowledge graph engine for monomind — AST extraction, graph construction, community detection, and persistent codebase understanding",
-  "main": "./dist/src/index.js",
-  "types": "./dist/src/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/src/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest run",
-    "clean": "rm -rf dist"
-  },
-  "dependencies": {
-    "graphology": "^0.25.4",
-    "graphology-types": "^0.24.7",
-    "graphology-communities-louvain": "^2.0.1",
-    "graphology-shortest-path": "^2.0.2",
-    "graphology-traversal": "^0.3.1",
-    "graphology-metrics": "^2.4.0",
-    "chokidar": "^3.6.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.3.0",
-    "vitest": "^4.1.4"
-  },
-  "optionalDependencies": {
-    "node-tree-sitter": "^0.22.4",
-    "tree-sitter-typescript": "^0.23.2",
-    "tree-sitter-javascript": "^0.23.1",
-    "tree-sitter-python": "^0.23.6",
-    "tree-sitter-go": "^0.23.4",
-    "tree-sitter-rust": "^0.23.2",
-    "tree-sitter-java": "^0.23.5",
-    "tree-sitter-c": "^0.23.4",
-    "tree-sitter-cpp": "^0.23.4",
-    "tree-sitter-ruby": "^0.23.1",
-    "tree-sitter-c-sharp": "^0.23.1",
-    "tree-sitter-kotlin": "^0.3.9",
-    "tree-sitter-swift": "^0.6.1",
-    "tree-sitter-scala": "^0.23.4",
-    "tree-sitter-php": "^0.23.11"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}

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

@@ -1,9 +0,0 @@
-/**
- * MonoVector LLM WASM MCP Tools
- *
- * Exposes @monoes/ruvllm-wasm operations via MCP protocol.
- * All tools gracefully degrade when the WASM package is not installed.
- */
-import type { MCPTool } from './types.js';
-export declare const ruvllmWasmTools: MCPTool[];
-//# sourceMappingURL=ruvllm-tools.d.ts.map

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

@@ -1,295 +0,0 @@
-/**
- * MonoVector LLM WASM MCP Tools
- *
- * Exposes @monoes/ruvllm-wasm operations via MCP protocol.
- * All tools gracefully degrade when the WASM package is not installed.
- */
-async function loadRuvllmWasm() {
-    return import('../monovector/ruvllm-wasm.js');
-}
-// ── Instance Registries ──────────────────────────────────────
-const hnswRouters = new Map();
-const sonaInstances = new Map();
-const loraInstances = new Map();
-// ── Map eviction (prevents WASM object leaks in long-running MCP servers) ────
-const MAX_MAP_SIZE = 50;
-function setWithEviction(map, key, value) {
-    if (map.size >= MAX_MAP_SIZE) {
-        // Evict the oldest entry (first inserted)
-        const firstKey = map.keys().next().value;
-        map.delete(firstKey);
-    }
-    map.set(key, value);
-}
-export const ruvllmWasmTools = [
-    {
-        name: 'ruvllm_status',
-        description: 'Get ruvllm-wasm availability and initialization status.',
-        inputSchema: { type: 'object', properties: {} },
-        handler: async () => {
-            try {
-                const mod = await loadRuvllmWasm();
-                const status = await mod.getRuvllmStatus();
-                return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_hnsw_create',
-        description: 'Create a WASM HNSW router for semantic pattern routing. Max ~11 patterns (v2.0.1 limit).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                dimensions: { type: 'number', description: 'Embedding dimensions (e.g., 64, 128, 384)' },
-                maxPatterns: { type: 'number', description: 'Max patterns capacity (limit ~11 in v2.0.1)' },
-                efSearch: { type: 'number', description: 'HNSW ef search parameter (higher = more accurate, slower)' },
-            },
-            required: ['dimensions', 'maxPatterns'],
-        },
-        handler: async (args) => {
-            try {
-                const mod = await loadRuvllmWasm();
-                const router = await mod.createHnswRouter({
-                    dimensions: args.dimensions,
-                    maxPatterns: args.maxPatterns,
-                    efSearch: args.efSearch,
-                });
-                // Store router in module-level registry
-                const id = `hnsw-${Date.now().toString(36)}`;
-                setWithEviction(hnswRouters, id, router);
-                return { content: [{ type: 'text', text: JSON.stringify({ success: true, routerId: id, dimensions: args.dimensions, maxPatterns: args.maxPatterns }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_hnsw_add',
-        description: 'Add a pattern to an HNSW router. Embedding must match router dimensions.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                routerId: { type: 'string', description: 'HNSW router ID from ruvllm_hnsw_create' },
-                name: { type: 'string', description: 'Pattern name/label' },
-                embedding: { type: 'array', items: { type: 'number' }, description: 'Float array embedding vector' },
-                metadata: { type: 'object', description: 'Optional metadata object' },
-            },
-            required: ['routerId', 'name', 'embedding'],
-        },
-        handler: async (args) => {
-            try {
-                const router = hnswRouters.get(args.routerId);
-                if (!router)
-                    return { content: [{ type: 'text', text: JSON.stringify({ error: `Router not found: ${args.routerId}` }) }], isError: true };
-                const embedding = new Float32Array(args.embedding);
-                const ok = router.addPattern({
-                    name: args.name,
-                    embedding,
-                    metadata: args.metadata,
-                });
-                return { content: [{ type: 'text', text: JSON.stringify({ success: ok, patternCount: router.patternCount() }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_hnsw_route',
-        description: 'Route a query embedding to nearest patterns in HNSW index.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                routerId: { type: 'string', description: 'HNSW router ID' },
-                query: { type: 'array', items: { type: 'number' }, description: 'Query embedding vector' },
-                k: { type: 'number', description: 'Number of nearest neighbors (default: 3)' },
-            },
-            required: ['routerId', 'query'],
-        },
-        handler: async (args) => {
-            try {
-                const router = hnswRouters.get(args.routerId);
-                if (!router)
-                    return { content: [{ type: 'text', text: JSON.stringify({ error: `Router not found: ${args.routerId}` }) }], isError: true };
-                const query = new Float32Array(args.query);
-                const k = typeof args.k === 'number' && args.k > 0 ? Math.floor(args.k) : 3;
-                const results = router.route(query, k);
-                return { content: [{ type: 'text', text: JSON.stringify({ results }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_sona_create',
-        description: 'Create a SONA instant adaptation loop (<1ms adaptation cycles).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                hiddenDim: { type: 'number', description: 'Hidden dimension (default: 64)' },
-                learningRate: { type: 'number', description: 'Learning rate (default: 0.01)' },
-                patternCapacity: { type: 'number', description: 'Max stored patterns' },
-            },
-        },
-        handler: async (args) => {
-            try {
-                const mod = await loadRuvllmWasm();
-                const sona = await mod.createSonaInstant({
-                    hiddenDim: args.hiddenDim,
-                    learningRate: args.learningRate,
-                    patternCapacity: args.patternCapacity,
-                });
-                const id = `sona-${Date.now().toString(36)}`;
-                setWithEviction(sonaInstances, id, sona);
-                return { content: [{ type: 'text', text: JSON.stringify({ success: true, sonaId: id }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_sona_adapt',
-        description: 'Run SONA instant adaptation with a quality signal.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                sonaId: { type: 'string', description: 'SONA instance ID' },
-                quality: { type: 'number', description: 'Quality signal (0.0-1.0)' },
-            },
-            required: ['sonaId', 'quality'],
-        },
-        handler: async (args) => {
-            try {
-                const sona = sonaInstances.get(args.sonaId);
-                if (!sona)
-                    return { content: [{ type: 'text', text: JSON.stringify({ error: `SONA not found: ${args.sonaId}` }) }], isError: true };
-                sona.adapt(args.quality);
-                return { content: [{ type: 'text', text: JSON.stringify({ success: true, stats: sona.stats() }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_microlora_create',
-        description: 'Create a MicroLoRA adapter (ultra-lightweight LoRA, ranks 1-4).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                inputDim: { type: 'number', description: 'Input dimension' },
-                outputDim: { type: 'number', description: 'Output dimension' },
-                rank: { type: 'number', description: 'LoRA rank (1-4, default: 2)' },
-                alpha: { type: 'number', description: 'LoRA alpha scaling (default: 1.0)' },
-            },
-            required: ['inputDim', 'outputDim'],
-        },
-        handler: async (args) => {
-            try {
-                const mod = await loadRuvllmWasm();
-                const lora = await mod.createMicroLora({
-                    inputDim: args.inputDim,
-                    outputDim: args.outputDim,
-                    rank: args.rank,
-                    alpha: args.alpha,
-                });
-                const id = `lora-${Date.now().toString(36)}`;
-                setWithEviction(loraInstances, id, lora);
-                return { content: [{ type: 'text', text: JSON.stringify({ success: true, loraId: id }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_microlora_adapt',
-        description: 'Adapt MicroLoRA weights with quality feedback.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                loraId: { type: 'string', description: 'MicroLoRA instance ID' },
-                quality: { type: 'number', description: 'Quality signal (0.0-1.0)' },
-                learningRate: { type: 'number', description: 'Learning rate (default: 0.01)' },
-                success: { type: 'boolean', description: 'Whether the adaptation was successful (default: true)' },
-            },
-            required: ['loraId', 'quality'],
-        },
-        handler: async (args) => {
-            try {
-                const lora = loraInstances.get(args.loraId);
-                if (!lora)
-                    return { content: [{ type: 'text', text: JSON.stringify({ error: `MicroLoRA not found: ${args.loraId}` }) }], isError: true };
-                lora.adapt(args.quality, args.learningRate, args.success);
-                return { content: [{ type: 'text', text: JSON.stringify({ success: true, stats: lora.stats() }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_chat_format',
-        description: 'Format chat messages using a template (llama3, mistral, chatml, phi, gemma, or auto-detect).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                messages: {
-                    type: 'array',
-                    items: { type: 'object', properties: { role: { type: 'string' }, content: { type: 'string' } }, required: ['role', 'content'] },
-                    description: 'Array of {role, content} message objects',
-                },
-                template: { type: 'string', description: 'Template preset (llama3, mistral, chatml, phi, gemma) or model ID for auto-detection' },
-            },
-            required: ['messages', 'template'],
-        },
-        handler: async (args) => {
-            try {
-                const mod = await loadRuvllmWasm();
-                const messages = args.messages;
-                const templateStr = args.template;
-                const presets = ['llama3', 'mistral', 'chatml', 'phi', 'gemma'];
-                const template = presets.includes(templateStr)
-                    ? templateStr
-                    : { modelId: templateStr };
-                const formatted = await mod.formatChat(messages, template);
-                return { content: [{ type: 'text', text: formatted }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'ruvllm_generate_config',
-        description: 'Create a generation config (maxTokens, temperature, topP, etc.) as JSON.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                maxTokens: { type: 'number', description: 'Max tokens to generate' },
-                temperature: { type: 'number', description: 'Sampling temperature (note: f32 precision)' },
-                topP: { type: 'number', description: 'Top-p sampling' },
-                topK: { type: 'number', description: 'Top-k sampling' },
-                repetitionPenalty: { type: 'number', description: 'Repetition penalty' },
-                stopSequences: { type: 'array', items: { type: 'string' }, description: 'Stop sequences' },
-            },
-        },
-        handler: async (args) => {
-            try {
-                const mod = await loadRuvllmWasm();
-                const config = await mod.createGenerateConfig(args);
-                return { content: [{ type: 'text', text: config }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-];
-//# sourceMappingURL=ruvllm-tools.js.map