monomind 1.10.57 → 1.11.1

package/packages/@monomind/cli/dist/src/benchmarks/benchmark-runner.js

@@ -149,9 +149,17 @@ const pursuitTask = {
     stepBudget: 10,
     evaluate(agentOutputs) {
         const target = 'TARGET_FOUND';
-        const hits = agentOutputs.filter(o => o.includes(target)).length;
+        const hits = agentOutputs.filter((o) => o.includes(target)).length;
         const score = agentOutputs.length > 0 ? hits / agentOutputs.length : 0;
-        return { taskId: this.id, type: this.type, passed: score >= 0.75, score, stepsTaken: 1, agentCount: agentOutputs.length, details: `${hits}/${agentOutputs.length} agents converged` };
+        return {
+            taskId: this.id,
+            type: this.type,
+            passed: score >= 0.75,
+            score,
+            stepsTaken: 1,
+            agentCount: agentOutputs.length,
+            details: `${hits}/${agentOutputs.length} agents converged`,
+        };
     },
 };
 /** Synchronization — all agents must emit the same token at the same logical step. */
@@ -163,7 +171,15 @@ const synchronizationTask = {
     stepBudget: 5,
     evaluate(agentOutputs) {
         if (agentOutputs.length === 0)
-            return { taskId: this.id, type: this.type, passed: false, score: 0, stepsTaken: 0, agentCount: 0, details: 'no outputs' };
+            return {
+                taskId: this.id,
+                type: this.type,
+                passed: false,
+                score: 0,
+                stepsTaken: 0,
+                agentCount: 0,
+                details: 'no outputs',
+            };
         const counts = new Map();
         for (const o of agentOutputs) {
             const tok = o.trim().split(/\s+/)[0] ?? '';
@@ -171,7 +187,15 @@ const synchronizationTask = {
         }
         const maxAgree = Math.max(...counts.values());
         const score = maxAgree / agentOutputs.length;
-        return { taskId: this.id, type: this.type, passed: score >= 0.8, score, stepsTaken: 1, agentCount: agentOutputs.length, details: `majority agreement: ${(score * 100).toFixed(0)}%` };
+        return {
+            taskId: this.id,
+            type: this.type,
+            passed: score >= 0.8,
+            score,
+            stepsTaken: 1,
+            agentCount: agentOutputs.length,
+            details: `majority agreement: ${(score * 100).toFixed(0)}%`,
+        };
     },
 };
 /** Foraging — agents must collectively mention ≥ N distinct resources. */
@@ -190,7 +214,15 @@ const foragingTask = {
         }
         const goal = 4;
         const score = Math.min(1, found.size / goal);
-        return { taskId: this.id, type: this.type, passed: found.size >= goal, score, stepsTaken: 1, agentCount: agentOutputs.length, details: `${found.size}/${goal} resources found: ${[...found].join(', ')}` };
+        return {
+            taskId: this.id,
+            type: this.type,
+            passed: found.size >= goal,
+            score,
+            stepsTaken: 1,
+            agentCount: agentOutputs.length,
+            details: `${found.size}/${goal} resources found: ${[...found].join(', ')}`,
+        };
     },
 };
 /** Flocking — each agent must maintain formation by referencing its neighbour. */
@@ -202,9 +234,17 @@ const flockingTask = {
     stepBudget: 20,
     evaluate(agentOutputs) {
         const cohesionKeyword = 'NEIGHBOUR_OK';
-        const aligned = agentOutputs.filter(o => o.includes(cohesionKeyword)).length;
+        const aligned = agentOutputs.filter((o) => o.includes(cohesionKeyword)).length;
         const score = agentOutputs.length > 0 ? aligned / agentOutputs.length : 0;
-        return { taskId: this.id, type: this.type, passed: score >= 0.7, score, stepsTaken: 1, agentCount: agentOutputs.length, details: `${aligned}/${agentOutputs.length} in formation` };
+        return {
+            taskId: this.id,
+            type: this.type,
+            passed: score >= 0.7,
+            score,
+            stepsTaken: 1,
+            agentCount: agentOutputs.length,
+            details: `${aligned}/${agentOutputs.length} in formation`,
+        };
     },
 };
 /** Transport — item must appear in successive agent outputs showing relay progress. */
