monomind 1.11.6 → 1.11.8

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

@@ -51,7 +51,7 @@ const monographQueryTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb, ftsSearch } = await import('@monoes/monograph');
-        const { hybridQuery } = await import('./monograph-compat.js');
+        const { hybridQuery } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
             const limit = input.limit ?? 20;
@@ -290,7 +290,7 @@ const monographSuggestTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { hybridQuery } = await import('./monograph-compat.js');
+        const { hybridQuery } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
             const limit = input.limit ?? 10;
@@ -460,7 +460,7 @@ const monographStalenessTool = {
         },
     },
     handler: async (input) => {
-        const { getMonographStaleness } = await import('./monograph-compat.js');
+        const { getMonographStaleness } = await import('@monoes/monograph');
         const repoPath = input.path ?? getProjectCwd();
         const report = await getMonographStaleness(repoPath);
         return text(JSON.stringify(report, null, 2));
@@ -548,7 +548,7 @@ const monographContextTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { getMonographContext } = await import('./monograph-compat.js');
+        const { getMonographContext } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
             const result = getMonographContext(db, {
@@ -577,7 +577,7 @@ const monographImpactTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { getMonographImpact } = await import('./monograph-compat.js');
+        const { getMonographImpact } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
             const result = getMonographImpact(db, {
@@ -605,7 +605,7 @@ const monographDetectChangesTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { detectMonographChanges } = await import('./monograph-compat.js');
+        const { detectMonographChanges } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
             const result = detectMonographChanges(db, {
@@ -635,7 +635,7 @@ const monographRenameTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { getMonographRename } = await import('./monograph-compat.js');
+        const { getMonographRename } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
             const result = getMonographRename(db, {
@@ -665,7 +665,7 @@ const monographRouteMapTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { getMonographRouteMap } = await import('./monograph-compat.js');
+        const { getMonographRouteMap } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
             const result = getMonographRouteMap(db, {
@@ -694,7 +694,7 @@ const monographApiImpactTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { getMonographApiImpact } = await import('./monograph-compat.js');
+        const { getMonographApiImpact } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
             const result = getMonographApiImpact(db, {
@@ -721,7 +721,7 @@ const monographEmbedTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { runEmbed } = await import('./monograph-compat.js');
+        const { runEmbed } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
             const result = await runEmbed(db, { codeOnly: input.codeOnly ?? false, force: input.force ?? false });
@@ -752,7 +752,7 @@ const monographCypherTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { getMonographCypher } = await import('./monograph-compat.js');
+        const { getMonographCypher } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
             const result = getMonographCypher(db, input.query);
@@ -780,7 +780,7 @@ const monographGroupListTool = {
         },
     },
     handler: async (input) => {
-        const { getGroupList } = await import('./monograph-compat.js');
+        const { getGroupList } = await import('@monoes/monograph');
         const configPath = input.configPath ?? join(getProjectCwd(), 'group.yaml');
         const result = await getGroupList(configPath);
         return text(JSON.stringify(result, null, 2));
@@ -800,7 +800,7 @@ const monographGroupQueryTool = {
         required: ['query'],
     },
     handler: async (input) => {
-        const { runGroupQuery } = await import('./monograph-compat.js');
+        const { runGroupQuery } = await import('@monoes/monograph');
         const configPath = input.configPath ?? join(getProjectCwd(), 'group.yaml');
         const results = await runGroupQuery(configPath, input.query, input.limit);
         if (results.length === 0)
@@ -821,7 +821,7 @@ const monographWikiTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { getWikiToolResult } = await import('./monograph-compat.js');
+        const { getWikiToolResult } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
             const result = getWikiToolResult(db, { communityId: input.communityId });
@@ -846,7 +846,7 @@ const monographWikiBuildTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { runWikiBuildTool } = await import('./monograph-compat.js');
+        const { runWikiBuildTool } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
             const result = await runWikiBuildTool(db, {
@@ -874,7 +874,7 @@ const monographServeTool = {
     },
     handler: async (input) => {
         const { openDb } = await import('@monoes/monograph');
-        const { serveMonograph } = await import('./monograph-compat.js');
+        const { serveMonograph } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         const result = await serveMonograph({
             port: input.port ?? 7374,
@@ -896,7 +896,7 @@ const monographToolMapTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { getToolMap } = await import('./monograph-compat.js');
+        const { getToolMap } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
             const results = getToolMap(db, { tool: input.tool });
@@ -922,7 +922,7 @@ const monographShapeCheckTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { getShapeCheck } = await import('./monograph-compat.js');
+        const { getShapeCheck } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         const repoPath = getProjectCwd();
         try {
@@ -948,7 +948,7 @@ const monographGroupSyncTool = {
         },
     },
     handler: async (input) => {
-        const { runGroupSync } = await import('./monograph-compat.js');
+        const { runGroupSync } = await import('@monoes/monograph');
         const configPath = input.configPath ?? join(getProjectCwd(), 'group.yaml');
         try {
             const result = await runGroupSync(configPath);
@@ -974,7 +974,7 @@ const monographAugmentTool = {
         required: ['query'],
     },
     handler: async (input) => {
-        const { augmentContext } = await import('./monograph-compat.js');
+        const { augmentContext } = await import('@monoes/monograph');
         const repoPath = getProjectCwd();
         const result = await augmentContext({
             query: input.query,
@@ -1000,7 +1000,7 @@ const monographInjectContextTool = {
         },
     },
     handler: async (input) => {
-        const { injectAiContext } = await import('./monograph-compat.js');
+        const { injectAiContext } = await import('@monoes/monograph');
         const repoPath = getProjectCwd();
         const result = await injectAiContext({
             repoPath,
@@ -1020,7 +1020,7 @@ const monographSkillGenTool = {
         },
     },
     handler: async (input) => {
-        const { generateSkillFiles } = await import('./monograph-compat.js');
+        const { generateSkillFiles } = await import('@monoes/monograph');
         const repoPath = getProjectCwd();
         const allowedRoot = resolve(repoPath);
         if (input.outputDir) {
@@ -1056,7 +1056,7 @@ const monographInstallSkillsTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb } = await import('@monoes/monograph');
-        const { installSkillsForPlatform } = await import('./monograph-compat.js');
+        const { installSkillsForPlatform } = await import('@monoes/monograph');
         const rawRepoPath = input.repoPath ?? getProjectCwd();
         const repoPath = resolve(rawRepoPath);
         const allowedRoot = resolve(getProjectCwd());
@@ -1149,7 +1149,7 @@ const monographDoctorTool = {
         properties: {},
     },
     handler: async (_input) => {
-        const { runDoctor } = await import('./monograph-compat.js');
+        const { runDoctor } = await import('@monoes/monograph');
         const repoPath = getProjectCwd();
         const result = await runDoctor(repoPath);
         const lines = result.checks.map(c => `${c.status === 'ok' ? '✅' : c.status === 'warn' ? '⚠️' : '❌'} ${c.name}: ${c.message}`);
@@ -1167,7 +1167,7 @@ const monographListReposTool = {
         properties: {},
     },
     handler: async (_input) => {
-        const { listRepos } = await import('./monograph-compat.js');
+        const { listRepos } = await import('@monoes/monograph');
         const repos = listRepos();
         if (repos.length === 0)
             return text('No repositories registered. Run monograph build in a repo to register it.');

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

@@ -4,7 +4,7 @@
  * V2 Compatibility - Neural network and ML tools
  *
  * ✅ HYBRID Implementation:
- * - Uses @monomind/embeddings for REAL ML embeddings when available
+ * - Uses agentic-flow/reasoningbank for REAL ML embeddings when available
  * - Falls back to deterministic hash-based embeddings when ML model not installed
  * - 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,7 +4,7 @@
  * V2 Compatibility - Neural network and ML tools
  *
  * ✅ HYBRID Implementation:
- * - Uses @monomind/embeddings for REAL ML embeddings when available
+ * - Uses agentic-flow/reasoningbank for REAL ML embeddings when available
  * - Falls back to deterministic hash-based embeddings when ML model not installed
  * - Pattern storage and search with cosine similarity (real math in all tiers)
  * - Training stores patterns as searchable embeddings (not simulated)
@@ -16,42 +16,16 @@ 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 — prefer agentic-flow v1 ReasoningBank, then @monomind/embeddings
+// Try to import real embeddings — agentic-flow v1 ReasoningBank when available,
+// otherwise the deterministic hash fallback below.
 let realEmbeddings = null;
 let embeddingServiceName = 'none';
 try {
-    // Tier 1: agentic-flow v1 ReasoningBank (fastest — WASM-accelerated)
     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';
     }
-    // Tier 2: @monomind/embeddings
-    if (!realEmbeddings) {
-        const embeddingsModule = await import('@monomind/embeddings').catch(() => null);
-        if (embeddingsModule?.createEmbeddingService) {
-            try {
-                const service = embeddingsModule.createEmbeddingService({ provider: 'agentic-flow' });
-                realEmbeddings = {
-                    embed: async (text) => {
-                        const result = await service.embed(text);
-                        return Array.from(result.embedding);
-                    },
-                };
-                embeddingServiceName = 'agentic-flow';
-            }
-            catch {
-                const service = embeddingsModule.createEmbeddingService({ provider: 'mock' });
-                realEmbeddings = {
-                    embed: async (text) => {
-                        const result = await service.embed(text);
-                        return Array.from(result.embedding);
-                    },
-                };
-                embeddingServiceName = 'mock';
-            }
-        }
-    }
 }
 catch {
     // No embedding provider available, will use fallback
@@ -646,7 +620,7 @@ export const neuralTools = [
             const patterns = Object.values(store.patterns);
             return {
                 _realEmbeddings: !!realEmbeddings,
-                embeddingProvider: realEmbeddings ? `@monomind/embeddings (${embeddingServiceName})` : 'hash-based (deterministic)',
+                embeddingProvider: realEmbeddings ? embeddingServiceName : 'hash-based (deterministic)',
                 models: {
                     total: models.length,
                     ready: models.filter(m => m.status === 'ready').length,

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

@@ -1221,48 +1221,6 @@ 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/plugins/store/discovery.js

@@ -278,38 +278,6 @@ export class PluginDiscoveryService {
                     issues: [],
                 },
             },
-            {
-                id: '@monomind/embeddings',
-                name: '@monomind/embeddings',
-                displayName: 'Vector Embeddings',
-                description: 'Vector embeddings service with sql.js, document chunking, and hyperbolic embeddings',
-                version: '3.0.0',
-                cid: 'bafybeiembeddingsplugin',
-                size: 320000,
-                checksum: 'sha256:ghi789embeddings',
-                author: officialAuthor,
-                license: 'MIT',
-                categories: ['ai-ml'],
-                tags: ['embeddings', 'vectors', 'search', 'sqlite', 'hyperbolic'],
-                keywords: ['embeddings', 'vectors'],
-                downloads: 8500,
-                rating: 4.7,
-                ratingCount: 156,
-                lastUpdated: baseTime,
-                createdAt: '2024-02-01T00:00:00Z',
-                minMonomindVersion: '3.0.0',
-                dependencies: [
-                    { name: '@monomind/core', version: '^3.0.0' },
-                    { name: 'sql.js', version: '^1.8.0' },
-                ],
-                type: 'core',
-                hooks: ['embeddings:embed', 'embeddings:search'],
-                commands: ['embeddings embed', 'embeddings batch', 'embeddings search'],
-                permissions: ['memory', 'filesystem'],
-                exports: ['EmbeddingsService', 'VectorStore', 'DocumentChunker'],
-                verified: true,
-                trustLevel: 'official',
-            },
             {
                 id: '@monomind/claims',
                 name: '@monomind/claims',
@@ -712,7 +680,6 @@ export class PluginDiscoveryService {
             '@monomind/claims',
             '@monomind/security',
             '@monomind/plugins',
-            '@monomind/embeddings',
             '@monomind/performance',
             '@monomind/teammate-plugin',
             // Gas Town Bridge

package/packages/@monomind/cli/dist/src/routing/llm-caller.d.ts

@@ -0,0 +1,24 @@
+/** Cheap, cached check that the `claude` CLI is installed and on PATH. */
+export declare function isClaudeCodeAvailable(): boolean;
+export interface ClaudeLLMCallerOptions {
+    /** Routing model alias passed to `claude --model` (default: "haiku"). */
+    model?: 'haiku' | 'sonnet' | 'opus';
+    /** Per-call timeout in milliseconds (default: 20s). */
+    timeoutMs?: number;
+    /**
+     * Working directory for the spawned process. Defaults to the OS temp dir so
+     * the child does NOT inherit the host project's `.claude/` hooks (e.g.
+     * monomind's own SessionStart graph build), which would add seconds of
+     * unrelated startup work to every fallback classification.
+     */
+    cwd?: string;
+}
+/**
+ * Build an `llmCaller` that delegates a classification prompt to a headless
+ * Claude Code agent (`claude --print --model <model> -- <prompt>`).
+ *
+ * Returns `null` when the `claude` CLI is not available, so callers can omit
+ * `llmFallback` entirely and let routing run keyword + semantic only.
+ */
+export declare function createClaudeLLMCaller(options?: ClaudeLLMCallerOptions): ((prompt: string) => Promise<string>) | null;
+//# sourceMappingURL=llm-caller.d.ts.map

package/packages/@monomind/cli/dist/src/routing/llm-caller.js

@@ -0,0 +1,109 @@
+/**
+ * Claude Code (headless) LLM caller for semantic-routing fallback.
+ *
+ * Monomind always runs on top of Claude Code, so low-confidence route
+ * classification is delegated to the local `claude` CLI in headless print
+ * mode — NOT to the Anthropic API with a managed key. There is no
+ * `@anthropic-ai/sdk` dependency and no `ANTHROPIC_API_KEY` requirement: the
+ * host's existing Claude Code auth is reused.
+ *
+ * The returned function matches `LLMFallbackConfig.llmCaller` from
+ * `@monomind/routing` — `(prompt: string) => Promise<string>`. When the
+ * `claude` CLI is unavailable it throws, which the routing layer already
+ * catches and degrades to the best semantic match.
+ */
+import { spawn, execSync } from 'child_process';
+import { tmpdir } from 'os';
+/** Default model for routing fallback — Haiku is fast and cheap for slug classification. */
+const DEFAULT_ROUTING_MODEL = 'haiku';
+/**
+ * Max time to wait for a single classification before giving up.
+ * `claude --print` is a full headless session (cold start ~10s, can spike),
+ * so this is generous; the routing layer degrades to the best semantic match
+ * on timeout rather than blocking the caller.
+ */
+const DEFAULT_TIMEOUT_MS = 45_000;
+let claudeAvailable = null;
+/** Cheap, cached check that the `claude` CLI is installed and on PATH. */
+export function isClaudeCodeAvailable() {
+    if (claudeAvailable !== null)
+        return claudeAvailable;
+    try {
+        execSync('claude --version', { encoding: 'utf-8', stdio: 'pipe', timeout: 5000, windowsHide: true });
+        claudeAvailable = true;
+    }
+    catch {
+        claudeAvailable = false;
+    }
+    return claudeAvailable;
+}
+/**
+ * Build an `llmCaller` that delegates a classification prompt to a headless
+ * Claude Code agent (`claude --print --model <model> -- <prompt>`).
+ *
+ * Returns `null` when the `claude` CLI is not available, so callers can omit
+ * `llmFallback` entirely and let routing run keyword + semantic only.
+ */
+export function createClaudeLLMCaller(options = {}) {
+    if (!isClaudeCodeAvailable())
+        return null;
+    const model = options.model ?? DEFAULT_ROUTING_MODEL;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const cwd = options.cwd ?? tmpdir();
+    return (prompt) => new Promise((resolve, reject) => {
+        const env = { ...process.env };
+        // Don't let the child detect a "nested" session.
+        delete env.CLAUDE_SESSION_ID;
+        delete env.CLAUDE_PARENT_SESSION_ID;
+        // Constrain to a pure one-shot classifier:
+        //  --strict-mcp-config (with no --mcp-config) loads ZERO MCP servers, so
+        //    the child never loads monomind's own MCP server — avoids latency and
+        //    a potential routing→MCP→routing recursion.
+        //  --no-session-persistence keeps throwaway classification calls out of
+        //    the user's session history.
+        //  `--` terminates option parsing so a prompt can't smuggle flags.
+        const child = spawn('claude', ['--print', '--model', model, '--strict-mcp-config', '--no-session-persistence', '--', prompt], {
+            cwd,
+            env,
+            // 'ignore' closes stdin at spawn so `claude --print` doesn't block on EOF.
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            try {
+                child.kill('SIGTERM');
+            }
+            catch { /* may already be dead */ }
+            settled = true;
+            reject(new Error(`claude routing fallback timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timer.unref?.();
+        child.stdout?.on('data', (d) => { stdout += d.toString(); });
+        child.stderr?.on('data', (d) => { stderr += d.toString(); });
+        child.on('error', (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on('close', (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve(stdout.trim());
+            }
+            else {
+                reject(new Error(stderr.trim() || `claude exited with code ${code}`));
+            }
+        });
+    });
+}
+//# sourceMappingURL=llm-caller.js.map

package/packages/@monomind/cli/dist/src/update/checker.js

@@ -17,7 +17,6 @@ const DEFAULT_CONFIG = {
     priority: {
         '@monomind/security': 'critical',
         '@monomind/cli': 'high',
-        '@monomind/embeddings': 'normal',
     },
     exclude: [],
 };

package/packages/@monomind/cli/dist/src/update/validator.js

@@ -6,12 +6,8 @@ import * as semver from 'semver';
 // Known compatibility matrix between @monomind packages
 const COMPATIBILITY_MATRIX = {
     '@monomind/cli': {
-        '@monomind/embeddings': { minVersion: '3.0.0-alpha.1' },
         '@monomind/security': { minVersion: '3.0.0-alpha.1' },
     },
-    '@monomind/embeddings': {
-        '@monomind/cli': { minVersion: '3.0.0-alpha.50' },
-    },
 };
 // Known breaking changes by version
 const BREAKING_CHANGES = {
@@ -22,12 +18,6 @@ const BREAKING_CHANGES = {
             'Agent spawning now requires type parameter',
         ],
     },
-    '@monomind/embeddings': {
-        '3.0.0': [
-            'Switched from better-sqlite3 to sql.js',
-            'New initialization required with initEmbeddings()',
-        ],
-    },
 };
 export function validateUpdate(packageName, fromVersion, toVersion, installedPackages) {
     const result = {

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.11.6",
+  "version": "1.11.8",
   "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",
@@ -87,26 +87,20 @@
   "dependencies": {
     "ws": "^8.18.0",
     "@noble/ed25519": "^2.1.0",
-    "@monoes/monograph": "^1.1.0",
+    "@monoes/monograph": "^1.2.0",
     "@monomind/aidefence": "workspace:*",
-    "@monomind/embeddings": "workspace:*",
     "@monomind/guidance": "workspace:*",
     "@monomind/mcp": "workspace:*",
+    "@monomind/routing": "workspace:*",
     "graphology": "^0.25.4",
-    "graphology-communities-louvain": "^2.0.1",
     "graphology-metrics": "^2.4.0",
-    "graphology-shortest-path": "^2.0.2",
-    "graphology-traversal": "^0.3.1",
-    "graphology-types": "^0.24.7",
-    "chokidar": "^3.6.0",
     "semver": "^7.6.0"
   },
   "optionalDependencies": {
     "sql.js": "^1.14.1",
     "@monoes/memory": "workspace:*",
     "@monomind/plugin-gastown-bridge": "^0.1.3",
-    "agentic-flow": "^3.0.0-alpha.1",
-    "@anthropic-ai/sdk": "*"
+    "agentic-flow": "^3.0.0-alpha.1"
   },
   "publishConfig": {
     "access": "public",

package/packages/@monomind/guidance/package.json

@@ -140,8 +140,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@monomind/hooks": "workspace:*",
-    "@monoes/memory": "workspace:*"
+    "@monomind/hooks": "workspace:*"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",

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

@@ -1,18 +0,0 @@
-/**
- * CLI Embeddings Command
- * Vector embeddings, semantic search, similarity operations
- *
- * Features:
- * - Multiple providers: OpenAI, Transformers.js, Agentic-Flow, Mock
- * - Document chunking with overlap
- * - L2/L1/minmax/zscore normalization
- * - Hyperbolic embeddings (Poincaré ball)
- * - Neural substrate integration
- * - Persistent SQLite cache
- *
- * github.com/nokhodian/monomind
- */
-import type { Command } from '../types.js';
-export declare const embeddingsCommand: Command;
-export default embeddingsCommand;
-//# sourceMappingURL=embeddings.d.ts.map