monomind 2.5.1 → 2.5.3

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

@@ -88,6 +88,7 @@ const searchDocCommand = {
         { name: 'scope', short: 's', description: 'Knowledge scope (default: shared)', type: 'string', default: 'shared' },
         { name: 'min-score', description: 'Minimum similarity (default: 0.3)', type: 'number', default: 0.3 },
         { name: 'store', description: 'Which store(s): project | global | all (default: all — project results win ties)', type: 'string', default: 'all' },
+        { name: 'surfaces', description: "Override routing: comma list of chunks,kg,rules,memory (default: rule-based router picks)", type: 'string' },
     ],
     examples: [
         { command: 'monomind doc search -q "authentication flow"', description: 'Search project + global brain' },
@@ -100,28 +101,84 @@ const searchDocCommand = {
             return { success: false, exitCode: 1 };
         }
         const { searchKnowledge } = await import('../knowledge/document-pipeline.js');
+        const { routeQuery, rrfFuse, recordRouteOverride } = await import('../memory/query-router.js');
         const storeFlag = String(ctx.flags.store || 'all');
-        const excerpts = await searchKnowledge(query, {
-            scope: String(ctx.flags.scope || 'shared'),
-            limit: Number(ctx.flags.limit || 10),
-            minScore: Number(ctx.flags['min-score'] || 0.3),
-            store: storeFlag === 'project' || storeFlag === 'global' ? storeFlag : 'all',
-        });
-        if (!excerpts.length) {
+        const limit = Number(ctx.flags.limit || 10);
+        // Same surface routing as the MCP knowledge_search tool and the warm
+        // /api/knowledge/search endpoint: the rule-based router picks which
+        // retrieval surfaces to spend queries on; --surfaces overrides it.
+        const route = routeQuery(query);
+        const VALID_SURFACES = ['chunks', 'kg', 'rules', 'memory'];
+        const rawSurfaces = String(ctx.flags.surfaces || '').split(',').map(s => s.trim()).filter(Boolean);
+        const requested = rawSurfaces.filter(s => VALID_SURFACES.includes(s));
+        const invalidSurfaces = rawSurfaces.filter(s => !VALID_SURFACES.includes(s));
+        if (invalidSurfaces.length) {
+            output.writeln(output.dim(`ignoring unknown surface(s): ${invalidSurfaces.join(',')} (valid: ${VALID_SURFACES.join(',')})`));
+        }
+        const surfaces = requested.length
+            ? requested
+            : (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: String(ctx.flags.scope || 'shared'),
+                    limit,
+                    minScore: Number(ctx.flags['min-score'] || 0.3),
+                    store: storeFlag === 'project' || storeFlag === 'global' ? storeFlag : 'all',
+                })
+                : [],
+            surfaces.includes('kg') ? kg.kgSearch({ query, limit: 6 }).catch(() => null) : null,
+            surfaces.includes('rules') ? bridge.bridgeSearchEntries({ query, namespace: 'rules', limit: 3, threshold: 0.35 }).catch(() => null) : null,
+            surfaces.includes('memory') ? bridge.bridgeSearchEntries({ query, namespace: 'patterns', limit: 3 }).catch(() => null) : null,
+        ]);
+        // Confident non-chunk routing against an empty surface (e.g. a project
+        // with no KG yet) must not read as "no knowledge" — fall back to chunks.
+        let fellBack = false;
+        let chunkExcerpts = excerpts;
+        if (!requested.length && !chunkExcerpts.length && !(graph?.triplets?.length) && !(rules?.results?.length) && !(memories?.results?.length) && !surfaces.includes('chunks')) {
+            fellBack = true;
+            recordRouteOverride(surfaces[0], 'chunks');
+            chunkExcerpts = await searchKnowledge(query, {
+                scope: String(ctx.flags.scope || 'shared'),
+                limit,
+                minScore: Number(ctx.flags['min-score'] || 0.3),
+                store: storeFlag === 'project' || storeFlag === 'global' ? storeFlag : 'all',
+            });
+        }
+        const fused = rrfFuse([
+            chunkExcerpts.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, score: r.score, importance: 0.7 })),
+            (memories?.results ?? []).map(r => ({ id: r.id, kind: 'memory', key: r.key, text: r.content, score: r.score })),
+        ], limit);
+        if (!fused.length) {
             output.writeln(output.dim('No results found.'));
             return { success: true, data: [] };
         }
