monomind 2.5.4 → 2.5.6

package/packages/@monomind/cli/bin/mcp-server.js

@@ -41,22 +41,31 @@ process.stdin.on('data', async (chunk) => {
 
   for (const line of lines) {
     if (line.trim()) {
+      let parsed;
       try {
-        const message = JSON.parse(line);
-        const response = await handleMessage(message);
+        parsed = JSON.parse(line);
+      } catch {
+        console.log(JSON.stringify({
+          jsonrpc: '2.0',
+          id: null,
+          error: { code: -32700, message: 'Parse error' },
+        }));
+        continue;
+      }
+      try {
+        const response = await handleMessage(parsed);
         if (response) {
           console.log(JSON.stringify(response));
         }
       } catch (error) {
         console.error(
-          `[${new Date().toISOString()}] ERROR [monomind-mcp] Failed to parse:`,
+          `[${new Date().toISOString()}] ERROR [monomind-mcp] handler error:`,
           error instanceof Error ? error.message : String(error)
         );
-        // Send parse error response
         console.log(JSON.stringify({
           jsonrpc: '2.0',
-          id: null,
-          error: { code: -32700, message: 'Parse error' },
+          id: parsed.id ?? null,
+          error: { code: -32603, message: error instanceof Error ? error.message : 'Internal error' },
         }));
       }
     }
@@ -122,7 +131,7 @@ async function handleMessage(message) {
       }
 
       case 'tools/list': {
-        const tools = listMCPTools();
+        const tools = await listMCPTools();
         return {
           jsonrpc: '2.0',
           id: message.id,
@@ -140,7 +149,7 @@ async function handleMessage(message) {
         const toolName = params.name;
         const toolParams = params.arguments || {};
 
-        if (!hasTool(toolName)) {
+        if (!await hasTool(toolName)) {
           return {
             jsonrpc: '2.0',
             id: message.id,

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

@@ -44,7 +44,7 @@ export const AGENT_TYPES = [
     { value: 'optimizer', label: 'Optimizer', hint: 'Performance optimization and bottleneck analysis' },
     { value: 'security-architect', label: 'Security Architect', hint: 'Security architecture and threat modeling' },
     { value: 'security-auditor', label: 'Security Auditor', hint: 'CVE remediation and security testing' },
-    { value: 'memory-specialist', label: 'Memory Specialist', hint: 'LanceDB ANN search (150x-12,500x faster)' },
+    { value: 'memory-specialist', label: 'Memory Specialist', hint: 'SQLite-backed ANN search (150x-12,500x faster)' },
     { value: 'swarm-specialist', label: 'Swarm Specialist', hint: 'Unified coordination engine' },
     { value: 'performance-engineer', label: 'Performance Engineer', hint: '2.49x-7.47x optimization targets' },
     { value: 'core-architect', label: 'Core Architect', hint: 'Domain-driven design restructure' },

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

@@ -58,7 +58,7 @@ export const metricsCommand = {
                 note: totalAgents === 0 ? 'No agents spawned yet. Use: agent spawn -t coder' : undefined,
             },
             byType,
-            performance: { memoryEntries: `${vectorCount} entries`, searchBackend: vectorCount > 0 ? 'LanceDB' : 'none' },
+            performance: { memoryEntries: `${vectorCount} entries`, searchBackend: vectorCount > 0 ? 'SQLite' : 'none' },
         };
         if (ctx.flags.format === 'json') {
             output.printJson(metrics);

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

@@ -5,7 +5,7 @@
  * github.com/monoes/monomind
  */
 import { output } from '../output.js';
-import { existsSync, lstatSync, rmSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { existsSync, lstatSync, rmSync, readdirSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, statSync } from 'fs';
 import { join, dirname } from 'path';
 /**
  * Artifact directories and files that monomind/monomind may create
@@ -374,6 +374,58 @@ export const cleanupCommand = {
             output.writeln();
             return { success: true, message: `Removed ${removed} stale scratch file(s)`, data: { found: stale, removedCount: removed, removedSize, dryRun } };
         }
+        // Kill background processes before removing their state files
+        if (force) {
+            // Guard against a stale PID file outliving its process and the OS
+            // recycling that PID for an unrelated process — verify the live
+            // process actually looks like ours before signaling it.
+            const looksLikeOurProcess = (pid) => {
+                try {
+                    const { execSync } = require('child_process');
+                    const cmd = execSync(`ps -p ${pid} -o command=`, { timeout: 2000, encoding: 'utf-8' }).trim();
+                    // Covers direct `node ...` spawns as well as the npx fallback in
+                    // control-start.cjs's findCliPath(), which shows up in `ps` as
+                    // "npm exec ..." / "npx ..." with no literal "node".
+                    const looksLikeNode = cmd.includes('node') || cmd.includes('npx') || cmd.includes('npm exec');
+                    return looksLikeNode && (cmd.includes('monomind') || cmd.includes(cwd));
+                }
+                catch {
+                    return false;
+                }
+            };
+            const controlPath = join(cwd, '.monomind', 'control.json');
+            try {
+                if (existsSync(controlPath) && statSync(controlPath).size <= 4096) {
+                    const status = JSON.parse(readFileSync(controlPath, 'utf-8'));
+                    if (status?.pid && Number.isInteger(status.pid) && status.pid > 0 && looksLikeOurProcess(status.pid)) {
+                        process.kill(status.pid, 'SIGTERM');
+                        output.writeln(output.info(`  Stopped dashboard server (pid ${status.pid})`));
+                    }
+                    try {
+                        unlinkSync(controlPath);
+                    }
+                    catch { }
+                }
+            }
+            catch { /* already gone */ }
+            for (const pidName of ['monograph.watch.pid', 'monograph-watch.pid']) {
+                try {
+                    const pp = join(cwd, '.monomind', pidName);
+                    if (!existsSync(pp) || statSync(pp).size > 32)
+                        continue;
+                    const pid = parseInt(readFileSync(pp, 'utf-8').trim(), 10);
+                    if (Number.isInteger(pid) && pid > 0 && looksLikeOurProcess(pid)) {
+                        process.kill(pid, 'SIGTERM');
+                        output.writeln(output.info(`  Stopped monograph watcher (pid ${pid})`));
+                    }
+                    try {
+                        unlinkSync(pp);
+                    }
+                    catch { }
+                }
+                catch { /* already gone */ }
+            }
+        }
         output.writeln();
         output.writeln(output.bold(dryRun
             ? 'Monomind Cleanup (dry run)'

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

@@ -140,7 +140,7 @@ const setCommand = {
     ],
     examples: [
         { command: 'monomind config set swarm.maxAgents 20', description: 'Set max agents' },
-        { command: 'monomind config set -k memory.backend -v lancedb', description: 'Set memory backend' }
+        { command: 'monomind config set -k memory.backend -v sqlite', description: 'Set memory backend' }
     ],
     action: async (ctx) => {
         const key = (ctx.flags.key || ctx.args[0] || '').slice(0, 256);

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

@@ -400,7 +400,7 @@ export const statuslineCommand = {
         const mcpColor = mcpStats.enabled > 0 ? c.brightGreen : c.dim;
         const sizeDisplay = memoryStats.dbSizeKB >= 1024 ? `${(memoryStats.dbSizeKB / 1024).toFixed(1)}MB` : `${memoryStats.dbSizeKB}KB`;
         const hnswIndicator = memoryStats.hasHnsw ? `${c.brightGreen}⚡${c.reset}` : '';
-        const line4 = `${c.brightCyan}📊 LanceDB${c.reset}    ` +
+        const line4 = `${c.brightCyan}📊 SQLite${c.reset}    ` +
             `${c.cyan}Vectors${c.reset} ${vectorColor}●~${memoryStats.vectorCount}${hnswIndicator}${c.reset}  ${c.dim}│${c.reset}  ` +
             `${c.cyan}Size${c.reset} ${c.brightWhite}${sizeDisplay}${c.reset}  ${c.dim}│${c.reset}  ` +
             `${c.cyan}Tests${c.reset} ${testColor}●${testStats.testFiles}${c.reset} ${c.dim}(~${testStats.testCases} est.)${c.reset}  ${c.dim}│${c.reset}  ` +

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

@@ -486,7 +486,7 @@ export const hooksCommand = {
         output.printList([
             '🧠 Trajectory + outcome logging',
             '🎯 Keyword routing + route-outcome measurement',
-            '🔍 LanceDB integration (ANN vector search)',
+            '🔍 SQLite-backed vector search (ANN)',
             '🎯 32.3% token reduction',
             '👥 Agent Teams integration (auto task assignment)'
         ]);

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

@@ -144,6 +144,7 @@ export const commandsByCategory = {
         statusCommand,
         agentCommand,
         swarmCommand,
+        orgCommand,
         memoryCommand,
         docCommand,
         taskCommand,
@@ -156,11 +157,14 @@ export const commandsByCategory = {
         performanceCommand,
         guidanceCommand,
         autopilotCommand,
+        designCommand,
     ],
     utility: [
         configCommand,
         doctorCommand,
         completionsCommand,
+        reportCrashCommand,
+        crashReportingCommand,
     ],
     analysis: [
         analyzeCommand,

package/packages/@monomind/cli/dist/src/commands/init-wizard.js

@@ -60,7 +60,7 @@ export const wizardCommand = {
                         message: 'Select skill sets:',
                         options: [
                             { value: 'core', label: 'Core', hint: 'Swarm, memory skills', selected: true },
-                            { value: 'memory', label: 'Memory (LanceDB)', hint: 'Vector database skills', selected: true },
+                            { value: 'memory', label: 'Memory (SQLite)', hint: 'Vector database skills', selected: true },
                             { value: 'github', label: 'GitHub', hint: 'GitHub integration skills', selected: true },
                         ],
                     });
@@ -111,8 +111,8 @@ export const wizardCommand = {
             const memoryBackend = await select({
                 message: 'Select memory backend:',
                 options: [
-                    { value: 'hybrid', label: 'Hybrid', hint: 'SQLite + LanceDB (recommended)' },
-                    { value: 'lancedb', label: 'LanceDB', hint: '150x faster vector search' },
+                    { value: 'hybrid', label: 'Hybrid', hint: 'SQLite with vector search (recommended)' },
+                    { value: 'lancedb', label: 'LanceDB (legacy alias)', hint: 'Historical name — now backed by SQLite' },
                     { value: 'sqlite', label: 'SQLite', hint: 'Standard SQL storage' },
                     { value: 'memory', label: 'In-Memory', hint: 'Fast but non-persistent' },
                 ],

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

@@ -94,7 +94,7 @@ const initAction = async (ctx) => {
         if (!noWatch) {
             try {
                 const { spawn } = await import('child_process');
-                const pidFile = path.join(ctx.cwd, '.monomind', 'monograph-watch.pid');
+                const pidFile = path.join(ctx.cwd, '.monomind', 'monograph.watch.pid');
                 let alreadyRunning = false;
                 if (fs.existsSync(pidFile) && fs.statSync(pidFile).size <= 32) {
                     const existingPid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
@@ -107,7 +107,7 @@ const initAction = async (ctx) => {
                     }
                 }
                 if (!alreadyRunning) {
-                    const logPath = path.join(ctx.cwd, '.monomind', 'monograph-watch.log');
+                    const logPath = path.join(ctx.cwd, '.monomind', 'monograph.watch.log');
                     const { openSync } = fs;
                     const logFd = openSync(logPath, 'a');
                     const proc = spawn(process.execPath, [process.argv[1], 'monograph', 'watch'], {

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

@@ -364,7 +364,7 @@ const toolsCommand = {
         // Use local tool registry
         let tools;
         // Get tools from local registry
-        const registeredTools = listMCPTools(category);
+        const registeredTools = await listMCPTools(category);
         if (registeredTools.length > 0) {
             tools = registeredTools.map(tool => ({
                 name: tool.name,
@@ -542,7 +542,7 @@ const execCommand = {
         }
         try {
             // Execute through local MCP tool registry
-            if (!hasTool(tool)) {
+            if (!await hasTool(tool)) {
                 output.printError(`Tool not found: ${tool}`);
                 return { success: false, exitCode: 1 };
             }

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

@@ -7,16 +7,16 @@ import { select, confirm } from '../prompt.js';
 import { configManager } from '../services/config-file-manager.js';
 // Memory backends (needed for configureCommand)
 const BACKENDS = [
-    { value: 'lancedb', label: 'LanceDB', hint: 'Vector database with ANN indexing' },
+    { value: 'lancedb', label: 'LanceDB (legacy alias)', hint: 'Historical name — now backed by SQLite' },
     { value: 'sqlite', label: 'SQLite', hint: 'Lightweight local storage' },
-    { value: 'hybrid', label: 'Hybrid', hint: 'SQLite + LanceDB (recommended)' },
+    { value: 'hybrid', label: 'Hybrid', hint: 'SQLite with vector search (recommended)' },
     { value: 'memory', label: 'In-Memory', hint: 'Fast but non-persistent' }
 ];
 // Delete command
 export const deleteCommand = {
     name: 'delete',
     aliases: ['rm'],
-    description: 'Delete a memory entry (LanceDB, Memory Palace, or knowledge chunk)',
+    description: 'Delete a memory entry (SQLite-backed, Memory Palace, or knowledge chunk)',
     options: [
         {
             name: 'key',
@@ -189,16 +189,17 @@ export const statsCommand = {
             const memoryConfig = configManager.get(ctx.cwd, 'memory');
             const configuredBackend = memoryConfig?.backend || 'hybrid';
             // The actual storage engine currently in use for reads/writes is always
-            // LanceDB (memory-bridge.ts) — report the real on-disk path, not the
-            // configured (but not-yet-wired) backend's path.
+            // SQLite (better-sqlite3, sql.js WASM fallback — see memory-bridge.ts) —
+            // report the real on-disk path, not the configured (but not-yet-wired)
+            // backend's path.
             const backendStats = await bridgeGetBackendStats();
             const realLocation = bridgeGetDbPath();
             const statsResult = {
                 totalEntries: entries.length,
                 totalSize: totalBytes >= 1048576 ? `${(totalBytes / 1048576).toFixed(1)} MB`
                     : totalBytes >= 1024 ? `${(totalBytes / 1024).toFixed(1)} KB` : `${totalBytes} B`,
-                version: 'lancedb',
-                backend: `LanceDB (configured: ${configuredBackend})`,
+                version: 'sqlite',
+                backend: `SQLite (configured: ${configuredBackend})`,
                 location: realLocation,
                 oldestEntry: times[0] ? new Date(times[0]).toISOString() : null,
                 newestEntry: times.length ? new Date(times[times.length - 1]).toISOString() : null,

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

@@ -103,7 +103,7 @@ export const listCommand = {
 // Edit command
 export const editCommand = {
     name: 'edit',
-    description: 'Edit a memory entry (LanceDB, Memory Palace, or knowledge chunk)',
+    description: 'Edit a memory entry (SQLite-backed, Memory Palace, or knowledge chunk)',
     options: [
         { name: 'key', short: 'k', description: 'Storage key', type: 'string' },
         { name: 'namespace', short: 'n', description: 'Memory namespace', type: 'string', default: 'default' },
@@ -112,7 +112,7 @@ export const editCommand = {
         { name: 'id', description: 'Entry ID (palace/knowledge)', type: 'string' }
     ],
     examples: [
-        { command: 'monomind memory edit -k "pattern/auth" --value "updated content"', description: 'Edit LanceDB entry' },
+        { command: 'monomind memory edit -k "pattern/auth" --value "updated content"', description: 'Edit SQLite-backed entry' },
         { command: 'monomind memory edit --source palace --id "abc123" --value "new content"', description: 'Edit Memory Palace drawer' },
         { command: 'monomind memory edit --source knowledge --id "chunk-42" --value "updated"', description: 'Edit knowledge chunk' }
     ],

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

@@ -1,6 +1,6 @@
 /**
  * CLI Memory Command
- * Memory operations for LanceDB integration
+ * Memory operations — SQLite-backed (better-sqlite3, sql.js WASM fallback)
  *
  * Split into sub-modules:
  *   memory-crud.ts     — store, retrieve, search

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

@@ -1,6 +1,6 @@
 /**
  * CLI Memory Command
- * Memory operations for LanceDB integration
+ * Memory operations — SQLite-backed (better-sqlite3, sql.js WASM fallback)
  *
  * Split into sub-modules:
  *   memory-crud.ts     — store, retrieve, search
@@ -59,7 +59,7 @@ const initMemoryCommand = {
     ],
     examples: [
         { command: 'monomind memory init', description: 'Initialize hybrid backend with all features' },
-        { command: 'monomind memory init -b lancedb', description: 'Initialize LanceDB backend' },
+        { command: 'monomind memory init -b lancedb', description: 'Initialize memory backend (legacy "lancedb" alias, now SQLite-backed)' },
         { command: 'monomind memory init -p ./data/memory.db --force', description: 'Reinitialize at custom path' },
         { command: 'monomind memory init --verbose --verify', description: 'Initialize with full verification' }
     ],
@@ -264,11 +264,11 @@ export const memoryCommand = {
         output.printList([
             `${output.highlight('init')}        - Initialize memory database (sql.js)`,
             `${output.highlight('store')}       - Store data in memory`,
-            `${output.highlight('edit')}        - Edit an entry (LanceDB, palace, knowledge)`,
+            `${output.highlight('edit')}        - Edit an entry (SQLite-backed, palace, knowledge)`,
             `${output.highlight('retrieve')}    - Retrieve data from memory`,
             `${output.highlight('search')}      - Semantic/vector search`,
             `${output.highlight('list')}        - List memory entries`,
-            `${output.highlight('delete')}      - Delete an entry (LanceDB, palace, knowledge)`,
+            `${output.highlight('delete')}      - Delete an entry (SQLite-backed, palace, knowledge)`,
             `${output.highlight('templates')}   - Show best-practice entry templates`,
             `${output.highlight('stats')}       - Show statistics`,
             `${output.highlight('configure')}   - Configure backend`,

package/packages/@monomind/cli/dist/src/commands/neural-core.js

@@ -52,7 +52,7 @@ export const statusCommand = {
                         component: 'Pattern Index',
                         status: hnswStatus.available ? output.success('Ready') : output.dim('Empty'),
                         details: hnswStatus.available
-                            ? `${hnswStatus.entryCount} vectors, ${hnswStatus.dimensions}-dim (ANN via LanceDB)`
+                            ? `${hnswStatus.entryCount} vectors, ${hnswStatus.dimensions}-dim (ANN via SQLite)`
                             : 'No vectors indexed yet',
                     },
                     {

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

@@ -554,17 +554,16 @@ const bottleneckCommand = {
             }
             catch { /* ok */ }
         }
-        const memoryDir = '.monomind/memory';
-        if (fs.existsSync(memoryDir)) {
-            try {
-                const stat = fs.statSync(path.join(memoryDir, 'lance.db')).size ?? 0;
-                const sizeMB = stat / 1024 / 1024;
-                if (sizeMB > 100) {
-                    findings.push({ component: 'Memory DB', bottleneck: `LanceDB ${sizeMB.toFixed(0)}MB`, severity: output.warning('Medium'), solution: 'Run: monomind memory compact' });
-                }
+        try {
+            const { bridgeGetDbPath } = await import('../memory/memory-bridge.js');
+            const dbFile = path.join(bridgeGetDbPath(), 'memory.db');
+            const stat = fs.statSync(dbFile).size ?? 0;
+            const sizeMB = stat / 1024 / 1024;
+            if (sizeMB > 100) {
+                findings.push({ component: 'Memory DB', bottleneck: `SQLite ${sizeMB.toFixed(0)}MB`, severity: output.warning('Medium'), solution: 'Run: monomind memory compact' });
             }
-            catch { /* no lance.db */ }
         }
+        catch { /* no memory.db yet */ }
         const network = (perf.network ?? {});
         if (!network.batching) {
             findings.push({ component: 'Network', bottleneck: 'No request batching', severity: output.info('Low'), solution: 'Run: monomind performance optimize --apply -t latency' });

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

@@ -83,7 +83,7 @@ async function getSystemStatus() {
         const memoryStatus = {
             entries: 0,
             size: 0,
-            backend: 'lancedb',
+            backend: 'sqlite',
             performance: { avgSearchTime: 0, cacheHitRate: 0 },
         };
         // Get task status
@@ -507,7 +507,7 @@ const memoryCommand = {
             const entries = listed?.success ? listed.entries : [];
             const totalBytes = entries.reduce((s, e) => s + (e.content || '').length, 0);
             const result = {
-                backend: 'LanceDB',
+                backend: 'SQLite',
                 entries: entries.length,
                 size: totalBytes,
             };

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

@@ -289,7 +289,7 @@ const initCommand = {
             output.writeln(output.dim('  Initializing memory namespace...'));
             output.writeln(output.dim('  Setting up communication channels...'));
             if (v1Mode) {
-                output.writeln(output.dim('  Configuring LanceDB integration (ANN)....'));
+                output.writeln(output.dim('  Configuring SQLite-backed vector search (ANN)....'));
                 output.writeln(output.dim('  Initializing keyword routing + outcome measurement...'));
             }
             output.writeln();

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

@@ -310,7 +310,7 @@ export class CLI {
         this.output.writeln(this.output.bold('V1 FEATURES:'));
         this.output.printList([
             '15-agent hierarchical mesh coordination',
-            'LanceDB with ANN vector indexing',
+            'SQLite-backed ANN vector indexing',
             'Keyword routing + route-outcome measurement',
             'Unified SwarmCoordinator engine',
             'Event-sourced state management',

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

@@ -192,7 +192,7 @@ function cliCommandsTable() {
 | \`init\` | 5 | Project initialization |
 | \`agent\` | 7 | Agent lifecycle management |
 | \`swarm\` | 6 | Multi-agent swarm coordination |
-| \`memory\` | 12 | LanceDB memory with ANN search |
+| \`memory\` | 12 | SQLite memory with ANN search |
 | \`task\` | 5 | Task creation and lifecycle |
 | \`session\` | 6 | Session state management |
 | \`hooks\` | 29 | Self-learning hooks + 15 background workers${unavailNote(avail.hooks)} |
@@ -371,7 +371,7 @@ function intelligenceSystem() {
 
 - **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**: LanceDB ANN vector search for finding similar past patterns
+- **Pattern search**: SQLite-backed ANN vector search 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.`;

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

@@ -1617,7 +1617,7 @@ async function writeCapabilitiesDoc(targetDir, options, result) {
 Monomind is a domain-driven design architecture for multi-agent AI coordination with:
 
 - **15-Agent Swarm Coordination** with hierarchical and mesh topologies
-- **ANN Vector Search** - indexed pattern retrieval via LanceDB
+- **ANN Vector Search** - indexed pattern retrieval via SQLite (better-sqlite3, sql.js WASM fallback)
 - **Keyword Routing** - deterministic task→agent routing with outcome measurement
 - **Byzantine Fault Tolerance** - Queen-led consensus mechanisms
 - **MCP Server Integration** - Model Context Protocol support
@@ -1712,7 +1712,7 @@ npx monomind@latest swarm monitor
 | \`init\` | 5 | Project initialization |
 | \`agent\` | 7 | Agent lifecycle management |
 | \`swarm\` | 6 | Multi-agent coordination |
-| \`memory\` | 12 | LanceDB with ANN vector search |
+| \`memory\` | 12 | SQLite with ANN vector search |
 | \`mcp\` | 9 | MCP server management |
 | \`task\` | 5 | Task assignment |
 | \`session\` | 6 | Session persistence |
@@ -1819,7 +1819,7 @@ session start when their output is >6h old; run on demand with
 
 ### Intelligence System
 - **Keyword routing**: Deterministic task→agent routing with outcome measurement
-- **ANN pattern search**: Indexed vector search via LanceDB
+- **ANN pattern search**: Indexed vector search via SQLite
 - **ReasoningBank**: Stores learned patterns and trajectories for retrieval
 - **Int8 Quantization**: ~4x memory reduction for stored embeddings
 
@@ -1891,7 +1891,7 @@ npx monomind@latest memory init --force
 
 | Metric | Target | Status |
 |--------|--------|--------|
-| ANN Search | Indexed vector search | ✅ Implemented (LanceDB) |
+| ANN Search | Indexed vector search | ✅ Implemented (SQLite) |
 | Memory Reduction | 50-75% | ✅ Implemented (~4x via Int8 quantization) |
 | Pattern Learning | Recorded + retrievable | ✅ Implemented (ReasoningBank) |
 | MCP Response | <100ms | ✅ Achieved |
@@ -1909,7 +1909,7 @@ npx monomind@latest memory init --force
 ### Integrated Packages
 | Package | Version | Purpose |
 |---------|---------|---------|
-| @lancedb/lancedb | latest | Vector database (ANN search) |
+| better-sqlite3 (sql.js WASM fallback) | latest | SQLite vector database (ANN search) |
 
 ### Optional Integrations
 | Package | Command |
@@ -1994,7 +1994,8 @@ async function writeClaudeMd(targetDir, options, result) {
             '# Monomind Integration (auto-generated by monomind init)',
             'When working on multi-file tasks or complex features, use ToolSearch to find and invoke monomind MCP tools.',
             'Key tools: memory_store, memory_search, hooks_route, swarm_init, agent_spawn.',
-            'Check system-reminder tags for [INTELLIGENCE] pattern suggestions before starting work.',
+            '**Code navigation**: ALWAYS call `mcp__monomind__monograph_query` BEFORE grep/rg/find for code exploration — it returns file path + line number from a pre-built knowledge graph. Call `mcp__monomind__monograph_suggest` with a task description for multi-file tasks. Only fall back to grep if monograph returns 0 results or the DB is not built.',
+            'Check system-reminder tags for [INTELLIGENCE] pattern suggestions and [MONOGRAPH] context before starting work.',
             '',
         ].join('\n');
         try {
@@ -2007,6 +2008,12 @@ async function writeClaudeMd(targetDir, options, result) {
                     fs.appendFileSync(globalClaudeMd, monomindBlock);
                     result.created.files.push('~/.claude/CLAUDE.md (appended monomind block)');
                 }
+                else if (!existing.includes('monograph_query')) {
+                    // Upgrade existing block to include monograph instructions
+                    const updated = existing.replace(/# Monomind Integration[^\n]*\n(?:(?!^#).+\n)*/m, monomindBlock.trimStart() + '\n');
+                    atomicWriteFile(globalClaudeMd, updated);
+                    result.created.files.push('~/.claude/CLAUDE.md (upgraded monomind block)');
+                }
             }
             else {
                 atomicWriteFile(globalClaudeMd, monomindBlock.trimStart());

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

@@ -487,12 +487,33 @@ export function generateHookHandler() {
         '  },',
         '',
         "  'pre-bash': () => {",
-        '    // Graph-assisted grep: resolve patterns via monograph DB before grep runs',
         '    var cmd = (hookInput.toolInput || hookInput.tool_input || {}).command || hookInput.command || "";',
         '    if (typeof cmd !== "string") cmd = "";',
-        '    if (!/\\b(?:grep|rg|ag)\\b/.test(cmd)) return;',
+        '    var isGrep = /\\b(?:grep|rg|ag|find|fd)\\b/.test(cmd);',
+        '    if (!isGrep) return;',
+        '    // Graph gate: remind to use monograph before grep',
+        '    var dbPath = path.join(process.cwd(), ".monomind", "monograph.db");',
+        '    if (fs.existsSync(dbPath)) {',
+        '      var stateFile = path.join(process.cwd(), ".monomind", "graph-gate-state.json");',
+        '      var gateState = {};',
+        '      try { gateState = JSON.parse(fs.readFileSync(stateFile, "utf-8")); } catch(e) {}',
+        '      var sessions = (gateState && typeof gateState.sessions === "object") ? gateState.sessions : {};',
+        '      var sessId = hookInput.sessionId || hookInput.session_id || "";',
+        '      if (sessId) {',
+        '        var s = sessions[sessId] || { queried: false, blockedOnce: false };',
+        '        if (!s.queried && !s.blockedOnce) {',
+        '          s.blockedOnce = true; s.ts = Date.now(); sessions[sessId] = s;',
+        '          try { fs.mkdirSync(path.join(process.cwd(), ".monomind"), { recursive: true }); fs.writeFileSync(stateFile, JSON.stringify({ sessions: sessions })); } catch(e) {}',
+        '          process.stderr.write(JSON.stringify({ decision: "block", reason: "[graph-gate] Call mcp__monomind__monograph_query or monograph_suggest before grep/find. This blocks once per session." }) + "\\n");',
+        '          process.exitCode = 2; return;',
+        '        }',
+        '        if (!s.queried) {',
+        '          console.log("[MONOGRAPH_REMINDER] monograph_query/suggest not yet called this session — try monograph first for faster results.");',
+        '        }',
+        '      }',
+        '    }',
+        '    // Graph-assisted grep: resolve patterns via monograph DB',
         '    try {',
-        '      var dbPath = path.join(process.cwd(), ".monomind", "monograph.db");',
         '      if (!fs.existsSync(dbPath)) return;',
         '      var Database;',
         '      try { Database = require("better-sqlite3"); } catch(e) {',
@@ -518,6 +539,33 @@ export function generateHookHandler() {
         '    } catch (e) { /* non-fatal */ }',
         '  },',
         '',
+        "  'pre-search': () => {",
+        '    // Graph gate for Grep/Glob tools (same logic as pre-bash)',
+        '    var dbPath = path.join(process.cwd(), ".monomind", "monograph.db");',
+        '    if (!fs.existsSync(dbPath)) return;',
+        '    var stateFile = path.join(process.cwd(), ".monomind", "graph-gate-state.json");',
+        '    var gateState = {};',
+        '    try { gateState = JSON.parse(fs.readFileSync(stateFile, "utf-8")); } catch(e) {}',
+        '    var sessions = (gateState && typeof gateState.sessions === "object") ? gateState.sessions : {};',
+        '    var sessId = hookInput.sessionId || hookInput.session_id || "";',
+        '    if (sessId) {',
+        '      var s = sessions[sessId] || { queried: false, blockedOnce: false };',
+        '      if (!s.queried && !s.blockedOnce) {',
+        '        s.blockedOnce = true; s.ts = Date.now(); sessions[sessId] = s;',
+        '        try { fs.writeFileSync(stateFile, JSON.stringify({ sessions: sessions })); } catch(e) {}',
+        '        process.stderr.write(JSON.stringify({ decision: "block", reason: "[graph-gate] Call mcp__monomind__monograph_query or monograph_suggest before Grep/Glob. This blocks once per session." }) + "\\n");',
+        '        process.exitCode = 2; return;',
+        '      }',
+        '      if (!s.queried) {',
+        '        console.log("[MONOGRAPH_REMINDER] monograph_query/suggest not yet called this session.");',
+        '      }',
+        '    }',
+        '  },',
+        '',
+        "  'pre-write': () => {",
+        '    // Stub — real implementation in the full hook-handler.cjs',
+        '  },',
+        '',
         "  'post-edit': () => {",
         '    if (session && session.metric) {',
         "      try { session.metric('edits'); } catch (e) { /* no active session */ }",
@@ -563,6 +611,21 @@ export function generateHookHandler() {
         '    }',
         '  },',
         '',
+        "  'post-graph-tool': () => {",
+        '    // Clear the graph gate when a real monograph tool is called',
+        '    var sessId = hookInput.sessionId || hookInput.session_id || "";',
+        '    if (!sessId) return;',
+        '    var stateFile = path.join(process.cwd(), ".monomind", "graph-gate-state.json");',
+        '    try {',
+        '      var gateState = {};',
+        '      try { gateState = JSON.parse(fs.readFileSync(stateFile, "utf-8")); } catch(e) {}',
+        '      var sessions = (gateState && typeof gateState.sessions === "object") ? gateState.sessions : {};',
+        '      var s = sessions[sessId] || { blockedOnce: false };',
+        '      s.queried = true; s.ts = Date.now(); sessions[sessId] = s;',
+        '      fs.writeFileSync(stateFile, JSON.stringify({ sessions: sessions }));',
+        '    } catch(e) {}',
+        '  },',
+        '',
         "  'session-end': () => {",
         '    if (intelligence && intelligence.consolidate) {',
         '      try {',

package/packages/@monomind/cli/dist/src/init/shared-instructions-generator.d.ts

@@ -3,7 +3,7 @@
  *
  * Auto-detects project profile and generates:
  * 1. .agents/shared_instructions.md  — prepended to every agent prompt
- * 2. Memory seeds — pre-loaded into LanceDB so agents start with project best practices
+ * 2. Memory seeds — pre-loaded into SQLite so agents start with project best practices
  */
 import type { InitResult } from './types.js';
 export interface ProjectProfile {