monomind 2.5.1 → 2.5.2

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

@@ -44,6 +44,29 @@ export async function checkMemoryDatabase() {
     }
     return { name: 'Memory Database', status: 'warn', message: 'Not initialized', fix: 'monomind memory configure --backend hybrid' };
 }
+/** Memory knowledge graph (cognee port): entities/relations/rules distilled
+ * from sessions and org runs. Informational — an empty graph on a fresh
+ * project is normal, so it never fails. */
+export async function checkMemoryKnowledgeGraph() {
+    const name = 'Memory Knowledge Graph';
+    try {
+        const kg = await import('../memory/memory-kg.js');
+        const bridge = await import('../memory/memory-bridge.js');
+        const project = await kg.kgStats();
+        const orgDb = join(process.cwd(), '.monomind', 'org-memory');
+        const org = existsSync(orgDb) ? await kg.kgStats({ dbPath: orgDb }) : null;
+        await bridge.shutdownBridge().catch(() => { });
+        const total = project.nodes + (org?.nodes ?? 0);
+        const fmt = (s) => `${s.nodes}n/${s.edges}e/${s.rules}r`;
+        if (total === 0) {
+            return { name, status: 'warn', message: 'Empty — sessions/org runs have not distilled knowledge yet', fix: 'org runs call org_learn automatically; sessions use memory_kg_ingest' };
+        }
+        return { name, status: 'pass', message: `project ${fmt(project)}${org ? ` · org ${fmt(org)}` : ''}` };
+    }
+    catch (err) {
+        return { name, status: 'warn', message: `Check failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
 /** 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. */

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, checkSecondBrainModel, } from './doctor-project-checks.js';
+import { checkConfigFile, checkMemoryDatabase, checkApiKeys, checkMcpServers, checkMonograph, checkMonographFreshness, checkMonoesMemory, checkHelpersFresh, fixStaleHelpers, checkMonoesIntegration, checkGuidanceGates, checkGitignoreCoverage, checkAgentRegistry, checkMemoryProficiency, checkMetricsFreshness, checkSecurityAuditFindings, checkSecondBrainModel, checkMemoryKnowledgeGraph, } from './doctor-project-checks.js';
 import { checkMonoesTools, fixMonoesTools } from './doctor-monoes-checks.js';
 function formatCheck(check) {
     const icon = check.status === 'pass' ? output.success('✓') :
@@ -65,7 +65,7 @@ export const doctorCommand = {
             checkMonograph, checkMonoesMemory, checkHelpersFresh, checkMonoesIntegration,
             checkGuidanceGates, checkAgentRegistry, checkGit, checkApiKeys,
             checkMemoryProficiency, checkMetricsFreshness, checkSecurityAuditFindings,
-            checkSecondBrainModel,
+            checkSecondBrainModel, checkMemoryKnowledgeGraph,
         ];
         const codeOnlyChecks = [
             checkGitRepo, checkMcpServers,
@@ -79,7 +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,
+            'second-brain': checkSecondBrainModel, kg: checkMemoryKnowledgeGraph,
             typescript: checkBuildTools, monograph: checkMonograph,
             'graph-freshness': checkMonographFreshness, 'memory-pkg': checkMonoesMemory,
             helpers: checkHelpersFresh, monoes: checkMonoesIntegration,

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

@@ -73,10 +73,21 @@ const runAction = async (ctx) => {
             const { buildRolePrompt } = await import('../orgrt/session.js');
             const roster = def.roles.map(r => r.id);
             const perRole = Math.floor((def.run_config.budget_tokens ?? 1_000_000) / def.roles.length);
+            // Same KG entity glossary the live daemon injects — the preview must
+            // match what sessions actually receive.
+            const glossary = await (async () => {
+                try {
+                    const kg = await import('../memory/memory-kg.js');
+                    return await kg.kgGlossary({ dbPath: join(process.cwd(), '.monomind', 'org-memory') });
+                }
+                catch {
+                    return [];
+                }
+            })();
             log(output.info(`DRY RUN — org ${name}: ${def.roles.length} roles, ${perRole} tokens each, goal: ${taskFlag ?? def.goal}`));
             for (const role of def.roles) {
                 log(output.info(`\n─── ${role.id} (${role.title || role.type})${role.adapter_config?.model ? ` [${role.adapter_config.model}]` : ''} ───`));
-                log(buildRolePrompt(role, { name: def.name, goal: taskFlag ?? def.goal }, roster));
+                log(buildRolePrompt(role, { name: def.name, goal: taskFlag ?? def.goal }, roster, glossary));
             }
             return { success: true, message: 'dry run complete — no sessions started' };
         }
@@ -107,15 +118,20 @@ const runAction = async (ctx) => {
         return { success: false, message: 'org start failed' };
     }
     log(output.info(`org ${name} running (${running.def.roles.length} agents, run ${running.run}) — Ctrl-C or "monomind org stop ${name}" to stop`));
-    // stopfile poll lets `org stop` work from another terminal;
-    // clear any stale stopfile from a previous run before polling
+    // stopfile poll lets `org stop` work from another terminal; the daemon can
+    // also stop the org itself (boss called org_complete, or the idle watchdog
+    // fired) — detect that via getOrg() so the CLI exits instead of polling a
+    // stopfile forever after a finished run. Clear any stale stopfile from a
+    // previous run before polling.
     clearStopfile(ctx.cwd, name);
     const stopfile = join(ctx.cwd, ORG_DIR, name, 'stop');
     await new Promise(resolvePromise => {
-        const iv = setInterval(() => { if (existsSync(stopfile)) {
-            clearInterval(iv);
-            resolvePromise();
-        } }, 2000);
+        const iv = setInterval(() => {
+            if (existsSync(stopfile) || !daemon.getOrg(name)) {
+                clearInterval(iv);
+                resolvePromise();
+            }
+        }, 2000);
         process.once('SIGINT', () => { clearInterval(iv); resolvePromise(); });
         process.once('SIGTERM', () => { clearInterval(iv); resolvePromise(); });
     });
@@ -291,7 +307,18 @@ const listAction = async (ctx) => {
             const sched = def.schedule ? `every ${def.schedule}` : 'manual';
             let status = 'never run';
             try {
-                status = JSON.parse(readFileSync(join(orgsDir, stem, 'runtime.json'), 'utf8')).status ?? status;
+                const rt = JSON.parse(readFileSync(join(orgsDir, stem, 'runtime.json'), 'utf8'));
+                status = rt.status ?? status;
+                // Same liveness rule as `org status`: a 'running' record with a dead
+                // pid is a crashed daemon, not a running org — list must not disagree.
+                if (status === 'running' && rt.pid) {
+                    try {
+                        process.kill(rt.pid, 0);
+                    }
+                    catch {
+                        status = 'crashed';
+                    }
+                }
             }
             catch { /* no runtime state yet */ }
             const goal = typeof def.goal === 'string' && def.goal
@@ -381,7 +408,16 @@ const markCompleteAction = async (ctx) => {
     }
     catch { /* default */ }
     try {
-        const res = await fetch(`${ctrlUrl}/api/orgs/${encodeURIComponent(orgName)}/mark-complete`, { method: 'POST' });
+        // All dashboard /api routes are auth-gated — attach the local session token.
+        let auth = '';
+        try {
+            auth = readFileSync(join(cwd, '.monomind', 'dashboard-token'), 'utf8').trim();
+        }
+        catch { /* server may be pre-auth */ }
+        const res = await fetch(`${ctrlUrl}/api/orgs/${encodeURIComponent(orgName)}/mark-complete`, {
+            method: 'POST',
+            headers: auth ? { 'x-monomind-token': auth } : {},
+        });
         const body = await res.json().catch(() => ({}));
         if (!res.ok) {
             log(output.error(`mark-complete failed (${res.status}): ${body.error || 'unknown error'}`));
@@ -489,6 +525,70 @@ export const orgCommand = {
                 return reportAction(ctx, v.name);
             },
         },
+        {
+            name: 'memory', description: 'Inspect an org\'s cross-run memory and knowledge graph (stats | search <query> | rules | rollback <run-ref>)',
+            examples: [
+                { command: 'monomind org memory growth stats', description: 'KG size and namespaces' },
+                { command: 'monomind org memory growth search "launch checklist"', description: 'Search org memory + KG' },
+                { command: 'monomind org memory growth rollback run:m4x2', description: 'Delete everything one run wrote to the KG' },
+            ],
+            action: async (ctx) => {
+                const v = validateOrgName(ctx.args[0]);
+                if (!v.ok)
+                    return v.result;
+                const sub = String(ctx.args[1] ?? 'stats');
+                const { join } = await import('node:path');
+                const dbPath = join(process.cwd(), '.monomind', 'org-memory');
+                const kg = await import('../memory/memory-kg.js');
+                const bridge = await import('../memory/memory-bridge.js');
+                try {
+                    if (sub === 'stats') {
+                        const [stats, glossary, backend] = await Promise.all([
+                            kg.kgStats({ dbPath }), kg.kgGlossary({ dbPath, limit: 15 }), bridge.bridgeGetBackendStats(dbPath),
+                        ]);
+                        log(output.info(`Knowledge graph: ${stats.nodes} entities, ${stats.edges} relations, ${stats.rules} rules`));
+                        if (glossary.length)
+                            log(output.info(`Top entities: ${glossary.join(', ')}`));
+                        const byNs = backend?.entriesByNamespace ?? {};
+                        for (const [ns, count] of Object.entries(byNs))
+                            log(output.info(`  ${ns}: ${count} entries`));
+                        return { success: true, message: 'org memory stats', data: { ...stats, namespaces: byNs } };
+                    }
+                    if (sub === 'search') {
+                        const q = ctx.args.slice(2).join(' ');
+                        if (!q)
+                            return { success: false, message: 'usage: org memory <org> search <query>' };
+                        const [mem, graph] = await Promise.all([
+                            bridge.bridgeSearchEntries({ query: q, namespace: `org:${v.name}`, limit: 5, dbPath }),
+                            kg.kgSearch({ query: q, dbPath, limit: 8 }),
+                        ]);
+                        for (const r of mem?.results ?? [])
+                            log(output.info(`[${r.score.toFixed(2)}] ${r.key}: ${r.content.slice(0, 160)}`));
+                        if (graph.context)
+                            log(output.info(`\nKnowledge graph:\n${graph.context}`));
+                        return { success: true, message: `${(mem?.results ?? []).length} memories, ${graph.triplets.length} triplets` };
+                    }
+                    if (sub === 'rules') {
+                        const rules = await kg.kgListRules({ dbPath, limit: 50 });
+                        for (const r of rules)
+                            log(output.info(`- ${r.rule.slice(0, 200)}`));
+                        return { success: true, message: `${rules.length} rules`, data: { rules } };
+                    }
+                    if (sub === 'rollback') {
+                        const ref = ctx.args[2];
+                        if (!ref)
+                            return { success: false, message: 'usage: org memory <org> rollback <origin-ref> (e.g. run:m4x2)' };
+                        const res = await kg.kgRollback({ originRef: ref, dbPath });
+                        log(output.info(`Rolled back ${ref}: ${res.deleted} deleted, ${res.retained} retained (shared with other origins)`));
+                        return { success: res.success, message: `rollback ${ref}`, data: res };
+                    }
+                    return { success: false, message: `unknown subcommand "${sub}" — use stats | search | rules | rollback` };
+                }
+                finally {
+                    await bridge.shutdownBridge().catch(() => { });
+                }
+            },
+        },
         {
             name: 'questions', description: 'List pending ask_human questions from an org\'s agents',
             options: [{ name: 'all', description: 'Include answered questions', type: 'boolean' }],

package/packages/@monomind/cli/dist/src/init/executor.js

@@ -75,9 +75,11 @@ const SKILLS_MAP = {
         'monolean-help',
         'hive-mind-advanced',
         // The mastermind command files installed by init invoke
-        // Skill("mastermind-skills:*") at runtime — this directory must ship
-        // with core or those references break in user projects.
-        'mastermind-skills',
+        // Skill("mastermind-<name>") at runtime — one top-level
+        // mastermind-<name>/SKILL.md directory per skill. The glob expands in
+        // copySkills against the source tree, so newly added mastermind skills
+        // ship automatically; without them those references break in user projects.
+        'mastermind-*',
     ],
     browser: ['agent-browser-testing'],
     // NOTE: memory-toolkit and github-toolkit are single consolidated skills
@@ -981,6 +983,15 @@ async function copySkills(targetDir, options, result) {
         result.errors.push('Could not find source skills directory');
         return;
     }
+    // Expand glob-style entries ('mastermind-*') against the source tree.
+    // Only directories that actually contain a SKILL.md count — this also
+    // filters exFAT AppleDouble junk (._mastermind-…).
+    for (const entry of skillsToCopy.filter(e => e.endsWith('*'))) {
+        const prefix = entry.slice(0, -1);
+        skillsToCopy.splice(skillsToCopy.indexOf(entry), 1);
+        skillsToCopy.push(...fs.readdirSync(sourceSkillsDir).filter(n => n.startsWith(prefix) &&
+            fs.existsSync(path.join(sourceSkillsDir, n, 'SKILL.md'))));
+    }
     // Remove stale skill directories no longer in the current version's map
     const knownSkills = new Set([...new Set(skillsToCopy)]);
     if (fs.existsSync(targetSkillsDir)) {

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

@@ -19,6 +19,8 @@ export interface BatchIngestResult {
     results: IngestResult[];
 }
 export interface KnowledgeExcerpt {
+    /** Memory entry id — pass back to memory_feedback/bridgeApplyFeedback to rate usefulness. */
+    id: string;
     filePath: string;
     text: string;
     similarity: number;

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

@@ -390,6 +390,7 @@ export async function searchKnowledge(query, opts) {
             // content, and goes empty when a re-ingested file's hash changed.
             const srcTag = (r.tags ?? []).find((tag) => tag.startsWith('src:'));
             return {
+                id: r.id,
                 filePath: srcTag ? srcTag.slice(4) : hashToFile.get(hash) ?? '',
                 text: r.content,
                 similarity: r.score + t.boost,

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

@@ -71,7 +71,7 @@ const knowledgeIngest = {
 };
 const knowledgeSearch = {
     name: 'knowledge_search',
-    description: 'Semantic search over the Second Brain knowledge base. Returns relevant document excerpts ranked by similarity.',
+    description: 'Search the Second Brain. A rule-based router picks the retrieval surfaces per query — document excerpts, knowledge-graph triplets, distilled rules, past memories — and fuses them by reciprocal rank. Excerpt ids can be rated via memory_feedback.',
     category: 'knowledge',
     tags: ['documents', 'search', 'second-brain', 'rag'],
     inputSchema: {
@@ -81,21 +81,52 @@ const knowledgeSearch = {
             scope: { type: 'string', description: 'Knowledge scope (default: shared)' },
             limit: { type: 'number', description: 'Max results (default: 10)' },
             minScore: { type: 'number', description: 'Minimum similarity threshold (default: 0.3)' },
+            surfaces: { type: 'array', items: { type: 'string' }, description: "Override routing: any of 'chunks','kg','rules','memory'" },
         },
         required: ['query'],
     },
     handler: async (input) => {
         const { searchKnowledge } = await import('../knowledge/document-pipeline.js');
+        const { routeQuery, rrfFuse } = await import('../memory/query-router.js');
         try {
-            const excerpts = await searchKnowledge(String(input.query), {
-                scope: input.scope ? String(input.scope) : undefined,
-                limit: input.limit ? Number(input.limit) : undefined,
-                minScore: input.minScore ? Number(input.minScore) : undefined,
-            });
+            const query = String(input.query);
+            const limit = input.limit ? Number(input.limit) : 10;
+            const route = routeQuery(query);
+            const surfaces = Array.isArray(input.surfaces) && input.surfaces.length
+                ? input.surfaces
+                : (route.confident ? route.surfaces : ['chunks', ...route.surfaces.filter(s => s !== 'chunks')]);
+            const bridge = await import('../memory/memory-bridge.js');
+            const kg = await import('../memory/memory-kg.js');
+            const [excerpts, graph, rules, memories] = await Promise.all([
+                surfaces.includes('chunks')
+                    ? searchKnowledge(query, {
+                        scope: input.scope ? String(input.scope) : undefined,
+                        limit,
+                        minScore: input.minScore ? Number(input.minScore) : undefined,
+                    })
+                    : [],
+                surfaces.includes('kg') ? kg.kgSearch({ query, limit: 6 }) : null,
+                surfaces.includes('rules') ? bridge.bridgeSearchEntries({ query, namespace: 'rules', limit: 3, threshold: 0.35 }) : null,
+                surfaces.includes('memory') ? bridge.bridgeSearchEntries({ query, namespace: 'patterns', limit: 3 }) : null,
+            ]);
+            // Rank-fuse heterogeneous lists (raw scores aren't comparable).
+            const fused = rrfFuse([
+                excerpts.map(e => ({ id: e.id || `${e.filePath}#${e.chunkIndex}`, kind: 'excerpt', ...e })),
+                (graph?.triplets ?? []).map((t, i) => ({ id: `kg:${i}:${t.source}|${t.relation}|${t.target}`, kind: 'triplet', ...t })),
+                (rules?.results ?? []).map(r => ({ id: r.id, kind: 'rule', key: r.key, text: r.content, importance: 0.7 })),
+                (memories?.results ?? []).map(r => ({ id: r.id, kind: 'memory', key: r.key, text: r.content })),
+            ], limit);
             return {
                 content: [{
                         type: 'text',
-                        text: JSON.stringify({ success: true, count: excerpts.length, excerpts }),
+                        text: JSON.stringify({
+                            success: true,
+                            count: fused.length,
+                            routing: { surfaces, confident: route.confident },
+                            results: fused,
+                            // Back-compat: excerpt-only view for existing consumers.
+                            excerpts,
+                        }),
                     }],
             };
         }

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