@@ -217,9 +257,19 @@ const transportTask = {
     evaluate(agentOutputs) {
         const payload = 'PAYLOAD_DELIVERED';
         const lastAgentDelivered = agentOutputs.length > 0 && agentOutputs[agentOutputs.length - 1].includes(payload);
-        const relayCount = agentOutputs.filter(o => o.includes('RELAY')).length;
+        const relayCount = agentOutputs.filter((o) => o.includes('RELAY')).length;
         const score = lastAgentDelivered ? 1 : relayCount / Math.max(agentOutputs.length, 1);
-        return { taskId: this.id, type: this.type, passed: lastAgentDelivered, score, stepsTaken: agentOutputs.length, agentCount: agentOutputs.length, details: lastAgentDelivered ? 'payload delivered' : `relay progress: ${relayCount}/${agentOutputs.length}` };
+        return {
+            taskId: this.id,
+            type: this.type,
+            passed: lastAgentDelivered,
+            score,
+            stepsTaken: agentOutputs.length,
+            agentCount: agentOutputs.length,
+            details: lastAgentDelivered
+                ? 'payload delivered'
+                : `relay progress: ${relayCount}/${agentOutputs.length}`,
+        };
     },
 };
 export const SWARM_BENCH_TASKS = [
@@ -229,6 +279,10 @@ export const SWARM_BENCH_TASKS = [
     flockingTask,
     transportTask,
 ];
+/**
+ * Alias for {@link SWARM_BENCH_TASKS}. Kept for ergonomic imports.
+ */
+export const SWARM = SWARM_BENCH_TASKS;
 /**
  * SwarmBenchRunner — runs the 5 SwarmBench coordination task types.
  * Wraps BenchmarkRunner for regression baseline tracking.
@@ -240,14 +294,14 @@ export class SwarmBenchRunner {
     baselines = new Map();
     /** Run all (or a subset of) SwarmBench tasks against simulated agent outputs. */
     runAll(agentOutputsByTask) {
-        return SWARM_BENCH_TASKS.map(task => {
+        return SWARM_BENCH_TASKS.map((task) => {
             const outputs = agentOutputsByTask.get(task.id) ?? [];
             return task.evaluate(outputs);
         });
     }
     /** Run a single task type by id. */
     runTask(taskId, agentOutputs) {
-        const task = SWARM_BENCH_TASKS.find(t => t.id === taskId);
+        const task = SWARM_BENCH_TASKS.find((t) => t.id === taskId);
         return task?.evaluate(agentOutputs);
     }
     /** Pin current results as the regression baseline. */
@@ -259,11 +313,11 @@ export class SwarmBenchRunner {
     /** Detect regression: returns task IDs whose score dropped below baseline. */
     detectRegressions(current) {
         return current
-            .filter(r => {
+            .filter((r) => {
             const baseline = this.baselines.get(r.taskId);
             return baseline !== undefined && r.score < baseline.score;
         })
-            .map(r => r.taskId);
+            .map((r) => r.taskId);
     }
     /** Expose underlying BenchmarkRunner for general benchmarks. */
     get benchmarkRunner() {

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

@@ -1,16 +1,3 @@
-/**
- * Self-Learning Pre-Training Benchmark Suite
- * Comprehensive benchmarks for SONA, EWC++, MoE, pattern learning
- *
- * Metrics measured:
- * - SONA adaptation latency (<0.05ms target)
- * - Pattern learning throughput
- * - EWC++ consolidation effectiveness
- * - Memory retrieval accuracy
- * - Pre-training convergence speed
- *
- * @module v1/cli/benchmarks/pretrain
- */
 export interface BenchmarkResult {
     name: string;
     iterations: number;

package/packages/@monomind/cli/dist/src/commands/agent-wasm.d.ts

@@ -1,8 +1,8 @@
 /**
  * WASM Agent CLI Subcommands
  *
- * Exposes @ruvector/rvagent-wasm operations via the `agent` CLI command.
- * Wraps functions from ruvector/agent-wasm.ts for CLI usage.
+ * Exposes @monoes/rvagent-wasm operations via the `agent` CLI command.
+ * Wraps functions from monovector/agent-wasm.ts for CLI usage.
  */
 import type { Command } from '../types.js';
 export declare const wasmStatusCommand: Command;

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

@@ -1,14 +1,14 @@
 /**
  * WASM Agent CLI Subcommands
  *
- * Exposes @ruvector/rvagent-wasm operations via the `agent` CLI command.
- * Wraps functions from ruvector/agent-wasm.ts for CLI usage.
+ * Exposes @monoes/rvagent-wasm operations via the `agent` CLI command.
+ * Wraps functions from monovector/agent-wasm.ts for CLI usage.
  */
 import { output } from '../output.js';
-const WASM_NOT_AVAILABLE_MSG = '@ruvector/rvagent-wasm is not installed.\n' +
-    'Install it with: npm install @ruvector/rvagent-wasm';
+const WASM_NOT_AVAILABLE_MSG = '@monoes/rvagent-wasm is not installed.\n' +
+    'Install it with: npm install @monoes/rvagent-wasm';
 async function loadWasm() {
-    const mod = await import('../ruvector/agent-wasm.js');
+    const mod = await import('../monovector/agent-wasm.js');
     return mod;
 }
 // agent wasm-status

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

@@ -5,7 +5,6 @@
 import { output } from '../output.js';
 import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import { wasmSubcommands } from './agent-wasm.js';
 import * as fs from 'fs';
 import * as path from 'path';
 /**
@@ -874,7 +873,7 @@ function formatLogLevel(level) {
 export const agentCommand = {
     name: 'agent',
     description: 'Agent management commands',
-    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand, logsCommand, ...wasmSubcommands],
+    subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand, logsCommand],
     options: [],
     examples: [
         { command: 'monomind agent spawn -t coder', description: 'Spawn a coder agent' },
@@ -898,10 +897,6 @@ export const agentCommand = {
             `${output.highlight('pool')}          - Manage agent pool`,
             `${output.highlight('health')}        - Show agent health`,
             `${output.highlight('logs')}          - Show agent logs`,
-            `${output.highlight('wasm-status')}   - Check WASM runtime availability`,
-            `${output.highlight('wasm-create')}   - Create a WASM-sandboxed agent`,
-            `${output.highlight('wasm-prompt')}   - Send a prompt to a WASM agent`,
-            `${output.highlight('wasm-gallery')}  - List WASM agent gallery templates`,
         ]);
         output.writeln();
         output.writeln('Run "monomind agent <subcommand> --help" for subcommand help');

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

@@ -3,7 +3,7 @@
  * Code analysis, diff classification, AST analysis, and change risk assessment
  *
  * Features:
- * - AST analysis using ruvector (tree-sitter) with graceful fallback
+ * - AST analysis using monovector (tree-sitter) with graceful fallback
  * - Symbol extraction (functions, classes, variables, types)
  * - Cyclomatic complexity scoring
  * - Diff classification and risk assessment

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

@@ -3,7 +3,7 @@
  * Code analysis, diff classification, AST analysis, and change risk assessment
  *
  * Features:
- * - AST analysis using ruvector (tree-sitter) with graceful fallback
+ * - AST analysis using monovector (tree-sitter) with graceful fallback
  * - Symbol extraction (functions, classes, variables, types)
  * - Cyclomatic complexity scoring
  * - Diff classification and risk assessment
@@ -20,23 +20,13 @@ import * as fs from 'fs/promises';
 import { writeFile } from 'fs/promises';
 import { resolve } from 'path';
 import { execSync } from 'child_process';
-// Dynamic import for AST analyzer
+// AST analyzer module was never shipped — always falls back to the regex path.
 async function getASTAnalyzer() {
-    try {
-        return await import('../ruvector/ast-analyzer.js');
-    }
-    catch {
-        return null;
-    }
+    return null;
 }
-// Dynamic import for graph analyzer
+// Graph analyzer module was never shipped — callers handle the null path.
 async function getGraphAnalyzer() {
-    try {
-        return await import('../ruvector/graph-analyzer.js');
-    }
-    catch {
-        return null;
-    }
+    return null;
 }
 // Diff subcommand
 const diffCommand = {
@@ -395,7 +385,7 @@ const codeCommand = {
     },
 };
 // ============================================================================
-// AST Analysis Subcommands (using ruvector tree-sitter with fallback)
+// AST Analysis Subcommands (using monovector tree-sitter with fallback)
 // ============================================================================
 /**
  * Helper: Truncate file path for display
@@ -445,7 +435,7 @@ function getComplexityRatingAst(value) {
  */
 const astCommand = {
     name: 'ast',
-    description: 'Analyze code using AST parsing (tree-sitter via ruvector)',
+    description: 'Analyze code using AST parsing (tree-sitter via monovector)',
     options: [
         {
             name: 'complexity',
@@ -1142,7 +1132,7 @@ async function scanSourceFiles(dir, maxDepth = 10) {
     return files;
 }
 /**
- * Fallback analysis when ruvector is not available
+ * Fallback analysis when monovector is not available
  */
 function fallbackAnalyze(code, filePath) {
     const lines = code.split('\n');

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

@@ -531,6 +531,54 @@ async function checkAgenticFlow() {
         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) {
+    return v === null ? 'n/a' : `${Math.round(v * 100)}%`;
+}
+// Render the windowed routing-accuracy metric (C1) as a one-line summary.
+// Tells an operator whether routing learning is actually helping.
+async function routingAccuracyLine() {
+    try {
+        const { computeRoutingAccuracy, computeAdherence } = await import('../monovector/route-outcomes.js');
+        const baseDir = join(process.cwd(), '.monomind');
+        const acc = await computeRoutingAccuracy(baseDir, 100);
+        const adh = await computeAdherence(baseDir);
+        const adhStr = ` | adherence ${fmtPct(adh.adherence)} (n=${adh.sample})`;
+        if (acc.accuracy === null) {
+            return `routing accuracy (last 100): no outcome data yet${adhStr}`;
+        }
+        const trend = acc.recentVsPrior === null
+            ? ''
+            : ` trend ${acc.recentVsPrior >= 0 ? '+' : ''}${Math.round(acc.recentVsPrior * 100)}%`;
+        return `routing accuracy (last ${acc.window}): ${fmtPct(acc.accuracy)} ` +
+            `[native ${fmtPct(acc.byMode.native)} / js ${fmtPct(acc.byMode.js)}]${trend}${adhStr}`;
+    }
+    catch {
+        return 'routing accuracy (last 100): no outcome data yet';
+    }
+}
+// Lean teardown: the native @monoes acceleration matrix (sona/router/attention/
+// learning-wasm) has been removed. This check now reports only the honest routing
+// learning metric — the windowed recommendation→outcome accuracy and adherence,
+// which is the lean system's measurable signal.
+async function checkMonoesIntegration() {
+    try {
+        const accLine = await routingAccuracyLine();
+        return {
+            name: 'Routing Learning',
+            status: 'pass',
+            message: accLine,
+        };
+    }
+    catch (err) {
+        return {
+            name: 'Routing Learning',
+            status: 'warn',
+            message: `Could not compute routing accuracy: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
 // Format health check result
 function formatCheck(check) {
     const icon = check.status === 'pass' ? output.success('✓') :
@@ -560,7 +608,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)',
+            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, monoes)',
             type: 'string'
         },
         {
@@ -604,7 +652,8 @@ export const doctorCommand = {
             checkBuildTools,
             checkMonograph,
             checkHelpersFresh,
-            checkAgenticFlow
+            checkAgenticFlow,
+            checkMonoesIntegration
         ];
         const componentMap = {
             'version': checkVersionFreshness,
@@ -622,7 +671,8 @@ export const doctorCommand = {
             'typescript': checkBuildTools,
             'monograph': checkMonograph,
             'helpers': checkHelpersFresh,
-            'agentic-flow': checkAgenticFlow
+            'agentic-flow': checkAgenticFlow,
+            'monoes': checkMonoesIntegration
         };
         let checksToRun = allChecks;
         if (component && componentMap[component]) {

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

@@ -524,7 +524,7 @@ const indexCommand = {
                         { key: 'value', header: 'Value', width: 30 },
                     ],
                     data: [
-                        { metric: 'HNSW Available', value: status.available ? output.success('Yes (@ruvector/core)') : output.warning('No') },
+                        { metric: 'HNSW Available', value: status.available ? output.success('Yes (pure-JS)') : output.warning('No') },
                         { metric: 'Index Initialized', value: status.initialized ? output.success('Yes') : output.dim('No') },
                         { metric: 'Vector Count', value: status.entryCount.toLocaleString() },
                         { metric: 'Dimensions', value: String(status.dimensions) },
@@ -555,8 +555,7 @@ const indexCommand = {
                 }
                 else if (!status.available) {
                     output.writeln();
-                    output.printWarning('@ruvector/core not available');
-                    output.printInfo('Install: npm install @ruvector/core');
+                    output.printWarning('HNSW index not available');
                 }
                 else {
                     output.writeln();
@@ -576,8 +575,7 @@ const indexCommand = {
                 // Force rebuild if requested
                 const index = await getHNSWIndex({ forceRebuild: action === 'rebuild' });
                 if (!index) {
-                    spinner.fail('@ruvector/core not available');
-                    output.printInfo('Install: npm install @ruvector/core');
+                    spinner.fail('HNSW index not available');
                     return { success: false, exitCode: 1 };
                 }
                 spinner.succeed(`Index ${action} complete`);
@@ -996,16 +994,16 @@ const hyperbolicCommand = {
 // Neural subcommand
 const neuralCommand = {
     name: 'neural',
-    description: 'Neural substrate features (RuVector integration)',
+    description: 'Embedding substrate features (drift, memory physics, coherence)',
     options: [
         { name: 'feature', short: 'f', type: 'string', description: 'Feature: drift, memory, swarm, coherence, all', default: 'all' },
-        { name: 'init', type: 'boolean', description: 'Initialize neural substrate with RuVector' },
+        { name: 'init', type: 'boolean', description: 'Initialize embedding substrate' },
         { name: 'drift-threshold', type: 'string', description: 'Semantic drift detection threshold', default: '0.3' },
         { name: 'decay-rate', type: 'string', description: 'Memory decay rate (hippocampal dynamics)', default: '0.01' },
         { name: 'consolidation-interval', type: 'string', description: 'Memory consolidation interval (ms)', default: '60000' },
     ],
     examples: [
-        { command: 'monomind embeddings neural --init', description: 'Initialize RuVector substrate' },
+        { command: 'monomind embeddings neural --init', description: 'Initialize embedding substrate' },
         { command: 'monomind embeddings neural -f drift', description: 'Semantic drift detection' },
         { command: 'monomind embeddings neural -f memory', description: 'Memory physics (hippocampal)' },
         { command: 'monomind embeddings neural -f coherence', description: 'Safety & alignment monitoring' },
@@ -1018,7 +1016,7 @@ const neuralCommand = {
         const decayRate = parseFloat((ctx.flags['decay-rate'] || ctx.flags.decayRate || '0.01'));
         const consolidationInterval = parseInt((ctx.flags['consolidation-interval'] || ctx.flags.consolidationInterval || '60000'), 10);
         output.writeln();
-        output.writeln(output.bold('Neural Embedding Substrate (RuVector)'));
+        output.writeln(output.bold('Neural Embedding Substrate'));
         output.writeln(output.dim('Treating embeddings as a synthetic nervous system'));
         output.writeln(output.dim('─'.repeat(60)));
         // Check if embeddings config exists
@@ -1045,12 +1043,6 @@ const neuralCommand = {
                 driftThreshold,
                 decayRate,
                 consolidationInterval,
-                ruvector: {
-                    enabled: true,
-                    sona: true, // Self-Optimizing Neural Architecture
-                    flashAttention: true,
-                    ewcPlusPlus: true, // Elastic Weight Consolidation
-                },
                 features: {
                     semanticDrift: true,
                     memoryPhysics: true,
@@ -1073,7 +1065,6 @@ const neuralCommand = {
         }
         const neuralConfig = (config.neural || {});
         const features = (neuralConfig.features || {});
-        const ruvector = (neuralConfig.ruvector || {});
         output.printTable({
             columns: [
                 { key: 'feature', header: 'Feature', width: 24 },
@@ -1109,7 +1100,7 @@ const neuralCommand = {
             ],
         });
         output.writeln();
-        output.writeln(output.bold('RuVector Integration'));
+        output.writeln(output.bold('Embedding Geometry'));
         output.printTable({
             columns: [
                 { key: 'component', header: 'Component', width: 24 },
@@ -1117,21 +1108,6 @@ const neuralCommand = {
                 { key: 'status', header: 'Status', width: 12 },
             ],
             data: [
-                {
-                    component: 'SONA',
-                    description: 'Self-Optimizing Neural Architecture (<0.05ms)',
-                    status: ruvector.sona ? output.success('Enabled') : output.dim('Disabled')
-                },
-                {
-                    component: 'Flash Attention',
-                    description: '2.49x-7.47x attention speedup',
-                    status: ruvector.flashAttention ? output.success('Enabled') : output.dim('Disabled')
-                },
-                {
-                    component: 'EWC++',
-                    description: 'Elastic Weight Consolidation (anti-forgetting)',
-                    status: ruvector.ewcPlusPlus ? output.success('Enabled') : output.dim('Disabled')
-                },
                 {
                     component: 'Hyperbolic Space',
                     description: 'Poincaré ball for hierarchy preservation',
@@ -1638,7 +1614,7 @@ export const embeddingsCommand = {
         output.writeln();
         output.writeln('Performance:');
         output.printList([
-            'HNSW indexing: 150x-12,500x faster search',
+            'HNSW indexing: O(log n) pure-JS vector search',
             'Agentic Flow: 75x faster than Transformers.js (~3ms)',
             'Persistent cache: SQLite-backed, survives restarts',
             'Hyperbolic: Better hierarchical representation',