@monoes/monomindcli 1.10.57 → 1.11.1

package/dist/src/mcp-tools/hooks-tools.js

@@ -5,6 +5,14 @@
 import { mkdirSync, writeFileSync, renameSync, existsSync, readFileSync, statSync, unlinkSync, readdirSync } from 'fs';
 import { dirname, join, resolve, sep } from 'path';
 import { getProjectCwd } from './types.js';
+import { getCapabilities } from '../monovector/capabilities.js';
+import { randomUUID } from 'node:crypto';
+import { recordRoute, joinOutcome, joinLatestUnresolved } from '../monovector/route-outcomes.js';
+import { recordCommand, deriveRecentSuccess } from '../monovector/command-outcomes.js';
+// Base dir for per-route outcome records — sits alongside routing-outcomes.json
+function getRouteOutcomesBaseDir() {
+    return join(getProjectCwd(), '.monomind');
+}
 // Real vector search functions - lazy loaded to avoid circular imports
 let searchEntriesFn = null;
 async function getRealSearchFunction() {
@@ -64,29 +72,6 @@ async function getEWCConsolidator() {
     }
     return ewcConsolidator;
 }
-// MoE Router - lazy loaded
-let moeRouter = null;
-async function getMoERouter() {
-    if (!moeRouter) {
-        try {
-            const { getMoERouter: getMoE } = await import('../ruvector/moe-router.js');
-            moeRouter = await getMoE();
-        }
-        catch {
-            moeRouter = null;
-        }
-    }
-    return moeRouter;
-}
-// Semantic Router - lazy loaded
-// Tries native VectorDb first (16k+ routes/s HNSW), falls back to pure JS (47k routes/s cosine)
-let semanticRouter = null;
-let nativeVectorDb = null;
-let semanticRouterInitialized = false;
-let routerBackend = 'none';
-// Pre-computed embeddings for common task patterns (cached, capped to prevent unbounded growth)
-const MAX_PATTERN_EMBEDDINGS = 2000;
-const TASK_PATTERN_EMBEDDINGS = new Map();
 function generateSimpleEmbedding(text, dimension = 384) {
     // Simple deterministic embedding based on character codes
     // This is for routing purposes where we need consistent, fast embeddings
@@ -125,7 +110,10 @@ function generateSimpleEmbedding(text, dimension = 384) {
 }
 // ── Runtime routing outcome persistence ──────────────────────────────
 // Closes the learning loop: post-task records outcomes → route loads them.
-const ROUTING_OUTCOMES_PATH = join(resolve('.'), '.monomind/routing-outcomes.json');
+// Evaluated lazily via getter so it uses runtime CWD, not import-time CWD
+function getRoutingOutcomesPath() {
+    return join(getProjectCwd(), '.monomind', 'routing-outcomes.json');
+}
 const ROUTING_STOPWORDS = new Set([
     'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had',
     'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'shall', 'can',
@@ -146,8 +134,8 @@ function extractKeywords(text) {
 }
 function loadRoutingOutcomes() {
     try {
-        if (existsSync(ROUTING_OUTCOMES_PATH)) {
-            const data = JSON.parse(readFileSync(ROUTING_OUTCOMES_PATH, 'utf-8'));
+        if (existsSync(getRoutingOutcomesPath())) {
+            const data = JSON.parse(readFileSync(getRoutingOutcomesPath(), 'utf-8'));
             return data.outcomes || [];
         }
     }
@@ -156,14 +144,14 @@ function loadRoutingOutcomes() {
 }
 function saveRoutingOutcomes(outcomes) {
     try {
-        const dir = dirname(ROUTING_OUTCOMES_PATH);
+        const dir = dirname(getRoutingOutcomesPath());
         if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
         // Cap at 500 entries to bound file size
         const capped = outcomes.slice(-500);
-        const tmp = ROUTING_OUTCOMES_PATH + '.tmp';
+        const tmp = getRoutingOutcomesPath() + '.tmp';
         writeFileSync(tmp, JSON.stringify({ outcomes: capped }, null, 2));
-        renameSync(tmp, ROUTING_OUTCOMES_PATH);
+        renameSync(tmp, getRoutingOutcomesPath());
     }
     catch { /* non-critical */ }
 }
@@ -257,107 +245,6 @@ const TASK_PATTERNS = {
         agents: ['memory-specialist', 'architect', 'coder'],
     },
 };
-/**
- * Get the semantic router with environment detection.
- * Tries native VectorDb first (HNSW, 16k routes/s), falls back to pure JS (47k routes/s cosine).
- */
-async function getSemanticRouter() {
-    if (semanticRouterInitialized) {
-        return { router: semanticRouter, backend: routerBackend, native: nativeVectorDb };
-    }
-    semanticRouterInitialized = true;
-    // STEP 1: Try native VectorDb from @ruvector/router (HNSW-backed)
-    // Note: Native VectorDb uses a persistent database file which can have lock issues
-    // in concurrent environments. We try it first but fall back gracefully to pure JS.
-    try {
-        // Use createRequire for ESM compatibility with native modules
-        const { createRequire } = await import('module');
-        const require = createRequire(import.meta.url);
-        const router = require('@ruvector/router');
-        if (router.VectorDb && router.DistanceMetric) {
-            // Try to create VectorDb - may fail with lock error in concurrent envs
-            const db = new router.VectorDb({
-                dimensions: 384,
-                distanceMetric: router.DistanceMetric.Cosine,
-                hnswM: 16,
-                hnswEfConstruction: 200,
-                hnswEfSearch: 100,
-            });
-            // Initialize with static + runtime-learned task patterns
-            for (const [patternName, { keywords }] of Object.entries(getMergedTaskPatterns())) {
-                for (const keyword of keywords) {
-                    const embedding = generateSimpleEmbedding(keyword);
-                    db.insert(`${patternName}:${keyword}`, embedding);
-                    if (TASK_PATTERN_EMBEDDINGS.size < MAX_PATTERN_EMBEDDINGS) {
-                        TASK_PATTERN_EMBEDDINGS.set(`${patternName}:${keyword}`, embedding);
-                    }
-                }
-            }
-            nativeVectorDb = db;
-            routerBackend = 'native';
-            return { router: null, backend: routerBackend, native: nativeVectorDb };
-        }
-    }
-    catch (err) {
-        // Native not available or database locked - fall back to pure JS
-        // Common errors: "Database already open. Cannot acquire lock." or "MODULE_NOT_FOUND"
-        // This is expected in concurrent environments or when binary isn't installed
-    }
-    // STEP 2: Fall back to pure JS SemanticRouter
-    try {
-        const { SemanticRouter } = await import('../ruvector/semantic-router.js');
-        semanticRouter = new SemanticRouter({ dimension: 384 });
-        for (const [patternName, { keywords, agents }] of Object.entries(getMergedTaskPatterns())) {
-            const embeddings = keywords.map(kw => generateSimpleEmbedding(kw));
-            semanticRouter.addIntentWithEmbeddings(patternName, embeddings, { agents, keywords });
-            // Cache embeddings for keywords (capped)
-            keywords.forEach((kw, i) => {
-                if (TASK_PATTERN_EMBEDDINGS.size < MAX_PATTERN_EMBEDDINGS) {
-                    TASK_PATTERN_EMBEDDINGS.set(kw, embeddings[i]);
-                }
-            });
-        }
-        routerBackend = 'pure-js';
-    }
-    catch {
-        semanticRouter = null;
-        routerBackend = 'none';
-    }
-    return { router: semanticRouter, backend: routerBackend, native: nativeVectorDb };
-}
-/**
- * Get router backend info for status display.
- */
-function getRouterBackendInfo() {
-    switch (routerBackend) {
-        case 'native':
-            return { backend: 'native VectorDb (HNSW)', speed: '16k+ routes/s' };
-        case 'pure-js':
-            return { backend: 'pure JS (cosine)', speed: '47k routes/s' };
-        default:
-            return { backend: 'none', speed: 'N/A' };
-    }
-}
-// Flash Attention - lazy loaded
-let flashAttention = null;
-async function getFlashAttention() {
-    if (!flashAttention) {
-        try {
-            const { getFlashAttention: getFlash } = await import('../ruvector/flash-attention.js');
-            flashAttention = await getFlash();
-        }
-        catch {
-            flashAttention = null;
-        }
-    }
-    return flashAttention;
-}
-// LoRA Adapter removed — superseded by SONA instant adaptation
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let loraAdapter = null;
-async function getLoRAAdapter() {
-    return loraAdapter;
-}
 // In-memory trajectory tracking (persisted on end)
 const activeTrajectories = new Map();
 const MEMORY_DIR = '.monomind/memory';
@@ -533,50 +420,12 @@ function suggestAgentsForTask(task) {
 // Canonical set of valid monomind agent type strings.
 // Patterns whose type is not in this set (e.g. 'action', 'observation', 'routing')
 // are structural labels, not agent names, and must be excluded from routing.
-// Singleton neural router — initialized once per process and reused across route calls.
-// Creating + destroying NeuralLearningSystem on every call would read learned-state.json
-// on each invocation and call consolidateEWC() on cleanup, both of which are wrong.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let _neuralRouterInstance = null;
-let _neuralRouterInitPromise = null;
-async function applyNeuralAdaptation(text, dimensions) {
-    if (!_neuralRouterInitPromise) {
-        _neuralRouterInitPromise = (async () => {
-            try {
-                const neural = await import('@monomind/neural').catch(() => null);
-                if (neural?.createNeuralLearningSystem) {
-                    const sys = neural.createNeuralLearningSystem('balanced');
-                    await sys.initialize();
-                    _neuralRouterInstance = sys;
-                }
-            }
-            catch {
-                _neuralRouterInstance = null;
-            }
-        })();
-    }
-    await _neuralRouterInitPromise;
-    if (!_neuralRouterInstance)
-        return null;
-    try {
-        const base = new Float32Array(dimensions);
-        // Use a hash embedding as the base for the LoRA transform
-        const words = text.toLowerCase().split(/\s+/);
-        for (let i = 0; i < dimensions; i++) {
-            let v = 0;
-            for (let w = 0; w < words.length; w++) {
-                for (let c = 0; c < words[w].length; c++) {
-                    v += Math.sin((words[w].charCodeAt(c) * (i + 1) + w * 17) * 0.0137);
-                }
-            }
-            base[i] = v;
-        }
-        return await _neuralRouterInstance.getSONAManager().applyAdaptations(base);
-    }
-    catch {
-        return null;
-    }
-}
+//
+// Lean teardown: the SONA neural LoRA routing adaptation (applyNeuralAdaptation +
+// the @monomind/neural NeuralLearningSystem singleton) has been removed. Routing now
+// uses the pure keyword path plus the deterministic generateSimpleEmbedding query
+// against the pattern index, with outcomes recorded via route-outcomes. No ONNX /
+// LoRA inference happens on the routing hot path anymore.
 const VALID_AGENT_TYPES = new Set([
     'coder', 'reviewer', 'tester', 'planner', 'researcher',
     'architect', 'security-architect', 'security-auditor',
@@ -712,6 +561,9 @@ export const hooksPostEdit = {
                 success,
                 quality: success ? 0.85 : 0.3,
                 agent,
+                // B1.2: give the SONA embedder real semantics (the edited file) instead of
+                // the opaque task ID.
+                task: `edit ${filePath}`,
             });
         }
         catch {
@@ -779,6 +631,14 @@ export const hooksPostCommand = {
         const command = params.command;
         const exitCode = params.exitCode || 0;
         const success = exitCode === 0;
+        // Record the real exit code in the time-windowed command-outcome store so
+        // post-task can derive a MEASURED success signal (grounded in actual exit
+        // codes) when the caller does not explicitly assert --success. Non-fatal.
+        await recordCommand(getRouteOutcomesBaseDir(), {
+            ts: Date.now(),
+            command: typeof command === 'string' ? command.slice(0, 200) : String(command).slice(0, 200),
+            exitCode,
+        });
         // Persist command outcome via AgentDB
         let _storedIn = 'none';
         try {
@@ -842,10 +702,26 @@ export const hooksRoute = {
                 if (agentdbRoute && agentdbRoute.confidence > 0.5) {
                     const agents = agentdbRoute.agents.length > 0 ? agentdbRoute.agents : ['coder', 'researcher'];
                     const complexity = task.length > 200 ? 'high' : task.length < 50 ? 'low' : 'medium';
+                    const agentdbMethod = `agentdb-${agentdbRoute.controller}`;
+                    const agentdbConfidence = Math.round(agentdbRoute.confidence * 100) / 100;
+                    // Record the route recommendation so post-task can join the actual outcome
+                    const routeId = randomUUID();
+                    const caps = await getCapabilities();
+                    const learningMode = (caps.sona || caps.router === 'native' || caps.attention) ? 'native' : 'js';
+                    await recordRoute(getRouteOutcomesBaseDir(), {
+                        routeId,
+                        ts: Date.now(),
+                        task,
+                        recommendedAgent: agents[0],
+                        routingMethod: agentdbMethod,
+                        confidence: agentdbConfidence,
+                        learningMode,
+                    });
                     return {
+                        routeId,
                         task,
                         routing: {
-                            method: `agentdb-${agentdbRoute.controller}`,
+                            method: agentdbMethod,
                             backend: agentdbRoute.controller,
                             latencyMs: 0,
                             throughput: 'N/A',
@@ -875,71 +751,16 @@ export const hooksRoute = {
                 // AgentDB router not available — fall through to local routing
             }
         }
-        // Get router (tries native VectorDb first, falls back to pure JS)
-        const { router, backend, native } = useSemanticRouter
-            ? await getSemanticRouter()
-            : { router: null, backend: 'none', native: null };
-        let semanticResult = [];
+        // Deterministic keyword routing is the baseline (and only) local path.
+        const semanticResult = [];
         let routingMethod = 'keyword';
-        let routingLatencyMs = 0;
+        const routingLatencyMs = 0;
         let backendInfo = '';
-        const queryText = context ? `${task} ${context}` : task;
-        // Apply LoRA adaptations from the neural system when available.
-        // The adapted embedding reflects what was learned in prior sessions
-        // (loaded from learned-state.json during _neuralRouterInstance.initialize()).
-        let queryEmbedding = generateSimpleEmbedding(queryText);
-        try {
-            const adapted = await applyNeuralAdaptation(queryText, 768);
-            if (adapted)
-                queryEmbedding = adapted.slice(0, 384);
-        }
-        catch { /* fall through to hash embedding */ }
-        // Try native VectorDb (HNSW-backed)
-        if (native && backend === 'native') {
-            const routeStart = performance.now();
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const results = native.search(queryEmbedding, 5);
-                routingLatencyMs = performance.now() - routeStart;
-                routingMethod = 'semantic-native';
-                backendInfo = 'native VectorDb (HNSW)';
-                // Convert results to semantic format
-                const mergedPatterns = getMergedTaskPatterns();
-                semanticResult = results.map((r) => {
-                    const [patternName] = r.id.split(':');
-                    const pattern = mergedPatterns[patternName];
-                    return {
-                        intent: patternName,
-                        score: 1 - r.score, // Native uses distance (lower is better), convert to similarity
-                        metadata: {
-                            agents: pattern?.agents || (patternName.startsWith('learned-') ? [patternName.slice(8)] : ['coder']),
-                        },
-                    };
-                });
-            }
-            catch {
-                // Native failed, try pure JS fallback
-            }
-        }
-        // Try pure JS SemanticRouter fallback
-        if (router && backend === 'pure-js' && semanticResult.length === 0) {
-            const routeStart = performance.now();
-            semanticResult = router.routeWithEmbedding(queryEmbedding, 3);
-            routingLatencyMs = performance.now() - routeStart;
-            routingMethod = 'semantic-pure-js';
-            backendInfo = 'pure JS (cosine similarity)';
-        }
-        // Get agents from semantic routing or fall back to keyword
+        // Get agents from keyword routing
         let agents;
         let confidence;
         let matchedPattern = '';
-        if (semanticResult.length > 0 && semanticResult[0].score > 0.4) {
-            const topMatch = semanticResult[0];
-            agents = topMatch.metadata.agents || ['coder', 'researcher'];
-            confidence = topMatch.score;
-            matchedPattern = topMatch.intent;
-        }
-        else {
+        {
             // Keyword fallback is the baseline
             const keywordSuggestion = suggestAgentsForTask(task);
             agents = keywordSuggestion.agents;
@@ -973,7 +794,22 @@ export const hooksRoute = {
             : taskLower.includes('simple') || taskLower.includes('fix') || task.length < 50
                 ? 'low'
                 : 'medium';
+        const primaryConfidence = Math.round(confidence * 100) / 100;
+        // Record the route recommendation so post-task can join the actual outcome
+        const routeId = randomUUID();
+        const caps = await getCapabilities();
+        const learningMode = (caps.sona || caps.router === 'native' || caps.attention) ? 'native' : 'js';
+        await recordRoute(getRouteOutcomesBaseDir(), {
+            routeId,
+            ts: Date.now(),
+            task,
+            recommendedAgent: agents[0],
+            routingMethod,
+            confidence: primaryConfidence,
+            learningMode,
+        });
         return {
+            routeId,
             task,
             routing: {
                 method: routingMethod,
@@ -1136,43 +972,8 @@ export const hooksPreTask = {
             : descLower.includes('simple') || descLower.includes('fix') || description.length < 50
                 ? 'low'
                 : 'medium';
-        // Enhanced model routing with Agent Booster AST (ADR-026)
-        let modelRouting;
-        try {
-            const { getEnhancedModelRouter } = await import('../ruvector/enhanced-model-router.js');
-            const router = getEnhancedModelRouter();
-            const routeResult = await router.route(description, { filePath });
-            if (routeResult.tier === 1) {
-                // Agent Booster can handle this task
-                modelRouting = {
-                    tier: 1,
-                    handler: 'agent-booster',
-                    canSkipLLM: true,
-                    agentBoosterIntent: routeResult.agentBoosterIntent?.type,
-                    intentDescription: routeResult.agentBoosterIntent?.description,
-                    confidence: routeResult.confidence,
-                    estimatedLatencyMs: routeResult.estimatedLatencyMs,
-                    estimatedCost: routeResult.estimatedCost,
-                    recommendation: `[AGENT_BOOSTER_AVAILABLE] Skip LLM - use Agent Booster for "${routeResult.agentBoosterIntent?.type}"`,
-                };
-            }
-            else {
-                // LLM required
-                modelRouting = {
-                    tier: routeResult.tier,
-                    handler: routeResult.handler,
-                    model: routeResult.model,
-                    complexity: routeResult.complexity,
-                    confidence: routeResult.confidence,
-                    estimatedLatencyMs: routeResult.estimatedLatencyMs,
-                    estimatedCost: routeResult.estimatedCost,
-                    recommendation: `[TASK_MODEL_RECOMMENDATION] Use model="${routeResult.model}" for this task`,
-                };
-            }
-        }
-        catch {
-            // Enhanced router not available
-        }
+        // Enhanced model routing module was never shipped — modelRouting stays undefined.
+        const modelRouting = undefined;
         // ERL: Retrieve past heuristics to inject into recommendations
         // Source: https://arxiv.org/abs/2603.24639
         const erlHints = [];
@@ -1246,12 +1047,37 @@ export const hooksPostTask = {
             quality: { type: 'number', description: 'Quality score (0-1)' },
             task: { type: 'string', description: 'Task description text (used for learning keyword extraction)' },
             storeDecisions: { type: 'boolean', description: 'Also store routing decision in memory DB' },
+            routeId: { type: 'string', description: 'Route ID from a prior hooks_route call — joins the recommendation to this outcome' },
         },
         required: ['taskId'],
     },
     handler: async (params) => {
         const taskId = params.taskId;
-        const success = params.success !== false;
+        // The success flag, when the caller asserts it (--success true), is taken as
+        // ground truth. But callers usually do NOT pass it. Rather than treating every
+        // unverified task as "unknown" (and thus excluding it from learning), we now
+        // derive a MEASURED success signal from the real command exit codes recorded by
+        // post-command within a recent time window. post-command appends each exit code
+        // to the command-outcome store keyed by timestamp; deriveRecentSuccess returns:
+        //   true  → recent commands exist and ALL exited 0
+        //   false → recent commands exist and ANY exited non-zero
+        //   null  → no recent commands (genuinely no signal → stays unknown)
+        // Precedence: an explicit --success ALWAYS wins; the derived signal only fills
+        // in when no explicit flag is given; only when there is also no recent command
+        // signal does the outcome stay unknown (and excluded from SONA + route join,
+        // per the existing "unknown ≠ success" principle).
+        const explicitSuccess = typeof params.success === 'boolean';
+        let outcomeKnown = explicitSuccess;
+        let success = params.success !== false;
+        let successSource = explicitSuccess ? 'explicit' : 'unknown';
+        if (!explicitSuccess) {
+            const derived = await deriveRecentSuccess(getRouteOutcomesBaseDir());
+            if (derived !== null) {
+                outcomeKnown = true;
+                success = derived;
+                successSource = 'derived-commands';
+            }
+        }
         const agent = params.agent;
         const quality = params.quality || (success ? 0.85 : 0.3);
         const startTime = Date.now();
@@ -1264,6 +1090,11 @@ export const hooksPostTask = {
                 success,
                 quality,
                 agent,
+                // B1.2: thread the real task description into the SONA trajectory so the
+                // embedder encodes meaning, not the opaque task ID.
+                task: params.task || undefined,
+                // B1.3: only feed the SONA LoRA update when the outcome is actually known.
+                outcomeKnown,
                 duration: params.duration || undefined,
                 patterns: params.patterns || undefined,
             });
@@ -1284,11 +1115,14 @@ export const hooksPostTask = {
         catch {
             // Non-fatal
         }
-        // Persist routing outcome for runtime learning (file-based, always reliable)
+        // Persist routing outcome for runtime learning (file-based, always reliable).
+        // B1.3: also gate this sibling learning sink on a known outcome — an unverified
+        // task must not train the router as a success either. When the caller did not
+        // assert success, the outcome is unknown and we skip persisting a labeled sample.
         const taskText = params.task || '';
         const outcomeKeywords = extractKeywords(taskText);
         let outcomePersisted = false;
-        if (taskText && agent && agent.length <= 100 && /^[a-zA-Z0-9_-]+$/.test(agent)) {
+        if (outcomeKnown && taskText && agent && agent.length <= 100 && /^[a-zA-Z0-9_-]+$/.test(agent)) {
             try {
                 const outcomes = loadRoutingOutcomes();
                 outcomes.push({
@@ -1304,6 +1138,26 @@ export const hooksPostTask = {
             }
             catch { /* non-critical */ }
         }
+        // Join this outcome back onto the original route recommendation. This is the
+        // recommendation→actual→success link that routing-accuracy metrics and SONA
+        // labels depend on. When the caller threads an explicit routeId we join that
+        // record; otherwise we auto-correlate to the most recent unresolved route
+        // (within a 10-min window) so the loop closes without the LLM manually
+        // threading the routeId. Only join when the outcome is actually measured —
+        // per "unknown ≠ success", an unverified task must not pollute the metric.
+        if (outcomeKnown) {
+            const outcome = {
+                agentActuallyUsed: agent,
+                measuredSuccess: success,
+                quality: typeof params.quality === 'number' ? params.quality : undefined,
+            };
+            if (params.routeId) {
+                await joinOutcome(getRouteOutcomesBaseDir(), params.routeId, outcome);
+            }
+            else {
+                await joinLatestUnresolved(getRouteOutcomesBaseDir(), outcome);
+            }
+        }
         // ERL: Extract and persist structured heuristic for future pre-task injection
         // Source: https://arxiv.org/abs/2603.24639
         if (taskText && agent && success !== undefined) {
@@ -1376,6 +1230,8 @@ export const hooksPostTask = {
         return {
             taskId,
             success,
+            outcomeKnown,
+            successSource,
             duration,
             learningUpdates: {
                 patternsUpdated: feedbackResult?.updated || (success ? 2 : 1),
@@ -1427,7 +1283,7 @@ export const hooksExplain = {
         let historicalSuccess = null;
         let historicalNote = 'No historical data yet';
         try {
-            const outcomesPath = join(resolve('.'), '.monomind/routing-outcomes.json');
+            const outcomesPath = getRoutingOutcomesPath();
             if (existsSync(outcomesPath)) {
                 const data = JSON.parse(readFileSync(outcomesPath, 'utf-8'));
                 const outcomes = data.outcomes || [];
@@ -1843,7 +1699,11 @@ export const hooksSessionEnd = {
     handler: async (params) => {
         const saveState = params.saveState !== false;
         const shouldStopDaemon = params.stopDaemon !== false;
-        const sessionId = `session-${Date.now() - 3600000}`; // Default session (1 hour ago)
+        // Use caller-supplied sessionId if provided, otherwise generate a current-time ID.
+        // The -3600000 offset was incorrect — it prevented matching session-start IDs.
+        const sessionId = typeof params.sessionId === 'string' && params.sessionId
+            ? params.sessionId
+            : `session-${Date.now()}`;
         // Stop daemon if enabled
         let daemonStopped = false;
         if (shouldStopDaemon) {
@@ -1866,7 +1726,7 @@ export const hooksSessionEnd = {
         // Check for pending-insights.jsonl
         let insightCount = 0;
         try {
-            const insightsPath = resolve(join('.monomind', 'data', 'pending-insights.jsonl'));
+            const insightsPath = join(getProjectCwd(), '.monomind', 'data', 'pending-insights.jsonl');
             if (existsSync(insightsPath)) {
                 const content = readFileSync(insightsPath, 'utf-8').trim();
                 insightCount = content ? content.split('\n').length : 0;
@@ -2019,10 +1879,10 @@ export const hooksInit = {
         };
     },
 };
-// Intelligence hook - RuVector intelligence system
+// Intelligence hook - JS pattern/trajectory logging
 export const hooksIntelligence = {
     name: 'hooks_intelligence',
-    description: 'RuVector intelligence system status (shows REAL metrics from memory store)',
+    description: 'Intelligence status: pattern/trajectory logging metrics from the memory store',
     inputSchema: {
         type: 'object',
         properties: {
@@ -2043,29 +1903,25 @@ export const hooksIntelligence = {
         const realStats = getIntelligenceStatsFromMemory();
         // Check actual implementation availability
         const sonaAvailable = (await getSONAOptimizer()) !== null;
-        const moeAvailable = (await getMoERouter()) !== null;
-        const flashAvailable = (await getFlashAttention()) !== null;
-        const ewcAvailable = (await getEWCConsolidator()) !== null;
-        const loraAvailable = (await getLoRAAdapter()) !== null;
         return {
             mode,
             status: 'active',
             components: {
                 sona: {
                     enabled: enableSona,
-                    status: sonaAvailable ? 'active' : 'loading',
-                    implemented: true, // NOW IMPLEMENTED in alpha.102
+                    status: sonaAvailable ? 'active' : 'idle',
+                    implemented: true,
                     trajectoriesRecorded: realStats.trajectories.total,
                     trajectoriesSuccessful: realStats.trajectories.successful,
                     patternsLearned: realStats.patterns.learned,
-                    note: sonaAvailable ? 'SONA optimizer active - learning from trajectories' : 'SONA loading...',
+                    note: 'Trajectory + pattern logging (no neural training in the lean build)',
                 },
                 moe: {
-                    enabled: enableMoe,
-                    status: moeAvailable ? 'active' : 'loading',
-                    implemented: true, // NOW IMPLEMENTED in alpha.102
+                    enabled: false,
+                    status: 'removed',
+                    implemented: false,
                     routingDecisions: realStats.routing.decisions,
-                    note: moeAvailable ? 'MoE router with 8 experts (coder, tester, reviewer, architect, security, performance, researcher, coordinator)' : 'MoE loading...',
+                    note: 'MoE removed in lean build; keyword routing is used instead (see monoes-full-loop)',
                 },
                 hnsw: {
                     enabled: enableHnsw,
@@ -2073,25 +1929,25 @@ export const hooksIntelligence = {
                     implemented: true,
                     indexSize: realStats.memory.indexSize,
                     memorySizeBytes: realStats.memory.memorySizeBytes,
-                    note: 'HNSW vector indexing with 150x-12,500x speedup',
+                    note: 'Pure-JS HNSW vector indexing (O(log n) vs O(n))',
                 },
                 flashAttention: {
-                    enabled: true,
-                    status: flashAvailable ? 'active' : 'loading',
-                    implemented: true, // NOW IMPLEMENTED in alpha.102
-                    note: flashAvailable ? 'Flash Attention with O(N) memory (2.49x-7.47x speedup)' : 'Flash Attention loading...',
+                    enabled: false,
+                    status: 'removed',
+                    implemented: false,
+                    note: 'Flash Attention removed in lean build; lives on monoes-full-loop branch',
                 },
                 ewc: {
-                    enabled: true,
-                    status: ewcAvailable ? 'active' : 'loading',
-                    implemented: true, // NOW IMPLEMENTED in alpha.102
-                    note: ewcAvailable ? 'EWC++ consolidation prevents catastrophic forgetting' : 'EWC++ loading...',
+                    enabled: false,
+                    status: 'removed',
+                    implemented: false,
+                    note: 'EWC++ removed in lean build; lives on monoes-full-loop branch',
                 },
                 lora: {
-                    enabled: true,
-                    status: loraAvailable ? 'active' : 'loading',
-                    implemented: true, // NOW IMPLEMENTED in alpha.102
-                    note: loraAvailable ? 'LoRA adapter with 128x memory compression (rank=8)' : 'LoRA loading...',
+                    enabled: false,
+                    status: 'removed',
+                    implemented: false,
+                    note: 'LoRA removed in lean build; lives on monoes-full-loop branch',
                 },
                 embeddings: {
                     provider: 'transformers',
@@ -2110,11 +1966,13 @@ export const hooksIntelligence = {
             implementationStatus: {
                 working: [
                     'memory-store', 'embeddings', 'trajectory-recording', 'claims', 'swarm-coordination',
-                    'hnsw-index', 'pattern-storage', 'sona-optimizer', 'ewc-consolidation', 'moe-routing',
-                    'flash-attention', 'lora-adapter'
+                    'hnsw-index', 'pattern-storage', 'keyword-routing'
                 ],
                 partial: [],
                 notImplemented: [],
+                removed: [
+                    'sona-optimizer', 'ewc-consolidation', 'moe-routing', 'flash-attention', 'lora-adapter'
+                ],
             },
             version: '3.0.0-alpha.102',
         };
@@ -2575,7 +2433,7 @@ export const hooksPatternSearch = {
 // Intelligence stats hook
 export const hooksIntelligenceStats = {
     name: 'hooks_intelligence_stats',
-    description: 'Get RuVector intelligence layer statistics',
+    description: 'Get intelligence-layer statistics (pattern/trajectory logging)',
     inputSchema: {
         type: 'object',
         properties: {
@@ -2587,9 +2445,6 @@ export const hooksIntelligenceStats = {
         // Get REAL statistics from actual implementations
         const sona = await getSONAOptimizer();
         const ewc = await getEWCConsolidator();
-        const moe = await getMoERouter();
-        const flash = await getFlashAttention();
-        const lora = await getLoRAAdapter();
         // Fallback to memory store for legacy data
         const memoryStats = getIntelligenceStatsFromMemory();
         // SONA stats from real implementation
@@ -2647,59 +2502,21 @@ export const hooksIntelligenceStats = {
             loadBalance: null,
             implementation: 'not-loaded',
         };
-        if (moe) {
-            const loadBalance = moe.getLoadBalance();
-            const activeExperts = Object.values(loadBalance.routingCounts).filter((u) => u > 0).length;
-            // Calculate average utilization as proxy for confidence
-            const utilValues = Object.values(loadBalance.utilization);
-            const avgUtil = utilValues.length > 0 ? utilValues.reduce((a, b) => a + b, 0) / utilValues.length : 0;
-            moeStats = {
-                expertsTotal: 8,
-                expertsActive: activeExperts,
-                routingDecisions: loadBalance.totalRoutings,
-                avgRoutingTimeMs: 0.15, // Theoretical performance
-                avgConfidence: Math.round(avgUtil * 100) / 100,
-                loadBalance: {
-                    giniCoefficient: Math.round(loadBalance.giniCoefficient * 1000) / 1000,
-                    coefficientOfVariation: Math.round(loadBalance.coefficientOfVariation * 1000) / 1000,
-                    expertUsage: loadBalance.routingCounts,
-                },
-                implementation: 'real-moe',
-            };
-        }
-        // Flash Attention stats from real implementation
-        let flashStats = {
+        // Flash Attention stats (native MoE/Flash removed in lean build — defaults only)
+        const flashStats = {
             speedup: 1.0,
             avgComputeTimeMs: 0,
             blockSize: 64,
             implementation: 'not-loaded',
         };
-        if (flash) {
-            flashStats = {
-                speedup: Math.round(flash.getSpeedup() * 100) / 100,
-                avgComputeTimeMs: 0, // Would need benchmarking
-                blockSize: 64,
-                implementation: 'real-flash-attention',
-            };
-        }
-        // LoRA stats from real implementation
-        let loraStats = {
+        // LoRA Adapter removed — superseded by SONA instant adaptation
+        const loraStats = {
             rank: 8,
             alpha: 16,
             adaptations: 0,
             avgLoss: 0,
             implementation: 'not-loaded',
         };
-        if (lora) {
-            const realLora = lora.getStats();
-            loraStats = {
-                rank: realLora.rank,
-                alpha: 16, // Default alpha from config
-                adaptations: realLora.totalAdaptations,
-                avgLoss: Math.round(realLora.avgAdaptationNorm * 10000) / 10000,
-                implementation: 'real-lora',
-            };
-        }
         const stats = {
             sona: sonaStats,
             moe: moeStats,
@@ -2723,9 +2540,9 @@ export const hooksIntelligenceStats = {
                 implementationStatus: {
                     sona: sona ? 'loaded' : 'not-loaded',
                     ewc: ewc ? 'loaded' : 'not-loaded',
-                    moe: moe ? 'loaded' : 'not-loaded',
-                    flash: flash ? 'loaded' : 'not-loaded',
-                    lora: lora ? 'loaded' : 'not-loaded',
+                    moe: 'not-loaded',
+                    flash: 'not-loaded',
+                    lora: 'not-loaded',
                 },
                 performance: {
                     sonaLearningMs: sonaStats.avgLearningTimeMs,
@@ -2812,7 +2629,7 @@ export const hooksIntelligenceLearn = {
 // Intelligence attention hook
 export const hooksIntelligenceAttention = {
     name: 'hooks_intelligence_attention',
-    description: 'Compute attention-weighted similarity using MoE/Flash/Hyperbolic',
+    description: 'Compute attention-weighted similarity (pure-JS cosine/hyperbolic)',
     inputSchema: {
         type: 'object',
         properties: {
@@ -2829,76 +2646,9 @@ export const hooksIntelligenceAttention = {
         const startTime = performance.now();
         let implementation = 'placeholder';
         const results = [];
-        if (mode === 'moe') {
-            // Try MoE routing
-            const moe = await getMoERouter();
-            if (moe) {
-                try {
-                    // Generate a simple embedding from query (hash-based for demo)
-                    const embedding = new Float32Array(384);
-                    for (let i = 0; i < 384; i++) {
-                        embedding[i] = Math.sin(query.charCodeAt(i % query.length) * (i + 1) * 0.01);
-                    }
-                    const routingResult = moe.route(embedding);
-                    for (let i = 0; i < Math.min(topK, routingResult.experts.length); i++) {
-                        const expert = routingResult.experts[i];
-                        results.push({
-                            index: i,
-                            weight: expert.weight,
-                            pattern: `Expert: ${expert.name}`,
-                            expert: expert.name,
-                        });
-                    }
-                    implementation = 'real-moe-router';
-                }
-                catch {
-                    // Fall back to placeholder
-                }
-            }
-        }
-        else if (mode === 'flash') {
-            // Try Flash Attention
-            const flash = await getFlashAttention();
-            if (flash) {
-                try {
-                    // Generate query/key/value embeddings
-                    const q = new Float32Array(384);
-                    const keys = [];
-                    const values = [];
-                    for (let i = 0; i < 384; i++) {
-                        q[i] = Math.sin(query.charCodeAt(i % query.length) * (i + 1) * 0.01);
-                    }
-                    // Generate some keys/values
-                    for (let k = 0; k < topK; k++) {
-                        const key = new Float32Array(384);
-                        const value = new Float32Array(384);
-                        for (let i = 0; i < 384; i++) {
-                            key[i] = Math.cos((k + 1) * (i + 1) * 0.01);
-                            value[i] = k + 1;
-                        }
-                        keys.push(key);
-                        values.push(value);
-                    }
-                    const attentionResult = flash.attention([q], keys, values);
-                    // Compute softmax weights from output magnitudes
-                    const outputMags = attentionResult.output[0]
-                        ? Array.from(attentionResult.output[0]).slice(0, topK).map(v => Math.abs(v))
-                        : new Array(topK).fill(1);
-                    const sumMags = outputMags.reduce((a, b) => a + b, 0) || 1;
-                    for (let i = 0; i < topK; i++) {
-                        results.push({
-                            index: i,
-                            weight: outputMags[i] / sumMags,
-                            pattern: `Flash attention target #${i + 1}`,
-                        });
-                    }
-                    implementation = 'real-flash-attention';
-                }
-                catch {
-                    // Fall back to placeholder
-                }
-            }
-        }
+        // Native MoE-router / Flash-attention backends were removed in the lean build.
+        // Both modes degrade to the honest empty result handled below.
+        void mode;
         // If no real implementation worked, return empty with honest marker
         if (results.length === 0) {
             implementation = 'none';
@@ -2910,10 +2660,8 @@ export const hooksIntelligenceAttention = {
             results,
             stats: {
                 computeTimeMs,
-                speedup: implementation.startsWith('real-') ? (mode === 'flash' ? '2.49x-7.47x' : '1.5x-3x') : null,
-                memoryReduction: implementation.startsWith('real-') ? (mode === 'flash' ? '50-75%' : '25-40%') : null,
                 _stub: implementation === 'none',
-                _note: implementation === 'none' ? 'No attention backend available. Install @ruvector/attention for real computation.' : undefined,
+                _note: implementation === 'none' ? 'Pure-JS similarity only; native attention backends are not part of the lean build.' : undefined,
             },
             implementation,
         };
@@ -3361,20 +3109,6 @@ export const hooksWorkerDetect = {
         return result;
     },
 };
-// Model router - lazy loaded
-let modelRouterInstance = null;
-async function getModelRouterInstance() {
-    if (!modelRouterInstance) {
-        try {
-            const { getModelRouter } = await import('../ruvector/model-router.js');
-            modelRouterInstance = getModelRouter();
-        }
-        catch {
-            modelRouterInstance = null;
-        }
-    }
-    return modelRouterInstance;
-}
 // Model route tool - intelligent model selection
 export const hooksModelRoute = {
     name: 'hooks_model-route',
@@ -3390,29 +3124,14 @@ export const hooksModelRoute = {
     },
     handler: async (params) => {
         const task = params.task;
-        const router = await getModelRouterInstance();
-        if (!router) {
-            // Fallback to simple heuristic
-            const complexity = analyzeComplexityFallback(task);
-            return {
-                model: complexity > 0.7 ? 'opus' : complexity > 0.4 ? 'sonnet' : 'haiku',
-                confidence: 0.7,
-                complexity,
-                reasoning: 'Fallback heuristic (model router not available)',
-                implementation: 'fallback',
-            };
-        }
-        const result = await router.route(task);
+        // Native neural model-router removed in the lean build — keyword complexity heuristic.
+        const complexity = analyzeComplexityFallback(task);
         return {
-            model: result.model,
-            confidence: result.confidence,
-            uncertainty: result.uncertainty,
-            complexity: result.complexity,
-            reasoning: result.reasoning,
-            alternatives: result.alternatives,
-            inferenceTimeUs: result.inferenceTimeUs,
-            costMultiplier: result.costMultiplier,
-            implementation: 'tiny-dancer-neural',
+            model: complexity > 0.7 ? 'opus' : complexity > 0.4 ? 'sonnet' : 'haiku',
+            confidence: 0.7,
+            complexity,
+            reasoning: 'Keyword complexity heuristic',
+            implementation: 'heuristic',
         };
     },
 };
@@ -3442,10 +3161,8 @@ export const hooksModelOutcome = {
             ? (exitCode === 0 ? 'success' : 'failure')
             : params.outcome;
         const outcome = effectiveOutcome;
-        const router = await getModelRouterInstance();
-        if (router) {
-            router.recordOutcome(task, model, outcome);
-        }
+        // Native model-router removed in the lean build — outcome is acknowledged but not
+        // fed to a neural learner (keyword routing has no online-learning store).
         return {
             recorded: true,
             task: task.slice(0, 50),
@@ -3464,18 +3181,10 @@ export const hooksModelStats = {
         properties: {},
     },
     handler: async () => {
-        const router = await getModelRouterInstance();
-        if (!router) {
-            return {
-                available: false,
-                message: 'Model router not initialized',
-            };
-        }
-        const stats = router.getStats();
+        // Native model-router removed in the lean build — no neural routing stats to report.
         return {
-            available: true,
-            ...stats,
-            timestamp: new Date().toISOString(),
+            available: false,
+            message: 'Model router not available in the lean build (keyword routing has no stats)',
         };
     },
 };