monomind 2.7.4 → 2.7.6

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

@@ -980,7 +980,7 @@ export const hooksExplain = {
 // Pretrain hook - repository analysis for intelligence bootstrap
 export const hooksPretrain = {
     name: 'hooks_pretrain',
-    description: 'Analyze repository to bootstrap intelligence (4-step pipeline)',
+    description: 'Walk the repository counting file extensions and directory patterns to seed the keyword router. This is a filesystem scan writing JSON state — despite the name, no model is trained.',
     inputSchema: {
         type: 'object',
         properties: {

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

@@ -26,7 +26,6 @@ export { autopilotTools } from './autopilot-tools.js';
 export { graphifyTools } from './graphify-tools.js';
 export { monographTools } from './monograph-tools.js';
 export { terminalTools } from './terminal-tools.js';
-export { daaTools } from './daa-tools.js';
 export { browserTools } from './browser-tools.js';
 export { knowledgeTools } from './knowledge-tools.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -26,7 +26,6 @@ export { autopilotTools } from './autopilot-tools.js';
 export { graphifyTools } from './graphify-tools.js';
 export { monographTools } from './monograph-tools.js';
 export { terminalTools } from './terminal-tools.js';
-export { daaTools } from './daa-tools.js';
 export { browserTools } from './browser-tools.js';
 export { knowledgeTools } from './knowledge-tools.js';
 //# sourceMappingURL=index.js.map

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

@@ -6,7 +6,7 @@
  */
 import { join, resolve, sep } from 'path';
 import { execSync } from 'child_process';
-import { statSync } from 'fs';
+import { statSync, readdirSync, existsSync } from 'fs';
 import { randomUUID } from 'crypto';
 import { getProjectCwd } from './types.js';
 let _cachedDbPath;
@@ -2108,7 +2108,6 @@ const monographDeadCodeTool = {
     },
 };
 function findStaleDist(repoPath) {
-    const { readdirSync, existsSync } = require('fs');
     const distSrc = join(repoPath, 'dist', 'src');
     const src = join(repoPath, 'src');
     // Scan a single package for stale dist artifacts

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

@@ -201,7 +201,7 @@ export const neuralTools = [
     },
     {
         name: 'neural_patterns',
-        description: 'Get or manage neural patterns',
+        description: 'List, inspect, or delete entries in the stored pattern set (CRUD over the embedding-backed pattern store — no model or network involved)',
         category: 'neural',
         inputSchema: {
             type: 'object',

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

@@ -374,12 +374,25 @@ export const sessionTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                sessionId: { type: 'string', description: 'Session ID' },
+                sessionId: { type: 'string', description: 'Session ID (defaults to the most recently saved session)' },
+                includeStats: { type: 'boolean', description: 'Include per-session statistics in the response' },
             },
-            required: ['sessionId'],
+            // `sessionId` is deliberately NOT required — it defaults to the most
+            // recent session, which is what the `session current` CLI subcommand
+            // asks for. It used to be declared required while the CLI called this
+            // tool with no id at all; nothing enforced the declaration, so instead
+            // of an error the undefined id reached getSessionPath(), threw a
+            // TypeError on `.replace`, and was swallowed by loadSession()'s catch.
+            // The net effect was that `session current` could never succeed — it
+            // always reported "Session not found".
         },
         handler: async (input) => {
-            const sessionId = input.sessionId;
+            const sessionId = input.sessionId
+                ?? listSessions()
+                    .sort((a, b) => new Date(b.savedAt).getTime() - new Date(a.savedAt).getTime())[0]?.sessionId;
+            if (!sessionId) {
+                return { sessionId: null, error: 'No saved sessions found' };
+            }
             const session = loadSession(sessionId);
             if (session) {
                 const path = getSessionPath(sessionId);

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

@@ -56,7 +56,7 @@ const VALID_TOPOLOGIES = new Set([
 export const swarmTools = [
     {
         name: 'swarm_init',
-        description: 'Initialize a swarm with persistent state tracking',
+        description: 'Record a swarm topology/strategy in persistent state. This writes a JSON state file — it does not start any process, thread, or agent. Actual concurrent work only happens when the caller separately dispatches subagents with Claude Code\'s Task tool.',
         category: 'swarm',
         inputSchema: {
             type: 'object',
@@ -193,7 +193,7 @@ export const swarmTools = [
     },
     {
         name: 'swarm_scale',
-        description: 'Scale a swarm to a target agent count by spawning or terminating agents',
+        description: 'Adjust the number of agent records in a swarm\'s persistent state to a target count. Adds or removes bookkeeping entries only — no process is started or stopped.',
         category: 'swarm',
         inputSchema: {
             type: 'object',

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

@@ -1,14 +1,27 @@
 /**
  * Transfer MCP Tools
- * Pattern sharing via IPFS-based decentralized registry
+ *
+ * Only the PII scanner remains. The IPFS pattern-marketplace tools that used to
+ * live here (`transfer_ipfs-resolve`, `transfer_store-search`, `-info`,
+ * `-download`, `-featured`, `-trending`) were deleted along with the ~4,600-line
+ * `src/transfer/{store,ipfs,storage,models,serialization}` subtree they wrapped.
+ *
+ * They were unreachable three ways over: gated out of the default MCP surface,
+ * exposed on a CLI path the dispatcher cannot reach (`hooks transfer store …`
+ * is four levels deep; the dispatcher handles three), and pointed at a registry
+ * whose bootstrap config carried the placeholder `publicKey:
+ * 'ed25519:monomind-registry-key'` rather than a real key.
+ *
+ * `transfer_detect-pii` is unrelated to all of that — it is a real regex PII
+ * scanner over `src/transfer/anonymization/`, which has no store or IPFS
+ * dependency, and it stays visible by default.
  *
  * @module @monomind/cli/mcp-tools/transfer-tools
- * @version 3.0.0
+ * @version 4.0.0
  */
 import type { MCPTool } from './types.js';
-/**
- * Transfer MCP tools for pattern export, import, anonymization, and sharing
- */
+/** Ungated — internal/test use only. MCP clients get `transferTools` below. */
+export declare const allTransferTools: MCPTool[];
 export declare const transferTools: MCPTool[];
 export default transferTools;
 //# sourceMappingURL=transfer-tools.d.ts.map

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

@@ -1,9 +1,23 @@
 /**
  * Transfer MCP Tools
- * Pattern sharing via IPFS-based decentralized registry
+ *
+ * Only the PII scanner remains. The IPFS pattern-marketplace tools that used to
+ * live here (`transfer_ipfs-resolve`, `transfer_store-search`, `-info`,
+ * `-download`, `-featured`, `-trending`) were deleted along with the ~4,600-line
+ * `src/transfer/{store,ipfs,storage,models,serialization}` subtree they wrapped.
+ *
+ * They were unreachable three ways over: gated out of the default MCP surface,
+ * exposed on a CLI path the dispatcher cannot reach (`hooks transfer store …`
+ * is four levels deep; the dispatcher handles three), and pointed at a registry
+ * whose bootstrap config carried the placeholder `publicKey:
+ * 'ed25519:monomind-registry-key'` rather than a real key.
+ *
+ * `transfer_detect-pii` is unrelated to all of that — it is a real regex PII
+ * scanner over `src/transfer/anonymization/`, which has no store or IPFS
+ * dependency, and it stays visible by default.
  *
  * @module @monomind/cli/mcp-tools/transfer-tools
- * @version 3.0.0
+ * @version 4.0.0
  */
 /**
  * Helper to create MCP tool result
@@ -19,31 +33,11 @@ function createResult(data, isError = false) {
         isError,
     };
 }
-/**
- * Cached PatternStore — initialize() may open IPFS connections, sql.js/WASM,
- * or download registry data. Re-creating on every handler call wastes work
- * and risks file-descriptor / socket-pool leaks on rapid invocations.
- */
-let cachedPatternStore = null;
-async function getPatternStore() {
-    if (cachedPatternStore)
-        return cachedPatternStore;
-    const { PatternStore } = await import('../transfer/store/index.js');
-    const store = new PatternStore();
-    await store.initialize();
-    cachedPatternStore = store;
-    return cachedPatternStore;
-}
-/**
- * Transfer MCP tools for pattern export, import, anonymization, and sharing
- */
-export const transferTools = [
-    // ═══════════════════════════════════════════════════════════════
-    // ANONYMIZATION TOOLS
-    // ═══════════════════════════════════════════════════════════════
+/** Ungated — internal/test use only. MCP clients get `transferTools` below. */
+export const allTransferTools = [
     {
         name: 'transfer_detect-pii',
-        description: 'Detect PII in content without redacting',
+        description: 'Scan content for personally identifiable information with regex patterns and report what was found, without redacting it. Runs locally; no network or registry involved.',
         category: 'transfer',
         version: '1.0.0',
         inputSchema: {
@@ -73,207 +67,10 @@ export const transferTools = [
             }
         },
     },
-    // ═══════════════════════════════════════════════════════════════
-    // IPFS TOOLS
-    // ═══════════════════════════════════════════════════════════════
-    {
-        name: 'transfer_ipfs-resolve',
-        description: 'Resolve IPNS name to CID',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'IPNS name to resolve',
-                },
-            },
-            required: ['name'],
-        },
-        handler: async (input) => {
-            try {
-                const { resolveIPNS } = await import('../transfer/ipfs/client.js');
-                // Cap IPNS name length — uncapped strings may trigger O(n) path parsing
-                // inside the IPFS client or be reflected in error messages.
-                const MAX_IPNS_NAME_LEN = 512;
-                const rawName = input.name;
-                const name = typeof rawName === 'string' && rawName.length > MAX_IPNS_NAME_LEN
-                    ? rawName.slice(0, MAX_IPNS_NAME_LEN) : rawName;
-                const result = await resolveIPNS(name);
-                return createResult({ success: true, cid: result });
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    // ═══════════════════════════════════════════════════════════════
-    // PATTERN STORE TOOLS
-    // ═══════════════════════════════════════════════════════════════
-    {
-        name: 'transfer_store-search',
-        description: 'Search the pattern store',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: {
-                    type: 'string',
-                    description: 'Search query',
-                },
-                category: {
-                    type: 'string',
-                    description: 'Filter by category',
-                },
-                minRating: {
-                    type: 'number',
-                    description: 'Minimum rating',
-                },
-                verified: {
-                    type: 'boolean',
-                    description: 'Only show verified patterns',
-                },
-                limit: {
-                    type: 'number',
-                    description: 'Maximum results',
-                },
-            },
-        },
-        handler: async (input) => {
-            try {
-                const store = await getPatternStore();
-                // Cap query and limit to prevent DoS via large string or result set.
-                const MAX_TRANSFER_QUERY_LEN = 4 * 1024;
-                const MAX_TRANSFER_LIMIT = 500;
-                const inp = input;
-                const cappedInput = {
-                    ...inp,
-                    query: typeof inp.query === 'string' && inp.query.length > MAX_TRANSFER_QUERY_LEN
-                        ? inp.query.slice(0, MAX_TRANSFER_QUERY_LEN) : inp.query,
-                    limit: typeof inp.limit === 'number' && Number.isFinite(inp.limit)
-                        ? Math.min(Math.floor(Math.max(inp.limit, 1)), MAX_TRANSFER_LIMIT) : inp.limit,
-                };
-                const results = store.search(cappedInput);
-                return createResult(results);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    {
-        name: 'transfer_store-info',
-        description: 'Get detailed info about a pattern',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                id: {
-                    type: 'string',
-                    description: 'Pattern ID',
-                },
-            },
-            required: ['id'],
-        },
-        handler: async (input) => {
-            try {
-                const store = await getPatternStore();
-                const pattern = store.getPattern(input.id);
-                if (!pattern) {
-                    return createResult({ error: 'Pattern not found' }, true);
-                }
-                return createResult(pattern);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    {
-        name: 'transfer_store-download',
-        description: 'Download a pattern from the store',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                id: {
-                    type: 'string',
-                    description: 'Pattern ID',
-                },
-                verify: {
-                    type: 'boolean',
-                    description: 'Verify pattern integrity',
-                },
-            },
-            required: ['id'],
-        },
-        handler: async (input) => {
-            try {
-                const store = await getPatternStore();
-                const result = await store.download(input.id, { verify: input.verify });
-                return createResult(result);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    {
-        name: 'transfer_store-featured',
-        description: 'Get featured patterns from the store',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: {
-                    type: 'number',
-                    description: 'Maximum results',
-                },
-            },
-        },
-        handler: async (input) => {
-            try {
-                const store = await getPatternStore();
-                const featured = store.getFeatured();
-                const limit = input.limit || 10;
-                return createResult(featured.slice(0, limit));
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-    {
-        name: 'transfer_store-trending',
-        description: 'Get trending patterns from the store',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: {
-                    type: 'number',
-                    description: 'Maximum results',
-                },
-            },
-        },
-        handler: async (input) => {
-            try {
-                const store = await getPatternStore();
-                const trending = store.getTrending();
-                const limit = input.limit || 10;
-                return createResult(trending.slice(0, limit));
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
 ];
+// Nothing here is gated any more — the speculative IPFS tools this flag used to
+// hide have been deleted outright. The export shape is kept so callers and the
+// category loader continue to work unchanged.
+export const transferTools = allTransferTools;
 export default transferTools;
 //# sourceMappingURL=transfer-tools.js.map

package/packages/@monomind/cli/dist/src/memory/ewc-consolidation.d.ts

@@ -1,21 +1,33 @@
 /**
- * EWC++ (Elastic Weight Consolidation) Implementation
- * Prevents catastrophic forgetting of important patterns during continual learning
+ * EWC-inspired pattern consolidation.
  *
- * Algorithm:
- * L_total = L_new + (lambda/2) * sum_i(F_i * (theta_i - theta_old_i)^2)
+ * Protects high-importance stored patterns from being overwritten by newer,
+ * similar ones — the pattern-store analogue of avoiding catastrophic
+ * forgetting.
  *
- * Where:
- * - L_new is the loss on new data
- * - lambda is the importance weight (ewcLambda)
- * - F_i is the Fisher information for parameter i
- * - theta_i is the current parameter value
- * - theta_old_i is the previous parameter value
+ * HONEST SCOPE — read before extending this:
+ * This is *not* Elastic Weight Consolidation. Real EWC penalises drift in a
+ * model's parameters using Fisher information estimated from training
+ * gradients:
  *
- * Features:
- * - Fisher Information Matrix computation from gradient history
- * - Online EWC updates for streaming patterns
- * - Selective consolidation based on pattern importance
+ *   L_total = L_new + (lambda/2) * sum_i(F_i * (theta_i - theta_old_i)^2)
+ *
+ * There is no model here, no training loop, and therefore no gradients. What
+ * this file actually computes is a per-dimension importance weight from the
+ * *squared embedding values* of stored patterns, used as a stand-in for the
+ * Fisher diagonal (see computeFisherMatrix — the substitution is noted at the
+ * line that performs it), smoothed with an EMA and applied as a quadratic
+ * penalty when a new pattern would displace an existing one.
+ *
+ * That heuristic is real, deterministic, and useful. The EWC name and the
+ * formula above describe the *inspiration*, not the implementation — do not
+ * cite this as an EWC implementation or reason about it as if `F_i` carried
+ * Fisher semantics.
+ *
+ * What it does:
+ * - Per-dimension importance from squared embedding magnitudes (gradient proxy)
+ * - Online EMA updates as new patterns stream in
+ * - Selective consolidation based on that importance
  * - Persistent storage in .swarm/ewc-fisher.json
  *
  * @module v1/cli/memory/ewc-consolidation

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

@@ -1,21 +1,33 @@
 /**
- * EWC++ (Elastic Weight Consolidation) Implementation
- * Prevents catastrophic forgetting of important patterns during continual learning
+ * EWC-inspired pattern consolidation.
  *
- * Algorithm:
- * L_total = L_new + (lambda/2) * sum_i(F_i * (theta_i - theta_old_i)^2)
+ * Protects high-importance stored patterns from being overwritten by newer,
+ * similar ones — the pattern-store analogue of avoiding catastrophic
+ * forgetting.
  *
- * Where:
- * - L_new is the loss on new data
- * - lambda is the importance weight (ewcLambda)
- * - F_i is the Fisher information for parameter i
- * - theta_i is the current parameter value
- * - theta_old_i is the previous parameter value
+ * HONEST SCOPE — read before extending this:
+ * This is *not* Elastic Weight Consolidation. Real EWC penalises drift in a
+ * model's parameters using Fisher information estimated from training
+ * gradients:
  *
- * Features:
- * - Fisher Information Matrix computation from gradient history
- * - Online EWC updates for streaming patterns
- * - Selective consolidation based on pattern importance
+ *   L_total = L_new + (lambda/2) * sum_i(F_i * (theta_i - theta_old_i)^2)
+ *
+ * There is no model here, no training loop, and therefore no gradients. What
+ * this file actually computes is a per-dimension importance weight from the
+ * *squared embedding values* of stored patterns, used as a stand-in for the
+ * Fisher diagonal (see computeFisherMatrix — the substitution is noted at the
+ * line that performs it), smoothed with an EMA and applied as a quadratic
+ * penalty when a new pattern would displace an existing one.
+ *
+ * That heuristic is real, deterministic, and useful. The EWC name and the
+ * formula above describe the *inspiration*, not the implementation — do not
+ * cite this as an EWC implementation or reason about it as if `F_i` carried
+ * Fisher semantics.
+ *
+ * What it does:
+ * - Per-dimension importance from squared embedding magnitudes (gradient proxy)
+ * - Online EMA updates as new patterns stream in
+ * - Selective consolidation based on that importance
  * - Persistent storage in .swarm/ewc-fisher.json
  *
  * @module v1/cli/memory/ewc-consolidation

package/packages/@monomind/cli/dist/src/memory/intelligence.js

@@ -24,7 +24,15 @@ import { readJsonFileSync, writeJsonFileAtomic } from '../utils/json-file.js';
  * falling back to home directory
  */
 function getDataDir() {
-    const cwd = process.cwd();
+    // MONOMIND_CWD is the project root; process.cwd() is wherever the process
+    // happened to start. For a global or MCP install those differ — the server
+    // is launched by the editor, not from the project — so keying the pattern
+    // store off cwd scattered a project's learned patterns across whatever
+    // directory the server booted in (or fell through to ~/.monomind entirely).
+    // Every other consumer resolves the project this way; see getProjectCwd()
+    // in mcp-tools/types.ts. Inlined rather than imported to keep the memory
+    // layer independent of the MCP tool layer.
+    const cwd = process.env.MONOMIND_CWD || process.cwd();
     const localDir = join(cwd, '.monomind', 'neural');
     const homeDir = join(homedir(), '.monomind', 'neural');
     // Prefer local directory if .monomind exists
@@ -1083,6 +1091,14 @@ export function clearIntelligence() {
     sonaCoordinator = null;
     reasoningBank = null;
     intelligenceInitialized = false;
+    // Must be dropped too. initializeIntelligence() returns an existing
+    // initPromise without re-running init, so leaving the resolved promise here
+    // made every later init report success while sonaCoordinator and
+    // reasoningBank stayed null — after which the non-null assertions in
+    // clearAllPatterns()/getAllPatterns() etc. threw
+    // "Cannot read properties of null". Intelligence could never be
+    // re-initialized after a clear, for the life of the process.
+    initPromise = null;
     globalStats = {
         trajectoriesRecorded: 0,
         lastAdaptation: null

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

@@ -178,6 +178,18 @@ async function flushBackend(backend) {
     }
     catch { /* best effort */ }
 }
+/** Loads the local embedding model.
+ *
+ *  This is the single point where `onnxruntime-node` enters the CLI process
+ *  (via @huggingface/transformers). Once it has run, the process is subject to
+ *  docs/adrs/ADR-R001-onnxruntime-process-teardown.md: calling process.exit()
+ *  will abort with SIGABRT ("mutex lock failed") instead of exiting cleanly,
+ *  and disposing the pipeline first does not help.
+ *
+ *  Anything that reaches this — `doctor`, `memory store`, `memory search`, the
+ *  MCP memory tools — inherits that constraint, which is why it bit commands
+ *  that look nothing like ML work. Adding a new caller is fine; adding a new
+ *  process-exit path is not. */
 async function loadEmbedder() {
     if (_embedder)
         return;

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

@@ -2,6 +2,7 @@
 // monolean: single-process inter-org — upgrade path = daemon-to-daemon HTTP when multi-host is real
 import { readFileSync, mkdirSync, writeFileSync, existsSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
+import { reapOrphanedSdkProcesses } from '../utils/resource-governor.js';
 import { OrgBus } from './bus.js';
 import { PolicyEngine } from './policy.js';
 import { Mailbox } from './mailbox.js';
@@ -235,8 +236,11 @@ export class OrgDaemon {
         // monolean: process-scoped listener — upgrade path = per-org tracking
         const crashCleanup = () => {
             try {
-                const rg = require('../utils/resource-governor.js');
-                rg.reapOrphanedSdkProcesses(new Set(), process.pid);
+                // Statically imported: a process 'exit' handler must be synchronous,
+                // so `await import()` is unavailable — and a bare require() throws
+                // "require is not defined" in this ESM package. Guarded by
+                // no-cjs-require-in-esm.test.ts.
+                reapOrphanedSdkProcesses(new Set(), process.pid);
             }
             catch { /* best-effort */ }
         };

package/packages/@monomind/cli/dist/src/routing/embed-worker.js

@@ -56,6 +56,14 @@ async function main() {
     // and the parent's `close` listener waits until it force-kills us at the
     // timeout — discarding the result we already wrote. Force-exit once the
     // write is flushed (same onnx-teardown class as memory.ts's #1428 fix).
+    //
+    // The force-exit is REQUIRED here and FORBIDDEN in the main CLI process,
+    // where the identical thread pool makes process.exit() abort with SIGABRT
+    // instead. Same root cause, opposite fix — see
+    // docs/adrs/ADR-R001-onnxruntime-process-teardown.md before changing either.
+    // Safe here because we are a disposable child that has already flushed its
+    // result, and the parent resolves on the stdout marker rather than our exit
+    // code (route-layer-factory.ts), so even an aborted teardown loses nothing.
     const wroteSynchronously = process.stdout.write(`\n__ROUTE_RESULT__${JSON.stringify(result)}\n`);
     if (wroteSynchronously) {
         process.exit(0);