monomind 2.3.1 → 2.3.3

package/packages/@monomind/cli/dist/src/knowledge/document-pipeline.js

@@ -13,6 +13,21 @@ const DEFAULT_OVERLAP = 400;
 // Inline fallback identical to @monoes/memory's knowledge/document-chunker.ts —
 // used only if the dynamic import below fails (package not installed/built).
 // Keep in sync if the shared chunker's boundary-snapping logic changes.
+const HEADING_LINE_RE = /^#{1,6} /;
+function lastHeadingBefore(text, pos) {
+    let i = text.lastIndexOf('\n#', pos - 1);
+    while (i !== -1) {
+        const eol = text.indexOf('\n', i + 1);
+        const line = text.slice(i + 1, eol === -1 ? undefined : eol);
+        if (HEADING_LINE_RE.test(line))
+            return line.replace(/^#+ /, '').trim();
+        i = text.lastIndexOf('\n#', i - 1);
+    }
+    const firstEol = text.indexOf('\n');
+    const firstLine = firstEol === -1 ? text : text.slice(0, firstEol);
+    return HEADING_LINE_RE.test(firstLine) && firstEol !== -1 && firstEol < pos
+        ? firstLine.replace(/^#+ /, '').trim() : null;
+}
 function chunkDocumentInline(docId, text) {
     if (text.length === 0)
         return [];
@@ -21,18 +36,37 @@ function chunkDocumentInline(docId, text) {
     let chunkIndex = 0;
     while (startChar < text.length) {
         let endChar = Math.min(startChar + DEFAULT_CHUNK_SIZE, text.length);
+        let brokeAtHeading = false;
         if (endChar < text.length) {
             const windowStart = Math.max(startChar, endChar - Math.floor(DEFAULT_CHUNK_SIZE * 0.2));
             const window = text.slice(windowStart, endChar);
-            const lastParagraph = window.lastIndexOf('\n\n');
-            if (lastParagraph !== -1)
-                endChar = windowStart + lastParagraph + 2;
+            let h = window.lastIndexOf('\n#');
+            while (h !== -1) {
+                const eol = window.indexOf('\n', h + 1);
+                const line = window.slice(h + 1, eol === -1 ? undefined : eol);
+                if (HEADING_LINE_RE.test(line) && windowStart + h > startChar)
+                    break;
+                h = window.lastIndexOf('\n#', h - 1);
+            }
+            if (h !== -1 && windowStart + h > startChar) {
+                endChar = windowStart + h + 1;
+                brokeAtHeading = true;
+            }
+            else {
+                const lastParagraph = window.lastIndexOf('\n\n');
+                if (lastParagraph !== -1)
+                    endChar = windowStart + lastParagraph + 2;
+            }
         }
-        chunks.push({ chunkId: `${docId}:${chunkIndex}`, docId, text: text.slice(startChar, endChar), startChar, endChar, chunkIndex });
+        let chunkText = text.slice(startChar, endChar);
+        const heading = lastHeadingBefore(text, startChar + 1);
+        if (heading && !HEADING_LINE_RE.test(chunkText.trimStart()))
+            chunkText = `§ ${heading}\n${chunkText}`;
+        chunks.push({ chunkId: `${docId}:${chunkIndex}`, docId, text: chunkText, startChar, endChar, chunkIndex });
         chunkIndex++;
         if (endChar >= text.length)
             break;
-        startChar += Math.max(1, endChar - startChar - DEFAULT_OVERLAP);
+        startChar += brokeAtHeading ? Math.max(1, endChar - startChar) : Math.max(1, endChar - startChar - DEFAULT_OVERLAP);
     }
     return chunks;
 }

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

@@ -149,7 +149,9 @@ async function getBackend(dbPath) {
                     const hf = await import('@huggingface/transformers');
                     // revision must be a git ref — 'main' is the HF default; 'default' 404s and
                     // silently killed embeddings (every search degraded to keyword matching)
-                    const extractor = await hf.pipeline('feature-extraction', BRIDGE_EMBEDDING_MODEL, { revision: 'main' });
+                    // dtype pinned explicitly: transformers.js logs a "dtype not specified"
+                    // warning to the console on every load otherwise (leaks into CLI output).
+                    const extractor = await hf.pipeline('feature-extraction', BRIDGE_EMBEDDING_MODEL, { revision: 'main', dtype: 'fp32' });
                     embeddingGenerator = async (text) => {
                         const output = await extractor(text, { pooling: 'mean', normalize: true });
                         return new Float32Array(output.data);
@@ -167,6 +169,14 @@ async function getBackend(dbPath) {
                 // file lives inside that directory.
                 const dir = getDbPath(dbPath);
                 fs.mkdirSync(dir, { recursive: true });
+                // Origin marker: records which project this data dir belongs to, so
+                // `monomind cleanup --data` can verifiably prune dirs whose project
+                // no longer exists (the dir-name hash is one-way). Best-effort.
+                try {
+                    const originFile = path.join(projectDataDir(), 'origin.json');
+                    fs.writeFileSync(originFile, JSON.stringify({ path: path.resolve(process.cwd()), updatedAt: new Date().toISOString() }) + '\n', 'utf-8');
+                }
+                catch { /* non-fatal */ }
                 const cfg = {
                     databasePath: path.join(dir, 'memory.db'),
                     walMode: true,

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

@@ -99,6 +99,23 @@ export declare class OrgDaemon {
     private autoWake;
     stopOrg(name: string): Promise<void>;
     stopAll(): Promise<void>;
+    private orgMemoryNamespace;
+    /** Store dir for org cross-run memory — inside the org root so the bridge's
+     *  path guard accepts it when the daemon runs from the project (the normal
+     *  case) and test roots stay isolated. */
+    private orgMemoryDbPath;
+    /** The memory bridge's traversal guard silently redirects out-of-tree paths
+     *  to the per-project default store. For an org rooted outside cwd (tests,
+     *  unusual daemon setups) that redirect would write into the WRONG project's
+     *  memory — verify the guard kept our path, and skip org memory otherwise. */
+    private orgMemoryUsable;
+    /** org_recall implementation: search the org's memory namespace via the
+     *  memory bridge (semantic when the local model is available, tokenized
+     *  keyword otherwise). Failures return a message, never throw into the tool. */
+    private recallOrgMemory;
+    /** 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;
     private persistState;
 }
 export {};

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

@@ -75,6 +75,11 @@ export class OrgDaemon {
                 onComplete: (r, outcome, summary) => {
                     bus.emit({ type: 'status', from: r, reason: 'org-complete', msg: `run outcome: ${outcome}`, data: { outcome, summary } });
                 },
+                recall: async (r, q) => {
+                    const answer = await this.recallOrgMemory(name, def, q);
+                    bus.emit({ type: 'status', from: r, reason: 'org-recall', msg: `recall: ${q.slice(0, 80)}`, data: { hits: answer.hits } });
+                    return answer.text;
+                },
                 queryFn: this.opts.queryFn,
             };
             // Supervised session: transient crashes (provider blips, network) restart
@@ -384,8 +389,11 @@ export class OrgDaemon {
         try {
             const events = readRunEvents(this.root, name, org.run);
             if (events.length) {
+                const summary = summarizeRun(events);
                 const { appendFileSync } = await import('node:fs');
-                appendFileSync(historyFile(this.root, name), JSON.stringify(summarizeRun(events)) + '\n', 'utf8');
+                appendFileSync(historyFile(this.root, name), JSON.stringify(summary) + '\n', 'utf8');
+                // Cross-run memory: make this run's outcome recallable by meaning
+                await this.storeRunMemory(name, org.def, org.run, summary);
             }
         }
         catch (err) {
@@ -406,6 +414,87 @@ export class OrgDaemon {
     async stopAll() {
         await Promise.all([...this.orgs.keys()].map(n => this.stopOrg(n)));
     }
+    orgMemoryNamespace(name, def) {
+        return def.run_config.memory_namespace ?? `org:${name}`;
+    }
+    /** Store dir for org cross-run memory — inside the org root so the bridge's
+     *  path guard accepts it when the daemon runs from the project (the normal
+     *  case) and test roots stay isolated. */
+    orgMemoryDbPath() {
+        return join(this.root, '.monomind', 'org-memory');
+    }
+    /** The memory bridge's traversal guard silently redirects out-of-tree paths
+     *  to the per-project default store. For an org rooted outside cwd (tests,
+     *  unusual daemon setups) that redirect would write into the WRONG project's
+     *  memory — verify the guard kept our path, and skip org memory otherwise. */
+    async orgMemoryUsable() {
+        try {
+            const { bridgeGetDbPath } = await import('../memory/memory-bridge.js');
+            const want = this.orgMemoryDbPath();
+            const got = bridgeGetDbPath(want);
+            const { realpathSync } = await import('node:fs');
+            const real = (p) => { try {
+                return realpathSync(p);
+            }
+            catch {
+                return p;
+            } };
+            return real(got) === real(want);
+        }
+        catch {
+            return false;
+        }
+    }
+    /** org_recall implementation: search the org's memory namespace via the
+     *  memory bridge (semantic when the local model is available, tokenized
+     *  keyword otherwise). Failures return a message, never throw into the tool. */
+    async recallOrgMemory(name, def, query) {
+        try {
+            if (!(await this.orgMemoryUsable()))
+                return { text: 'org memory is not available in this environment.', hits: 0 };
+            const { bridgeSearchEntries } = await import('../memory/memory-bridge.js');
+            const res = await bridgeSearchEntries({
+                query, namespace: this.orgMemoryNamespace(name, def), limit: 5, dbPath: this.orgMemoryDbPath(),
+            });
+            const results = res?.results ?? [];
+            if (!results.length)
+                return { text: 'No matching org memory found — this may be the first run covering this topic.', hits: 0 };
+            const text = results.map((r, i) => `${i + 1}. [${r.key}] ${r.content}`).join('\n\n');
+            return { text, hits: results.length };
+        }
+        catch (err) {
+            return { text: `org memory 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) {
+        try {
+            if (!(await this.orgMemoryUsable()))
+                return;
+            const { bridgeStoreEntry } = await import('../memory/memory-bridge.js');
+            const when = summary.endedAt ? new Date(summary.endedAt).toISOString().slice(0, 10) : '';
+            const lines = [
+                `Org run ${run}${when ? ` (${when})` : ''} — goal: ${def.goal}`,
+                summary.outcome
+                    ? `Outcome: ${summary.outcome.status} — ${summary.outcome.summary}`
+                    : `Outcome: not recorded (${summary.messages} messages exchanged)`,
+                summary.assets.length ? `Assets produced: ${summary.assets.slice(0, 10).join(', ')}` : '',
+                summary.crashes.length ? `Crashed agents: ${summary.crashes.join(', ')}` : '',
+            ].filter(Boolean);
+            await bridgeStoreEntry({
+                key: `run-${run}`,
+                value: lines.join('\n'),
+                namespace: this.orgMemoryNamespace(name, def),
+                dbPath: this.orgMemoryDbPath(),
+                upsert: true,
+            });
+        }
+        catch (err) {
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error(`org ${name}: run memory store failed:`, err instanceof Error ? err.message : err);
+        }
+    }
     persistState(name, status, run) {
         const p = join(this.root, ORG_DIR, name, 'runtime.json');
         writeFileSync(p, JSON.stringify({ status, run, pid: process.pid, updated: new Date().toISOString() }, null, 2));

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

@@ -15,6 +15,8 @@ export interface SessionOpts {
     askHuman?: (role: string, question: string) => Promise<string>;
     /** Coordinator-only: records the run's outcome (daemon persists it to run history). */
     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>;
     def?: OrgDef;
     maxTurns?: number;
     queryFn?: typeof query;

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

@@ -14,6 +14,7 @@ export function buildRolePrompt(role, def, roster) {
         `The ONLY way to communicate with other agents is the org_send tool.`,
         `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.`,
         `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.`
@@ -52,6 +53,10 @@ async function runOneSession(opts) {
         name: 'org',
         version: '1.0.0',
         tools: [
+            ...(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 }] };
+                })] : []),
             ...(isCoordinator && opts.onComplete ? [tool('org_complete', 'Record the outcome of this run. Call exactly once, when the goal is achieved or clearly cannot be. The outcome and summary are persisted to the org run history and briefed to the next run.', { outcome: z.enum(['achieved', 'partial', 'failed']), summary: z.string() }, async (args) => {
                     opts.onComplete(role.id, args.outcome, args.summary);
                     return { content: [{ type: 'text', text: `outcome "${args.outcome}" recorded` }] };

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

@@ -1013,6 +1013,31 @@ export async function startServer({ port = 4242, projectDir, openBrowser = true
   // (not per-request inside the request handler below) since both only
   // close over per-server-start state (dashboardAuthValue) plus their
   // explicit req/res/corsOrigin params. ──────────────────────────────────
+  // ── Second Brain warm bridge: lazy singleton import of the compiled memory
+  // bridge (loads the local embedding model once for the server's lifetime).
+  // Boot-warmed below only when this project actually has a knowledge base.
+  let _knowledgeBridgePromise = null;
+  const _getKnowledgeBridge = () => {
+    if (!_knowledgeBridgePromise) {
+      _knowledgeBridgePromise = import('../memory/memory-bridge.js').catch((err) => {
+        _knowledgeBridgePromise = null; // allow retry on next request
+        if (process.env.MONOMIND_DEBUG) console.error('[knowledge] bridge import failed:', err.message);
+        return null;
+      });
+    }
+    return _knowledgeBridgePromise;
+  };
+  try {
+    if (fs.existsSync(path.join(projectDir || process.cwd(), '.monomind', 'knowledge', 'chunks.jsonl'))) {
+      // Warm off the startup path: first hook request should hit a hot model.
+      const _warmTimer = setTimeout(() => {
+        _getKnowledgeBridge().then(b => b?.bridgeSearchEntries?.({ query: 'warmup', namespace: 'knowledge:shared', limit: 1 }))
+          .catch(() => { /* warm-up is best-effort */ });
+      }, 3000);
+      if (_warmTimer.unref) _warmTimer.unref();
+    }
+  } catch (_) { /* non-fatal */ }
+
   const _checkAuth = (req) => {
     let _suppliedAuth = req.headers['x-monomind-token'] || '';
     if (!_suppliedAuth) {
@@ -5888,6 +5913,46 @@ new Sigma(g,document.getElementById('g'),{renderEdgeLabels:false,labelColor:{col
       return;
     }
 
+    // POST /api/knowledge/search — warm semantic knowledge search for hooks.
+    // The dashboard server is the one long-lived process on the machine, so it
+    // holds the local embedding model warm; per-prompt hook subprocesses (which
+    // cannot afford a model load) POST here and fall back to keyword scoring
+    // when this endpoint is cold/absent. Fully local — model + store on disk.
+    if (req.method === 'POST' && url === '/api/knowledge/search') {
+      let body = '';
+      req.on('data', c => { body += c; });
+      req.on('end', async () => {
+        try {
+          const payload = JSON.parse(body || '{}');
+          const query = String(payload.query || '').slice(0, 2000);
+          const limit = Math.min(Math.max(parseInt(payload.limit, 10) || 3, 1), 10);
+          const namespace = typeof payload.namespace === 'string' && /^[A-Za-z0-9:_-]{1,128}$/.test(payload.namespace)
+            ? payload.namespace : 'knowledge:shared';
+          if (!query) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end('{"error":"query required"}');
+            return;
+          }
+          const bridge = await _getKnowledgeBridge();
+          if (!bridge) {
+            res.writeHead(503, { 'Content-Type': 'application/json' });
+            res.end('{"error":"knowledge bridge unavailable"}');
+            return;
+          }
+          const out = await bridge.bridgeSearchEntries({ query, namespace, limit });
+          res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
+          res.end(JSON.stringify({
+            method: out?.searchMethod || 'none',
+            results: (out?.results || []).map(r => ({ key: r.key, content: String(r.content || '').slice(0, 2000), score: r.score })),
+          }));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+      });
+      return;
+    }
+
     // GET /api/mastermind/metrics — aggregate system metrics from token-summary and swarm-activity
     if (req.method === 'GET' && url === '/api/mastermind/metrics') {
       try {
@@ -6260,6 +6325,16 @@ new Sigma(g,document.getElementById('g'),{renderEdgeLabels:false,labelColor:{col
   const boundPort = await bindServer(server, port);
   const url = `http://localhost:${boundPort}`;
 
+  // Self-report the ACTUAL bound port for the spawner (control-start.cjs).
+  // An HTTP probe cannot distinguish this server from another project's server
+  // already answering on the requested port — this file is identity-proof.
+  if (process.env.MONOMIND_BOUND_REPORT) {
+    try {
+      fs.mkdirSync(path.dirname(process.env.MONOMIND_BOUND_REPORT), { recursive: true });
+      fs.writeFileSync(process.env.MONOMIND_BOUND_REPORT, JSON.stringify({ pid: process.pid, port: boundPort, ts: Date.now() }));
+    } catch (_) { /* non-fatal — spawner falls back to pid-matched HTTP probe */ }
+  }
+
   // ── One-time migration: mastermind-sessions.json → per-session JSONL ─────
   // Runs once on startup. Existing sessions in the old monolithic format are
   // split into individual JSONL files + _index.json for O(1) event writes.

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

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