monomind 1.16.3 → 1.16.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.16.3",
+  "version": "1.16.5",
   "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",
@@ -83,14 +83,26 @@
       "esbuild": ">=0.28.1",
       "protobufjs": ">=7.5.8",
       "@protobufjs/utf8": ">=1.1.1",
-      "@grpc/grpc-js": ">=1.14.4"
+      "@grpc/grpc-js": ">=1.14.4",
+      "vite": ">=8.0.16",
+      "postcss": ">=8.5.10",
+      "fast-uri": ">=3.1.2",
+      "form-data": ">=4.0.6",
+      "ip-address": ">=10.1.1",
+      "js-yaml": ">=4.2.0",
+      "undici": ">=7.28.0",
+      "http-proxy-middleware": ">=3.0.7",
+      "follow-redirects": ">=1.16.0",
+      "@anthropic-ai/claude-code": ">=2.1.163",
+      "handlebars": ">=4.7.9"
     },
     "peerDependencyRules": {
       "allowedVersions": {
         "tree-sitter": "0.22.4",
         "marked": "16",
         "@vitest/coverage-v8": "4.1.8",
-        "vitest": "4.1.4"
+        "vitest": "4.1.4",
+        "vite": "8"
       }
     }
   },

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.16.3",
+  "version": "1.16.5",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -94,7 +94,6 @@
   "optionalDependencies": {
     "sql.js": "^1.14.1",
     "@monoes/memory": "^1.0.0",
-    "agentic-flow": "^3.0.0-alpha.1",
     "@huggingface/transformers": "^3.8.1",
     "monofence-ai": "*",
     "@monomind/hooks": "*",