monomind 1.11.14 → 1.12.0

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

package/packages/@monomind/cli/dist/src/production/circuit-breaker.js

@@ -105,6 +105,11 @@ export class CircuitBreaker {
         this.failures.push(now);
         // Clean old failures outside window
         this.failures = this.failures.filter(t => t > now - this.config.failureWindowMs);
+        // Hard cap: prevent unbounded growth under rapid-fire recordFailure() calls
+        // before the window filter prunes entries (e.g. clock skew or test hammering).
+        if (this.failures.length > 10_000) {
+            this.failures = this.failures.slice(-10_000);
+        }
         // Check if we should open the circuit
         if (this.state === 'closed' && this.failures.length >= this.config.failureThreshold) {
             this.transitionTo('open');
@@ -214,17 +219,26 @@ export class CircuitBreaker {
 // ============================================================================
 const circuitBreakers = new Map();
 const MAX_CIRCUIT_BREAKERS = 1000;
+const MAX_CIRCUIT_BREAKER_NAME_LEN = 256;
+const FORBIDDEN_CB_NAMES = new Set(['__proto__', 'constructor', 'prototype']);
 /**
  * Get or create a circuit breaker by name
  */
 export function getCircuitBreaker(name, config) {
-    if (!circuitBreakers.has(name)) {
+    // Sanitize name: cap length and block prototype-pollution keys
+    const safeName = typeof name === 'string'
+        ? name.slice(0, MAX_CIRCUIT_BREAKER_NAME_LEN)
+        : 'default';
+    if (FORBIDDEN_CB_NAMES.has(safeName)) {
+        throw new Error(`Invalid circuit breaker name: ${safeName}`);
+    }
+    if (!circuitBreakers.has(safeName)) {
         if (circuitBreakers.size >= MAX_CIRCUIT_BREAKERS) {
             throw new Error(`Circuit breaker registry full (max ${MAX_CIRCUIT_BREAKERS})`);
         }
-        circuitBreakers.set(name, new CircuitBreaker(config));
+        circuitBreakers.set(safeName, new CircuitBreaker(config));
     }
-    return circuitBreakers.get(name);
+    return circuitBreakers.get(safeName);
 }
 /**
  * Get all circuit breaker stats

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

@@ -134,6 +134,9 @@ export class ErrorHandler {
             return input;
         if (_depth > 20)
             return { '[MAX_DEPTH]': true };
+        // Primitives and null cannot be stored in a WeakSet — return them as-is.
+        if (input === null || typeof input !== 'object')
+            return input;
         if (_seen.has(input))
             return { '[CIRCULAR]': true };
         _seen.add(input);

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

@@ -78,11 +78,25 @@ export class MonitoringHooks {
         // Apply sampling
         if (Math.random() > this.config.samplingRate)
             return;
+        // Cap metric name and label keys/values to prevent DoS
+        const safeName = String(name).slice(0, 256);
+        const safeLabels = {};
+        let labelCount = 0;
+        for (const [k, v] of Object.entries(labels)) {
+            if (!Object.hasOwn(labels, k))
+                continue;
+            if (++labelCount > 20)
+                break;
+            // Block prototype pollution keys
+            if (k === '__proto__' || k === 'constructor' || k === 'prototype')
+                continue;
+            safeLabels[String(k).slice(0, 64)] = String(v).slice(0, 512);
+        }
         const event = {
-            name,
+            name: safeName,
             type,
             value,
-            labels: { ...this.config.globalLabels, ...labels },
+            labels: { ...this.config.globalLabels, ...safeLabels },
             timestamp: Date.now(),
         };
         this.metrics.push(event);
@@ -131,7 +145,8 @@ export class MonitoringHooks {
      * Register a health check
      */
     registerHealthCheck(name, check) {
-        this.healthChecks.set(name, check);
+        // Cap name length to prevent map-key inflation
+        this.healthChecks.set(String(name).slice(0, 128), check);
     }
     /**
      * Run all health checks
@@ -285,6 +300,8 @@ export class MonitoringHooks {
     // Private Methods
     // ============================================================================
     checkAlerts(name, value) {
+        if (!Object.hasOwn(this.config.alertThresholds, name))
+            return;
         const thresholds = this.config.alertThresholds[name];
         if (!thresholds)
             return;

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

@@ -33,6 +33,11 @@ export class RateLimiter {
      * Check if a request is allowed
      */
     check(operation, userId) {
+        // Cap operation and userId lengths so bucket keys cannot inflate the Map
+        const safeOp = typeof operation === 'string' ? operation.slice(0, 256) : 'unknown';
+        const safeUserId = userId ? userId.slice(0, 256) : undefined;
+        operation = safeOp;
+        userId = safeUserId;
         // Check whitelist
         if (this.config.whitelist.includes(operation)) {
             return { allowed: true, remaining: Infinity, resetAt: 0 };
@@ -157,10 +162,14 @@ export class RateLimiter {
     // Private Methods
     // ============================================================================
     getLimits(operation) {
-        return (this.config.operationLimits[operation] || {
-            maxRequests: this.config.maxRequests,
-            windowMs: this.config.windowMs,
-        });
+        // Object.hasOwn guards against prototype-pollution: if someone passes
+        // '__proto__' as the operation name, falling through to the default is safe.
+        return (Object.hasOwn(this.config.operationLimits, operation)
+            ? this.config.operationLimits[operation]
+            : {
+                maxRequests: this.config.maxRequests,
+                windowMs: this.config.windowMs,
+            });
     }
     createBucket() {
         return {

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

@@ -59,13 +59,15 @@ function calculateDelay(attempt, config, strategy = 'exponential') {
     return Math.round(Math.max(0, delay));
 }
 /**
- * Fibonacci helper for fibonacci backoff
+ * Fibonacci helper for fibonacci backoff — capped at n=40 to prevent
+ * excessively long loops when maxAttempts is set to a large value.
  */
 function fibonacci(n) {
-    if (n <= 1)
+    const capped = Math.min(n, 40);
+    if (capped <= 1)
         return 1;
     let a = 1, b = 1;
-    for (let i = 2; i <= n; i++) {
+    for (let i = 2; i <= capped; i++) {
         [a, b] = [b, a + b];
     }
     return b;
@@ -99,8 +101,12 @@ function sleep(ms) {
  */
 export async function withRetry(fn, config = {}, strategy = 'exponential') {
     const finalConfig = { ...DEFAULT_CONFIG, ...config };
+    // Clamp maxAttempts and maxDelayMs to safe ranges to prevent runaway retry loops
+    finalConfig.maxAttempts = Math.min(Math.max(1, finalConfig.maxAttempts), 100);
+    finalConfig.maxDelayMs = Math.min(Math.max(0, finalConfig.maxDelayMs), 300_000); // 5 min ceiling
     const startTime = Date.now();
     const retryHistory = [];
+    const MAX_RETRY_HISTORY = 100;
     let lastError;
     let attempt = 0;
     while (attempt < finalConfig.maxAttempts) {
@@ -129,12 +135,14 @@ export async function withRetry(fn, config = {}, strategy = 'exponential') {
             }
             // Calculate delay
             const delay = calculateDelay(attempt, finalConfig, strategy);
-            // Record retry
-            retryHistory.push({
-                attempt,
-                error: lastError.message,
-                delayMs: delay,
-            });
+            // Record retry (cap history size and error message length to prevent OOM)
+            if (retryHistory.length < MAX_RETRY_HISTORY) {
+                retryHistory.push({
+                    attempt,
+                    error: lastError.message.slice(0, 512),
+                    delayMs: delay,
+                });
+            }
             // Call retry callback
             if (finalConfig.onRetry) {
                 finalConfig.onRetry(lastError, attempt, delay);

package/packages/@monomind/cli/dist/src/routing/embed-worker.js

@@ -22,12 +22,16 @@ import { createSemanticRouting } from './embedder.js';
 // don't land on stdout and corrupt the single JSON result line the parent
 // parses. Must be set before the (lazy) transformers import in embedder.ts.
 process.env.TRANSFORMERS_VERBOSITY ??= 'error';
+/** Max task string length before it's silently truncated — prevents OOM in the embedding model. */
+const MAX_TASK_LENGTH = 2_000;
 async function main() {
-    const task = process.argv[2];
-    if (!task) {
+    const rawTask = process.argv[2];
+    if (!rawTask) {
         process.stderr.write('embed-worker: missing task argument\n');
         process.exit(2);
     }
+    // Cap the task to prevent OOM when an oversized string is passed to the embedding model.
+    const task = rawTask.length > MAX_TASK_LENGTH ? rawTask.slice(0, MAX_TASK_LENGTH) : rawTask;
     const { RouteLayer, ALL_ROUTES } = await import('@monomind/routing');
     const semantic = await createSemanticRouting(ALL_ROUTES);
     if (!semantic) {

package/packages/@monomind/cli/dist/src/routing/llm-caller.js

@@ -16,6 +16,8 @@ import { spawn, execSync } from 'child_process';
 import { tmpdir } from 'os';
 /** Default model for routing fallback — Haiku is fast and cheap for slug classification. */
 const DEFAULT_ROUTING_MODEL = 'haiku';
+/** Runtime-validated set of allowed model aliases. */
+const ALLOWED_MODELS = new Set(['haiku', 'sonnet', 'opus']);
 /**
  * Max time to wait for a single classification before giving up.
  * `claude --print` is a full headless session (cold start ~10s, can spike),
@@ -23,6 +25,8 @@ const DEFAULT_ROUTING_MODEL = 'haiku';
  * on timeout rather than blocking the caller.
  */
 const DEFAULT_TIMEOUT_MS = 45_000;
+/** Hard upper cap on caller-supplied timeoutMs — prevents disabling the SIGTERM/SIGKILL guard. */
+const MAX_TIMEOUT_MS = 120_000;
 /** Cap captured output so a runaway child can't grow parent memory unbounded. */
 const MAX_OUTPUT = 1024 * 1024; // 1 MB — a slug response is tiny
 let claudeAvailable = null;
@@ -49,8 +53,15 @@ export function isClaudeCodeAvailable() {
 export function createClaudeLLMCaller(options = {}) {
     if (!isClaudeCodeAvailable())
         return null;
-    const model = options.model ?? DEFAULT_ROUTING_MODEL;
-    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    // Runtime enum guard — TypeScript union is compile-time only; JS callers
+    // could otherwise inject an arbitrary string into the --model flag.
+    const rawModel = options.model ?? DEFAULT_ROUTING_MODEL;
+    const model = ALLOWED_MODELS.has(rawModel) ? rawModel : DEFAULT_ROUTING_MODEL;
+    // Cap caller-supplied timeout so a huge value can't disable the SIGTERM/SIGKILL guard.
+    const rawTimeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const timeoutMs = Math.min(typeof rawTimeout === 'number' && Number.isFinite(rawTimeout) && rawTimeout > 0
+        ? rawTimeout
+        : DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
     const cwd = options.cwd ?? tmpdir();
     return (prompt) => new Promise((resolve, reject) => {
         const env = { ...process.env };

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

@@ -25,12 +25,20 @@ const WORKER_PATH = join(dirname(fileURLToPath(import.meta.url)), 'embed-worker.
 const WORKER_TIMEOUT_MS = 90_000;
 /** Cap worker stdout so a runaway child can't grow parent memory unbounded. */
 const MAX_WORKER_OUTPUT = 4 * 1024 * 1024; // 4 MB
+/** Cap the task string length to prevent OOM/DoS via oversized argv. */
+const MAX_TASK_LENGTH = 2_000;
+/** Cap stderr reflected in error messages to prevent log-inflation attacks. */
+const MAX_STDERR_IN_ERROR = 500;
+/** Cap allScores array passed to the LLM fallback to prevent downstream OOM. */
+const MAX_ALL_SCORES = 100;
 /** Marker the worker prefixes its result line with (see embed-worker.ts). */
 const RESULT_MARKER = '__ROUTE_RESULT__';
 /** Run the embedding worker for one task. Resolves the RouteResult, or rejects. */
 function runWorker(task) {
+    // Cap task length before passing as argv to prevent OOM/DoS via oversized args.
+    const safeTask = task.length > MAX_TASK_LENGTH ? task.slice(0, MAX_TASK_LENGTH) : task;
     return new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [WORKER_PATH, task], {
+        const child = spawn(process.execPath, [WORKER_PATH, safeTask], {
             stdio: ['ignore', 'pipe', 'pipe'],
             windowsHide: true,
         });
@@ -75,7 +83,10 @@ function runWorker(task) {
             settled = true;
             clearTimeout(timer);
             if (code !== 0) {
-                reject(new Error(stderr.trim() || `worker exited ${code}`));
+                // Truncate stderr before embedding in Error to prevent log-inflation via
+                // a malicious or runaway child writing oversized diagnostic output.
+                const stderrSnippet = stderr.trim().slice(0, MAX_STDERR_IN_ERROR);
+                reject(new Error(stderrSnippet || `worker exited ${code}`));
                 return;
             }
             // Extract the marked result line — model-loader output may have written
@@ -130,8 +141,12 @@ export async function createConfiguredRouteLayer(opts = {}) {
                 }
                 // 3. Below threshold → Claude fallback in the parent, reusing scores.
                 if (llmCaller && Array.isArray(semantic.allScores) && semantic.allScores.length) {
+                    // Cap allScores to prevent downstream OOM if the worker sends an oversized array.
+                    const scores = semantic.allScores.length > MAX_ALL_SCORES
+                        ? semantic.allScores.slice(0, MAX_ALL_SCORES)
+                        : semantic.allScores;
                     const fallback = new LLMFallbackRouter({ llmCaller, model: 'haiku' });
-                    return fallback.classify(taskDescription, ALL_ROUTES, semantic.allScores);
+                    return fallback.classify(taskDescription, ALL_ROUTES, scores);
                 }
                 if (!opts.debug)
                     delete semantic.allScores;

package/packages/@monomind/cli/dist/src/services/claim-service.d.ts

@@ -129,6 +129,7 @@ export declare class ClaimService extends EventEmitter {
     private eventLog;
     constructor(projectRoot: string, config?: Partial<ClaimServiceConfig>);
     initialize(): Promise<void>;
+    private static readonly MAX_CLAIMS_FILE_BYTES;
     private loadClaims;
     private _saveQueue;
     private saveClaims;

package/packages/@monomind/cli/dist/src/services/claim-service.js

@@ -57,10 +57,18 @@ export class ClaimService extends EventEmitter {
         // Load existing claims
         await this.loadClaims();
     }
+    // Hard cap on claims.json: a file larger than this is malformed or
+    // adversarially crafted (normal claim files are tiny).
+    static MAX_CLAIMS_FILE_BYTES = 10 * 1024 * 1024; // 10 MB
     async loadClaims() {
         const claimsFile = path.join(this.storagePath, 'claims.json');
         if (fs.existsSync(claimsFile)) {
             try {
+                const fileSize = fs.statSync(claimsFile).size;
+                if (fileSize > ClaimService.MAX_CLAIMS_FILE_BYTES) {
+                    // Oversized file — skip loading rather than OOM-ing the daemon
+                    return;
+                }
                 const data = JSON.parse(fs.readFileSync(claimsFile, 'utf-8'));
                 for (const claim of data.claims || []) {
                     claim.claimedAt = new Date(claim.claimedAt);