monomind 2.4.0 → 2.5.1

package/README.md

@@ -223,6 +223,8 @@ monomind doc list                  # what's indexed
 monomind doc export                # portable OKF bundle — move your brain between machines
 ```
 
+**And it follows you across projects.** Ingest a path from *outside* the current project (`monomind doc ingest ~/notes`, or add `--global`) and it lands in your personal global brain at `~/.monomind/global-brain` — searchable from every project on the machine. All retrieval (CLI search, per-prompt injection, the dashboard) merges both stores automatically, with project knowledge winning ties and global hits labeled `[global]`. `doc export --global` moves your whole brain between machines as an OKF bundle — still no cloud, ever.
+
 Retrieval quality is a tested invariant, not a hope: a golden-set eval (paraphrase queries against notes written in different vocabulary) runs in CI with an 80% recall bar.
 
 > **Privacy note:** the embedding model (~90MB) is fetched once from HuggingFace's CDN when your first document is indexed, then cached locally forever. That download is the only outbound request the Second Brain ever makes — your documents and queries never leave your machine. Offline at first index? Search degrades gracefully to keyword matching and `monomind doctor` tells you how to warm up later.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "2.4.0",
+  "version": "2.5.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/README.md

@@ -223,6 +223,8 @@ monomind doc list                  # what's indexed
 monomind doc export                # portable OKF bundle — move your brain between machines
 ```
 
+**And it follows you across projects.** Ingest a path from *outside* the current project (`monomind doc ingest ~/notes`, or add `--global`) and it lands in your personal global brain at `~/.monomind/global-brain` — searchable from every project on the machine. All retrieval (CLI search, per-prompt injection, the dashboard) merges both stores automatically, with project knowledge winning ties and global hits labeled `[global]`. `doc export --global` moves your whole brain between machines as an OKF bundle — still no cloud, ever.
+
 Retrieval quality is a tested invariant, not a hope: a golden-set eval (paraphrase queries against notes written in different vocabulary) runs in CI with an 80% recall bar.
 
 > **Privacy note:** the embedding model (~90MB) is fetched once from HuggingFace's CDN when your first document is indexed, then cached locally forever. That download is the only outbound request the Second Brain ever makes — your documents and queries never leave your machine. Offline at first index? Search degrades gracefully to keyword matching and `monomind doctor` tells you how to warm up later.

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