-        output.writeln(output.bold(`${excerpts.length} results:`));
+        output.writeln(output.bold(`${fused.length} results ${output.dim(`(surfaces: ${fellBack ? surfaces.join(',') + ' → chunks fallback' : surfaces.join(',')})`)}:`));
         output.writeln();
-        for (let i = 0; i < excerpts.length; i++) {
-            const ex = excerpts[i];
-            const origin = ex.scope === 'global' ? ` ${output.dim('[global]')}` : '';
-            output.writeln(`${output.highlight(`${i + 1}.`)} ${output.dim(`(${ex.similarity.toFixed(3)})`)} ${ex.filePath || 'unknown'}${origin}`);
-            const preview = ex.text.length > 200 ? ex.text.slice(0, 200) + '...' : ex.text;
-            output.writeln(`   ${output.dim(preview)}`);
+        for (let i = 0; i < fused.length; i++) {
+            const r = fused[i];
+            const n = output.highlight(`${i + 1}.`);
+            if (r.kind === 'triplet') {
+                const fact = r.fact && r.fact !== `${r.source} ${r.relation} ${r.target}` ? ` ${output.dim(`(${String(r.fact).slice(0, 160)})`)}` : '';
+                output.writeln(`${n} ${output.dim('[kg]')} ${r.source} —${r.relation}→ ${r.target}${fact}`);
+            }
+            else if (r.kind === 'rule' || r.kind === 'memory') {
+                output.writeln(`${n} ${output.dim(`[${r.kind}]`)} ${String(r.text || '').replace(/\s+/g, ' ').slice(0, 200)}`);
+            }
+            else {
+                const origin = r.scope === 'global' ? ` ${output.dim('[global]')}` : '';
+                const sim = typeof r.similarity === 'number' ? `(${r.similarity.toFixed(3)}) ` : '';
+                output.writeln(`${n} ${output.dim(sim)}${r.filePath || 'unknown'}${origin}`);
+                const text = String(r.text || '');
+                output.writeln(`   ${output.dim(text.length > 200 ? text.slice(0, 200) + '...' : text)}`);
+            }
             output.writeln();
         }
-        return { success: true, data: excerpts };
+        return { success: true, data: fused };
     },
 };
 const listDocCommand = {

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>;
+/** 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 declare function checkMemoryKnowledgeGraph(): 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. */
@@ -22,7 +26,7 @@ export declare function checkGitignoreCoverage(): Promise<HealthCheck>;
 export declare function checkAgentRegistry(): Promise<HealthCheck>;
 export declare function checkGuidanceGates(): Promise<HealthCheck>;
 /**
- * Worker metrics freshness — reports the age of the @monomind/hooks worker
+ * Worker metrics freshness — reports the age of the @monoes/hooks worker
  * output files (written at session start with a 6h staleness gate, or on
  * demand via `monomind hooks worker run <name>`), so missing/stale worker
  * output is visible without digging through .monomind/metrics.

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. */
@@ -563,7 +586,7 @@ function readMetricsJSON(name) {
     }
 }
 /**
- * Worker metrics freshness — reports the age of the @monomind/hooks worker
+ * Worker metrics freshness — reports the age of the @monoes/hooks worker
  * output files (written at session start with a 6h staleness gate, or on
  * demand via `monomind hooks worker run <name>`), so missing/stale worker
  * output is visible without digging through .monomind/metrics.

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/hooks-workers.d.ts

@@ -1,6 +1,6 @@
 /**
  * Hooks Worker Commands
- * Background worker management (@monomind/hooks workers) + Intelligence command
+ * Background worker management (@monoes/hooks workers) + Intelligence command
  * Extracted from hooks.ts to reduce file size.
  */
 import type { Command } from '../types.js';