@@ -1,9 +1,9 @@
 /**
  * Memory MCP Tools — Phase 6 of ADR-053
  *
- * Exposes Memory backend operations as MCP tools.
- * Provides direct access to ReasoningBank, CausalGraph, SkillLibrary,
- * AttestationLog, and bridge health through the MCP protocol.
+ * Exposes Memory backend operations as MCP tools: pattern store/search,
+ * usage-weighted feedback (EWMA), the conversation knowledge graph
+ * (memory_kg_*), session records, weight-aware GC, and bridge health.
  *
  * Security: All handlers validate input types, enforce length bounds,
  * and sanitize error messages before returning to MCP callers.
@@ -17,6 +17,11 @@ export declare const memoryPatternStore: MCPTool;
 export declare const memoryPatternSearch: MCPTool;
 export declare const memoryFeedback: MCPTool;
 export declare const memoryCausalEdge: MCPTool;
+export declare const memoryKgIngest: MCPTool;
+export declare const memoryKgSearch: MCPTool;
+export declare const memoryKgRollback: MCPTool;
+export declare const memoryKgConsolidate: MCPTool;
+export declare const memoryKgStats: MCPTool;
 export declare const memoryRoute: MCPTool;
 export declare const memorySessionStart: MCPTool;
 export declare const memorySessionEnd: MCPTool;