monomind 2.3.1 → 2.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "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

@@ -316,6 +316,41 @@ module.exports = {
 
       if (output.length > 0) console.log(output.join('\n'));
 
+      // ── Second Brain: per-request knowledge injection ──────────────────
+      // When the project has an indexed knowledge base, surface the most
+      // relevant excerpts for THIS prompt so Claude has them without having
+      // to decide to call knowledge_search. Keyword-scored over chunks.jsonl
+      // (a hook subprocess can't afford a 1-3s embedding-model load per
+      // prompt; full semantic search stays behind the knowledge_search MCP
+      // tool / `monomind doc search`).
+      // monolean: [keyword-only injection] — upgrade path: warm control-server
+      // endpoint holding the embedding model for semantic per-prompt retrieval.
+      try {
+        var sbPrompt = String(prompt || '');
+        // Skip slash commands and trivial prompts — injection would be noise.
+        if (sbPrompt.length >= 12 && sbPrompt.charAt(0) !== '/') {
+          var sbKnowledgeDir = path.join(CWD, '.monomind', 'knowledge');
+          if (fs.existsSync(path.join(sbKnowledgeDir, 'chunks.jsonl'))) {
+            var sbSearch = hCtx._buildKnowledgeSearchFn(sbKnowledgeDir);
+            var sbHits = await hCtx.runWithTimeout(
+              function() { return sbSearch(sbPrompt, { namespace: 'knowledge:shared', limit: 3, minScore: 0.45 }); },
+              'second-brain-inject'
+            );
+            if (sbHits && sbHits.length > 0) {
+              var sbLines = ['[SECOND_BRAIN] ' + sbHits.length + ' relevant excerpt(s) from the project knowledge base:'];
+              for (var sbI = 0; sbI < sbHits.length; sbI++) {
+                var sbH = sbHits[sbI];
+                var sbSrc = (sbH.metadata && sbH.metadata.filePath) ? String(sbH.metadata.filePath).split('/').slice(-2).join('/') : sbH.key;
+                var sbText = String(sbH.value || '').replace(/\s+/g, ' ').slice(0, 240);
+                sbLines.push('  • [' + sbSrc + '] ' + sbText);
+              }
+              sbLines.push('  (deeper/semantic lookup: mcp__monomind__knowledge_search or `monomind doc search -q "..."`)');
+              console.log(sbLines.join('\n'));
+            }
+          }
+        }
+      } catch (e) { /* non-fatal — knowledge injection must never block a prompt */ }
+
       // Record any decision markers in this prompt (auto-ADR pipeline).
       try { hCtx._recordDecisionMarkers(prompt); } catch (e) {}
 

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

@@ -344,6 +344,65 @@ module.exports = {
       }
     } catch (e) { /* non-fatal */ }
 
+    // Second Brain continuous ingestion — the generated CLAUDE.md promises
+    // "re-indexing happens automatically on session start"; make that true for
+    // user documents, not just the 3 fixed files above. Gated on (a) an active
+    // knowledge base, (b) at least one document newer than the last ingest,
+    // (c) a 30-min rate limit. Detached+unref spawn (same pattern as the
+    // helper-heal block below) — session start never waits on model loading.
+    try {
+      var _kbMetaPath = path.join(CWD, '.monomind', 'knowledge', 'doc-metadata.jsonl');
+      if (fs.existsSync(_kbMetaPath)) {
+        var _kbMetaMtime = fs.statSync(_kbMetaPath).mtimeMs;
+        var _kbMarkerPath = path.join(CWD, '.monomind', 'knowledge', 'reindex-check.json');
+        var _kbLastCheck = 0;
+        try { _kbLastCheck = JSON.parse(fs.readFileSync(_kbMarkerPath, 'utf-8')).ts || 0; } catch (_) {}
+        if (Date.now() - _kbLastCheck > 30 * 60 * 1000) {
+          // Cheap bounded scan: any document changed since the last ingest?
+          var _DOC_EXT = { '.md': 1, '.txt': 1, '.pdf': 1, '.docx': 1 };
+          var _kbDirty = false;
+          var _kbScanned = 0;
+          var _kbWalk = function(dir, depth) {
+            if (_kbDirty || depth > 3 || _kbScanned > 2000) return;
+            var names;
+            try { names = fs.readdirSync(dir); } catch (_) { return; }
+            for (var ni = 0; ni < names.length && !_kbDirty; ni++) {
+              var n = names[ni];
+              if (n.charAt(0) === '.' || n === 'node_modules' || n === 'dist') continue;
+              var p = path.join(dir, n);
+              var st;
+              try { st = fs.statSync(p); } catch (_) { continue; }
+              _kbScanned++;
+              if (st.isDirectory()) { _kbWalk(p, depth + 1); continue; }
+              var ext = path.extname(n).toLowerCase();
+              if (_DOC_EXT[ext] && st.mtimeMs > _kbMetaMtime) _kbDirty = true;
+            }
+          };
+          _kbWalk(CWD, 0);
+          if (_kbDirty) {
+            var _kbMarkerOk = false;
+            try {
+              fs.writeFileSync(_kbMarkerPath, JSON.stringify({ ts: Date.now() }), 'utf-8');
+              _kbMarkerOk = true;
+            } catch (_) {}
+            if (_kbMarkerOk) {
+              var _kbSpawn = require('child_process').spawn;
+              var _kbChild = _kbSpawn('npx', ['-y', 'monomind@latest', 'doc', 'ingest', '.'], {
+                cwd: CWD,
+                detached: true,
+                stdio: 'ignore',
+                env: process.env,
+                shell: process.platform === 'win32',
+                windowsHide: true,
+              });
+              _kbChild.unref();
+              console.log('[KNOWLEDGE_REINDEX] changed documents detected — re-ingesting in background');
+            }
+          }
+        }
+      }
+    } catch (e) { /* non-fatal — reindex must never block session start */ }
+
     // Monograph Context Injection — delegates to shared helper in utils/monograph.cjs.
     injectGodNodesContext(CWD);
 

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