package/packages/@monomind/cli/dist/src/commands/hooks-workers.js

@@ -1,6 +1,6 @@
 /**
  * Hooks Worker Commands
- * Background worker management (@monomind/hooks workers) + Intelligence command
+ * Background worker management (@monoes/hooks workers) + Intelligence command
  * Extracted from hooks.ts to reduce file size.
  */
 import { output } from '../output.js';
@@ -414,21 +414,21 @@ export const intelligenceCommand = {
     }
 };
 // =============================================================================
-// Worker Commands (@monomind/hooks WorkerManager)
+// Worker Commands (@monoes/hooks WorkerManager)
 // =============================================================================
 // The old worker subcommands (dispatch/status/detect/cancel) dispatched to a
 // simulated in-memory tracker that fronted the deleted worker daemon. The
-// surviving commands run the real @monomind/hooks workers in-process.
+// surviving commands run the real @monoes/hooks workers in-process.
 const workerListCommand = {
     name: 'list',
-    description: 'List all @monomind/hooks background workers',
+    description: 'List all @monoes/hooks background workers',
     options: [],
     examples: [
         { command: 'monomind hooks worker list', description: 'List all workers' },
     ],
     action: async () => {
         try {
-            const hooks = await import('@monomind/hooks');
+            const hooks = await import('@monoes/hooks');
             const workers = Object.values(hooks.WORKER_CONFIGS).map(w => ({
                 name: w.name,
                 description: w.description,
@@ -478,7 +478,7 @@ const workerRunCommand = {
         const spinner = output.createSpinner({ text: `Running ${name} worker...`, spinner: 'dots' });
         spinner.start();
         try {
-            const hooks = await import('@monomind/hooks');
+            const hooks = await import('@monoes/hooks');
             if (!hooks.WORKER_CONFIGS[name]) {
                 spinner.fail(`Unknown worker: ${name}`);
                 output.writeln(`Available workers: ${Object.keys(hooks.WORKER_CONFIGS).join(', ')}`);
@@ -516,7 +516,7 @@ const workerRunCommand = {
 // Worker parent command
 export const workerCommand = {
     name: 'worker',
-    description: 'Background worker management (@monomind/hooks workers, run in-process)',
+    description: 'Background worker management (@monoes/hooks workers, run in-process)',
     subcommands: [
         workerListCommand,
         workerRunCommand,
@@ -528,7 +528,7 @@ export const workerCommand = {
     ],
     action: async () => {
         output.writeln();
-        output.writeln(output.bold('Background Worker System (@monomind/hooks)'));
+        output.writeln(output.bold('Background Worker System (@monoes/hooks)'));
         output.writeln();
         output.writeln('Workers run in-process and write their results to .monomind/metrics/.');
         output.writeln('The metrics-producing workers (ddd, map, audit, optimize, consolidate)');

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

@@ -215,7 +215,7 @@ const initAction = async (ctx) => {
                 // Audit" as unconfigured, even though nothing is actually broken.
                 try {
                     output.writeln(output.dim('  Seeding worker metrics...'));
-                    const hooksMod = await import('@monomind/hooks').catch(() => null);
+                    const hooksMod = await import('@monoes/hooks').catch(() => null);
                     if (hooksMod && hooksMod.createWorkerManager) {
                         const manager = hooksMod.createWorkerManager(ctx.cwd);
                         await manager.ensureMetricsDir();
@@ -236,7 +236,7 @@ const initAction = async (ctx) => {
                         }
                     }
                     else {
-                        output.writeln(output.dim('  Worker metrics seeding skipped (@monomind/hooks unavailable)'));
+                        output.writeln(output.dim('  Worker metrics seeding skipped (@monoes/hooks unavailable)'));
                     }
                 }
                 catch (e) {

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/index.d.ts

@@ -49,7 +49,7 @@ export declare class CLI {
     private loadConfig;
     /**
      * Initialize optional subsystems at startup (non-blocking, all failures are silent).
-     * Starts the @monomind/hooks WorkerManager, wires SwarmCheckpointer, and builds
+     * Starts the @monoes/hooks WorkerManager, wires SwarmCheckpointer, and builds
      * the unified agent registry so that packages/@monomind/* actually contribute
      * to the live runtime.
      */

package/packages/@monomind/cli/dist/src/index.js

@@ -458,12 +458,12 @@ export class CLI {
     }
     /**
      * Initialize optional subsystems at startup (non-blocking, all failures are silent).
-     * Starts the @monomind/hooks WorkerManager, wires SwarmCheckpointer, and builds
+     * Starts the @monoes/hooks WorkerManager, wires SwarmCheckpointer, and builds
      * the unified agent registry so that packages/@monomind/* actually contribute
      * to the live runtime.
      */
     async initSubsystems() {
-        // NOTE: the @monomind/hooks WorkerManager is intentionally NOT started
+        // NOTE: the @monoes/hooks WorkerManager is intentionally NOT started
         // here. Workers run from the session-restore hook (6h staleness gate) and
         // on demand via `monomind hooks worker run <name>`. Starting it on every
         // CLI invocation scheduled staggered 1-10s timers that usually died with
@@ -510,7 +510,7 @@ export class CLI {
         // could skip the warning even when the underlying issue was present. Doctor
         // runs it synchronously within its own check pass instead, so it's always
         // visible and itemized when you actually look for it.
-        // NOTE: Semantic routing (@monomind/routing) is constructed on-demand by
+        // NOTE: Semantic routing (@monoes/routing) is constructed on-demand by
         // its consumers — `monomind route semantic` (commands/route.ts) and the
         // `hooks_route_semantic` MCP tool (mcp-tools/hooks-routing.ts), both via
         // routing/route-layer-factory.ts. `monomind agent` has no --task flag —

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

@@ -22,9 +22,9 @@ function detectOptionalPackages() {
         }
     };
     _availabilityCache = {
-        hooks: resolvable('@monomind/hooks'),
-        mcp: resolvable('@monomind/mcp'),
-        routing: resolvable('@monomind/routing'),
+        hooks: resolvable('@monoes/hooks'),
+        mcp: resolvable('@monoes/mcp'),
+        routing: resolvable('@monoes/routing'),
         monofence: resolvable('monofence-ai'),
     };
     return _availabilityCache;
@@ -242,7 +242,7 @@ function hooksSystem() {
 | \`intelligence\` | Pattern-learning intelligence system |
 | \`worker\` | Background worker management |
 
-### Background Workers (@monomind/hooks, run in-process)${unavailNote(avail.hooks)}
+### Background Workers (@monoes/hooks, run in-process)${unavailNote(avail.hooks)}
 
 | Worker | Priority | Description |
 |--------|----------|-------------|
@@ -255,7 +255,7 @@ function hooksSystem() {
 | \`performance\`, \`health\`, \`swarm\`, \`git\`, \`learning\`, \`adr\`, \`patterns\`, \`cache\`, \`progress\` | various | See \`hooks worker list\` for the full 15 |
 
 Metrics-producing workers refresh at session start when output is >6h old.
-${avail.hooks ? '' : '\n> \\@monomind/hooks is not resolvable in this install — background workers will fail to load (see `hooks worker list`). This is an install/publish gap, not a project misconfiguration.\n'}
+${avail.hooks ? '' : '\n> \\@monoes/hooks is not resolvable in this install — background workers will fail to load (see `hooks worker list`). This is an install/publish gap, not a project misconfiguration.\n'}
 \`\`\`bash
 npx monomind@latest hooks pre-task --description "[task]"
 npx monomind@latest hooks post-task --task-id "[id]" --success true

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)) {
@@ -1582,7 +1593,7 @@ async function writeCapabilitiesDoc(targetDir, options, result) {
         result.skipped.push('.monomind/CAPABILITIES.md');
         return;
     }
-    const hooksAvailable = _isOptionalPackageResolvable('@monomind/hooks');
+    const hooksAvailable = _isOptionalPackageResolvable('@monoes/hooks');
     const capabilities = `# Monomind - Complete Capabilities Reference
 > Generated: ${new Date().toISOString()}
 > Full documentation: https://github.com/monoes/monomind
@@ -1743,7 +1754,7 @@ npx monomind@latest doctor --fix
 
 ## Hooks System
 
-### 29 Available Hook Subcommands${hooksAvailable ? '' : ' — background workers unavailable in this install (@monomind/hooks did not resolve)'}
+### 29 Available Hook Subcommands${hooksAvailable ? '' : ' — background workers unavailable in this install (@monoes/hooks did not resolve)'}
 
 #### Core Hooks (6)
 | Hook | Description |
@@ -1779,7 +1790,7 @@ npx monomind@latest doctor --fix
 | \`coverage-suggest\` | Improvement suggestions |
 | \`coverage-gaps\` | Gap analysis |
 
-### 15 Background Workers (@monomind/hooks, run in-process)
+### 15 Background Workers (@monoes/hooks, run in-process)
 | Worker | Priority | Purpose |
 |--------|----------|---------|
 | \`performance\` | normal | Benchmark performance |

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

@@ -312,7 +312,9 @@ export async function ingestDirectory(dirPath, scope = 'shared', opts) {
             return;
         }
         for (const entry of entries) {
-            if (entry.name.startsWith('.') || entry.name.startsWith('._'))
+            // Skip dotfiles/dot-dirs (incl. exFAT `._*` junk) — except `.monodesign`,
+            // whose critique snapshots are markdown worth surfacing in the Second Brain.
+            if (entry.name.startsWith('.') && entry.name !== '.monodesign')
                 continue;
             const full = path.join(dir, entry.name);
             if (entry.isDirectory()) {
@@ -390,6 +392,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-server.js

@@ -677,8 +677,8 @@ export class MCPServerManager extends EventEmitter {
         }
         // Dynamically import the MCP server package
         // FIX for issue #942: Use proper package import instead of broken relative path
-        // @ts-ignore — @monomind/mcp is an optional peer resolved at runtime
-        const { createMCPServer } = await import('@monomind/mcp');
+        // @ts-ignore — @monoes/mcp is an optional peer resolved at runtime
+        const { createMCPServer } = await import('@monoes/mcp');
         const logger = {
             debug: (msg, data) => this.emit('log', { level: 'debug', msg, data }),
             info: (msg, data) => this.emit('log', { level: 'info', msg, data }),

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

@@ -4,7 +4,7 @@
  * intelligence stats/learn/attention, and model routing.
  * Extracted from hooks-tools.ts.
  * The simulated worker dispatch/status/detect/cancel tools were deleted with
- * the worker daemon -- real workers live in @monomind/hooks (`hooks worker run`).
+ * the worker daemon -- real workers live in @monoes/hooks (`hooks worker run`).
  */
 import { type MCPTool } from './types.js';
 export declare const hooksIntelligenceReset: MCPTool;

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

@@ -4,7 +4,7 @@
  * intelligence stats/learn/attention, and model routing.
  * Extracted from hooks-tools.ts.
  * The simulated worker dispatch/status/detect/cancel tools were deleted with
- * the worker daemon -- real workers live in @monomind/hooks (`hooks worker run`).
+ * the worker daemon -- real workers live in @monoes/hooks (`hooks worker run`).
  */
 import { existsSync, readdirSync, unlinkSync } from 'fs';
 import { join } from 'path';