monomind 2.7.5 → 2.7.7

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

@@ -1,14 +1,25 @@
 /**
  * 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[];

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,32 +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
- */
 /** Ungated — internal/test use only. MCP clients get `transferTools` below. */
 export const allTransferTools = [
-    // ═══════════════════════════════════════════════════════════════
-    // ANONYMIZATION TOOLS
-    // ═══════════════════════════════════════════════════════════════
     {
         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: {
@@ -74,216 +67,10 @@ export const allTransferTools = [
             }
         },
     },
-    // ═══════════════════════════════════════════════════════════════
-    // 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);
-            }
-        },
-    },
 ];
-// The IPFS pattern-registry tools (ipfs-resolve, store-*) have zero test
-// coverage and no evidence of production use — gated behind
-// MONOMIND_MCP_SPECULATIVE=1. transfer_detect-pii is an unrelated, real PII
-// scanner bundled in this file and stays visible by default.
-const SPECULATIVE = process.env['MONOMIND_MCP_SPECULATIVE'] === '1';
-const CORE_TRANSFER_NAMES = new Set(['transfer_detect-pii']);
-export const transferTools = SPECULATIVE
-    ? allTransferTools
-    : allTransferTools.filter(t => CORE_TRANSFER_NAMES.has(t.name));
+// 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.d.ts

@@ -63,7 +63,11 @@ export declare function bridgeSearchEntries(options: {
         tags?: string[];
     }[];
     searchTime: number;
-    searchMethod?: string;
+    /** What actually ran, never what was requested. 'keyword-fallback' means the
+     *  vector path was attempted and did not produce the results. */
+    searchMethod?: 'semantic' | 'keyword' | 'keyword-fallback';
+    /** Why the vector path did not serve these results (absent when it did). */
+    fallbackReason?: 'no-embedding-model' | 'embedding-failed' | 'no-semantic-matches';
     error?: string;
 } | null>;
 export declare function bridgeListEntries(options: {

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;
@@ -394,7 +406,11 @@ export async function bridgeSearchEntries(options) {
         const startTime = Date.now();
         let results = [];
         let searchMethod = 'keyword';
+        // Reported to callers so "(semantic)" can never be printed over keyword hits.
+        let fallbackReason = _embedder && queryStr.length > 0 ? undefined : 'no-embedding-model';
+        let semanticAttempted = false;
         if (_embedder && queryStr.length > 0) {
+            semanticAttempted = true;
             try {
                 const queryEmbedding = await _embedder(queryStr);
                 const searchResults = await backend.search(queryEmbedding, {
@@ -419,8 +435,14 @@ export async function bridgeSearchEntries(options) {
                     };
                 }).sort((a, b) => b.score - a.score);
                 searchMethod = 'semantic';
+                fallbackReason = undefined;
+            }
+            catch (e) {
+                // fall through to keyword search — but never claim this was semantic
+                fallbackReason = 'embedding-failed';
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[memory-bridge] semantic search failed — falling back to keyword matching:', e);
             }
-            catch { /* fall through to keyword search */ }
         }
         // Keyword fallback — scan all entries in namespace (not just first 100)
         // to avoid missing documents that were ingested later in the batch.
@@ -451,14 +473,22 @@ export async function bridgeSearchEntries(options) {
                     id: e.id,
                     key: e.key,
                     content: e.content || '',
-                    score: Math.min(0.9, 0.3 + score * 0.6),
+                    // Raw token-overlap fraction, NOT rescaled to look like a cosine.
+                    // The old `min(0.9, 0.3 + score*0.6)` floor/ceiling made a weak
+                    // keyword hit outrank a genuine cosine match (0.90 vs 0.63 for the
+                    // same entry) and fed cosine-calibrated gates (memory-kg dedup)
+                    // scores that never came from a vector.
+                    score,
                     namespace: e.namespace,
                     provenance: `keyword:${score.toFixed(2)}`,
                     tags: e.tags ?? [],
                     _createdAt: e.createdAt || 0,
                 }));
             }
-            searchMethod = 'keyword';
+            // The vector path ran and simply matched nothing — still not semantic.
+            searchMethod = semanticAttempted ? 'keyword-fallback' : 'keyword';
+            if (semanticAttempted && !fallbackReason)
+                fallbackReason = 'no-semantic-matches';
         }
         // Filter stale entries based on automem config — skip for knowledge
         // namespaces (documents should remain searchable indefinitely)
@@ -482,6 +512,7 @@ export async function bridgeSearchEntries(options) {
             results,
             searchTime: Date.now() - startTime,
             searchMethod,
+            ...(searchMethod === 'semantic' ? {} : { fallbackReason }),
         };
     }
     catch {

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

@@ -25,6 +25,10 @@ export declare function searchEntries(options: {
         namespace: string;
     }[];
     searchTime: number;
+    /** What actually ran — propagated from the bridge so callers can report the
+     *  real method instead of echoing the requested one. */
+    searchMethod?: 'semantic' | 'keyword' | 'keyword-fallback' | 'hybrid';
+    fallbackReason?: string;
     error?: string;
 }>;
 /**

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

@@ -66,7 +66,8 @@ export async function searchEntries(options) {
             return {
                 success: true,
                 results: filtered,
-                searchTime: Date.now() - startTime
+                searchTime: Date.now() - startTime,
+                searchMethod: 'semantic'
             };
         }
         // Fall back to brute-force SQLite search
@@ -127,7 +128,9 @@ export async function searchEntries(options) {
         return {
             success: true,
             results: results.slice(0, limit),
-            searchTime: Date.now() - startTime
+            searchTime: Date.now() - startTime,
+            // Per-row: cosine when the entry had a vector, keyword overlap otherwise.
+            searchMethod: 'hybrid'
         };
     }
     catch (error) {

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);

package/packages/@monomind/cli/dist/src/routing/route-layer-factory.d.ts

@@ -1,3 +1,18 @@
+/**
+ * Pick the argv prefix used to spawn the embedding worker.
+ *
+ * dist/: `embed-worker.js` exists → `node embed-worker.js <task>`, byte-identical
+ * to the original behaviour, no extra flags, no extra resolution.
+ *
+ * src/ (tsx / vitest): only `embed-worker.ts` exists. Node's
+ * `--experimental-strip-types` cannot run it — the worker imports
+ * `./embedder.js`, and type-stripping does no `.js`→`.ts` extension rewriting,
+ * so it dies with ERR_MODULE_NOT_FOUND. tsx does rewrite, so the source path
+ * runs through tsx's CLI (a devDependency, never needed by dist/).
+ *
+ * Exported for tests.
+ */
+export declare function resolveWorkerArgv(): string[];
 type RouteResult = any;
 export interface ConfiguredRouteLayer {
     route: (taskDescription: string) => Promise<RouteResult>;