@@ -11,6 +11,20 @@ interface StaleScratchItem {
     description: string;
     size: number;
 }
+/**
+ * Find prunable entries under the per-project data base (default
+ * ~/.monomind/projects). Exported for tests — `baseDir`/`now` injectable.
+ *
+ * Classification per dir:
+ * - `origin.json` present and its recorded path still exists → keep the dir,
+ *   but flag a leftover `lancedb/` subdir (dead since the SQLite engine swap).
+ * - `origin.json` present, recorded path gone → orphaned → prune.
+ * - no `origin.json` (pre-2.3.1 dirs can't prove their origin) → prune only
+ *   when untouched for {@link UNKNOWN_DIR_MAX_AGE_MS} — or immediately with
+ *   `--aggressive`, which treats unprovable dirs as junk (safe: every live
+ *   project rewrites origin.json on its next memory access).
+ */
+export declare function findOrphanedProjectData(baseDir: string, now: number, aggressive: boolean): StaleScratchItem[];
 /**
  * Find stale mastermind scratch under `.monomind/taskdev/` and `.monomind/loops/`.
  * Exported for tests. Never returns `progress.md` (the taskdev recovery ledger),

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

@@ -33,6 +33,63 @@ const KEEP_CONFIG_PATHS = [
 // 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
+/** Orphaned per-project data (--data): ~/.monomind/projects/<slug> dirs whose
+ * source project is gone, plus dead lancedb/ dirs left by the pre-2.3.1 engine. */
+const UNKNOWN_DIR_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+/**
+ * Find prunable entries under the per-project data base (default
+ * ~/.monomind/projects). Exported for tests — `baseDir`/`now` injectable.
+ *
+ * Classification per dir:
+ * - `origin.json` present and its recorded path still exists → keep the dir,
+ *   but flag a leftover `lancedb/` subdir (dead since the SQLite engine swap).
+ * - `origin.json` present, recorded path gone → orphaned → prune.
+ * - no `origin.json` (pre-2.3.1 dirs can't prove their origin) → prune only
+ *   when untouched for {@link UNKNOWN_DIR_MAX_AGE_MS} — or immediately with
+ *   `--aggressive`, which treats unprovable dirs as junk (safe: every live
+ *   project rewrites origin.json on its next memory access).
+ */
+export function findOrphanedProjectData(baseDir, now, aggressive) {
+    const out = [];
+    if (!existsSync(baseDir))
+        return out;
+    for (const name of readdirSync(baseDir)) {
+        if (name.startsWith('.'))
+            continue;
+        const dir = join(baseDir, name);
+        let mtime = 0;
+        try {
+            const st = lstatSync(dir);
+            if (!st.isDirectory())
+                continue;
+            mtime = st.mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        const originFile = join(dir, 'origin.json');
+        let originPath = null;
+        let hasOrigin = false;
+        try {
+            originPath = String(JSON.parse(readFileSync(originFile, 'utf-8')).path ?? '');
+            hasOrigin = originPath.length > 0;
+        }
+        catch { /* no/corrupt marker */ }
+        if (hasOrigin && originPath && existsSync(originPath)) {
+            const lance = join(dir, 'lancedb');
+            if (existsSync(lance))
+                out.push({ path: lance, description: `dead lancedb store (project: ${originPath})`, size: 0 });
+            continue;
+        }
+        if (hasOrigin) {
+            out.push({ path: dir, description: `orphaned project data (origin gone: ${originPath})`, size: 0 });
+        }
+        else if (aggressive || now - mtime > UNKNOWN_DIR_MAX_AGE_MS) {
+            out.push({ path: dir, description: aggressive ? 'unverifiable project data (no origin marker)' : 'unverifiable project data (untouched >30d)', size: 0 });
+        }
+    }
+    return out;
+}
 /**
  * Find stale mastermind scratch under `.monomind/taskdev/` and `.monomind/loops/`.
  * Exported for tests. Never returns `progress.md` (the taskdev recovery ledger),
@@ -208,6 +265,19 @@ export const cleanupCommand = {
             type: 'boolean',
             default: false,
         },
+        {
+            name: 'data',
+            short: 'd',
+            description: 'Prune orphaned per-project data in ~/.monomind/projects (gone projects, dead lancedb stores)',
+            type: 'boolean',
+            default: false,
+        },
+        {
+            name: 'aggressive',
+            description: 'With --data: also prune dirs that cannot prove their origin (pre-2.3.1, no origin marker)',
+            type: 'boolean',
+            default: false,
+        },
     ],
     examples: [
         {
@@ -232,6 +302,35 @@ export const cleanupCommand = {
         const keepConfig = ctx.flags['keep-config'] === true;
         const cwd = ctx.cwd;
         const dryRun = !force;
+        if (ctx.flags.data === true) {
+            const { homedir } = await import('os');
+            const baseDir = join(homedir(), '.monomind', 'projects');
+            output.writeln();
+            output.writeln(output.bold(dryRun ? 'Monomind Project-Data Cleanup (dry run)' : 'Monomind Project-Data Cleanup'));
+            output.writeln();
+            const orphans = findOrphanedProjectData(baseDir, Date.now(), ctx.flags.aggressive === true);
+            if (orphans.length === 0) {
+                output.writeln(output.info('No orphaned project data found.'));
+                return { success: true, message: 'Nothing to clean' };
+            }
+            let removed = 0;
+            for (const o of orphans) {
+                output.writeln(`  ${dryRun ? 'would remove' : 'removing'}: ${o.path}  (${o.description})`);
+                if (!dryRun) {
+                    try {
+                        rmSync(o.path, { recursive: true, force: true });
+                        removed++;
+                    }
+                    catch { /* skip unremovable */ }
+                }
+            }
+            output.writeln();
+            if (dryRun) {
+                output.writeln(output.dim(`  ${orphans.length} item(s). This was a dry run. Use --force to delete.`));
+                return { success: true, message: `Dry run: ${orphans.length} orphaned item(s) found`, data: { found: orphans, dryRun } };
+            }
+            return { success: true, message: `Removed ${removed} orphaned item(s)`, data: { found: orphans, removedCount: removed, dryRun } };
+        }
         if (ctx.flags.scratch === true) {
             const now = Date.now();
             output.writeln();

package/packages/@monomind/cli/dist/src/commands/doctor-project-checks.d.ts

@@ -6,6 +6,10 @@ import type { HealthCheck } from './doctor-env-checks.js';
 export type { HealthCheck };
 export declare function checkConfigFile(): Promise<HealthCheck>;
 export declare function checkMemoryDatabase(): Promise<HealthCheck>;
+/** Second Brain: when this project has an indexed knowledge base, semantic
+ * search needs the local embedding model. Its absence is silent (search
+ * degrades to keyword matching) — surface it here instead. */
+export declare function checkSecondBrainModel(): Promise<HealthCheck>;
 export declare function checkApiKeys(): Promise<HealthCheck>;
 export declare function checkMcpServers(): Promise<HealthCheck>;
 export declare function checkMonograph(): Promise<HealthCheck>;

package/packages/@monomind/cli/dist/src/commands/doctor-project-checks.js

@@ -44,6 +44,31 @@ export async function checkMemoryDatabase() {
     }
     return { name: 'Memory Database', status: 'warn', message: 'Not initialized', fix: 'monomind memory configure --backend hybrid' };
 }