@@ -399,12 +399,15 @@ If the \`documents\` capability is active (check \`.monomind/capabilities.json\`
 
 **CLI access:**
 \`\`\`bash
-monomind doc search -q "your query"    # Semantic search
-monomind doc list                       # List indexed docs
-monomind doc ingest ./path              # Ingest new documents
-monomind doc export                     # Export as OKF bundle
+monomind doc search -q "your query"    # Semantic search (project + global brain merged)
+monomind doc search -q "..." --store global   # Personal global brain only
+monomind doc list                       # List indexed docs (--global for the global brain)
+monomind doc ingest ./path              # Ingest new documents (paths outside the project auto-route to the global brain)
+monomind doc export                     # Export as OKF bundle (--global to move your brain between machines)
 \`\`\`
 
+**Global brain:** the user has a personal cross-project knowledge store at \`~/.monomind/global-brain\`. All searches (knowledge_search, doc search, per-prompt injection) automatically merge it with project knowledge — project results win ties, global hits are labeled \`[global]\`. Cite the label so the user knows which brain answered.
+
 **Re-indexing** happens automatically on session start (unchanged files are skipped via content hash).`;
 }
 function graphifySection() {

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

@@ -260,7 +260,9 @@ export async function bridgeStoreEntry(options) {
             ? options.value.slice(0, BRIDGE_MAX_VALUE_LEN) : options.value;
         const namespace = options.namespace ?? 'default';
         const tags = Array.isArray(options.tags)
-            ? options.tags.filter(t => typeof t === 'string' && t.length > 0 && t.length <= MAX_TAG_LEN).slice(0, MAX_TAGS)
+            // src: tags carry the ingest source path for excerpt provenance — paths
+            // routinely exceed the general 64-char tag cap, so they get 512.
+            ? options.tags.filter(t => typeof t === 'string' && t.length > 0 && t.length <= (t.startsWith('src:') ? 512 : MAX_TAG_LEN)).slice(0, MAX_TAGS)
             : [];
         const now = Date.now();
         const id = generateId('entry');

package/packages/@monomind/cli/dist/src/orgrt/daemon.d.ts

@@ -113,6 +113,14 @@ export declare class OrgDaemon {
      *  memory bridge (semantic when the local model is available, tokenized
      *  keyword otherwise). Failures return a message, never throw into the tool. */
     private recallOrgMemory;
+    /** knowledge_search implementation for org agents: the user's Second Brain
+     *  (this project's documents + the personal global brain), merged with the
+     *  same project-first ranking every other surface uses. Failures return a
+     *  message, never throw into the tool call. */
+    searchProjectKnowledge(query: string): Promise<{
+        text: string;
+        hits: number;
+    }>;
     /** Persist the run's outcome into cross-run org memory so org_recall (and
      *  future runs) can find it by meaning, not just recency. Best-effort. */
     private storeRunMemory;

package/packages/@monomind/cli/dist/src/orgrt/daemon.js

@@ -88,6 +88,11 @@ export class OrgDaemon {
                     bus.emit({ type: 'status', from: r, reason: 'org-recall', msg: `recall: ${q.slice(0, 80)}`, data: { hits: answer.hits } });
                     return answer.text;
                 },
+                searchKnowledge: async (r, q) => {
+                    const answer = await this.searchProjectKnowledge(q);
+                    bus.emit({ type: 'status', from: r, reason: 'knowledge-search', msg: `knowledge: ${q.slice(0, 80)}`, data: { hits: answer.hits } });
+                    return answer.text;
+                },
                 queryFn: this.opts.queryFn,
             };
             // Supervised session: transient crashes (provider blips, network) restart
@@ -502,6 +507,23 @@ export class OrgDaemon {
             return { text: `org memory unavailable (${err instanceof Error ? err.message : 'error'})`, hits: 0 };
         }
     }
+    /** knowledge_search implementation for org agents: the user's Second Brain
+     *  (this project's documents + the personal global brain), merged with the
+     *  same project-first ranking every other surface uses. Failures return a
+     *  message, never throw into the tool call. */
+    async searchProjectKnowledge(query) {
+        try {
+            const { searchKnowledge } = await import('../knowledge/document-pipeline.js');
+            const excerpts = await searchKnowledge(query, { rootDir: this.root, limit: 5, store: 'all' });
+            if (!excerpts.length)
+                return { text: 'No matching documents in the Second Brain for that query.', hits: 0 };
+            const text = excerpts.map((e, i) => `${i + 1}. [${e.filePath || 'unknown'}${e.scope === 'global' ? ' · global' : ''}] (${e.similarity.toFixed(2)})\n${e.text.slice(0, 800)}`).join('\n\n');
+            return { text, hits: excerpts.length };
+        }
+        catch (err) {
+            return { text: `knowledge search unavailable (${err instanceof Error ? err.message : 'error'})`, hits: 0 };
+        }
+    }
     /** Persist the run's outcome into cross-run org memory so org_recall (and
      *  future runs) can find it by meaning, not just recency. Best-effort. */
     async storeRunMemory(name, def, run, summary) {

package/packages/@monomind/cli/dist/src/orgrt/session.d.ts

@@ -17,6 +17,8 @@ export interface SessionOpts {
     onComplete?: (role: string, outcome: 'achieved' | 'partial' | 'failed', summary: string) => void;
     /** Search the org's accumulated cross-run memory (memory_namespace). */
     recall?: (role: string, query: string) => Promise<string>;
+    /** Search the user's Second Brain (project documents + personal global brain). */
+    searchKnowledge?: (role: string, query: string) => Promise<string>;
     def?: OrgDef;
     maxTurns?: number;
     queryFn?: typeof query;

package/packages/@monomind/cli/dist/src/orgrt/session.js

@@ -15,6 +15,7 @@ export function buildRolePrompt(role, def, roster) {
         `Roster: ${roster.join(', ')}. Address another org's agent as "<org-name>:<role-id>".`,
         `If you need a human decision, call ask_human with your question, then end your turn — you'll receive the human's answer as a new message when it arrives. Do not call ask_human for anything you can resolve yourself.`,
         `Before starting substantial work, call org_recall to check what previous runs already learned or delivered — do not redo finished work.`,
+        `The user's documents (notes, handbooks, specs) are searchable with knowledge_search — ground your work in them instead of guessing; results labeled [global] come from the user's personal cross-project brain.`,
         `When you receive a message, act on it, then org_send your result to the requester.`,
         isCoordinator
             ? `When the org's goal for this run is achieved (or clearly can't be), call org_complete exactly once with the outcome and a concise summary of what was done — it is recorded in the org's run history and briefed to the next run. Then end your turn.`
@@ -56,6 +57,10 @@ async function runOneSession(opts) {
         name: 'org',
         version: '1.0.0',
         tools: [
+            ...(opts.searchKnowledge ? [tool('knowledge_search', 'Semantic search over the user\'s Second Brain: this project\'s indexed documents plus their personal cross-project global brain. Use to ground work in the user\'s actual notes, handbooks, and documents.', { query: z.string() }, async (args) => {
+                    const text = await opts.searchKnowledge(role.id, args.query);
+                    return { content: [{ type: 'text', text }] };
+                })] : []),
             ...(opts.recall ? [tool('org_recall', 'Search this org\'s accumulated memory from previous runs (outcomes, decisions, learnings). Use before starting work that may already have been done.', { query: z.string() }, async (args) => {
                     const text = await opts.recall(role.id, args.query);
                     return { content: [{ type: 'text', text }] };

package/packages/@monomind/cli/dist/src/ui/dashboard.html

@@ -1917,6 +1917,11 @@ select.pb-cfg-inp { padding: 4px 7px; cursor: pointer; }
           <div class="filter-bar" style="margin-bottom:6px">
             <input class="filter-input" id="sb-search-input" type="text" placeholder="Ask your Second Brain — semantic search by meaning…"
               onkeydown="if(event.key==='Enter')secondBrainSearch()">
+            <select id="sb-search-scope" class="btn" title="Which brain to search" style="padding:3px 6px">
+              <option value="all" selected>project + global</option>
+              <option value="project">project only</option>
+              <option value="global">global only</option>
+            </select>
             <button class="btn" onclick="secondBrainSearch()" title="Semantic search (warm local model)">⌕ Search</button>
           </div>
           <div id="sb-search-results" style="display:none;margin-bottom:12px"></div>
@@ -13609,10 +13614,11 @@ async function secondBrainSearch() {
   box.style.display = 'block';
   box.innerHTML = '<div class="loading-txt">Searching…</div>';
   try {
+    const scopeSel = document.getElementById('sb-search-scope');
     const r = await fetch('/api/knowledge/search', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ query: q, limit: 5 }),
+      body: JSON.stringify({ query: q, limit: 5, scope: scopeSel ? scopeSel.value : 'all' }),
     });
     if (!r.ok) throw new Error('HTTP ' + r.status);
     const data = await r.json();
@@ -13625,8 +13631,11 @@ async function secondBrainSearch() {
       '<div style="font-size:10px;letter-spacing:0.07em;text-transform:uppercase;color:var(--text-xs);margin-bottom:6px">' +
         results.length + ' result(s) · ' + esc(data.method || '') + '</div>' +
       results.map(function (res) {
+        var srcTag = (res.tags || []).find(function (t) { return t.indexOf('src:') === 0; });
+        var label = srcTag ? srcTag.slice(4).split('/').slice(-2).join('/') : (res.key || '');
         return '<div style="border:1px solid var(--border);border-radius:8px;padding:8px 10px;margin-bottom:6px">' +
-          '<div style="font-size:10px;color:var(--text-lo);margin-bottom:3px">' + esc(res.key || '') +
+          '<div style="font-size:10px;color:var(--text-lo);margin-bottom:3px">' + esc(label) +
+            (res.global ? ' <span style="color:var(--accent-dim,#888);border:1px solid var(--border);border-radius:4px;padding:0 4px">global</span>' : '') +
             ' <span style="color:var(--accent)">' + (typeof res.score === 'number' ? res.score.toFixed(2) : '') + '</span></div>' +
           '<div style="font-size:12px;white-space:pre-wrap;max-height:120px;overflow:hidden">' + esc(String(res.content || '').slice(0, 600)) + '</div>' +
         '</div>';

package/packages/@monomind/cli/dist/src/ui/server.mjs

@@ -1035,6 +1035,89 @@ export async function startServer({ port = 4242, projectDir, openBrowser = true
           .catch(() => { /* warm-up is best-effort */ });
       }, 3000);
       if (_warmTimer.unref) _warmTimer.unref();
+
+      // ── Second Brain live ingestion ──────────────────────────────────
+      // This server is the one long-lived local process AND holds the warm
+      // embedding model — so it watches for document changes and ingests
+      // in-process within seconds, instead of waiting for the next session
+      // start. Best-effort: recursive fs.watch is unsupported on some
+      // platforms/volumes; the session-start reindex remains the backstop.
+      try {
+        const _sbDocExts = new Set(['.md', '.txt', '.pdf', '.docx']);
+        const _sbSkip = /(^|\/)(node_modules|\.git|dist|\.monomind|\.claude|\.next|__pycache__|\.venv|vendor)(\/|$)/;
+        const _sbPending = new Map(); // file -> debounce timer
+        const _sbRoot = path.resolve(projectDir || process.cwd());
+        const _sbWatcher = fs.watch(_sbRoot, { recursive: true }, (_evt, rel) => {
+          try {
+            if (!rel) return;
+            const relStr = String(rel);
+            if (_sbSkip.test(relStr) || relStr.startsWith('.')) return;
+            if (!_sbDocExts.has(path.extname(relStr).toLowerCase())) return;
+            const full = path.join(_sbRoot, relStr);
+            clearTimeout(_sbPending.get(full));
+            _sbPending.set(full, setTimeout(async () => {
+              _sbPending.delete(full);
+              try {
+                if (!fs.existsSync(full)) return; // deleted — session-start reindex handles removal
+                const pipeline = await import('../knowledge/document-pipeline.js');
+                const r = await pipeline.ingestDocument(full, 'shared', _sbRoot);
+                if (r.chunksIndexed > 0 && !r.skipped) {
+                  console.log(`[knowledge] live-ingested ${path.basename(full)} (${r.chunksIndexed} chunks)`);
+                }
+              } catch (_) { /* single-file ingest failure never matters here */ }
+            }, 5000));
+          } catch (_) { /* watcher callback must never throw */ }
+        });
+        activeWatchers.push(_sbWatcher);
+      } catch (_) { /* recursive watch unavailable — the sweep below still covers it */ }
+
+      // Polling sweep backstop: fs.watch/fsevents silently stops delivering on
+      // some volumes (exFAT/SMB — exactly where many projects live). Every 60s,
+      // a bounded mtime walk ingests anything the watcher missed. Stat-only
+      // when nothing changed; skips while a sweep is already running.
+      try {
+        const _sbDocExts2 = new Set(['.md', '.txt', '.pdf', '.docx']);
+        const _sbSkipDirs = new Set(['node_modules', '.git', 'dist', '.monomind', '.claude', '.next', '__pycache__', '.venv', 'vendor']);
+        const _sbSweepRoot = path.resolve(projectDir || process.cwd());
+        let _sbLastSweep = Date.now();
+        let _sbSweeping = false;
+        const _sbSweepTimer = setInterval(async () => {
+          if (_sbSweeping) return;
+          _sbSweeping = true;
+          const since = _sbLastSweep - 5000; // small overlap so boundary writes aren't missed
+          _sbLastSweep = Date.now();
+          try {
+            const changed = [];
+            let scanned = 0;
+            const walk = (dir, depth) => {
+              if (depth > 4 || scanned > 3000 || changed.length >= 20) return;
+              let names;
+              try { names = fs.readdirSync(dir, { withFileTypes: true }); } catch (_) { return; }
+              for (const ent of names) {
+                if (scanned++ > 3000 || changed.length >= 20) return;
+                if (ent.name.startsWith('.') || _sbSkipDirs.has(ent.name)) continue;
+                const full = path.join(dir, ent.name);
+                if (ent.isDirectory()) { walk(full, depth + 1); continue; }
+                if (!_sbDocExts2.has(path.extname(ent.name).toLowerCase())) continue;
+                try { if (fs.statSync(full).mtimeMs > since) changed.push(full); } catch (_) {}
+              }
+            };
+            walk(_sbSweepRoot, 0);
+            if (changed.length) {
+              const pipeline = await import('../knowledge/document-pipeline.js');
+              for (const f of changed) {
+                try {
+                  const r = await pipeline.ingestDocument(f, 'shared', _sbSweepRoot);
+                  if (r.chunksIndexed > 0 && !r.skipped) console.log(`[knowledge] sweep-ingested ${path.basename(f)} (${r.chunksIndexed} chunks)`);
+                } catch (_) { /* per-file failures never matter here */ }
+              }
+            }
+          } catch (_) { /* sweep is best-effort */ }
+          finally { _sbSweeping = false; }
+        }, 60_000);
+        if (_sbSweepTimer.unref) _sbSweepTimer.unref();
+        activeWatchers.push({ close: () => clearInterval(_sbSweepTimer) });
+      } catch (_) { /* non-fatal */ }
     }
   } catch (_) { /* non-fatal */ }
 

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "2.4.0",
+  "version": "2.5.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.8",
+    "@monoes/memory": "^1.0.10",
     "@monomind/hooks": "*",
     "@monomind/mcp": "*",
     "@monomind/routing": "*",