monomind 2.5.4 → 2.5.5

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

@@ -4,8 +4,8 @@
  * Thin wrapper for calling MCP tools from CLI commands.
  * Implements ADR-005: MCP-First API Design - CLI as thin wrapper around MCP tools
  *
- * This provides a simple interface for CLI commands to call MCP tools without
- * containing hardcoded business logic. All business logic lives in MCP tool handlers.
+ * Tool modules are lazy-loaded on first use to avoid pulling ~300 tools'
+ * transitive dependencies into the heap at import time.
  */
 import type { MCPTool } from './mcp-tools/types.js';
 export declare function isToolDisabled(toolName: string, cwd?: string): boolean;
@@ -19,76 +19,38 @@ export declare class MCPClientError extends Error {
 }
 /**
  * Call an MCP tool by name with input parameters
- *
- * @param toolName - Name of the MCP tool (e.g., 'agent_spawn', 'swarm_init')
- * @param input - Input parameters for the tool
- * @param context - Optional tool context
- * @returns Promise resolving to tool result
- * @throws {MCPClientError} If tool not found or execution fails
- *
- * @example
- * ```typescript
- * // Spawn an agent
- * const result = await callMCPTool('agent_spawn', {
- *   agentType: 'coder',
- *   priority: 'normal'
- * });
- *
- * // Initialize swarm
- * const swarm = await callMCPTool('swarm_init', {
- *   topology: 'hierarchical-mesh',
- *   maxAgents: 15
- * });
- * ```
  */
 export declare function callMCPTool<T = unknown>(toolName: string, input?: Record<string, unknown>, context?: Record<string, unknown>): Promise<T>;
 /**
  * Get tool metadata by name
- *
- * @param toolName - Name of the MCP tool
- * @returns Tool metadata or undefined if not found
  */
-export declare function getToolMetadata(toolName: string): Omit<MCPTool, 'handler'> | undefined;
+export declare function getToolMetadata(toolName: string): Promise<Omit<MCPTool, 'handler'> | undefined>;
 /**
- * List all available MCP tools
- *
- * @param category - Optional category filter
- * @returns Array of tool metadata
+ * List all available MCP tools (loads all categories on first call)
  */
-export declare function listMCPTools(category?: string): Array<Omit<MCPTool, 'handler'> & {
+export declare function listMCPTools(category?: string): Promise<Array<Omit<MCPTool, 'handler'> & {
     enabled: boolean;
-}>;
+}>>;
 /**
  * Return all registered tools including their handler functions, excluding
- * any disabled via `mcp toggle`. Used by startHttpServer() to register tools
- * with the HTTP/WS MCP server, so a disabled tool is never exposed to
- * external MCP clients after the next server start.
+ * any disabled via `mcp toggle`. Loads all categories on first call.
  */
-export declare function getAllMCPTools(): MCPTool[];
+export declare function getAllMCPTools(): Promise<MCPTool[]>;
 /**
- * Check if an MCP tool exists
- *
- * @param toolName - Name of the MCP tool
- * @returns True if tool exists
+ * Check if an MCP tool exists (checks loaded categories + known prefixes)
  */
-export declare function hasTool(toolName: string): boolean;
+export declare function hasTool(toolName: string): Promise<boolean>;
 /**
  * Get all tool categories
- *
- * @returns Array of unique categories
  */
-export declare function getToolCategories(): string[];
+export declare function getToolCategories(): Promise<string[]>;
 /**
  * Validate tool input against schema
- *
- * @param toolName - Name of the MCP tool
- * @param input - Input to validate
- * @returns Validation result with errors if any
  */
