monomind 1.11.14 → 1.13.0

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

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

@@ -35,7 +35,8 @@ export const coverageRouterTools = [
         },
         handler: async (input) => {
             try {
-                const result = await coverageRoute(input.path || '', { threshold: input.threshold ?? 80 });
+                const rawPath = typeof input.path === 'string' ? input.path.slice(0, 512) : '';
+                const result = await coverageRoute(rawPath, { threshold: input.threshold ?? 80 });
                 if (!result.found) {
                     return text('No coverage report found. Run your test suite with coverage enabled (e.g. `vitest run --coverage`), then retry.');
                 }
@@ -66,7 +67,7 @@ export const coverageRouterTools = [
             try {
                 const result = await coverageGaps({
                     threshold: input.threshold ?? 80,
-                    path: input.path || undefined,
+                    path: typeof input.path === 'string' ? input.path.slice(0, 512) : undefined,
                     groupByAgent: true,
                 });
                 if (!result.found)
@@ -96,7 +97,9 @@ export const coverageRouterTools = [
         },
         handler: async (input) => {
             try {
-                const result = await coverageSuggest(input.path || '.', { threshold: input.threshold ?? 80, limit: input.limit ?? 20 });
+                const rawPath = typeof input.path === 'string' ? input.path.slice(0, 512) : '.';
+                const rawLimit = typeof input.limit === 'number' ? Math.min(Math.max(1, input.limit), 200) : 20;
+                const result = await coverageSuggest(rawPath, { threshold: input.threshold ?? 80, limit: rawLimit });
                 if (!result.found) {
                     return text('No coverage report found. Run your test suite with coverage enabled, then retry.');
                 }

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

@@ -626,8 +626,11 @@ export function suggestReviewers(files, fileRisks) {
     return Array.from(reviewers).slice(0, 5);
 }
 // Analysis result cache
+// FIFO eviction cap matches diffCache. Without a cap, repeated calls to analyzeDiff
+// with unique refs (e.g. HEAD~0...HEAD~N) would grow this Map to GBs.
 const analysisCache = new Map();
 const ANALYSIS_CACHE_TTL_MS = 3000; // 3 seconds
+const ANALYSIS_CACHE_MAX_ENTRIES = 50;
 /**
  * Analyze a diff with full analysis (optimized with caching)
  */
@@ -662,6 +665,11 @@ export async function analyzeDiff(options) {
         recommendedReviewers,
     };
     // Cache the result
+    if (analysisCache.size >= ANALYSIS_CACHE_MAX_ENTRIES) {
+        const oldestKey = analysisCache.keys().next().value;
+        if (oldestKey !== undefined)
+            analysisCache.delete(oldestKey);
+    }
     analysisCache.set(ref, { result, timestamp: Date.now() });
     return result;
 }
@@ -692,6 +700,11 @@ export function analyzeDiffSync(options) {
         fileRisks,
         recommendedReviewers,
     };
+    if (analysisCache.size >= ANALYSIS_CACHE_MAX_ENTRIES) {
+        const oldestKey = analysisCache.keys().next().value;
+        if (oldestKey !== undefined)
+            analysisCache.delete(oldestKey);
+    }
     analysisCache.set(ref, { result, timestamp: Date.now() });
     return result;
 }

package/packages/@monomind/cli/dist/src/monovector/route-outcomes.d.ts

@@ -10,7 +10,8 @@ export interface RouteOutcomeRecord {
     measuredSuccess?: boolean;
     quality?: number;
 }
-/** Append a route recommendation (pre-outcome). */
+/** Append a route recommendation (pre-outcome). Opportunistically trims the
+ *  file to MAX_ROUTE_RECORDS lines to prevent unbounded growth. */
 export declare function recordRoute(baseDir: string, rec: RouteOutcomeRecord): Promise<void>;
 /** Join outcome data onto the most recent matching route record by routeId. */
 export declare function joinOutcome(baseDir: string, routeId: string, outcome: {

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

@@ -3,16 +3,42 @@
  * what actually happened. This is the foundation for routing-accuracy metrics
  * and for giving SONA a real training label.
  */
-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 string fields stored in each record to prevent file bloat. */
+const MAX_FIELD_LEN = 500;
 function storePath(baseDir) {
     return join(baseDir, 'route-outcomes.jsonl');
 }
-/** Append a route recommendation (pre-outcome). */
+/** Maximum number of records to keep in route-outcomes.jsonl.
+ *  computeRoutingAccuracy only ever reads the last 100 records, so anything
+ *  older is dead weight. Keeping 500 gives a comfortable buffer while bounding
+ *  the file size and keeping joinOutcome's full-file rewrite cheap. */
+const MAX_ROUTE_RECORDS = 500;
+/** Append a route recommendation (pre-outcome). Opportunistically trims the
+ *  file to MAX_ROUTE_RECORDS lines to prevent unbounded growth. */
 export async function recordRoute(baseDir, rec) {
     try {
         await fs.mkdir(baseDir, { recursive: true });
-        await fs.appendFile(storePath(baseDir), JSON.stringify(rec) + '\n', 'utf8');
+        const path = storePath(baseDir);
+        // Cap string fields to prevent individual records from bloating the file.
+        const safeRec = {
+            ...rec,
+            routeId: rec.routeId.slice(0, MAX_FIELD_LEN),
+            task: rec.task.slice(0, MAX_FIELD_LEN),
+            recommendedAgent: rec.recommendedAgent.slice(0, MAX_FIELD_LEN),
+            routingMethod: rec.routingMethod.slice(0, 64),
+        };
+        await fs.appendFile(path, JSON.stringify(safeRec) + '\n', 'utf8');
+        // Opportunistic trim: rewrite only when the file exceeds the cap.
+        // Avoids an extra stat() on every call by catching the overcount lazily.
+        const content = await fs.readFile(path, 'utf8').catch(() => '');
+        const lines = content.trim().split('\n').filter(Boolean);
+        if (lines.length > MAX_ROUTE_RECORDS) {
+            await fs.writeFile(path, lines.slice(-MAX_ROUTE_RECORDS).join('\n') + '\n', 'utf8');
+        }
     }
     catch {
         // Non-fatal — telemetry must never break routing
@@ -22,6 +48,11 @@ export async function recordRoute(baseDir, rec) {
 export async function joinOutcome(baseDir, routeId, outcome) {
     try {
         const path = storePath(baseDir);
+        try {
+            if (statSync(path).size > MAX_FILE_BYTES)
+                return;
+        }
+        catch { /* file absent */ }
         const content = await fs.readFile(path, 'utf8').catch(() => '');
         if (!content)
             return;
@@ -52,6 +83,11 @@ export async function joinLatestUnresolved(baseDir, outcome, maxAgeMs = 600_000
 ) {
     try {
         const path = storePath(baseDir);
+        try {
+            if (statSync(path).size > MAX_FILE_BYTES)
+                return null;
+        }
+        catch { /* file absent */ }
         const content = await fs.readFile(path, 'utf8').catch(() => '');
         if (!content)
             return null;
@@ -81,7 +117,13 @@ export async function joinLatestUnresolved(baseDir, outcome, maxAgeMs = 600_000
 /** Read all outcome records (for metrics). */
 export async function readOutcomes(baseDir) {
     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 [];
         return content.trim().split('\n').map(l => {

package/packages/@monomind/cli/dist/src/plugins/manager.js

@@ -73,7 +73,8 @@ export class PluginManager {
     }
     async loadManifest() {
         try {
-            if (fs.existsSync(this.config.manifestPath)) {
+            const MAX_MANIFEST_BYTES = 10 * 1024 * 1024; // 10 MB
+            if (fs.existsSync(this.config.manifestPath) && fs.statSync(this.config.manifestPath).size <= MAX_MANIFEST_BYTES) {
                 const content = fs.readFileSync(this.config.manifestPath, 'utf-8');
                 const parsed = JSON.parse(content);
                 if (Object.prototype.hasOwnProperty.call(parsed, '__proto__') ||
@@ -148,7 +149,8 @@ export class PluginManager {
             let installedVersion = version || 'latest';
             let commands = [];
             let hooks = [];
-            if (fs.existsSync(packageJsonPath)) {
+            const MAX_PKG_JSON_BYTES = 1024 * 1024; // 1 MB
+            if (fs.existsSync(packageJsonPath) && fs.statSync(packageJsonPath).size <= MAX_PKG_JSON_BYTES) {
                 const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
                 installedVersion = pkg.version;
                 // Check for monomind plugin metadata
@@ -205,6 +207,9 @@ export class PluginManager {
             if (!fs.existsSync(packageJsonPath)) {
                 return { success: false, error: 'No package.json found at path' };
             }
+            if (fs.statSync(packageJsonPath).size > 1024 * 1024) {
+                return { success: false, error: 'package.json exceeds size limit' };
+            }
             const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
             const packageName = pkg.name;
             if (!isValidPluginKey(packageName)) {
@@ -423,7 +428,7 @@ export class PluginManager {
             // Update manifest
             const installDir = path.join(this.config.pluginsDir, 'node_modules');
             const packageJsonPath = path.join(installDir, packageName, 'package.json');
-            if (fs.existsSync(packageJsonPath)) {
+            if (fs.existsSync(packageJsonPath) && fs.statSync(packageJsonPath).size <= 1024 * 1024) {
                 const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
                 existing.version = pkg.version;
                 existing.commands = pkg['monomind']?.commands || existing.commands;

package/packages/@monomind/cli/dist/src/plugins/store/discovery.js

@@ -5,23 +5,67 @@
  */
 import * as crypto from 'crypto';
 import { resolveIPNS, fetchFromIPFS } from '../../transfer/ipfs/client.js';
+/** Maximum bytes accepted from npm API responses to prevent OOM. */
+const NPM_RESPONSE_MAX_BYTES = 256 * 1024; // 256 KB
+/**
+ * Read a fetch Response body up to maxBytes.  AbortSignal.timeout() only
+ * bounds wall-clock time, NOT response body size; a slow-drip or large
+ * response would otherwise buffer unbounded memory here.
+ */
+async function readBoundedJson(res, maxBytes) {
+    const lenHdr = res.headers.get('content-length');
+    if (lenHdr) {
+        const declared = parseInt(lenHdr, 10);
+        if (Number.isFinite(declared) && declared > maxBytes) {
+            throw new Error(`npm response too large: ${declared} bytes`);
+        }
+    }
+    if (!res.body)
+        return JSON.parse('');
+    const reader = res.body.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (value) {
+            total += value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel();
+                throw new Error(`npm response exceeded ${maxBytes} bytes`);
+            }
+            chunks.push(value);
+        }
+    }
+    const buf = new Uint8Array(total);
+    let off = 0;
+    for (const c of chunks) {
+        buf.set(c, off);
+        off += c.byteLength;
+    }
+    return JSON.parse(new TextDecoder('utf-8').decode(buf));
+}
 /**
  * Fetch real npm download stats for a package
  */
 async function fetchNpmStats(packageName) {
+    // Validate package name length to avoid constructing huge URLs
+    if (!packageName || packageName.length > 214)
+        return null;
     try {
         // Fetch last week downloads
         const downloadsUrl = `https://api.npmjs.org/downloads/point/last-week/${encodeURIComponent(packageName)}`;
         const downloadsRes = await fetch(downloadsUrl, { signal: AbortSignal.timeout(3000) });
         if (!downloadsRes.ok)
             return null;
-        const downloadsData = await downloadsRes.json();
+        const downloadsData = await readBoundedJson(downloadsRes, NPM_RESPONSE_MAX_BYTES);
         // Fetch package info for version
         const packageUrl = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
         const packageRes = await fetch(packageUrl, { signal: AbortSignal.timeout(3000) });
         let version = 'unknown';
         if (packageRes.ok) {
-            const packageData = await packageRes.json();
+            const packageData = await readBoundedJson(packageRes, NPM_RESPONSE_MAX_BYTES);
             version = packageData.version || 'unknown';
         }
         return {

package/packages/@monomind/cli/dist/src/plugins/store/search.js

@@ -9,7 +9,7 @@ export function searchPlugins(registry, options = {}) {
     let plugins = [...registry.plugins];
     // Text search (name, displayName, description, tags)
     if (options.query) {
-        const query = options.query.toLowerCase();
+        const query = options.query.slice(0, 256).toLowerCase();
         plugins = plugins.filter(p => p.name.toLowerCase().includes(query) ||
             p.displayName.toLowerCase().includes(query) ||
             p.description.toLowerCase().includes(query) ||
@@ -88,8 +88,8 @@ export function searchPlugins(registry, options = {}) {
     });
     // Pagination
     const total = plugins.length;
-    const limit = options.limit || 20;
-    const offset = options.offset || 0;
+    const limit = Math.min(Math.max(1, options.limit || 20), 200);
+    const offset = Math.max(0, Math.min(options.offset || 0, 100_000));
     const page = Math.floor(offset / limit) + 1;
     plugins = plugins.slice(offset, offset + limit);
     return {
@@ -105,7 +105,8 @@ export function searchPlugins(registry, options = {}) {
  * Get search suggestions based on partial query
  */
 export function getPluginSearchSuggestions(registry, partialQuery, limit = 10) {
-    const query = partialQuery.toLowerCase();
+    const query = partialQuery.slice(0, 256).toLowerCase();
+    limit = Math.min(Math.max(1, limit), 100);
     const suggestions = new Set();
     // Search in plugin names
     for (const plugin of registry.plugins) {