monomind 1.10.56 → 1.11.0

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

@@ -69,9 +69,9 @@ const benchmarkCommand = {
                 targetMet: embedTargetMet,
             });
         }
-        // 2. Flash Attention-style Batch Operations
+        // 2. Batch Vector Operations
         if (suite === 'all' || suite === 'wasm') {
-            spinner.setText('Benchmarking Flash Attention batch ops...');
+            spinner.setText('Benchmarking batch vector ops...');
             const flashTimes = [];
             // Generate test vectors
             const testVectors = Array.from({ length: 100 }, () => new Float32Array(Array.from({ length: 384 }, () => Math.random())));
@@ -92,7 +92,7 @@ const benchmarkCommand = {
             const speedup = baselineMs / mean;
             const flashTargetMet = speedup > 1;
             results.push({
-                operation: 'Flash Attention',
+                operation: 'Batch Vector Ops',
                 mean: `${mean.toFixed(3)}ms`,
                 p95: `${percentile(flashTimes, 95).toFixed(3)}ms`,
                 p99: `${percentile(flashTimes, 99).toFixed(3)}ms`,
@@ -150,13 +150,13 @@ const benchmarkCommand = {
                 });
             }
         }
-        // 4. SONA Adaptation Benchmark
+        // 4. Pattern Adaptation Benchmark (JS)
         if (suite === 'all' || suite === 'neural') {
-            spinner.setText('Benchmarking SONA adaptation...');
+            spinner.setText('Benchmarking pattern adaptation...');
             await initializeIntelligence();
             const sonaResult = benchmarkAdaptation(iterations);
             results.push({
-                operation: 'SONA Adaptation',
+                operation: 'Pattern Adaptation',
                 mean: `${(sonaResult.avgMs * 1000).toFixed(2)}μs`,
                 p95: `${(sonaResult.maxMs * 1000).toFixed(2)}μs`,
                 p99: `${(sonaResult.maxMs * 1000).toFixed(2)}μs`,
@@ -515,7 +515,6 @@ const optimizeCommand = {
             data: [
                 { priority: output.error('P0'), area: 'Memory', recommendation: 'Enable HNSW index quantization', impact: '+50% reduction' },
                 { priority: output.warning('P1'), area: 'CPU', recommendation: 'Enable WASM SIMD acceleration', impact: '+4x speedup' },
-                { priority: output.warning('P1'), area: 'Latency', recommendation: 'Enable Flash Attention', impact: '+2.49x speedup' },
                 { priority: output.info('P2'), area: 'Cache', recommendation: 'Increase pattern cache size', impact: '+15% hit rate' },
                 { priority: output.info('P2'), area: 'Network', recommendation: 'Enable request batching', impact: '-30% latency' },
             ],
@@ -554,7 +553,6 @@ const bottleneckCommand = {
             ],
             data: [
                 { component: 'Vector Search', bottleneck: 'Linear scan O(n)', severity: output.error('High'), solution: 'Enable HNSW indexing' },
-                { component: 'Neural Inference', bottleneck: 'Sequential attention', severity: output.warning('Medium'), solution: 'Enable Flash Attention' },
                 { component: 'Memory Store', bottleneck: 'Lock contention', severity: output.info('Low'), solution: 'Use sharded storage' },
             ],
         });
@@ -588,8 +586,7 @@ export const performanceCommand = {
         output.writeln();
         output.writeln('Performance Targets:');
         output.printList([
-            'HNSW Search: 150x-12,500x faster than brute force',
-            'Flash Attention: 2.49x-7.47x speedup',
+            'HNSW Search: O(log n) vs O(n) brute force (pure-JS)',
             'Memory: 50-75% reduction with quantization',
         ]);
         output.writeln();

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

@@ -388,7 +388,7 @@ const infoCommand = {
         { name: 'registry', short: 'r', type: 'string', description: 'Registry to use' },
     ],
     examples: [
-        { command: 'monomind plugins info -n @monomind/neural', description: 'Show plugin info' },
+        { command: 'monomind plugins info -n @monomind/security', description: 'Show plugin info' },
     ],
     action: async (ctx) => {
         const name = ctx.flags.name;
@@ -563,8 +563,8 @@ const upgradeCommand = {
         { name: 'version', short: 'v', type: 'string', description: 'Target version (default: latest)' },
     ],
     examples: [
-        { command: 'monomind plugins upgrade -n @monomind/neural', description: 'Upgrade to latest' },
-        { command: 'monomind plugins upgrade -n @monomind/neural -v 3.1.0', description: 'Upgrade to specific version' },
+        { command: 'monomind plugins upgrade -n @monomind/security', description: 'Upgrade to latest' },
+        { command: 'monomind plugins upgrade -n @monomind/security -v 3.1.0', description: 'Upgrade to specific version' },
     ],
     action: async (ctx) => {
         const name = ctx.flags.name;
@@ -779,7 +779,6 @@ export const pluginsCommand = {
         output.writeln();
         output.writeln(output.bold('Official Plugins:'));
         output.printList([
-            '@monomind/neural              - Neural patterns and inference (WASM SIMD)',
             '@monomind/security            - Security scanning and CVE detection',
             '@monomind/embeddings          - Vector embeddings with hyperbolic support',
             '@monomind/claims              - Claims-based authorization',

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

@@ -2,8 +2,8 @@
  * CLI Process Management Command
  * Background process management, daemon mode, and monitoring
  */
-import { writeFileSync, readFileSync, unlinkSync, existsSync, mkdirSync } from 'fs';
-import { dirname, resolve } from 'path';
+import { writeFileSync, readFileSync, unlinkSync, existsSync, mkdirSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
 // Helper functions for PID file management
 function writePidFile(pidFile, pid, port) {
     const resolved = resolve(pidFile);
@@ -23,8 +23,7 @@ function writePidFile(pidFile, pid, port) {
             // Stale PID file — caller is expected to have already verified the
             // referenced process is dead. Unlink and retry once.
             try {
-                const fs = require('fs');
-                fs.unlinkSync(resolved);
+                unlinkSync(resolved);
                 writeFileSync(resolved, data, { encoding: 'utf-8', flag: 'wx', mode: 0o600 });
             }
             catch (retryErr) {
@@ -270,7 +269,7 @@ const monitorCommand = {
         const totalMemMB = Math.round(totalMem / 1024 / 1024);
         // Try to read agent and task counts from local store files
         let agentCount = 0;
-        let taskCounts = { running: 0, queued: 0, completed: 0, failed: 0 };
+        const taskCounts = { running: 0, queued: 0, completed: 0, failed: 0 };
         try {
             const agentStorePath = resolve('.monomind/agents/store.json');
             if (existsSync(agentStorePath)) {
@@ -619,13 +618,7 @@ const logsCommand = {
         console.log('─'.repeat(70));
         // Read actual log files from .monomind/logs/ if they exist
         const logsDir = resolve('.monomind/logs');
-        let logEntries = [];
-        const levelIcons = {
-            debug: '🔍',
-            info: 'ℹ️ ',
-            warn: '⚠️ ',
-            error: '❌',
-        };
+        const logEntries = [];
         const levels = ['debug', 'info', 'warn', 'error'];
         const minLevelIdx = levels.indexOf(level);
         if (existsSync(logsDir)) {

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

@@ -31,7 +31,7 @@ const checkCommand = {
         const spinner = output.createSpinner({ text: 'Checking v1 progress...' });
         try {
             spinner.start();
-            const result = await callMCPTool('progress_check', { detailed });
+            const result = (await callMCPTool('progress_check', { detailed }));
             spinner.stop();
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
@@ -44,11 +44,16 @@ const checkCommand = {
             output.writeln(progressBar(progressValue, 30));
             output.writeln();
             if (detailed && result.cli) {
-                output.writeln(output.highlight('CLI Commands:') + `     ${result.cli.progress}% (${result.cli.commands}/${result.cli.target})`);
-                output.writeln(output.highlight('MCP Tools:') + `        ${result.mcp?.progress ?? 0}% (${result.mcp?.tools ?? 0}/${result.mcp?.target ?? 0})`);
-                output.writeln(output.highlight('Hooks:') + `            ${result.hooks?.progress ?? 0}% (${result.hooks?.subcommands ?? 0}/${result.hooks?.target ?? 0})`);
-                output.writeln(output.highlight('Packages:') + `         ${result.packages?.progress ?? 0}% (${result.packages?.total ?? 0}/${result.packages?.target ?? 0})`);
-                output.writeln(output.highlight('DDD Structure:') + `    ${result.ddd?.progress ?? 0}% (${result.packages?.withDDD ?? 0}/${result.packages?.total ?? 0})`);
+                output.writeln(output.highlight('CLI Commands:') +
+                    `     ${result.cli.progress}% (${result.cli.commands}/${result.cli.target})`);
+                output.writeln(output.highlight('MCP Tools:') +
+                    `        ${result.mcp?.progress ?? 0}% (${result.mcp?.tools ?? 0}/${result.mcp?.target ?? 0})`);
+                output.writeln(output.highlight('Hooks:') +
+                    `            ${result.hooks?.progress ?? 0}% (${result.hooks?.subcommands ?? 0}/${result.hooks?.target ?? 0})`);
+                output.writeln(output.highlight('Packages:') +
+                    `         ${result.packages?.progress ?? 0}% (${result.packages?.total ?? 0}/${result.packages?.target ?? 0})`);
+                output.writeln(output.highlight('DDD Structure:') +
+                    `    ${result.ddd?.progress ?? 0}% (${result.packages?.withDDD ?? 0}/${result.packages?.total ?? 0})`);
                 output.writeln();
                 if (result.codebase) {
                     output.writeln(output.dim(`Codebase: ${result.codebase.totalFiles} files, ${result.codebase.totalLines.toLocaleString()} lines`));
@@ -85,7 +90,7 @@ const syncCommand = {
         const spinner = output.createSpinner({ text: 'Syncing progress...' });
         try {
             spinner.start();
-            const result = await callMCPTool('progress_sync', {});
+            const result = (await callMCPTool('progress_sync', {}));
             spinner.stop();
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
@@ -117,14 +122,14 @@ const summaryCommand = {
         const spinner = output.createSpinner({ text: 'Getting progress summary...' });
         try {
             spinner.start();
-            const result = await callMCPTool('progress_summary', {});
+            const result = (await callMCPTool('progress_summary', {}));
             spinner.stop();
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
                 return { success: true, data: result };
             }
             output.writeln();
-            output.writeln(result.summary);
+            output.writeln(result.summary ?? '');
             return { success: true, data: result };
         }
         catch (error) {
@@ -159,7 +164,7 @@ const watchCommand = {
         let lastProgress = 0;
         const check = async () => {
             try {
-                const result = await callMCPTool('progress_check', {});
+                const result = (await callMCPTool('progress_check', {}));
                 const currentProgress = result.overall ?? result.progress ?? 0;
                 if (currentProgress !== lastProgress) {
                     output.writeln(`${output.warning('→')} Progress changed: ${lastProgress}% → ${output.success(currentProgress + '%')}`);
@@ -191,12 +196,7 @@ export const progressCommand = {
     name: 'progress',
     description: 'Check v1 implementation progress',
     aliases: ['prog'],
-    subcommands: [
-        checkCommand,
-        syncCommand,
-        summaryCommand,
-        watchCommand,
-    ],
+    subcommands: [checkCommand, syncCommand, summaryCommand, watchCommand],
     options: [
         {
             name: 'detailed',

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

@@ -1,9 +1,9 @@
 /**
  * CLI Route Command
- * Intelligent task-to-agent routing using Q-Learning
+ * Intelligent task-to-agent routing using keyword matching
  *
  * Features:
- * - Q-Learning based agent selection
+ * - Keyword-based agent selection
  * - Semantic task understanding
  * - Confidence scoring
  * - Learning from feedback

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

@@ -1,9 +1,9 @@
 /**
  * CLI Route Command
- * Intelligent task-to-agent routing using Q-Learning
+ * Intelligent task-to-agent routing using keyword matching
  *
  * Features:
- * - Q-Learning based agent selection
+ * - Keyword-based agent selection
  * - Semantic task understanding
  * - Confidence scoring
  * - Learning from feedback
@@ -11,7 +11,7 @@
  * github.com/nokhodian/monomind
  */
 import { output } from '../output.js';
-import { createQLearningRouter, isRuvectorAvailable, } from '../ruvector/index.js';
+import { createKeywordRouter, isMonovectorAvailable, } from '../monovector/index.js';
 /**
  * Available agent types for routing
  */
@@ -35,7 +35,7 @@ let routerInitialized = false;
  */
 async function getRouter() {
     if (!routerInstance) {
-        routerInstance = createQLearningRouter();
+        routerInstance = createKeywordRouter();
     }
     if (!routerInitialized) {
         await routerInstance.initialize();
@@ -54,19 +54,19 @@ function getAgentType(route) {
 // ============================================================================
 const routeTaskCommand = {
     name: 'task',
-    description: 'Route a task to the optimal agent using Q-Learning',
+    description: 'Route a task to the optimal agent using keyword matching',
     options: [
         {
             name: 'q-learning',
             short: 'q',
-            description: 'Use Q-Learning for agent selection (default: true)',
+            description: 'Use keyword routing for agent selection (default: true)',
             type: 'boolean',
             default: true,
         },
         {
             name: 'agent',
             short: 'a',
-            description: 'Force specific agent (bypasses Q-Learning)',
+            description: 'Force specific agent (bypasses keyword routing)',
             type: 'string',
         },
         {
@@ -136,7 +136,7 @@ const routeTaskCommand = {
             }
             // Use Q-Learning routing
             const router = await getRouter();
-            const result = router.route(taskDescription, useExploration);
+            const result = await router.route(taskDescription, useExploration);
             const agent = getAgentType(result.route) || AGENT_TYPES[0];
             spinner.succeed(`Routed to ${agent.name}`);
             if (jsonOutput) {
@@ -147,7 +147,7 @@ const routeTaskCommand = {
                     confidence: result.confidence,
                     qValues: result.qValues,
                     explored: result.explored,
-                    alternatives: result.alternatives.map(a => ({
+                    alternatives: (result.alternatives || []).map(a => ({
                         agentId: a.route,
                         agentName: getAgentType(a.route)?.name || a.route,
                         score: a.score,
@@ -281,14 +281,14 @@ const statsCommand = {
         try {
             const router = await getRouter();
             const stats = router.getStats();
-            const ruvectorAvailable = await isRuvectorAvailable();
-            const ruvectorStatus = {
-                available: ruvectorAvailable,
+            const monovectorAvailable = await isMonovectorAvailable();
+            const monovectorStatus = {
+                available: monovectorAvailable,
                 wasmAccelerated: stats.useNative === 1,
-                backend: stats.useNative === 1 ? 'ruvector-native' : 'fallback',
+                backend: stats.useNative === 1 ? 'monovector-native' : 'fallback',
             };
             if (jsonOutput) {
-                output.printJson({ stats, ruvector: ruvectorStatus });
+                output.printJson({ stats, monovector: monovectorStatus });
             }
             else {
                 output.writeln();
@@ -309,14 +309,14 @@ const statsCommand = {
                     ],
                 });
                 output.writeln();
-                output.writeln(output.bold('RuVector Status'));
+                output.writeln(output.bold('MonoVector Status'));
                 output.printList([
-                    `Available: ${ruvectorStatus.available ? output.success('Yes') : output.warning('No (using fallback)')}`,
-                    `WASM Accelerated: ${ruvectorStatus.wasmAccelerated ? output.success('Yes') : 'No'}`,
-                    `Backend: ${ruvectorStatus.backend}`,
+                    `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, ruvector: ruvectorStatus } };
+            return { success: true, data: { stats, monovector: monovectorStatus } };
         }
         catch (error) {
             output.printError(error instanceof Error ? error.message : String(error));
@@ -606,7 +606,7 @@ const coverageRouteCommand = {
         spinner.start();
         try {
             // Lazy load coverage router
-            const { coverageRoute, coverageSuggest, coverageGaps } = await import('../ruvector/coverage-router.js');
+            const { coverageRoute, coverageSuggest, coverageGaps } = await import('../monovector/coverage-router.js');
             if (gapsMode) {
                 // List coverage gaps with agent assignments
                 const result = await coverageGaps({ threshold, groupByAgent: true });
@@ -924,11 +924,11 @@ export const routeCommand = {
         ]);
         output.writeln();
         // Show quick status
-        const ruvectorAvailable = await isRuvectorAvailable();
+        const monovectorAvailable = await isMonovectorAvailable();
         output.writeln(output.bold('Backend Status:'));
         output.printList([
-            `RuVector: ${ruvectorAvailable ? output.success('Available') : output.warning('Fallback mode')}`,
-            `Backend: ${ruvectorAvailable ? 'ruvector-native' : 'JavaScript fallback'}`,
+            `MonoVector: ${monovectorAvailable ? output.success('Available') : output.warning('Fallback mode')}`,
+            `Backend: ${monovectorAvailable ? 'monovector-native' : 'JavaScript fallback'}`,
         ]);
         output.writeln();
         output.writeln(output.dim('Run "monomind route <subcommand> --help" for more info'));

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

@@ -111,7 +111,6 @@ async function getSystemStatus() {
             performance: {
                 cpuUsage: getProcessCpuUsage(),
                 memoryUsage: getProcessMemoryUsage(),
-                flashAttention: 'not measured',
                 searchSpeed: 'not measured'
             }
         };
@@ -139,7 +138,6 @@ async function getSystemStatus() {
             performance: {
                 cpuUsage: 0,
                 memoryUsage: 0,
-                flashAttention: 'N/A',
                 searchSpeed: 'N/A'
             }
         };
@@ -238,7 +236,6 @@ function displayStatus(status) {
     if (status.running) {
         output.writeln(output.bold('v1 Performance Gains'));
         output.printList([
-            `Flash Attention: ${output.success(status.performance.flashAttention)}`,
             `Vector Search: ${output.success(status.performance.searchSpeed)}`,
             `CPU Usage: ${status.performance.cpuUsage.toFixed(1)}%`,
             `Memory Usage: ${status.performance.memoryUsage.toFixed(1)}%`

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

@@ -260,9 +260,8 @@ const initCommand = {
             output.writeln(output.dim('  Initializing memory namespace...'));
             output.writeln(output.dim('  Setting up communication channels...'));
             if (v1Mode) {
-                output.writeln(output.dim('  Enabling Flash Attention (2.49x-7.47x speedup)...'));
-                output.writeln(output.dim('  Configuring AgentDB integration (150x faster)...'));
-                output.writeln(output.dim('  Initializing SONA learning system...'));
+                output.writeln(output.dim('  Configuring AgentDB integration (pure-JS HNSW)...'));
+                output.writeln(output.dim('  Initializing keyword routing + outcome measurement...'));
             }
             output.writeln();
             output.printTable({

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

@@ -1,6 +1,6 @@
 /**
  * CLI Update Command
- * Auto-update system for @monoes packages (ADR-025)
+ * Auto-update system for @monomind packages (ADR-025)
  */
 import type { Command } from '../types.js';
 declare const updateCommand: Command;

package/packages/@monomind/cli/dist/src/config-adapter.js

@@ -55,6 +55,17 @@ export function systemConfigToMonomindConfig(systemConfig) {
             autoExecute: false,
             hooks: [],
         },
+        // Neural / SONA learning configuration
+        neural: {
+            enabled: systemConfig.neural?.enabled ?? true,
+            disableNative: systemConfig.neural?.disableNative ?? false,
+            sona: {
+                mode: systemConfig.neural?.sona?.mode ?? 'balanced',
+                learningRate: systemConfig.neural?.sona?.learningRate,
+                ewcLambda: systemConfig.neural?.sona?.ewcLambda,
+                embeddingDim: systemConfig.neural?.sona?.embeddingDim,
+            },
+        },
     };
 }
 /**
@@ -132,6 +143,22 @@ export function configToSystemConfig(config) {
                 logging: true,
             },
         },
+        // Neural / SONA learning configuration — only emit when present so we don't
+        // synthesize a neural block for configs that never had one.
+        ...(config.neural
+            ? {
+                neural: {
+                    enabled: config.neural.enabled ?? true,
+                    disableNative: config.neural.disableNative ?? false,
+                    sona: {
+                        mode: config.neural.sona?.mode ?? 'balanced',
+                        learningRate: config.neural.sona?.learningRate,
+                        ewcLambda: config.neural.sona?.ewcLambda,
+                        embeddingDim: config.neural.sona?.embeddingDim,
+                    },
+                },
+            }
+            : {}),
     };
 }
 /**

package/packages/@monomind/cli/dist/src/consensus/audit-writer.d.ts

@@ -1,22 +1,47 @@
-/**
- * AuditWriter (Task 36)
- *
- * Append-only JSONL storage for consensus audit records and individual votes.
- */
-import type { ConsensusAuditRecord, ConsensusProtocol } from '../../../../@monoes/shared/src/types/consensus-audit.js';
-/** Input for recording a consensus decision */
+/** Supported consensus protocols. */
+export type ConsensusProtocol = 'byzantine' | 'raft' | 'gossip' | 'crdt' | 'quorum';
+/** A single signed vote cast by an agent. */
+export interface VoteRecord {
+    agentId: string;
+    agentSlug: string;
+    vote: unknown;
+    signature: string;
+    votedAt: string;
+}
+/** Proof that quorum was (or was not) achieved. */
+export interface QuorumProof {
+    required: number;
+    achieved: number;
+    threshold: number;
+    satisfied: boolean;
+}
+/** Full audit record for a consensus decision. */
+export interface ConsensusAuditRecord {
+    decisionId: string;
+    swarmId: string;
+    protocol: ConsensusProtocol;
+    topic: string;
+    decision: unknown;
+    votes: VoteRecord[];
+    quorumProof: QuorumProof;
+    quorumAchieved: boolean;
+    round: number;
+    startedAt: string;
+    completedAt: string;
+    durationMs: number | null;
+    /** HMAC-SHA256 over the full record (all fields above), keyed by the session secret. */
+    recordSignature?: string;
+}
+/** An unsigned vote supplied to {@link AuditWriter.record}. */
+export type UnsignedVote = Omit<VoteRecord, 'signature'>;
+/** Input to {@link AuditWriter.record}. */
 export interface RecordInput {
     decisionId: string;
     swarmId: string;
     protocol: ConsensusProtocol;
     topic: string;
     decision: unknown;
-    votes: Array<{
-        agentId: string;
-        agentSlug: string;
-        vote: unknown;
-        votedAt: string;
-    }>;
+    votes: UnsignedVote[];
     quorumRequired: number;
     quorumThreshold: number;
     round: number;
@@ -24,6 +49,11 @@ export interface RecordInput {
     completedAt: string;
     sessionSecret: string;
 }
+/** Result of re-verifying a stored consensus decision. */
+export interface VerifyResult {
+    valid: boolean;
+    invalidVotes: string[];
+}
 export declare class AuditWriter {
     private readonly auditPath;
     private readonly votesPath;
@@ -40,10 +70,7 @@ export declare class AuditWriter {
     /**
      * Re-verify all vote signatures in a decision.
      */
-    verifyDecision(decisionId: string, sessionSecret: string): {
-        valid: boolean;
-        invalidVotes: string[];
-    };
+    verifyDecision(decisionId: string, sessionSecret: string): VerifyResult;
     private appendLine;
     private readLines;
 }

package/packages/@monomind/cli/dist/src/dlq/dlq-replayer.d.ts

@@ -8,7 +8,7 @@
  * replay. readAll() merges status records into the base entries — the last status wins.
  * Compaction rewrites the file when status records exceed 20% of total lines.
  */
-import type { DLQReplayResult } from '../../../shared/src/types/dlq.js';
+import type { DLQReplayResult } from '../../../shared/dist/types/dlq.js';
 /** A function that attempts to call a tool with the original payload */
 export type ToolCaller = (toolName: string, payload: unknown) => Promise<void>;
 export declare class DLQReplayer {

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

@@ -50,7 +50,7 @@ export declare class CLI {
     /**
      * Initialize optional subsystems at startup (non-blocking, all failures are silent).
      * Wires TierManager, ObservabilityBus + TraceCollector, and SwarmCheckpointer
-     * so that packages/@monoes/* actually contribute to the live runtime.
+     * so that packages/@monomind/* actually contribute to the live runtime.
      */
     private initSubsystems;
     /**

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

@@ -62,7 +62,7 @@ export class CLI {
                 this.showVersion();
                 return;
             }
-            if (flags.noColor) {
+            if (flags.color === false || flags.noColor) {
                 this.output.setColorEnabled(false);
             }
             // Set verbosity level based on flags
@@ -283,8 +283,8 @@ export class CLI {
         this.output.writeln(this.output.bold('V1 FEATURES:'));
         this.output.printList([
             '15-agent hierarchical mesh coordination',
-            'AgentDB with HNSW indexing (150x-12,500x faster)',
-            'Flash Attention (2.49x-7.47x speedup)',
+            'AgentDB with pure-JS HNSW indexing',
+            'Keyword routing + route-outcome measurement',
             'Unified SwarmCoordinator engine',
             'Event-sourced state management',
             'Domain-Driven Design architecture'
@@ -419,7 +419,7 @@ export class CLI {
     async initSubsystems() {
         // GAP-003: TierManager
         try {
-            const { TierManager, createPersistentService } = await import('@monomind/memory');
+            const { TierManager, createPersistentService } = await import('@monoes/memory');
             const backend = createPersistentService('.monomind/memory');
             const _tierManager = new TierManager(backend, { shortTermCapacity: 1000 });
             void _tierManager;
@@ -433,7 +433,7 @@ export class CLI {
         catch { /* optional */ }
         // GAP-007: SwarmCheckpointer — write checkpoint files so crashed swarms can resume
         try {
-            const { SwarmCheckpointer } = await import('@monomind/memory');
+            const { SwarmCheckpointer } = await import('@monoes/memory');
             const _swarmCheckpointer = new SwarmCheckpointer({
                 dbPath: '.monomind/checkpoints/swarm.jsonl',
                 swarmId: 'default',

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

@@ -219,7 +219,7 @@ function hooksSystem() {
 | \`pre-edit\` / \`post-edit\` | File editing with neural training |
 | \`session-start\` / \`session-end\` | Session state persistence |
 | \`route\` | Route task to optimal agent |
-| \`intelligence\` | RuVector intelligence system |
+| \`intelligence\` | Pattern-learning intelligence system |
 | \`worker\` | Background worker management |
 
 ### 12 Background Workers
@@ -328,7 +328,7 @@ function performanceSection() {
 - Always run benchmarks before and after performance changes
 - Always profile before optimizing — never guess at bottlenecks
 - Prefer algorithmic improvements over micro-optimizations
-- Keep HNSW search within 150x-12,500x faster target
+- Prefer indexed (HNSW) vector search over brute-force scans for pattern lookup
 - Keep memory reduction within 50-75% target with quantization
 
 ### Performance Tooling
@@ -344,18 +344,14 @@ npx monomind@latest performance metrics --format table
 - Use agent routing code 7 (hierarchical/specialized) for performance tasks`;
 }
 function intelligenceSystem() {
-    return `## Intelligence System (RuVector)
-
-- **SONA**: Self-Optimizing Neural Architecture (<0.05ms adaptation)
-- **HNSW**: 150x-12,500x faster pattern search
-- **EWC++**: Elastic Weight Consolidation (prevents forgetting)
-- **Flash Attention**: 2.49x-7.47x speedup
-
-The 4-step intelligence pipeline:
-1. **RETRIEVE** - Fetch relevant patterns via HNSW
-2. **JUDGE** - Evaluate with verdicts (success/failure)
-3. **DISTILL** - Extract key learnings via LoRA
-4. **CONSOLIDATE** - Prevent catastrophic forgetting via EWC++`;
+    return `## Intelligence System
+
+- **Keyword routing**: Deterministic task→agent routing via \`createKeywordRouter\`
+- **Outcome measurement**: Route and command outcomes are recorded and scored to surface routing accuracy over time
+- **Pattern search**: Pure-JS HNSW vector search via AgentDB for finding similar past patterns
+
+Routing and learning are JS-only — no native engine is required. Outcomes
+feed back into the recorded metrics so routing quality is measured, not assumed.`;
 }
 function envVars() {
     return `## Environment Variables