+/** Second Brain: when this project has an indexed knowledge base, semantic
+ * search needs the local embedding model. Its absence is silent (search
+ * degrades to keyword matching) — surface it here instead. */
+export async function checkSecondBrainModel() {
+    const name = 'Second Brain Model';
+    if (!existsSync(join(process.cwd(), '.monomind', 'knowledge', 'chunks.jsonl'))) {
+        return { name, status: 'pass', message: 'No knowledge base in this project (nothing to check)' };
+    }
+    let pkgDir;
+    try {
+        // exports map blocks package.json — resolve the entry file and walk up
+        const entry = await import.meta.resolve?.('@huggingface/transformers');
+        if (!entry)
+            throw new Error('resolver unavailable');
+        pkgDir = fileURLToPath(entry).replace(/\/dist\/.*$/, '');
+    }
+    catch {
+        return { name, status: 'warn', message: '@huggingface/transformers not installed — semantic search degraded to keyword matching', fix: 'reinstall monomind (the model dependency is optional and may have failed to build)' };
+    }
+    const modelCache = join(pkgDir, '.cache', 'Xenova');
+    if (existsSync(modelCache)) {
+        return { name, status: 'pass', message: 'Local embedding model cached — semantic search active' };
+    }
+    return { name, status: 'warn', message: 'Embedding model not downloaded yet — searches use keyword matching until it is', fix: 'run once while online: monomind doc search -q "warmup" (downloads ~90MB locally, one time)' };
+}
 export async function checkApiKeys() {
     const keys = ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY', 'OPENAI_API_KEY'];
     const found = keys.filter(k => process.env[k]);

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

@@ -7,7 +7,7 @@
 import * as path from 'path';
 import { output } from '../output.js';
 import { checkNodeVersion, checkNpmVersion, checkGit, checkGitRepo, checkDiskSpace, checkBuildTools, checkVersionFreshness, checkClaudeCode, installClaudeCode, } from './doctor-env-checks.js';
-import { checkConfigFile, checkMemoryDatabase, checkApiKeys, checkMcpServers, checkMonograph, checkMonographFreshness, checkMonoesMemory, checkHelpersFresh, fixStaleHelpers, checkMonoesIntegration, checkGuidanceGates, checkGitignoreCoverage, checkAgentRegistry, checkMemoryProficiency, checkMetricsFreshness, checkSecurityAuditFindings, } from './doctor-project-checks.js';
+import { checkConfigFile, checkMemoryDatabase, checkApiKeys, checkMcpServers, checkMonograph, checkMonographFreshness, checkMonoesMemory, checkHelpersFresh, fixStaleHelpers, checkMonoesIntegration, checkGuidanceGates, checkGitignoreCoverage, checkAgentRegistry, checkMemoryProficiency, checkMetricsFreshness, checkSecurityAuditFindings, checkSecondBrainModel, } from './doctor-project-checks.js';
 import { checkMonoesTools, fixMonoesTools } from './doctor-monoes-checks.js';
 function formatCheck(check) {
     const icon = check.status === 'pass' ? output.success('✓') :
@@ -65,6 +65,7 @@ export const doctorCommand = {
             checkMonograph, checkMonoesMemory, checkHelpersFresh, checkMonoesIntegration,
             checkGuidanceGates, checkAgentRegistry, checkGit, checkApiKeys,
             checkMemoryProficiency, checkMetricsFreshness, checkSecurityAuditFindings,
+            checkSecondBrainModel,
         ];
         const codeOnlyChecks = [
             checkGitRepo, checkMcpServers,
@@ -78,6 +79,7 @@ export const doctorCommand = {
             node: checkNodeVersion, npm: checkNpmVersion, claude: checkClaudeCode,
             config: checkConfigFile, memory: checkMemoryDatabase,
             api: checkApiKeys, git: checkGit, mcp: checkMcpServers, disk: checkDiskSpace,
+            'second-brain': checkSecondBrainModel,
             typescript: checkBuildTools, monograph: checkMonograph,
             'graph-freshness': checkMonographFreshness, 'memory-pkg': checkMonoesMemory,
             helpers: checkHelpersFresh, monoes: checkMonoesIntegration,

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "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": "*",