-export declare function validateToolInput(toolName: string, input: Record<string, unknown>): {
+export declare function validateToolInput(toolName: string, input: Record<string, unknown>): Promise<{
     valid: boolean;
     errors?: string[];
-};
+}>;
 declare const _default: {
     callMCPTool: typeof callMCPTool;
     getToolMetadata: typeof getToolMetadata;

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

@@ -4,51 +4,16 @@
  * Thin wrapper for calling MCP tools from CLI commands.
  * Implements ADR-005: MCP-First API Design - CLI as thin wrapper around MCP tools
  *
- * This provides a simple interface for CLI commands to call MCP tools without
- * containing hardcoded business logic. All business logic lives in MCP tool handlers.
+ * Tool modules are lazy-loaded on first use to avoid pulling ~300 tools'
+ * transitive dependencies into the heap at import time.
  */
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-// Import MCP tool handlers from local package
-import { agentTools } from './mcp-tools/agent-tools.js';
-import { swarmTools } from './mcp-tools/swarm-tools.js';
-import { memoryTools } from './mcp-tools/memory-tools.js';
-import { configTools } from './mcp-tools/config-tools.js';
-import { hooksTools } from './mcp-tools/hooks-tools.js';
-import { taskTools } from './mcp-tools/task-tools.js';
-import { sessionTools } from './mcp-tools/session-tools.js';
-import { hiveMindTools } from './mcp-tools/hive-mind-tools.js';
-import { analyzeTools } from './mcp-tools/analyze-tools.js';
-import { embeddingsTools } from './mcp-tools/embeddings-tools.js';
-import { claimsTools } from './mcp-tools/claims-tools.js';
-import { securityTools } from './mcp-tools/security-tools.js';
-import { transferTools } from './mcp-tools/transfer-tools.js';
-// V2 Compatibility tools
-import { systemTools } from './mcp-tools/system-tools.js';
-import { terminalTools } from './mcp-tools/terminal-tools.js';
-import { neuralTools } from './mcp-tools/neural-tools.js';
-import { performanceTools } from './mcp-tools/performance-tools.js';
-import { githubTools } from './mcp-tools/github-tools.js';
-import { daaTools } from './mcp-tools/daa-tools.js';
-import { browserTools } from './mcp-tools/browser-tools.js';
-import { guidanceTools } from './mcp-tools/guidance-tools.js';
-import { autopilotTools } from './mcp-tools/autopilot-tools.js';
-// Knowledge graph tools (graphify — deprecated shims + monograph native)
-import { graphifyTools } from './mcp-tools/graphify-tools.js';
-import { monographTools } from './mcp-tools/monograph-tools.js';
-// Coverage-aware routing tools
-import { coverageRouterTools } from './monovector/coverage-tools.js';
-// Quality and Coherence core tools
-import { qualityTools } from './mcp-tools/quality-tools.js';
-import { coherenceTools } from './mcp-tools/coherence-tools.js';
-// Second Brain knowledge tools
-import { knowledgeTools } from './mcp-tools/knowledge-tools.js';
 /**
  * MCP Tool Registry
- * Maps tool names to their handler functions
+ * Maps tool names to their handler functions — populated lazily per category.
  */
 const TOOL_REGISTRY = new Map();
-// Register all tools — refuse silent overrides without an explicit override flag.
 function registerTools(tools, options = {}) {
     for (const tool of tools) {
         if (TOOL_REGISTRY.has(tool.name) && !options.override) {
@@ -57,46 +22,59 @@ function registerTools(tools, options = {}) {
         TOOL_REGISTRY.set(tool.name, tool);
     }
 }
-// Initialize registry with all available tools
-registerTools([
-    ...agentTools,
-    ...swarmTools,
-    ...memoryTools,
-    ...configTools,
-    ...hooksTools,
-    ...taskTools,
-    ...sessionTools,
-    ...hiveMindTools,
-    ...analyzeTools,
-    ...embeddingsTools,
-    ...claimsTools,
-    ...securityTools,
-    ...transferTools,
-    // V2 Compatibility tools
-    ...systemTools,
-    ...terminalTools,
-    ...neuralTools,
-    ...performanceTools,
-    ...githubTools,
-    ...daaTools,
-    ...browserTools,
-    // Guidance & discovery tools
-    ...guidanceTools,
-    // Autopilot persistent completion tools
-    ...autopilotTools,
-    // Knowledge graph — native monograph tools (replaces Python graphify)
-    ...monographTools,
-    // Graphify deprecated shims — proxy to monograph_* tools
-    ...graphifyTools,
-    // Coverage-aware routing tools
-    ...coverageRouterTools,
-    // Quality tools
-    ...qualityTools,
-    // Coherence tools
-    ...coherenceTools,
-    // Second Brain knowledge tools
-    ...knowledgeTools,
-]);
+const CATEGORY_LOADERS = {
+    agent: async () => (await import('./mcp-tools/agent-tools.js')).agentTools,
+    swarm: async () => (await import('./mcp-tools/swarm-tools.js')).swarmTools,
+    memory: async () => (await import('./mcp-tools/memory-tools.js')).memoryTools,
+    config: async () => (await import('./mcp-tools/config-tools.js')).configTools,
+    hooks: async () => (await import('./mcp-tools/hooks-tools.js')).hooksTools,
+    task: async () => (await import('./mcp-tools/task-tools.js')).taskTools,
+    session: async () => (await import('./mcp-tools/session-tools.js')).sessionTools,
+    'hive-mind': async () => (await import('./mcp-tools/hive-mind-tools.js')).hiveMindTools,
+    analyze: async () => (await import('./mcp-tools/analyze-tools.js')).analyzeTools,
+    embeddings: async () => (await import('./mcp-tools/embeddings-tools.js')).embeddingsTools,
+    claims: async () => (await import('./mcp-tools/claims-tools.js')).claimsTools,
+    monofence: async () => (await import('./mcp-tools/security-tools.js')).securityTools,
+    transfer: async () => (await import('./mcp-tools/transfer-tools.js')).transferTools,
+    system: async () => (await import('./mcp-tools/system-tools.js')).systemTools,
+    terminal: async () => (await import('./mcp-tools/terminal-tools.js')).terminalTools,
+    neural: async () => (await import('./mcp-tools/neural-tools.js')).neuralTools,
+    performance: async () => (await import('./mcp-tools/performance-tools.js')).performanceTools,
+    github: async () => (await import('./mcp-tools/github-tools.js')).githubTools,
+    daa: async () => (await import('./mcp-tools/daa-tools.js')).daaTools,
+    browser: async () => (await import('./mcp-tools/browser-tools.js')).browserTools,
+    guidance: async () => (await import('./mcp-tools/guidance-tools.js')).guidanceTools,
+    autopilot: async () => (await import('./mcp-tools/autopilot-tools.js')).autopilotTools,
+    monograph: async () => (await import('./mcp-tools/monograph-tools.js')).monographTools,
+    graphify: async () => (await import('./mcp-tools/graphify-tools.js')).graphifyTools,
+    coverage: async () => (await import('./monovector/coverage-tools.js')).coverageRouterTools,
+    quality: async () => (await import('./mcp-tools/quality-tools.js')).qualityTools,
+    coherence: async () => (await import('./mcp-tools/coherence-tools.js')).coherenceTools,
+    knowledge: async () => (await import('./mcp-tools/knowledge-tools.js')).knowledgeTools,
+    // system-tools.ts also exports tools with mcp_ and config_ prefixes
+    mcp: async () => (await import('./mcp-tools/system-tools.js')).systemTools,
+};
+const loadedCategories = new Set();
+async function ensureCategory(category) {
+    if (loadedCategories.has(category))
+        return;
+    const loader = CATEGORY_LOADERS[category];
+    if (!loader)
+        return;
+    loadedCategories.add(category);
+    registerTools(await loader(), { override: true });
+}
+function categoryFromToolName(name) {
+    const idx = name.indexOf('_');
+    return idx > 0 ? name.slice(0, idx) : name;
+}
+let _allLoaded = false;
+async function ensureAllLoaded() {
+    if (_allLoaded)
+        return;
+    _allLoaded = true;
+    await Promise.all(Object.keys(CATEGORY_LOADERS).map(cat => ensureCategory(cat)));
+}
 /**
  * Disabled-tools registry (`mcp toggle`)
  *
@@ -136,30 +114,11 @@ export class MCPClientError extends Error {
 }
 /**
  * Call an MCP tool by name with input parameters
- *
- * @param toolName - Name of the MCP tool (e.g., 'agent_spawn', 'swarm_init')
- * @param input - Input parameters for the tool
- * @param context - Optional tool context
- * @returns Promise resolving to tool result
- * @throws {MCPClientError} If tool not found or execution fails
- *
- * @example
- * ```typescript
- * // Spawn an agent
- * const result = await callMCPTool('agent_spawn', {
- *   agentType: 'coder',
- *   priority: 'normal'
- * });
- *
- * // Initialize swarm
- * const swarm = await callMCPTool('swarm_init', {
- *   topology: 'hierarchical-mesh',
- *   maxAgents: 15
- * });
- * ```
  */
 export async function callMCPTool(toolName, input = {}, context) {
-    // Look up tool in registry
+    // Lazy-load the tool's category if not yet loaded
+    const cat = categoryFromToolName(toolName);
+    await ensureCategory(cat);
     const tool = TOOL_REGISTRY.get(toolName);
     if (!tool) {
         throw new MCPClientError(`MCP tool not found: ${toolName}`, toolName);
@@ -168,27 +127,22 @@ export async function callMCPTool(toolName, input = {}, context) {
         throw new MCPClientError(`MCP tool '${toolName}' is disabled. Re-enable with: mcp toggle --enable ${toolName}`, toolName);
     }
     try {
-        // Call the tool handler
         const result = await tool.handler(input, context);
         return result;
     }
     catch (error) {
-        // Wrap and re-throw with context
         throw new MCPClientError(`Failed to execute MCP tool '${toolName}': ${error instanceof Error ? error.message : String(error)}`, toolName, error instanceof Error ? error : undefined);
     }
 }
 /**
  * Get tool metadata by name
- *
- * @param toolName - Name of the MCP tool
- * @returns Tool metadata or undefined if not found
  */
-export function getToolMetadata(toolName) {
+export async function getToolMetadata(toolName) {
+    const cat = categoryFromToolName(toolName);
+    await ensureCategory(cat);
     const tool = TOOL_REGISTRY.get(toolName);
-    if (!tool) {
+    if (!tool)
         return undefined;
-    }
-    // Return everything except the handler function
     return {
         name: tool.name,
         description: tool.description,
@@ -201,12 +155,10 @@ export function getToolMetadata(toolName) {
     };
 }
 /**
- * List all available MCP tools
- *
- * @param category - Optional category filter
- * @returns Array of tool metadata
+ * List all available MCP tools (loads all categories on first call)
  */
-export function listMCPTools(category) {
+export async function listMCPTools(category) {
+    await ensureAllLoaded();
     const tools = Array.from(TOOL_REGISTRY.values());
     const disabled = loadDisabledTools();
     const filtered = category
@@ -226,45 +178,39 @@ export function listMCPTools(category) {
 }
 /**
  * Return all registered tools including their handler functions, excluding
- * any disabled via `mcp toggle`. Used by startHttpServer() to register tools
- * with the HTTP/WS MCP server, so a disabled tool is never exposed to
- * external MCP clients after the next server start.
+ * any disabled via `mcp toggle`. Loads all categories on first call.
  */
-export function getAllMCPTools() {
+export async function getAllMCPTools() {
+    await ensureAllLoaded();
     const disabled = loadDisabledTools();
     return Array.from(TOOL_REGISTRY.values()).filter(t => !disabled.has(t.name));
 }
 /**
- * Check if an MCP tool exists
- *
- * @param toolName - Name of the MCP tool
- * @returns True if tool exists
+ * Check if an MCP tool exists (checks loaded categories + known prefixes)
  */
-export function hasTool(toolName) {
+export async function hasTool(toolName) {
+    const cat = categoryFromToolName(toolName);
+    await ensureCategory(cat);
     return TOOL_REGISTRY.has(toolName);
 }
 /**
  * Get all tool categories
- *
- * @returns Array of unique categories
  */
-export function getToolCategories() {
+export async function getToolCategories() {
+    await ensureAllLoaded();
     const categories = new Set();
     TOOL_REGISTRY.forEach(tool => {
-        if (tool.category) {
+        if (tool.category)
             categories.add(tool.category);
-        }
     });
     return Array.from(categories).sort();
 }
 /**
  * Validate tool input against schema
- *
- * @param toolName - Name of the MCP tool
- * @param input - Input to validate
- * @returns Validation result with errors if any
  */
-export function validateToolInput(toolName, input) {
+export async function validateToolInput(toolName, input) {
+    const cat = categoryFromToolName(toolName);
+    await ensureCategory(cat);
     const tool = TOOL_REGISTRY.get(toolName);
     if (!tool) {
         return {
@@ -272,7 +218,6 @@ export function validateToolInput(toolName, input) {
             errors: [`Tool '${toolName}' not found`],
         };
     }
-    // Basic validation - check required fields
     const schema = tool.inputSchema;
     const errors = [];
     if (schema.required && Array.isArray(schema.required)) {

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

@@ -405,6 +405,7 @@ export class MCPServerManager extends EventEmitter {
         process.stdin.on('end', () => { void shutdown('stdin closed'); });
         process.on('SIGINT', () => { void shutdown('Received SIGINT'); });
         process.on('SIGTERM', () => { void shutdown('Received SIGTERM'); });
+        process.on('SIGHUP', () => { void shutdown('Received SIGHUP'); });
         // Mark as ready immediately for stdio
         this.emit('ready');
     }
@@ -437,7 +438,7 @@ export class MCPServerManager extends EventEmitter {
                         },
                     };
                 case 'tools/list':
-                    const tools = listMCPTools();
+                    const tools = await listMCPTools();
                     return {
                         jsonrpc: '2.0',
                         id: message.id,
@@ -484,7 +485,7 @@ export class MCPServerManager extends EventEmitter {
                             };
                         }
                     }
-                    if (!hasTool(toolName)) {
+                    if (!await hasTool(toolName)) {
                         return {
                             jsonrpc: '2.0',
                             id: message.id,
@@ -709,7 +710,7 @@ export class MCPServerManager extends EventEmitter {
         // Without this the server only exposes its 4 built-in tools.
         try {
             const { getAllMCPTools } = await import('./mcp-client.js');
-            const registered = mcpServer.registerTools(getAllMCPTools());
+            const registered = mcpServer.registerTools(await getAllMCPTools());
             console.error(`[monomind-mcp] HTTP/WS server registered ${registered.registered} tools`);
         }
         catch (e) {

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

@@ -5,24 +5,21 @@
  * Sessions are keyed by session ID; each maps to a persistent CDP connection
  * on the configured port (default: MONOBROWSE_CDP_PORT env var or 9222).
  */
-const MAX_BROWSER_SESSIONS = 100;
-const SESSION_TTL_MS = 30 * 60 * 1000; // 30 minutes
+const MAX_BROWSER_SESSIONS = 5;
+const SESSION_TTL_MS = 10 * 60 * 1000; // 10 minutes
 // Session registry for multi-session support (sessionId → connection)
 const browserSessions = new Map();
 const connectionCache = new Map();
-function pruneExpiredSessions() {
+async function pruneExpiredSessions() {
     const cutoff = Date.now() - SESSION_TTL_MS;
+    const port = Number(process.env['MONOBROWSE_CDP_PORT'] ?? 9222);
     for (const [id, info] of browserSessions) {
         if (new Date(info.lastActivity).getTime() < cutoff) {
             browserSessions.delete(id);
             const conn = connectionCache.get(id);
-            if (conn) {
-                try {
-                    conn.client.close();
-                }
-                catch { /* ignore */ }
-            }
             connectionCache.delete(id);
+            if (conn)
+                await closeTarget(conn, port);
         }
     }
 }
@@ -40,7 +37,9 @@ async function getConnection(sessionId) {
             return conn;
         }
         catch {
+            const port = Number(process.env['MONOBROWSE_CDP_PORT'] ?? 9222);
             connectionCache.delete(sessionId);
+            await closeTarget(conn, port);
         }
     }
     const port = Number(process.env['MONOBROWSE_CDP_PORT'] ?? 9222);
@@ -50,16 +49,34 @@ async function getConnection(sessionId) {
     connectionCache.set(sessionId, conn);
     return conn;
 }
-function releaseConnection(sessionId) {
+async function releaseConnection(sessionId) {
     const conn = connectionCache.get(sessionId);
+    connectionCache.delete(sessionId);
+    browserSessions.delete(sessionId);
     if (conn) {
-        try {
-            conn.client.close();
+        const port = Number(process.env['MONOBROWSE_CDP_PORT'] ?? 9222);
+        // Close the actual Chrome tab — just closing the WebSocket leaves the
+        // renderer process alive and consuming ~250MB+ RAM each. Awaited (not
+        // fire-and-forget) so a burst of session churn can't pile up concurrent
+        // in-flight closes and leak renderers when one fails silently.
+        await closeTarget(conn, port);
+    }
+}
+async function closeTarget(conn, port) {
+    try {
+        // Get the target ID for this session so we can close the tab
+        const result = await conn.client.send('Target.getTargetInfo', {}, conn.cdpSessionId);
+        const targetId = result?.targetInfo?.targetId;
+        if (targetId) {
+            // Close via HTTP endpoint — works even if the CDP session is stale
+            await fetch(`http://127.0.0.1:${port}/json/close/${encodeURIComponent(targetId)}`, { method: 'GET' });
         }
-        catch { /* ignore */ }
     }
-    connectionCache.delete(sessionId);
-    browserSessions.delete(sessionId);
+    catch { /* best-effort */ }
+    try {
+        conn.client.close();
+    }
+    catch { /* ignore */ }
 }
 function ok(data = {}) {
     return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...data }, null, 2) }] };
@@ -195,13 +212,22 @@ export const browserTools = [
             catch (e) {
                 return fail(e.message);
             }
-            pruneExpiredSessions();
+            await pruneExpiredSessions();
             if (!browserSessions.has(sessionId)) {
+                // Refuse new sessions when system memory is critical
+                try {
+                    const os = await import('node:os');
+                    const freeRatio = os.freemem() / os.totalmem();
+                    if (freeRatio < 0.10) {
+                        return fail(`System memory critical (${Math.round(freeRatio * 100)}% free). Close existing browser sessions first.`);
+                    }
+                }
+                catch { /* non-critical */ }
                 if (browserSessions.size >= MAX_BROWSER_SESSIONS) {
                     const oldest = [...browserSessions.entries()]
                         .sort((a, b) => a[1].lastActivity.localeCompare(b[1].lastActivity))[0];
                     if (oldest)
-                        releaseConnection(oldest[0]);
+                        await releaseConnection(oldest[0]);
                 }
                 browserSessions.set(sessionId, {
                     sessionId,
@@ -332,7 +358,7 @@ export const browserTools = [
             catch (e) {
                 return fail(e.message);
             }
-            releaseConnection(sessionId);
+            await releaseConnection(sessionId);
             return ok({ session: sessionId });
         },
     },
@@ -1075,7 +1101,7 @@ export const browserTools = [
         tags: ['session'],
         inputSchema: { type: 'object', properties: {} },
         handler: async () => {
-            pruneExpiredSessions();
+            await pruneExpiredSessions();
             const sessions = Array.from(browserSessions.values());
             return ok({ sessions, count: sessions.length });
         },

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

@@ -76,7 +76,7 @@ const CAPABILITY_CATALOG = {
     },
     'memory-knowledge': {
         name: 'Memory & Knowledge',
-        description: 'Persistent memory with ANN vector search, LanceDB storage, and embeddings.',
+        description: 'Persistent memory with ANN vector search, SQLite storage, and embeddings.',
         tools: ['memory_store', 'memory_retrieve', 'memory_search', 'memory_list', 'memory_delete', 'memory_init', 'memory_export', 'memory_import', 'memory_stats', 'memory_compact', 'memory_namespace'],
         commands: ['memory store', 'memory retrieve', 'memory search', 'memory list', 'memory delete', 'memory init'],
         agents: ['swarm-memory-manager', 'v1-memory-specialist'],

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

@@ -803,7 +803,7 @@ export const hiveMindTools = [
                             tags: [proposal.type, proposalStrategy || 'raft', proposal.status],
                         });
                     }
-                    catch { /* LanceDB not available — JSON store is primary */ }
+                    catch { /* SQLite memory backend not available — JSON store is primary */ }
                     // Persist consensus audit record — uses MONOMIND_SESSION_SECRET when
                     // set, otherwise a per-project generated-and-persisted secret so the
                     // audit trail is populated by default (see getOrCreateSessionSecret).
@@ -1106,7 +1106,7 @@ export const hiveMindTools = [
                         namespace: 'hive-memory',
                     });
                 }
-                catch { /* LanceDB not available */ }
+                catch { /* SQLite memory backend not available */ }
                 return {
                     action,
                     key,

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

@@ -428,7 +428,7 @@ export const hooksPatternStore = {
             controller,
             implementation: controller === 'lancedb' ? 'lancedb-controller' : (storeResult.success ? 'real-hnsw-indexed' : 'memory-only'),
             note: controller === 'lancedb'
-                ? 'Pattern stored via lancedb bridge with HNSW indexing'
+                ? 'Pattern stored via SQLite-backed memory bridge with HNSW indexing'
                 : (storeResult.success ? 'Pattern stored with vector embedding for semantic search' : (storeResult.error || 'Store function unavailable')),
         };
     },
@@ -479,7 +479,7 @@ export const hooksPatternSearch = {
                     })),
                     searchTimeMs: 0,
                     backend: 'lancedb',
-                    note: 'Results from lancedb bridge',
+                    note: 'Results from SQLite-backed memory bridge',
                 };
             }
         }

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

@@ -4,7 +4,7 @@
 import { validateInput } from '../utils/input-guards.js';
 const knowledgeIngest = {
     name: 'knowledge_ingest',
-    description: 'Ingest documents into the Second Brain knowledge base. Accepts a file or directory path. Extracts text, chunks, embeds, and stores in LanceDB for semantic search.',
+    description: 'Ingest documents into the Second Brain knowledge base. Accepts a file or directory path. Extracts text, chunks, embeds, and stores in SQLite for semantic search.',
     category: 'knowledge',
     tags: ['documents', 'ingest', 'second-brain'],
     inputSchema: {

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

@@ -51,7 +51,7 @@ function readGroupConfig(configPath) {
  * Compute whether a repo's monograph index is stale relative to HEAD, the
  * same way monograph_staleness does: compare the last indexed commit hash
  * against `git rev-list --count <lastCommit>..HEAD`. Mirrors the threshold
- * used by monograph-tools.ts (STALENESS_THRESHOLD = 10).
+ * used by monograph-tools.ts (STALENESS_THRESHOLD = 3).
  */
 function isRepoStale(db, repoPath) {
     try {
@@ -63,7 +63,7 @@ function isRepoStale(db, repoPath) {
         const out = execSync(`git rev-list --count ${lastCommit}..HEAD`, {
             cwd: repoPath, encoding: 'utf-8',
         }).trim();
-        return parseInt(out, 10) > 10;
+        return parseInt(out, 10) > 3;
     }
     catch {
         return false;