monomind 1.11.14 → 1.12.0

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

@@ -145,7 +145,12 @@ export class EWCConsolidator {
             for (const newPattern of newPatterns) {
                 if (!newPattern.embedding || newPattern.embedding.length === 0)
                     continue;
-                const existingPattern = this.patterns.get(newPattern.id);
+                // Cap pattern ID length: unbounded IDs fill both the Map key and the
+                // modifiedPatterns/protectedPatterns result arrays without any limit.
+                const patternId = typeof newPattern.id === 'string'
+                    ? newPattern.id.slice(0, 256)
+                    : String(newPattern.id).slice(0, 256);
+                const existingPattern = this.patterns.get(patternId);
                 if (existingPattern) {
                     // Calculate EWC penalty for updating existing pattern
                     const penalty = this.getPenalty(existingPattern.weights, newPattern.embedding, fisher);
@@ -153,19 +158,19 @@ export class EWCConsolidator {
                     const importanceScore = this.calculateImportance(existingPattern);
                     if (importanceScore > this.config.importanceThreshold && penalty > this.config.lambda) {
                         // Protect high-importance patterns with high penalty
-                        result.protectedPatterns.push(newPattern.id);
+                        result.protectedPatterns.push(patternId);
                         // Apply constrained update: blend old and new based on importance
                         const blendFactor = 1 - importanceScore;
                         const blendedWeights = this.blendWeights(existingPattern.weights, newPattern.embedding, blendFactor, fisher);
                         existingPattern.weights = blendedWeights;
                         existingPattern.lastUpdated = Date.now();
-                        result.modifiedPatterns.push(newPattern.id);
+                        result.modifiedPatterns.push(patternId);
                     }
                     else {
                         // Low importance or low penalty: allow full update
                         existingPattern.weights = newPattern.embedding.slice(0, this.config.dimensions);
                         existingPattern.lastUpdated = Date.now();
-                        result.modifiedPatterns.push(newPattern.id);
+                        result.modifiedPatterns.push(patternId);
                     }
                     // Update Fisher diagonal for this pattern
                     existingPattern.fisherDiagonal = fisher;
@@ -174,7 +179,7 @@ export class EWCConsolidator {
                 else {
                     // New pattern: add directly
                     const weights = {
-                        id: newPattern.id,
+                        id: patternId,
                         weights: newPattern.embedding.slice(0, this.config.dimensions),
                         fisherDiagonal: fisher,
                         importance: 0.5,
@@ -184,8 +189,8 @@ export class EWCConsolidator {
                         type: newPattern.type,
                         description: newPattern.description
                     };
-                    this.patterns.set(newPattern.id, weights);
-                    result.modifiedPatterns.push(newPattern.id);
+                    this.patterns.set(patternId, weights);
+                    result.modifiedPatterns.push(patternId);
                 }
                 result.patternsConsolidated++;
             }
@@ -209,7 +214,10 @@ export class EWCConsolidator {
             return result;
         }
         catch (error) {
-            result.error = error instanceof Error ? error.message : String(error);
+            // Sanitize: strip filesystem paths and cap length so internal error
+            // messages are not reflected verbatim into CallerResult.error.
+            const rawMsg = error instanceof Error ? error.message : String(error);
+            result.error = rawMsg.replace(/\/[^\s:]+(\/|(?=\s|:|$))/g, '<path>/').slice(0, 500);
             result.duration = performance.now() - startTime;
             return result;
         }
@@ -513,6 +521,10 @@ export class EWCConsolidator {
         if (!fs.existsSync(this.config.storagePath)) {
             throw new Error('No persisted state found');
         }
+        const fileSize = fs.statSync(this.config.storagePath).size;
+        if (fileSize > 50 * 1024 * 1024) {
+            throw new Error(`EWC state file too large (${fileSize} bytes); refusing to load`);
+        }
         const content = fs.readFileSync(this.config.storagePath, 'utf-8');
         const state = JSON.parse(content);
         // Validate version
@@ -551,8 +563,12 @@ export class EWCConsolidator {
                 this.patterns.set(id, pattern);
             }
         }
-        // Restore history
-        this.consolidationHistory = Array.isArray(state.consolidationHistory) ? state.consolidationHistory : [];
+        // Restore history — cap to last 100 entries so a crafted state file cannot
+        // bloat the in-memory array (each entry is a small object, but the array is
+        // summed on every getConsolidationStats() call which is O(n)).
+        this.consolidationHistory = Array.isArray(state.consolidationHistory)
+            ? state.consolidationHistory.slice(-100)
+            : [];
         // Update config from persisted values, clamped to a sensible range to
         // prevent negative/NaN lambda from inverting the regularization sign.
         if (state.config && typeof state.config.lambda === 'number'

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

@@ -10,7 +10,7 @@
  *
  * @module v1/cli/intelligence
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync, renameSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 // ============================================================================
@@ -332,7 +332,7 @@ class LocalReasoningBank {
     loadFromDisk() {
         try {
             const path = getPatternsPath();
-            if (existsSync(path)) {
+            if (existsSync(path) && statSync(path).size <= 50 * 1024 * 1024) {
                 const data = JSON.parse(readFileSync(path, 'utf-8'));
                 if (Array.isArray(data)) {
                     // Validate each persisted pattern. The patterns file is part of the
@@ -393,9 +393,10 @@ class LocalReasoningBank {
             renameSync(tmp, path);
             this.dirty = false;
         }
-        catch (error) {
+        catch {
             // Log but don't throw - persistence failures shouldn't break training
-            console.error('Failed to persist patterns:', error);
+            // Do not reflect raw error to avoid leaking internal paths
+            console.error('Failed to persist patterns');
         }
     }
     /**
@@ -548,7 +549,7 @@ let globalStats = {
 function loadPersistedStats() {
     try {
         const path = getStatsPath();
-        if (existsSync(path)) {
+        if (existsSync(path) && statSync(path).size <= 10 * 1024 * 1024) {
             const data = JSON.parse(readFileSync(path, 'utf-8'));
             if (data && typeof data === 'object') {
                 globalStats.trajectoriesRecorded = data.trajectoriesRecorded ?? 0;
@@ -599,7 +600,7 @@ async function _doInitializeIntelligence(config) {
         // Seed neural learned patterns from @monomind/neural's LearningBridge flush.
         // This is the A→B bridge reader: connects the automatic learning loop to routing.
         const neuralPatternsPath = join(getDataDir(), 'patterns.json');
-        if (existsSync(neuralPatternsPath)) {
+        if (existsSync(neuralPatternsPath) && statSync(neuralPatternsPath).size <= 50 * 1024 * 1024) {
             try {
                 const { generateEmbedding: genEmb } = await import('./memory-initializer.js').catch(() => ({ generateEmbedding: null }));
                 const raw = readFileSync(neuralPatternsPath, 'utf-8');
@@ -804,6 +805,10 @@ export async function recordTrajectory(steps, verdict) {
     }
 }
 export async function findSimilarPatterns(query, options) {
+    // Cap query length to prevent OOM via embedding generation on unbounded input
+    if (typeof query === 'string' && query.length > 2000) {
+        query = query.slice(0, 2000);
+    }
     if (!reasoningBank) {
         const init = await initializeIntelligence();
         if (!init.success)
@@ -943,9 +948,11 @@ export function benchmarkAdaptation(iterations = 1000) {
     if (!sonaCoordinator) {
         return { totalMs: 0, avgMs: 0, minMs: 0, maxMs: 0, targetMet: false };
     }
+    // Cap iterations to prevent OOM/CPU exhaustion from unbounded caller input
+    const safeIterations = Math.min(Math.max(1, iterations >>> 0), 100_000);
     const times = [];
     const testEmbedding = Array.from({ length: 384 }, () => Math.random());
-    for (let i = 0; i < iterations; i++) {
+    for (let i = 0; i < safeIterations; i++) {
         const start = performance.now();
         sonaCoordinator.recordSignal({
             type: 'test',
@@ -956,7 +963,7 @@ export function benchmarkAdaptation(iterations = 1000) {
         times.push(performance.now() - start);
     }
     const totalMs = times.reduce((a, b) => a + b, 0);
-    const avgMs = totalMs / iterations;
+    const avgMs = totalMs / safeIterations;
     const minMs = Math.min(...times);
     const maxMs = Math.max(...times);
     return {
@@ -980,21 +987,75 @@ function loadSonaRoutingPatterns() {
         const sonaPath = join(process.cwd(), '.swarm', 'sona-patterns.json');
         if (!existsSync(sonaPath))
             return [];
+        if (statSync(sonaPath).size > 10 * 1024 * 1024)
+            return [];
         const raw = JSON.parse(readFileSync(sonaPath, 'utf-8'));
         const persisted = raw;
-        if (!persisted.patterns || typeof persisted.patterns !== 'object')
+        if (!persisted.patterns || typeof persisted.patterns !== 'object' || Array.isArray(persisted.patterns))
             return [];
         const now = Date.now();
-        return Object.entries(persisted.patterns).map(([key, p]) => ({
-            id: `sona:${key}`,
-            type: p.agent ?? 'routing',
-            content: (p.keywords ?? [key]).join(' '),
-            confidence: p.confidence ?? 0.5,
-            usageCount: (p.successCount ?? 0) + (p.failureCount ?? 0),
-            embedding: [],
-            createdAt: p.createdAt ?? now,
-            lastUsedAt: now,
-        }));
+        const results = [];
+        // Cap total entries to prevent DoS via an unbounded patterns map.
+        // sona-patterns.json is written by the SONA optimizer but could be
+        // replaced by a malicious IPFS bundle — validate every field before use.
+        const MAX_SONA_ENTRIES = 500;
+        let entryCount = 0;
+        for (const [key, p] of Object.entries(persisted.patterns)) {
+            // Prototype pollution guard — skip __proto__ / constructor / prototype keys.
+            if (key === '__proto__' || key === 'constructor' || key === 'prototype')
+                continue;
+            if (typeof key !== 'string' || key.length === 0 || key.length > 256)
+                continue;
+            if (entryCount++ >= MAX_SONA_ENTRIES)
+                break;
+            if (!p || typeof p !== 'object')
+                continue;
+            // Validate keywords: must be a bounded array of short strings.
+            const rawKw = p.keywords;
+            let keywords;
+            if (rawKw === undefined) {
+                keywords = [key];
+            }
+            else if (Array.isArray(rawKw) && rawKw.length <= 64
+                && rawKw.every(k => typeof k === 'string' && k.length > 0 && k.length <= 128)) {
+                keywords = rawKw;
+            }
+            else {
+                continue; // malformed keywords — skip entry
+            }
+            // Validate agent string.
+            const agent = p.agent;
+            if (agent !== undefined && (typeof agent !== 'string' || agent.length === 0 || agent.length > 128))
+                continue;
+            // Validate confidence is a finite number in [0, 1].
+            const rawConf = p.confidence;
+            const confidence = rawConf !== undefined ? rawConf : 0.5;
+            if (typeof confidence !== 'number' || !Number.isFinite(confidence) || confidence < 0 || confidence > 1)
+                continue;
+            // Validate usage counts are safe integers.
+            const sc = p.successCount ?? 0;
+            const fc = p.failureCount ?? 0;
+            if (typeof sc !== 'number' || !Number.isFinite(sc) || sc < 0 || sc > 1e9)
+                continue;
+            if (typeof fc !== 'number' || !Number.isFinite(fc) || fc < 0 || fc > 1e9)
+                continue;
+            // Validate createdAt is a reasonable epoch ms value.
+            const rawTs = p.createdAt;
+            const createdAt = (rawTs !== undefined && typeof rawTs === 'number' && Number.isFinite(rawTs) && rawTs >= 0 && rawTs <= 9.9e12)
+                ? rawTs
+                : now;
+            results.push({
+                id: `sona:${key}`,
+                type: agent ?? 'routing',
+                content: keywords.join(' '),
+                confidence,
+                usageCount: sc + fc,
+                embedding: [],
+                createdAt,
+                lastUsedAt: now,
+            });
+        }
+        return results;
     }
     catch {
         return [];

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

@@ -404,8 +404,12 @@ async function getOrBuildHnswIndex(db) {
     _hnswIndexBuilt = true; // Lock prevents concurrent re-build
     try {
         const memPkg = await import('@monoes/memory');
-        if (!memPkg?.HNSWIndex)
+        if (!memPkg?.HNSWIndex) {
+            // Release the lock so a later retry can succeed if the package becomes available.
+            _hnswIndexBuilt = false;
+            _hnswBuildFailedAt = Date.now();
             return null;
+        }
         const rows = db.prepare(`SELECT id, embedding FROM memory_entries WHERE status = 'active' AND (expires_at IS NULL OR expires_at > ?) AND embedding IS NOT NULL`).all(Date.now());
         const valid = [];
         for (const row of rows) {
@@ -447,7 +451,22 @@ export async function bridgeStoreEntry(options) {
     if (!ctx)
         return null;
     try {
-        const { key, value, namespace = 'default', tags: rawTags = [], ttl } = options;
+        const rawKey = options.key;
+        const rawValue = options.value;
+        // SECURITY: defensive caps so no caller — current or future — can pass an
+        // unbounded string directly into embedder.embed (hash fallback is O(n)) or
+        // inflate the AgentDB row beyond practical limits.
+        // Memory-tools already validates to 1 MB; these caps are a last-resort
+        // backstop for any internal caller that forgets to pre-truncate.
+        const BRIDGE_MAX_KEY_LEN = 4 * 1024; // 4 KB — generous for any realistic key
+        const BRIDGE_MAX_VALUE_LEN = 1024 * 1024; // 1 MB — matches memory-tools validator
+        const key = typeof rawKey === 'string' && rawKey.length > BRIDGE_MAX_KEY_LEN
+            ? rawKey.slice(0, BRIDGE_MAX_KEY_LEN) : rawKey;
+        const value = typeof rawValue === 'string' && rawValue.length > BRIDGE_MAX_VALUE_LEN
+            ? rawValue.slice(0, BRIDGE_MAX_VALUE_LEN) : rawValue;
+        const namespace = options.namespace ?? 'default';
+        const rawTags = options.tags ?? [];
+        const ttl = options.ttl;
         // SECURITY: cap tags array length and per-tag length. Without these, any
         // memory_store caller (every spawned agent) could submit
         // tags: new Array(1e5).fill("x".repeat(1e4)) → ~1GB persisted blob,

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

@@ -11,6 +11,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { safeParseEmbedding } from './memory-bridge.js';
+/** Maximum SQLite database file size accepted before read (256 MB). */
+const MAX_DB_FILE_BYTES = 256 * 1024 * 1024;
 // ADR-053: Lazy import of AgentDB v1 bridge
 let _bridge;
 async function getBridge() {
@@ -733,6 +735,11 @@ export async function ensureSchemaColumns(dbPath) {
         }
         const initSqlJs = (await import('sql.js')).default;
         const SQL = await initSqlJs();
+        // Guard against excessively large DB files to prevent OOM.
+        const ensureStat = fs.statSync(dbPath);
+        if (ensureStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, columnsAdded, error: `Database file too large: ${ensureStat.size} bytes` };
+        }
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         // Get current columns in memory_entries
@@ -802,6 +809,14 @@ export async function checkAndMigrateLegacy(options) {
             try {
                 const initSqlJs = (await import('sql.js')).default;
                 const SQL = await initSqlJs();
+                // Guard against excessively large legacy DB files to prevent OOM.
+                const legacyStat = fs.statSync(legacyPath);
+                if (legacyStat.size > MAX_DB_FILE_BYTES) {
+                    if (verbose) {
+                        console.warn(`[memory] Skipping legacy DB at ${legacyPath}: file too large (${legacyStat.size} bytes)`);
+                    }
+                    continue;
+                }
                 const legacyBuffer = fs.readFileSync(legacyPath);
                 const legacyDb = new SQL.Database(legacyBuffer);
                 // Check if it has data
@@ -1080,6 +1095,11 @@ export async function checkMemoryInitialization(dbPath) {
         // Try to load with sql.js
         const initSqlJs = (await import('sql.js')).default;
         const SQL = await initSqlJs();
+        // Guard against excessively large DB files to prevent OOM.
+        const checkStat = fs.statSync(path_);
+        if (checkStat.size > MAX_DB_FILE_BYTES) {
+            return { initialized: false };
+        }
         const fileBuffer = fs.readFileSync(path_);
         const db = new SQL.Database(fileBuffer);
         // Check for metadata table
@@ -1125,6 +1145,11 @@ export async function applyTemporalDecay(dbPath) {
     try {
         const initSqlJs = (await import('sql.js')).default;
         const SQL = await initSqlJs();
+        // Guard against excessively large DB files to prevent OOM.
+        const decayStat = fs.statSync(path_);
+        if (decayStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, patternsDecayed: 0, error: `Database file too large: ${decayStat.size} bytes` };
+        }
         const fileBuffer = fs.readFileSync(path_);
         const db = new SQL.Database(fileBuffer);
         // Apply decay: confidence *= exp(-decay_rate * days_since_last_use)
@@ -1445,6 +1470,11 @@ export async function verifyMemoryInit(dbPath, options) {
         const initSqlJs = (await import('sql.js')).default;
         const SQL = await initSqlJs();
         const fs = await import('fs');
+        // Guard against excessively large DB files to prevent OOM.
+        const verifyStat = fs.statSync(dbPath);
+        if (verifyStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, tests: [{ name: 'Database access', passed: false, details: `File too large: ${verifyStat.size} bytes` }], summary: { passed: 0, failed: 1, total: 1 } };
+        }
         // Load database
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
@@ -1631,6 +1661,11 @@ export async function storeEntry(options) {
         await ensureSchemaColumns(dbPath);
         const initSqlJs = (await import('sql.js')).default;
         const SQL = await initSqlJs();
+        // Guard against excessively large DB files to prevent OOM.
+        const storeStat = fs.statSync(dbPath);
+        if (storeStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, id: '', error: `Database file too large: ${storeStat.size} bytes` };
+        }
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         const id = `entry_${Date.now()}_${Math.random().toString(36).substring(7)}`;
@@ -1727,6 +1762,11 @@ export async function searchEntries(options) {
         }
         // Ensure schema has all required columns (migration for older DBs)
         await ensureSchemaColumns(dbPath);
+        // Guard against excessively large DB files to prevent OOM.
+        const searchStat = fs.statSync(dbPath);
+        if (searchStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, results: [], searchTime: 0, error: `Database file too large: ${searchStat.size} bytes` };
+        }
         // Generate query embedding
         const queryEmb = await generateEmbedding(query);
         const queryEmbedding = queryEmb.embedding;
@@ -1744,6 +1784,11 @@ export async function searchEntries(options) {
         // Fall back to brute-force SQLite search
         const initSqlJs = (await import('sql.js')).default;
         const SQL = await initSqlJs();
+        // Guard against excessively large DB files to prevent OOM.
+        const searchFbStat = fs.statSync(dbPath);
+        if (searchFbStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, results: [], searchTime: Date.now() - startTime, error: `Database file too large: ${searchFbStat.size} bytes` };
+        }
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         // Get entries with embeddings
@@ -1854,6 +1899,11 @@ export async function listEntries(options) {
         await ensureSchemaColumns(dbPath);
         const initSqlJs = (await import('sql.js')).default;
         const SQL = await initSqlJs();
+        // Guard against excessively large DB files to prevent OOM.
+        const listStat = fs.statSync(dbPath);
+        if (listStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, entries: [], total: 0, error: `Database file too large: ${listStat.size} bytes` };
+        }
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         // Get total count
@@ -1870,9 +1920,13 @@ export async function listEntries(options) {
         countStmt.free();
         const countResult = countRows.length > 0 ? [{ values: countRows }] : [];
         const total = countResult[0]?.values?.[0]?.[0] || 0;
-        // Get entries
-        const safeLimit = parseInt(String(limit), 10) || 100;
-        const safeOffset = parseInt(String(offset), 10) || 0;
+        // Get entries — cap limit to 10 000 to prevent full-table loads that OOM
+        // the sql.js in-memory database on large datasets.
+        const MAX_LIST_LIMIT = 10_000;
+        const rawLimit = parseInt(String(limit), 10);
+        const safeLimit = Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(rawLimit, MAX_LIST_LIMIT) : 100;
+        const rawOffset = parseInt(String(offset), 10);
+        const safeOffset = Number.isFinite(rawOffset) && rawOffset >= 0 ? rawOffset : 0;
         const listStmt = namespace
             ? db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' AND namespace = ? ORDER BY updated_at DESC LIMIT ? OFFSET ?`)
             : db.prepare(`SELECT id, key, namespace, content, embedding, access_count, created_at, updated_at FROM memory_entries WHERE status = 'active' ORDER BY updated_at DESC LIMIT ? OFFSET ?`);
@@ -1939,6 +1993,11 @@ export async function getEntry(options) {
         await ensureSchemaColumns(dbPath);
         const initSqlJs = (await import('sql.js')).default;
         const SQL = await initSqlJs();
+        // Guard against excessively large DB files to prevent OOM.
+        const getStat = fs.statSync(dbPath);
+        if (getStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, found: false, error: `Database file too large: ${getStat.size} bytes` };
+        }
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         // Find entry by key
@@ -2041,6 +2100,11 @@ export async function deleteEntry(options) {
         await ensureSchemaColumns(dbPath);
         const initSqlJs = (await import('sql.js')).default;
         const SQL = await initSqlJs();
+        // Guard against excessively large DB files to prevent OOM.
+        const deleteStat = fs.statSync(dbPath);
+        if (deleteStat.size > MAX_DB_FILE_BYTES) {
+            return { success: false, deleted: false, key, namespace, remainingEntries: 0, error: `Database file too large: ${deleteStat.size} bytes` };
+        }
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
         // Check if entry exists first

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

@@ -11,7 +11,7 @@
  * - Persists patterns to .swarm/sona-patterns.json
  * @module v1/cli/memory/sona-optimizer
  */
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'fs';
 import { dirname, join } from 'path';
 // ============================================================================
 // Constants
@@ -473,6 +473,8 @@ export class SONAOptimizer {
             if (!existsSync(fullPath)) {
                 return false;
             }
+            if (statSync(fullPath).size > 50 * 1024 * 1024)
+                return false;
             const data = readFileSync(fullPath, 'utf-8');
             const state = JSON.parse(data);
             // Validate version
@@ -480,9 +482,13 @@ export class SONAOptimizer {
                 console.error('[SONA] Incompatible state version, starting fresh');
                 return false;
             }
-            // Load patterns
+            // Load patterns — also cap key length so a crafted state file cannot
+            // store arbitrarily long keys that bloat the in-memory Map. The key is
+            // an agent:keyword string; 512 chars is ample for any real value.
             this.patterns.clear();
             for (const [key, pattern] of Object.entries(state.patterns)) {
+                if (typeof key !== 'string' || key.length > 512)
+                    continue;
                 if (this.validatePattern(pattern)) {
                     this.patterns.set(key, pattern);
                 }
@@ -497,7 +503,9 @@ export class SONAOptimizer {
             return true;
         }
         catch (err) {
-            console.error(`[SONA] Failed to load state: ${err}`);
+            // Strip filesystem paths from error before logging to prevent path disclosure
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[SONA] Failed to load state: ${msg.replace(/\/[^\s:]+(\/|(?=\s|:|$))/g, '<path>/').slice(0, 200)}`);
             return false;
         }
     }
@@ -532,7 +540,9 @@ export class SONAOptimizer {
             return true;
         }
         catch (err) {
-            console.error(`[SONA] Failed to save state: ${err}`);
+            // Strip filesystem paths from error before logging to prevent path disclosure
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[SONA] Failed to save state: ${msg.replace(/\/[^\s:]+(\/|(?=\s|:|$))/g, '<path>/').slice(0, 200)}`);
             return false;
         }
     }

package/packages/@monomind/cli/dist/src/monovector/command-outcomes.js

@@ -3,19 +3,43 @@
  * success signal from real command exit codes, instead of trusting a
  * caller-supplied --success flag.
  */
-import { promises as fs } from 'node:fs';
+import { promises as fs, statSync } from 'node:fs';
 import { join } from 'node:path';
+/** Refuse to read files larger than this to prevent OOM. */
+const MAX_FILE_BYTES = 50 * 1024 * 1024; // 50 MB
+/** Cap command string length to prevent file bloat. */
+const MAX_COMMAND_LEN = 500;
 function storePath(baseDir) {
     return join(baseDir, 'command-outcomes.jsonl');
 }
+/** Maximum number of command-outcome records to keep.
+ *  deriveRecentSuccess only uses records within a 5-minute window (typically < 50), so
+ *  anything older is dead weight. 500 gives a comfortable buffer. */
+const MAX_COMMAND_RECORDS = 500;
 /** Append a command outcome. Non-fatal on error. */
 export async function recordCommand(baseDir, cmd) {
     try {
         await fs.mkdir(baseDir, { recursive: true });
-        const rec = { ts: cmd.ts, command: cmd.command, exitCode: cmd.exitCode, success: cmd.exitCode === 0 };
-        await fs.appendFile(storePath(baseDir), JSON.stringify(rec) + '\n', 'utf8');
-        // Opportunistic trim: keep file bounded (last 500 lines) to avoid unbounded growth
-        // (cheap: only rewrite when it gets large)
+        const path = storePath(baseDir);
+        // Cap command length to prevent individual records from bloating the file.
+        const safeCommand = cmd.command.length > MAX_COMMAND_LEN ? cmd.command.slice(0, MAX_COMMAND_LEN) : cmd.command;
+        const rec = { ts: cmd.ts, command: safeCommand, exitCode: cmd.exitCode, success: cmd.exitCode === 0 };
+        await fs.appendFile(path, JSON.stringify(rec) + '\n', 'utf8');
+        // Opportunistic trim: rewrite only when the file exceeds the cap.
+        // Avoids an extra stat() on every call by catching the overcount lazily.
+        // Guard with size check first to prevent OOM on unexpectedly large files.
+        try {
+            if (statSync(path).size > MAX_FILE_BYTES)
+                return;
+        }
+        catch {
+            return;
+        }
+        const content = await fs.readFile(path, 'utf8').catch(() => '');
+        const lines = content.trim().split('\n').filter(Boolean);
+        if (lines.length > MAX_COMMAND_RECORDS) {
+            await fs.writeFile(path, lines.slice(-MAX_COMMAND_RECORDS).join('\n') + '\n', 'utf8');
+        }
     }
     catch { /* non-fatal */ }
 }
@@ -42,7 +66,13 @@ export async function recordCommand(baseDir, cmd) {
  */
 export async function deriveRecentSuccess(baseDir, windowMs = 300_000) {
     try {
-        const content = await fs.readFile(storePath(baseDir), 'utf8').catch(() => '');
+        const p = storePath(baseDir);
+        try {
+            if (statSync(p).size > MAX_FILE_BYTES)
+                return null;
+        }
+        catch { /* file absent */ }
+        const content = await fs.readFile(p, 'utf8').catch(() => '');
         if (!content)
             return null;
         const now = Date.now();
@@ -67,7 +97,13 @@ export async function deriveRecentSuccess(baseDir, windowMs = 300_000) {
 /** Read recent command outcomes (for diagnostics). */
 export async function readCommandOutcomes(baseDir, windowMs = 300_000) {
     try {
-        const content = await fs.readFile(storePath(baseDir), 'utf8').catch(() => '');
+        const p = storePath(baseDir);
+        try {
+            if (statSync(p).size > MAX_FILE_BYTES)
+                return [];
+        }
+        catch { /* file absent */ }
+        const content = await fs.readFile(p, 'utf8').catch(() => '');
         if (!content)
             return [];
         const now = Date.now();

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

@@ -10,7 +10,7 @@
  *
  * @module @monomind/cli/monovector/coverage-router
  */
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, statSync } from 'fs';
 import { join } from 'path';
 import { getProjectCwd } from '../mcp-tools/types.js';
 // ============================================================================
@@ -28,6 +28,10 @@ const EMPTY = {
         overallStatementCoverage: 0,
     },
 };
+/** Maximum bytes for a JSON coverage summary (20 MB). */
+const MAX_COVERAGE_JSON_BYTES = 20 * 1024 * 1024;
+/** Maximum bytes for an lcov.info file (50 MB). */
+const MAX_COVERAGE_LCOV_BYTES = 50 * 1024 * 1024;
 /**
  * Read coverage data from disk. Checks, in order:
  *  1. coverage/coverage-summary.json  (Jest/Istanbul)
@@ -39,7 +43,7 @@ const EMPTY = {
 export function readCoverage(cwd = getProjectCwd()) {
     for (const rel of ['coverage/coverage-summary.json', 'coverage-summary.json']) {
         const p = join(cwd, rel);
-        if (existsSync(p)) {
+        if (existsSync(p) && statSync(p).size <= MAX_COVERAGE_JSON_BYTES) {
             try {
                 return parseSummaryJson(JSON.parse(readFileSync(p, 'utf-8')), rel);
             }
@@ -50,7 +54,7 @@ export function readCoverage(cwd = getProjectCwd()) {
     }
     for (const rel of ['coverage/lcov.info', 'lcov.info']) {
         const p = join(cwd, rel);
-        if (existsSync(p)) {
+        if (existsSync(p) && statSync(p).size <= MAX_COVERAGE_LCOV_BYTES) {
             try {
                 return parseLcov(readFileSync(p, 'utf-8'), rel);
             }
@@ -60,7 +64,7 @@ export function readCoverage(cwd = getProjectCwd()) {
         }
     }
     const nyc = join(cwd, '.nyc_output', 'out.json');
-    if (existsSync(nyc)) {
+    if (existsSync(nyc) && statSync(nyc).size <= MAX_COVERAGE_JSON_BYTES) {
         try {
             return parseSummaryJson(JSON.parse(readFileSync(nyc, 'utf-8')), '.nyc_output/out.json');
         }