monomind 1.8.0 → 1.9.0

package/packages/@monomind/cli/dist/src/production/error-handler.d.ts

@@ -7,7 +7,7 @@
  * - Structured error responses
  * - Error aggregation and reporting
  *
- * @module @monoes/cli/production/error-handler
+ * @module @monomind/cli/production/error-handler
  */
 export interface ErrorContext {
     operation: string;
@@ -55,8 +55,10 @@ export declare class ErrorHandler {
     isRetryable(category: ErrorCategory): boolean;
     /**
      * Sanitize input to remove sensitive data
+     * Cycle-safe and depth-bounded — circular references and deeply nested objects
+     * will not cause stack overflow.
      */
-    sanitize(input: Record<string, unknown>): Record<string, unknown>;
+    sanitize(input: Record<string, unknown>, _seen?: WeakSet<object>, _depth?: number): Record<string, unknown>;
     /**
      * Handle an error and return a structured response
      */

package/packages/@monomind/cli/dist/src/production/error-handler.js

@@ -7,7 +7,7 @@
  * - Structured error responses
  * - Error aggregation and reporting
  *
- * @module @monoes/cli/production/error-handler
+ * @module @monomind/cli/production/error-handler
  */
 // ============================================================================
 // Error Classification
@@ -126,10 +126,17 @@ export class ErrorHandler {
     }
     /**
      * Sanitize input to remove sensitive data
+     * Cycle-safe and depth-bounded — circular references and deeply nested objects
+     * will not cause stack overflow.
      */
-    sanitize(input) {
+    sanitize(input, _seen = new WeakSet(), _depth = 0) {
         if (!this.config.sanitize)
             return input;
+        if (_depth > 20)
+            return { '[MAX_DEPTH]': true };
+        if (_seen.has(input))
+            return { '[CIRCULAR]': true };
+        _seen.add(input);
         const sanitized = {};
         for (const [key, value] of Object.entries(input)) {
             const lowerKey = key.toLowerCase();
@@ -138,7 +145,7 @@ export class ErrorHandler {
                 sanitized[key] = '[REDACTED]';
             }
             else if (typeof value === 'object' && value !== null) {
-                sanitized[key] = this.sanitize(value);
+                sanitized[key] = this.sanitize(value, _seen, _depth + 1);
             }
             else {
                 sanitized[key] = value;
@@ -154,8 +161,22 @@ export class ErrorHandler {
         const category = this.classifyError(error);
         const retryable = this.isRetryable(category);
         const now = new Date().toISOString();
-        // Track error counts for rate limiting
+        // Track error counts for rate limiting and enforce cap
         this.trackError(category);
+        const rateEntry = this.errorCounts.get(category);
+        if (rateEntry && rateEntry.count > this.config.maxErrorsPerMinute) {
+            return {
+                success: false,
+                error: {
+                    code: 'ERR_RATE_LIMITED',
+                    message: 'Error rate limit exceeded',
+                    category,
+                    retryable: false,
+                },
+                context,
+                timestamp: new Date().toISOString(),
+            };
+        }
         // Build structured error
         const structured = {
             success: false,
@@ -261,7 +282,8 @@ export class ErrorHandler {
         // Remove potential sensitive data from message
         let sanitized = message;
         for (const key of SENSITIVE_KEYS) {
-            const pattern = new RegExp(`${key}[=:]?\\s*["']?[^\\s"']+["']?`, 'gi');
+            // Use a non-backtracking pattern: key followed by = or : then non-whitespace
+            const pattern = new RegExp(`${key}[=:]\\S+`, 'gi');
             sanitized = sanitized.replace(pattern, `${key}=[REDACTED]`);
         }
         return sanitized;

package/packages/@monomind/cli/dist/src/production/monitoring.js

@@ -8,7 +8,7 @@
  * - Health checks
  * - Alerting
  *
- * @module @monoes/cli/production/monitoring
+ * @module @monomind/cli/production/monitoring
  */
 // ============================================================================
 // Default Configuration
@@ -101,13 +101,13 @@ export class MonitoringHooks {
         this.activeRequests++;
         this.requestCount++;
         const startTime = Date.now();
-        this.counter('request_started', 1, { requestId });
+        this.counter('request_started', 1, {});
         // Return end function
         return () => {
             this.activeRequests--;
             const duration = Date.now() - startTime;
             this.responseTimes.push(duration);
-            this.histogram('response_time_ms', duration, { requestId });
+            this.histogram('response_time_ms', duration, {});
             // Keep only last 1000 response times
             if (this.responseTimes.length > 1000) {
                 this.responseTimes = this.responseTimes.slice(-1000);
@@ -122,7 +122,6 @@ export class MonitoringHooks {
         this.counter('error', 1, {
             ...labels,
             errorType: error.name,
-            errorMessage: error.message.slice(0, 100),
         });
     }
     // ============================================================================
@@ -331,6 +330,11 @@ export class MonitoringHooks {
         }
         // Remove old acknowledged alerts
         this.alerts = this.alerts.filter(a => !a.acknowledged || Date.now() - a.timestamp < 300000);
+        // Cap total alerts to prevent unbounded growth
+        const MAX_ALERTS = 500;
+        if (this.alerts.length > MAX_ALERTS) {
+            this.alerts = this.alerts.slice(-MAX_ALERTS);
+        }
     }
 }
 // ============================================================================

package/packages/@monomind/cli/dist/src/production/rate-limiter.js

@@ -7,7 +7,7 @@
  * - Burst allowance
  * - Sliding window tracking
  *
- * @module @monoes/cli/production/rate-limiter
+ * @module @monomind/cli/production/rate-limiter
  */
 // ============================================================================
 // Rate Limiter
@@ -52,9 +52,8 @@ export class RateLimiter {
         }
         // Clean old requests from sliding window
         bucket.requests = bucket.requests.filter(t => t > now - limits.windowMs);
-        // Calculate remaining
-        const maxWithBurst = Math.floor(limits.maxRequests * this.config.burstMultiplier);
-        const remaining = maxWithBurst - bucket.requests.length;
+        // Calculate remaining — uses base maxRequests (consistent with getStatus())
+        const remaining = limits.maxRequests - bucket.requests.length;
         if (remaining <= 0) {
             // Rate limited
             const oldestRequest = bucket.requests[0];
@@ -134,7 +133,11 @@ export class RateLimiter {
         const operationCounts = new Map();
         const users = new Set();
         for (const [key, bucket] of this.buckets) {
-            const [operation, userId] = key.split(':');
+            const colonIdx = key.indexOf(':');
+            const prefix = colonIdx >= 0 ? key.slice(0, colonIdx) : key;
+            const suffix = colonIdx >= 0 ? key.slice(colonIdx + 1) : undefined;
+            const operation = prefix === 'global' ? (suffix ?? prefix) : prefix;
+            const userId = prefix === 'global' ? undefined : suffix;
             if (userId)
                 users.add(userId);
             const current = operationCounts.get(operation) || 0;
@@ -167,24 +170,29 @@ export class RateLimiter {
         };
     }
     cleanupBuckets() {
-        // Limit number of tracked buckets
-        if (this.buckets.size > this.config.maxTrackedUsers) {
-            const now = Date.now();
-            const toDelete = [];
-            // Find buckets with no recent requests
-            for (const [key, bucket] of this.buckets) {
-                const recent = bucket.requests.filter(t => t > now - this.config.windowMs * 2);
-                if (recent.length === 0) {
-                    toDelete.push(key);
-                }
-            }
-            // Delete stale buckets
-            for (const key of toDelete) {
+        if (this.buckets.size <= this.config.maxTrackedUsers)
+            return;
+        const now = Date.now();
+        const target = Math.floor(this.config.maxTrackedUsers * 0.8);
+        // First pass: delete buckets with no recent activity (cheap LRU)
+        for (const [key, bucket] of this.buckets) {
+            if (this.buckets.size <= target)
+                break;
+            const recent = bucket.requests.filter(t => t > now - this.config.windowMs * 2);
+            if (recent.length === 0)
                 this.buckets.delete(key);
-                if (this.buckets.size <= this.config.maxTrackedUsers * 0.8) {
-                    break;
-                }
-            }
+        }
+        if (this.buckets.size <= target)
+            return;
+        // Second pass: even active buckets get evicted if we are still over the cap.
+        // Eviction order: oldest first-request timestamp wins (true LRU on activity).
+        const entries = Array.from(this.buckets.entries())
+            .map(([key, bucket]) => ({ key, oldest: bucket.requests[0] ?? 0 }))
+            .sort((a, b) => a.oldest - b.oldest);
+        for (const { key } of entries) {
+            if (this.buckets.size <= target)
+                break;
+            this.buckets.delete(key);
         }
     }
 }

package/packages/@monomind/cli/dist/src/ruvector/agent-wasm.js

@@ -8,7 +8,7 @@
  * Published API (v0.1.0): WasmAgent, WasmGallery, WasmMcpServer,
  * WasmRvfBuilder, JsModelProvider, initSync.
  *
- * @module @monoes/cli/ruvector/agent-wasm
+ * @module @monomind/cli/ruvector/agent-wasm
  */
 import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
@@ -39,7 +39,7 @@ export async function initAgentWasm() {
         const require_ = createRequire(import.meta.url);
         const wasmPath = require_.resolve('@ruvector/rvagent-wasm/rvagent_wasm_bg.wasm');
         const wasmBytes = readFileSync(wasmPath);
-        mod.initSync(wasmBytes);
+        mod.initSync({ module: wasmBytes });
         _wasmReady = true;
     }
     catch (err) {

package/packages/@monomind/cli/dist/src/ruvector/coverage-router.js

@@ -9,11 +9,15 @@
 // ============================================================================
 // Caching for Performance
 // ============================================================================
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { resolve, normalize, isAbsolute, join } from 'node:path';
 /**
  * Cache for coverage data (1 minute TTL)
  */
 const coverageDataCache = new Map();
 const COVERAGE_CACHE_TTL_MS = 60 * 1000; // 1 minute
+const COVERAGE_CACHE_MAX = 50;
 /**
  * Clear coverage cache
  */
@@ -378,16 +382,14 @@ export async function coverageGaps(options = {}) {
  * Returns null if path is invalid or attempts traversal
  */
 function validateProjectPath(inputPath) {
-    const { resolve, normalize, isAbsolute } = require('path');
+    // resolve, normalize, isAbsolute imported at top of module
     // Default to cwd if not provided
     const basePath = inputPath || process.cwd();
     // Normalize and resolve the path
     const normalizedPath = normalize(basePath);
     const resolvedPath = isAbsolute(normalizedPath) ? normalizedPath : resolve(process.cwd(), normalizedPath);
-    // Check for path traversal attempts
-    if (normalizedPath.includes('..') && !resolvedPath.startsWith(process.cwd())) {
-        // Only allow .. if it resolves within or above cwd
-        // For safety, reject any path with .. that goes outside project
+    // Enforce containment: resolved path must stay within cwd regardless of how it was expressed
+    if (!resolvedPath.startsWith(process.cwd())) {
         return null;
     }
     // Additional validation: no null bytes or control characters
@@ -417,9 +419,7 @@ async function loadProjectCoverage(projectRoot, skipCache) {
             return cached.report;
         }
     }
-    const { existsSync } = require('fs');
-    const { readFile } = require('fs/promises');
-    const { join, normalize } = require('path');
+    // existsSync, readFile, join, normalize imported at top of module
     // Try common coverage locations (all relative to validated root)
     const coverageLocations = [
         ['coverage', 'coverage-final.json'],
@@ -436,6 +436,11 @@ async function loadProjectCoverage(projectRoot, skipCache) {
         }
         if (existsSync(coveragePath)) {
             try {
+                const { stat } = await import('node:fs/promises');
+                const MAX_COVERAGE_SIZE = 50 * 1024 * 1024; // 50 MB
+                const fileStats = await stat(coveragePath);
+                if (fileStats.size > MAX_COVERAGE_SIZE)
+                    continue;
                 // Use async file read for non-blocking I/O
                 const content = await readFile(coveragePath, 'utf-8');
                 const router = new CoverageRouter();
@@ -446,8 +451,13 @@ async function loadProjectCoverage(projectRoot, skipCache) {
                 else if (coveragePath.endsWith('.info')) {
                     report = router.parseCoverage(content, 'lcov');
                 }
-                // Cache the result
+                // Cache the result (evict oldest entry if at capacity)
                 if (report) {
+                    if (coverageDataCache.size >= COVERAGE_CACHE_MAX) {
+                        const firstKey = coverageDataCache.keys().next().value;
+                        if (firstKey !== undefined)
+                            coverageDataCache.delete(firstKey);
+                    }
                     coverageDataCache.set(root, { report, timestamp: Date.now() });
                     return report;
                 }

package/packages/@monomind/cli/dist/src/ruvector/diff-classifier.d.ts

@@ -52,6 +52,7 @@ export declare class DiffClassifier {
     private ruvectorEngine;
     private useNative;
     private classificationCache;
+    private static readonly MAX_CLASSIFICATION_CACHE;
     constructor(config?: Partial<DiffClassifierConfig>);
     initialize(): Promise<void>;
     parseDiff(diffContent: string): FileDiff[];

package/packages/@monomind/cli/dist/src/ruvector/diff-classifier.js

@@ -1,6 +1,9 @@
 /**
  * Diff Classifier for Change Analysis
  */
+import { execFileSync, execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
 const DEFAULT_CONFIG = {
     maxDiffSize: 10000,
     classifyByImpact: true,
@@ -25,6 +28,7 @@ export class DiffClassifier {
     ruvectorEngine = null;
     useNative = false;
     classificationCache = new Map();
+    static MAX_CLASSIFICATION_CACHE = 100;
     constructor(config = {}) {
         this.config = { ...DEFAULT_CONFIG, ...config };
     }
@@ -127,6 +131,11 @@ export class DiffClassifier {
         const testingStrategy = this.determineTestingStrategy(path, primary, impactLevel);
         const riskFactors = this.identifyRiskFactors(path, hunks, impactLevel);
         const classification = { primary, secondary, confidence, impactLevel, suggestedReviewers, testingStrategy, riskFactors };
+        if (this.classificationCache.size >= DiffClassifier.MAX_CLASSIFICATION_CACHE) {
+            const oldest = this.classificationCache.keys().next().value;
+            if (oldest !== undefined)
+                this.classificationCache.delete(oldest);
+        }
         this.classificationCache.set(cacheKey, classification);
         return classification;
     }
@@ -308,9 +317,10 @@ export function createDiffClassifier(config) {
 // ============================================================================
 // Optimized Git Diff Functions
 // ============================================================================
-// Cache for diff results (TTL-based)
+// Cache for diff results (TTL-based, bounded LRU)
 const diffCache = new Map();
 const CACHE_TTL_MS = 5000; // 5 seconds - short TTL since diffs change frequently
+const DIFF_CACHE_MAX_ENTRIES = 50;
 /**
  * Validate git ref to prevent command injection
  * Only allows safe characters: alphanumeric, -, _, /, ., ~, ^
@@ -320,6 +330,12 @@ function validateGitRef(ref) {
     if (!/^[a-zA-Z0-9_\-./~^@]+$/.test(ref)) {
         throw new Error(`Invalid git ref: contains unsafe characters`);
     }
+    // Reject leading dash — git interprets `-`-prefixed refs as flags (e.g. --output=...,
+    // -G<regex>, -S<string>). execFile defeats shell injection but does NOT prevent the
+    // git binary itself from treating an attacker-controlled ref as a flag.
+    if (ref.startsWith('-')) {
+        throw new Error(`Invalid git ref: must not start with '-'`);
+    }
     // Block multiple dots (path traversal)
     if (ref.includes('..') && !ref.match(/^[a-zA-Z0-9_\-]+\.\.\.?[a-zA-Z0-9_\-]+$/)) {
         if (!/^\w+\.\.[.\w]+$/.test(ref)) {
@@ -344,7 +360,7 @@ export function getGitDiffNumstat(ref = 'HEAD') {
     if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
         return cached.files;
     }
-    const { execFileSync } = require('child_process');
+    // execFileSync imported at top of module
     try {
         // SECURITY: Use execFileSync with args array instead of shell string
         // This prevents command injection via the ref parameter
@@ -397,7 +413,13 @@ export function getGitDiffNumstat(ref = 'HEAD') {
                 files.push({ path, status, additions, deletions, hunks: 1, binary });
             }
         }
-        // Cache the result
+        // Cache the result with FIFO eviction. Without a cap, an attacker calling
+        // analyze_diff with HEAD~0...HEAD~N (all valid refs) grew this Map to GBs.
+        if (diffCache.size >= DIFF_CACHE_MAX_ENTRIES) {
+            const oldestKey = diffCache.keys().next().value;
+            if (oldestKey !== undefined)
+                diffCache.delete(oldestKey);
+        }
         diffCache.set(cacheKey, { files, timestamp: Date.now() });
         return files;
     }
@@ -417,9 +439,7 @@ export async function getGitDiffNumstatAsync(ref = 'HEAD') {
     if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
         return cached.files;
     }
-    const { execFile } = require('child_process');
-    const { promisify } = require('util');
-    const execFileAsync = promisify(execFile);
+    // execFileAsync declared at top of module
     try {
         // SECURITY: Use execFile with args array instead of shell string
         const { stdout: numstatOutput } = await execFileAsync('git', [

package/packages/@monomind/cli/dist/src/ruvector/enhanced-model-router.js

@@ -8,8 +8,20 @@
  *
  * @module enhanced-model-router
  */
-import { existsSync, readFileSync } from 'fs';
-import { extname } from 'path';
+import { existsSync, readFileSync, realpathSync, statSync } from 'fs';
+import { extname, resolve, sep } from 'path';
+const MAX_ROUTE_FILE_SIZE = 1 * 1024 * 1024; // 1 MB
+function isPathSafe(filePath) {
+    const root = process.cwd();
+    try {
+        const real = realpathSync(filePath);
+        return real === root || real.startsWith(root + sep);
+    }
+    catch {
+        const resolved = resolve(filePath);
+        return resolved === root || resolved.startsWith(root + sep);
+    }
+}
 import { getModelRouter } from './model-router.js';
 // ============================================================================
 // Intent Detection Patterns
@@ -361,6 +373,11 @@ export class EnhancedModelRouter {
      */
     async analyzeASTComplexity(filePath) {
         try {
+            if (!isPathSafe(filePath))
+                return 0.5;
+            const st = statSync(filePath, { throwIfNoEntry: false });
+            if (!st || st.size > MAX_ROUTE_FILE_SIZE)
+                return 0.5;
             const content = readFileSync(filePath, 'utf-8');
             const lines = content.split('\n');
             // Simple heuristics for complexity
@@ -419,6 +436,11 @@ export class EnhancedModelRouter {
             if (!filePath || !existsSync(filePath)) {
                 return { success: false, confidence: 0 };
             }
+            if (!isPathSafe(filePath))
+                return { success: false, confidence: 0 };
+            const fst = statSync(filePath, { throwIfNoEntry: false });
+            if (!fst || fst.size > MAX_ROUTE_FILE_SIZE)
+                return { success: false, confidence: 0 };
             const originalCode = context?.originalCode || readFileSync(filePath, 'utf-8');
             const intentToInstruction = {
                 'var-to-const': 'Convert all var declarations to const',

package/packages/@monomind/cli/dist/src/ruvector/index.d.ts

@@ -10,7 +10,7 @@
  * - Graph boundary analysis
  * - Flash Attention for faster similarity computations
  *
- * @module @monoes/cli/ruvector
+ * @module @monomind/cli/ruvector
  */
 export { QLearningRouter, createQLearningRouter, type QLearningRouterConfig, type RouteDecision } from './q-learning-router.js';
 export { MoERouter, getMoERouter, resetMoERouter, createMoERouter, EXPERT_NAMES, NUM_EXPERTS, INPUT_DIM, HIDDEN_DIM, type ExpertType, type MoERouterConfig, type RoutingResult, type LoadBalanceStats, } from './moe-router.js';
@@ -20,7 +20,6 @@ export { CoverageRouter, createCoverageRouter, coverageRoute, coverageSuggest, c
 export { coverageRouterTools, hooksCoverageRoute, hooksCoverageSuggest, hooksCoverageGaps } from './coverage-tools.js';
 export { buildDependencyGraph, analyzeGraph, analyzeMinCutBoundaries, analyzeModuleCommunities, detectCircularDependencies, exportToDot, loadRuVector, fallbackMinCut, fallbackLouvain, clearGraphCaches, getGraphCacheStats, type GraphNode, type GraphEdge, type DependencyGraph, type MinCutBoundary, type ModuleCommunity, type CircularDependency, type GraphAnalysisResult, } from './graph-analyzer.js';
 export { FlashAttention, getFlashAttention, resetFlashAttention, computeAttention, benchmarkFlashAttention, getFlashAttentionSpeedup, type FlashAttentionConfig, type AttentionResult, type BenchmarkResult, } from './flash-attention.js';
-export { LoRAAdapter, getLoRAAdapter, resetLoRAAdapter, createLoRAAdapter, adaptEmbedding, trainLoRA, getLoRAStats, DEFAULT_RANK, DEFAULT_ALPHA, INPUT_DIM as LORA_INPUT_DIM, OUTPUT_DIM as LORA_OUTPUT_DIM, type LoRAConfig, type LoRAWeights, type AdaptationResult, type LoRAStats, } from './lora-adapter.js';
 export { ModelRouter, getModelRouter, resetModelRouter, createModelRouter, routeToModel, routeToModelFull, analyzeTaskComplexity, getModelRouterStats, recordModelOutcome, MODEL_CAPABILITIES, COMPLEXITY_INDICATORS, type ClaudeModel, type ModelRouterConfig, type ModelRoutingResult, type ComplexityAnalysis, } from './model-router.js';
 export { SemanticRouter, createSemanticRouter, type Intent, type RouteResult, type RouterConfig, } from './semantic-router.js';
 export { isRuvllmWasmAvailable, initRuvllmWasm, getRuvllmStatus, createHnswRouter, createSonaInstant, createMicroLora, formatChat, createKvCache, createGenerateConfig, createBufferPool, createInferenceArena, HNSW_MAX_SAFE_PATTERNS, type HnswRouterConfig, type HnswPattern, type HnswRouteResult, type SonaConfig, type MicroLoraConfig, type ChatMessage, type GenerateOptions, type RuvllmStatus, } from './ruvllm-wasm.js';

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

@@ -10,7 +10,7 @@
  * - Graph boundary analysis
  * - Flash Attention for faster similarity computations
  *
- * @module @monoes/cli/ruvector
+ * @module @monomind/cli/ruvector
  */
 export { QLearningRouter, createQLearningRouter } from './q-learning-router.js';
 export { MoERouter, getMoERouter, resetMoERouter, createMoERouter, EXPERT_NAMES, NUM_EXPERTS, INPUT_DIM, HIDDEN_DIM, } from './moe-router.js';
@@ -30,7 +30,7 @@ export { buildDependencyGraph, analyzeGraph, analyzeMinCutBoundaries, analyzeMod
 // Cache utilities (NEW)
 clearGraphCaches, getGraphCacheStats, } from './graph-analyzer.js';
 export { FlashAttention, getFlashAttention, resetFlashAttention, computeAttention, benchmarkFlashAttention, getFlashAttentionSpeedup, } from './flash-attention.js';
-export { LoRAAdapter, getLoRAAdapter, resetLoRAAdapter, createLoRAAdapter, adaptEmbedding, trainLoRA, getLoRAStats, DEFAULT_RANK, DEFAULT_ALPHA, INPUT_DIM as LORA_INPUT_DIM, OUTPUT_DIM as LORA_OUTPUT_DIM, } from './lora-adapter.js';
+// lora-adapter removed — superseded by SONA instant adaptation
 export { ModelRouter, getModelRouter, resetModelRouter, createModelRouter, routeToModel, routeToModelFull, analyzeTaskComplexity, getModelRouterStats, recordModelOutcome, MODEL_CAPABILITIES, COMPLEXITY_INDICATORS, } from './model-router.js';
 export { SemanticRouter, createSemanticRouter, } from './semantic-router.js';
 // ── RuVector LLM WASM (inference utilities) ─────────────────

package/packages/@monomind/cli/dist/src/ruvector/model-router.d.ts

@@ -160,7 +160,7 @@ export declare class ModelRouter {
     /**
      * Record outcome for learning
      */
-    recordOutcome(task: string, model: ClaudeModel, outcome: 'success' | 'failure' | 'escalated'): void;
+    recordOutcome(task: string, model: ClaudeModel, outcome: 'success' | 'failure' | 'escalated', complexity?: number): void;
     /**
      * Get router statistics
      */
@@ -186,7 +186,9 @@ export declare class ModelRouter {
     reset(): void;
 }
 /**
- * Get or create the singleton ModelRouter instance
+ * Get or create the singleton ModelRouter instance.
+ * Throws if called with a config that differs from the one used to create
+ * the existing instance — silent config mismatch causes hard-to-debug routing bugs.
  */
 export declare function getModelRouter(config?: Partial<ModelRouterConfig>): ModelRouter;
 /**

package/packages/@monomind/cli/dist/src/ruvector/model-router.js

@@ -18,7 +18,7 @@
  *
  * @module model-router
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'fs';
 import { dirname, join } from 'path';
 /**
  * Model capabilities and characteristics
@@ -323,7 +323,7 @@ export class ModelRouter {
     /**
      * Record outcome for learning
      */
-    recordOutcome(task, model, outcome) {
+    recordOutcome(task, model, outcome, complexity) {
         // Update circuit breaker state
         if (outcome === 'failure') {
             this.consecutiveFailures[model]++;
@@ -331,11 +331,14 @@ export class ModelRouter {
         else {
             this.consecutiveFailures[model] = 0;
         }
+        // Use per-task complexity when provided; fall back to running average so
+        // callers that don't have the routing result can still record outcomes.
+        const taskComplexity = complexity ?? this.state.avgComplexity;
         // Track in history
         this.state.learningHistory.push({
             task: task.slice(0, 100),
             model,
-            complexity: this.state.avgComplexity,
+            complexity: taskComplexity,
             outcome,
             timestamp: new Date().toISOString(),
         });
@@ -378,7 +381,16 @@ export class ModelRouter {
             const fullPath = join(process.cwd(), this.config.statePath);
             if (existsSync(fullPath)) {
                 const data = readFileSync(fullPath, 'utf-8');
-                return { ...defaultState, ...JSON.parse(data) };
+                const parsed = { ...defaultState, ...JSON.parse(data) };
+                if (!Number.isFinite(parsed.avgComplexity))
+                    parsed.avgComplexity = defaultState.avgComplexity;
+                if (!Number.isFinite(parsed.avgConfidence))
+                    parsed.avgConfidence = defaultState.avgConfidence;
+                if (!Number.isFinite(parsed.totalDecisions) || parsed.totalDecisions < 0)
+                    parsed.totalDecisions = defaultState.totalDecisions;
+                if (!Number.isFinite(parsed.circuitBreakerTrips) || parsed.circuitBreakerTrips < 0)
+                    parsed.circuitBreakerTrips = defaultState.circuitBreakerTrips;
+                return parsed;
             }
         }
         catch {
@@ -397,7 +409,9 @@ export class ModelRouter {
                 mkdirSync(dir, { recursive: true });
             }
             this.state.lastUpdated = new Date().toISOString();
-            writeFileSync(fullPath, JSON.stringify(this.state, null, 2));
+            const tmp = fullPath + '.tmp';
+            writeFileSync(tmp, JSON.stringify(this.state, null, 2));
+            renameSync(tmp, fullPath);
         }
         catch {
             // Ignore save errors in non-critical scenarios
@@ -425,12 +439,21 @@ export class ModelRouter {
 // Singleton & Factory Functions
 // ============================================================================
 let modelRouterInstance = null;
+let modelRouterInstanceConfig;
 /**
- * Get or create the singleton ModelRouter instance
+ * Get or create the singleton ModelRouter instance.
+ * Throws if called with a config that differs from the one used to create
+ * the existing instance — silent config mismatch causes hard-to-debug routing bugs.
  */
 export function getModelRouter(config) {
     if (!modelRouterInstance) {
         modelRouterInstance = new ModelRouter(config);
+        modelRouterInstanceConfig = config;
+        return modelRouterInstance;
+    }
+    if (config !== undefined && JSON.stringify(config) !== JSON.stringify(modelRouterInstanceConfig)) {
+        throw new Error('ModelRouter singleton already initialized with different config. ' +
+            'Call resetModelRouter() first, or use createModelRouter() for a separate instance.');
     }
     return modelRouterInstance;
 }
@@ -439,6 +462,7 @@ export function getModelRouter(config) {
  */
 export function resetModelRouter() {
     modelRouterInstance = null;
+    modelRouterInstanceConfig = undefined;
 }
 /**
  * Create a new ModelRouter instance (non-singleton)

package/packages/@monomind/cli/dist/src/ruvector/moe-router.d.ts

@@ -195,6 +195,13 @@ export declare class MoERouter {
  * @returns MoE router instance
  */
 export declare function getMoERouter(config?: Partial<MoERouterConfig>): MoERouter;
+/**
+ * Get singleton MoE router instance, waiting for initialization to complete
+ *
+ * @param config - Optional configuration (only used on first call)
+ * @returns Promise resolving to fully initialized MoE router instance
+ */
+export declare function getMoERouterReady(config?: Partial<MoERouterConfig>): Promise<MoERouter>;
 /**
  * Reset singleton instance (for testing)
  */