monomind 2.3.0 → 2.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "Open-source CLI extension for Claude Code. Adds an MCP server with a codebase knowledge graph, persistent memory, multi-agent coordination, and reusable slash commands. MIT licensed, runs locally, no data leaves your machine.",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/.claude/helpers/handlers/route-handler.cjs

@@ -358,7 +358,12 @@ module.exports = {
         if (fs.existsSync(secAuditFile) && fs.statSync(secAuditFile).size < 32768) {
           var secData = JSON.parse(fs.readFileSync(secAuditFile, 'utf-8'));
           if (secData && secData.findings && secData.findings.length > 0) {
-            console.log('[SECURITY] ' + secData.findings.length + ' findings from background scan. Review .monomind/metrics/security-audit.json');
+            var serious = secData.findings.filter(function (f) { return f && (f.severity === 'high' || f.severity === 'medium'); });
+            if (serious.length > 0) {
+              console.log('[SECURITY] ' + serious.length + ' finding(s) from background scan. Review .monomind/metrics/security-audit.json');
+            } else {
+              console.log('[AUDIT] ' + secData.findings.length + ' low-severity note(s) (architecture heuristics, not vulnerabilities) — .monomind/metrics/security-audit.json');
+            }
           }
         }
         // Codebase map top files (high-centrality god nodes from monograph)

package/packages/@monomind/cli/.claude/skills/mastermind-skills/taskdev.md

@@ -157,6 +157,8 @@ Implementer subagents report one of four statuses. Handle each appropriately:
 
 **Never** ignore an escalation or force the same model to retry without changes. If the implementer said it's stuck, something needs to change.
 
+**Async dispatches:** reviewer and implementer subagents may complete asynchronously even when dispatched synchronously. Wait for each result before acting on it — never proceed to the next gate, and never touch the files a dispatched subagent is working on, while its result is pending.
+
 ---
 
 ## Handling Reviewer ⚠️ Items

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

@@ -30,6 +30,7 @@ const KEEP_CONFIG_PATHS = [
     join('.claude', 'settings.json'),
 ];
 /** Scratch pruning (--scratch): taskdev handoff files and loop state. */
+// monolean: manual flag only — upgrade path: invoke from the `cache` background worker so crashed-run scratch is pruned without anyone remembering the flag
 const SCRATCH_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // taskdev scratch older than this is stale
 const LOOP_STALE_GRACE_MS = 24 * 60 * 60 * 1000; // a live loop reschedules every <=1h; overdue by a day = abandoned
 /**

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

@@ -121,6 +121,15 @@ let bridgeAvailable = null;
 let _embedder = null;
 const MAX_INIT_ATTEMPTS = 3;
 let initAttempts = 0;
+/** Flush after mutations: the sql.js fallback backend is in-memory WASM and
+ *  only reaches disk via persist(); the CLI process is short-lived, so waiting
+ *  for an auto-persist interval would lose writes. No-op on better-sqlite3. */
+async function flushBackend(backend) {
+    try {
+        await backend?.persist?.();
+    }
+    catch { /* best effort */ }
+}
 async function getBackend(dbPath) {
     if (bridgeAvailable === false)
         return null;
@@ -134,7 +143,6 @@ async function getBackend(dbPath) {
         backendPromise = (async () => {
             try {
                 const mod = await import('@monoes/memory');
-                const { LanceDBBackend } = mod;
                 // Try to create embedding generator from HuggingFace transformers
                 let embeddingGenerator;
                 try {
@@ -152,26 +160,39 @@ async function getBackend(dbPath) {
                     if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
                         console.error('[memory-bridge] embedding model failed to load — store and search without vectors:', e);
                 }
-                const backend = new LanceDBBackend({
-                    // Always route through getDbPath's traversal guard — dbPath here can
-                    // originate from a caller/tool-supplied value, and getDbPath(undefined)
-                    // already returns the correct default, so there's no case where
-                    // calling it unconditionally changes behavior for the no-path case.
-                    dbPath: getDbPath(dbPath),
-                    vectorDimension: BRIDGE_EMBEDDING_DIMS,
+                // Local SQLite engine (LanceDB replaced 2026-07): better-sqlite3 when its
+                // native binding loads, sql.js (pure WASM) otherwise — both persist text
+                // AND embeddings, so vectors are always recomputable/derivable data.
+                // getDbPath keeps its traversal guard and directory semantics; the SQLite
+                // file lives inside that directory.
+                const dir = getDbPath(dbPath);
+                fs.mkdirSync(dir, { recursive: true });
+                const cfg = {
+                    databasePath: path.join(dir, 'memory.db'),
+                    walMode: true,
+                    optimize: true,
+                    defaultNamespace: 'default',
                     embeddingGenerator,
-                    enableFts: false,
-                    nProbes: 20,
-                });
+                };
                 const origLog = console.log;
                 console.log = (...args) => {
                     const msg = String(args[0] ?? '');
-                    if (msg.includes('Transformers.js') || msg.includes('[LanceDB]') || msg.includes('Loading model'))
+                    if (msg.includes('Transformers.js') || msg.includes('Loading model'))
                         return;
                     origLog.apply(console, args);
                 };
+                let backend;
                 try {
-                    await backend.initialize();
+                    try {
+                        backend = new mod.SQLiteBackend(cfg);
+                        await backend.initialize();
+                    }
+                    catch (e) {
+                        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                            console.error('[memory-bridge] better-sqlite3 unavailable — using sql.js backend:', e);
+                        backend = new mod.SqlJsBackend(cfg);
+                        await backend.initialize();
+                    }
                 }
                 finally {
                     console.log = origLog;
@@ -256,6 +277,7 @@ export async function bridgeStoreEntry(options) {
             catch { /* non-fatal — store anyway */ }
         }
         await backend.store(entry);
+        await flushBackend(backend);
         return { success: true, id, embedding: embeddingInfo };
     }
     catch (err) {
@@ -302,20 +324,31 @@ export async function bridgeSearchEntries(options) {
                 namespace: namespace ?? 'default',
                 limit: 50000,
             });
-            const queryLower = queryStr.toLowerCase();
-            results = entries
-                .filter((e) => (e.content || '').toLowerCase().includes(queryLower)
-                || (e.key || '').toLowerCase().includes(queryLower))
-                .slice(0, limit)
-                .map((e) => ({
-                id: e.id,
-                key: e.key,
-                content: e.content || '',
-                score: 0.5,
-                namespace: e.namespace,
-                provenance: 'keyword',
-                _createdAt: e.createdAt || 0,
-            }));
+            // Token-based matching, not whole-phrase substring: "semantic test" must
+            // match an entry keyed "semantic-test" (the old .includes(query) required
+            // the exact phrase — including its whitespace — to appear verbatim).
+            // Score = fraction of query tokens present in key+content.
+            const tokens = queryStr.toLowerCase().split(/[^a-z0-9]+/).filter(t => t.length > 1);
+            if (tokens.length) {
+                results = entries
+                    .map((e) => {
+                    const haystack = `${e.key || ''} ${e.content || ''}`.toLowerCase();
+                    const hits = tokens.filter(t => haystack.includes(t)).length;
+                    return { e, score: hits / tokens.length };
+                })
+                    .filter((x) => x.score > 0)
+                    .sort((a, b) => b.score - a.score)
+                    .slice(0, limit)
+                    .map(({ e, score }) => ({
+                    id: e.id,
+                    key: e.key,
+                    content: e.content || '',
+                    score: Math.min(0.9, 0.3 + score * 0.6),
+                    namespace: e.namespace,
+                    provenance: `keyword:${score.toFixed(2)}`,
+                    _createdAt: e.createdAt || 0,
+                }));
+            }
             searchMethod = 'keyword';
         }
         // Filter stale entries based on automem config — skip for knowledge
@@ -413,6 +446,8 @@ export async function bridgeDeleteEntry(options) {
             if (entry)
                 deleted = await backend.delete(entry.id);
         }
+        if (deleted)
+            await flushBackend(backend);
         return { success: true, deleted };
     }
     catch {
@@ -667,6 +702,7 @@ export async function bridgeSessionEnd(options) {
                 }),
                 tags: ['session', 'ended'],
             });
+            await flushBackend(backend);
         }
         return { success: true };
     }
@@ -758,6 +794,8 @@ export async function bridgeConsolidate(params) {
                 deleted++;
             }
         }
+        if (deleted)
+            await flushBackend(backend);
         return { success: true, consolidated: deleted };
     }
     catch {

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "type": "module",
   "description": "CLI engine for Monomind — an open-source MCP server that extends Claude Code with a codebase knowledge graph (tree-sitter + SQLite), persistent memory, multi-agent task coordination, and session hooks. MIT licensed, fully local.",
   "main": "dist/src/index.js",
@@ -105,7 +105,7 @@
   },
   "optionalDependencies": {
     "@huggingface/transformers": "^3.8.1",
-    "@monoes/memory": "^1.0.5",
+    "@monoes/memory": "^1.0.6",
     "@monomind/hooks": "*",
     "@monomind/mcp": "*",
     "@monomind/routing": "*",