monomind 1.11.14 → 1.12.0

package/packages/@monomind/cli/dist/src/browser/cdp.js

@@ -68,6 +68,11 @@ export class CdpClient {
                 reject(new Error('CDP not connected'));
                 return;
             }
+            // Cap in-flight commands to prevent unbounded Map growth
+            if (this.pendingCommands.size >= 1000) {
+                reject(new Error('CDP command queue full (>1000 in-flight commands)'));
+                return;
+            }
             const id = this.nextId++;
             const cmd = { id, method, params };
             if (sessionId)
@@ -88,7 +93,12 @@ export class CdpClient {
         if (!this.eventListeners.has(event)) {
             this.eventListeners.set(event, new Set());
         }
-        this.eventListeners.get(event).add(fn);
+        const listeners = this.eventListeners.get(event);
+        // Cap listeners per event to prevent unbounded Set growth
+        if (listeners.size >= 100) {
+            throw new Error(`CDP event listener limit reached for event: ${event}`);
+        }
+        listeners.add(fn);
         return () => this.eventListeners.get(event)?.delete(fn);
     }
     once(event, sessionId) {
@@ -120,16 +130,24 @@ export class CdpClient {
         return this.connected;
     }
 }
+const CDP_RESPONSE_SIZE_LIMIT = 10 * 1024 * 1024; // 10 MB
+async function readCdpJson(res) {
+    const text = await res.text();
+    if (text.length > CDP_RESPONSE_SIZE_LIMIT) {
+        throw new Error(`CDP response too large: ${text.length} bytes`);
+    }
+    return JSON.parse(text);
+}
 export async function fetchTargets(port) {
     const res = await fetch(`http://127.0.0.1:${port}/json/list`);
     if (!res.ok)
         throw new Error(`Failed to fetch targets: ${res.statusText}`);
-    return res.json();
+    return readCdpJson(res);
 }
 export async function fetchNewTarget(port, url) {
     const res = await fetch(`http://127.0.0.1:${port}/json/new?${url}`);
     if (!res.ok)
         throw new Error(`Failed to create target: ${res.statusText}`);
-    return res.json();
+    return readCdpJson(res);
 }
 //# sourceMappingURL=cdp.js.map

package/packages/@monomind/cli/dist/src/browser/har.js

@@ -1,10 +1,29 @@
 import { writeFile } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
+import { join, resolve, relative, isAbsolute } from 'path';
+import { tmpdir, homedir } from 'os';
+const MAX_CONCURRENT_SESSIONS = 100;
+const MAX_REQUESTS_PER_SESSION = 5_000;
 const _sessions = new Map();
+/** Validate output path is within cwd or home dir to prevent path traversal. */
+function safeOutputPath(p) {
+    const resolved = resolve(p);
+    const cwd = process.cwd();
+    const home = homedir();
+    const relCwd = relative(cwd, resolved);
+    const relHome = relative(home, resolved);
+    if ((!relCwd.startsWith('..') && !isAbsolute(relCwd)) ||
+        (!relHome.startsWith('..') && !isAbsolute(relHome))) {
+        return resolved;
+    }
+    // Reject out-of-scope paths — fall back to tmpdir
+    return join(tmpdir(), `monomind-har-${Date.now()}.har`);
+}
 export async function startHarRecording(client, sessionId) {
     if (_sessions.has(sessionId))
         throw new Error('HAR recording already in progress');
+    if (_sessions.size >= MAX_CONCURRENT_SESSIONS) {
+        throw new Error(`HAR recording limit reached (max ${MAX_CONCURRENT_SESSIONS} concurrent sessions)`);
+    }
     const requests = new Map();
     const startTime = Date.now();
     const startWallMs = startTime;
@@ -17,6 +36,9 @@ export async function startHarRecording(client, sessionId) {
     const offReq = client.on('Network.requestWillBeSent', (params, sid) => {
         if (sid !== sessionId)
             return;
+        // Cap to prevent unbounded memory growth on high-traffic pages
+        if (requests.size >= MAX_REQUESTS_PER_SESSION)
+            return;
         const p = params;
         requests.set(p.requestId, {
             id: p.requestId,
@@ -78,9 +100,9 @@ export async function stopHarRecording(client, sessionId, outputPath, captureRes
         }
     }
     const har = buildHar(Array.from(state.requests.values()), state.startTime);
-    const path = outputPath ?? join(tmpdir(), `monomind-har-${Date.now()}.har`);
-    await writeFile(path, JSON.stringify(har, null, 2));
-    return path;
+    const safePath = outputPath ? safeOutputPath(outputPath) : join(tmpdir(), `monomind-har-${Date.now()}.har`);
+    await writeFile(safePath, JSON.stringify(har, null, 2));
+    return safePath;
 }
 export function getHarStatus(sessionId) {
     const state = _sessions.get(sessionId);

package/packages/@monomind/cli/dist/src/commands/agent.js

@@ -19,7 +19,7 @@ function updateSwarmActivityMetrics(agentCountDelta) {
             timestamp: new Date().toISOString(),
             swarm: { active: false, agent_count: 0, coordination_active: false },
         };
-        if (fs.existsSync(activityPath)) {
+        if (fs.existsSync(activityPath) && fs.statSync(activityPath).size <= 10 * 1024 * 1024) {
             data = JSON.parse(fs.readFileSync(activityPath, 'utf-8'));
         }
         else {
@@ -113,8 +113,8 @@ const spawnCommand = {
         { command: 'monomind agent spawn -t researcher --task "Research React 19"', description: 'Spawn researcher with task' }
     ],
     action: async (ctx) => {
-        let agentType = ctx.flags.type;
-        let agentName = ctx.flags.name;
+        let agentType = ctx.flags.type?.slice(0, 64) ?? '';
+        let agentName = ctx.flags.name?.slice(0, 128) ?? '';
         // Interactive mode if type not specified
         if (!agentType && ctx.interactive) {
             agentType = await select({
@@ -123,7 +123,7 @@ const spawnCommand = {
             });
         }
         // Semantic routing: if --type absent but --task provided, use RouteLayer
-        const taskDescription = ctx.flags.task;
+        const taskDescription = ctx.flags.task?.slice(0, 2048);
         if (!agentType && taskDescription) {
             try {
                 // Builds a RouteLayer with a real local embedding model + headless
@@ -453,7 +453,10 @@ const metricsCommand = {
                 const files = readdirSync(agentsDir).filter(f => f.endsWith('.json'));
                 for (const file of files) {
                     try {
-                        const data = JSON.parse(readFileSync(join(agentsDir, file), 'utf-8'));
+                        const agentFilePath = join(agentsDir, file);
+                        if (statSync(agentFilePath).size > 512 * 1024)
+                            continue; // skip files > 512 KB
+                        const data = JSON.parse(readFileSync(agentFilePath, 'utf-8'));
                         totalAgents++;
                         const agType = data.type || 'unknown';
                         if (!typeCounts[agType])
@@ -475,7 +478,7 @@ const metricsCommand = {
         }
         // Read swarm activity for additional state
         const activityFile = join(swarmDir, 'swarm-activity.json');
-        if (existsSync(activityFile)) {
+        if (existsSync(activityFile) && statSync(activityFile).size <= 10 * 1024 * 1024) {
             try {
                 const activity = JSON.parse(readFileSync(activityFile, 'utf-8'));
                 if (activity.totalAgents && totalAgents === 0)
@@ -801,9 +804,9 @@ const logsCommand = {
         { command: 'monomind agent logs -l error --since 1h', description: 'Show errors from last hour' }
     ],
     action: async (ctx) => {
-        const agentId = ctx.args[0] || ctx.flags.id;
+        const agentId = ((ctx.args[0] || ctx.flags.id) ?? '').slice(0, 128);
         const tail = ctx.flags.tail;
-        const level = ctx.flags.level;
+        const level = ctx.flags.level?.slice(0, 32);
         if (!agentId) {
             output.printError('Agent ID is required. Use --id or -i');
             return { success: false, exitCode: 1 };

package/packages/@monomind/cli/dist/src/commands/analyze.js

@@ -28,6 +28,19 @@ async function getASTAnalyzer() {
 async function getGraphAnalyzer() {
     return null;
 }
+/**
+ * Write analysis output to a file, constraining the path to the current working
+ * directory to prevent path traversal attacks via --output /etc/cron.d/x or
+ * similar. Throws if the resolved path escapes cwd.
+ */
+async function safeWriteOutputFile(outputFile, data) {
+    const projectRoot = path.resolve(process.cwd());
+    const fullPath = path.resolve(process.cwd(), outputFile);
+    if (!fullPath.startsWith(projectRoot + path.sep) && fullPath !== projectRoot) {
+        throw new Error(`Output path must resolve within the project directory: ${projectRoot}`);
+    }
+    await writeFile(fullPath, data);
+}
 // Diff subcommand
 const diffCommand = {
     name: 'diff',
@@ -557,7 +570,7 @@ const astCommand = {
             if (formatType === 'json') {
                 const jsonOutput = { files: results, totals };
                 if (outputFile) {
-                    await writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
+                    await safeWriteOutputFile(outputFile, JSON.stringify(jsonOutput, null, 2));
                     output.printSuccess(`Results written to ${outputFile}`);
                 }
                 else {
@@ -649,7 +662,7 @@ const astCommand = {
                 }
             }
             if (outputFile) {
-                await writeFile(outputFile, JSON.stringify({ files: results, totals }, null, 2));
+                await safeWriteOutputFile(outputFile, JSON.stringify({ files: results, totals }, null, 2));
                 output.printSuccess(`Results written to ${outputFile}`);
             }
             return { success: true, data: { files: results, totals } };
@@ -750,7 +763,7 @@ const complexityAstCommand = {
             if (formatType === 'json') {
                 const jsonOutput = { files: results, summary: { total: results.length, flagged: flaggedCount, avgComplexity, threshold } };
                 if (outputFile) {
-                    await writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
+                    await safeWriteOutputFile(outputFile, JSON.stringify(jsonOutput, null, 2));
                     output.printSuccess(`Results written to ${outputFile}`);
                 }
                 else {
@@ -800,7 +813,7 @@ const complexityAstCommand = {
                 output.writeln(output.dim(`  ... and ${results.length - 15} more files`));
             }
             if (outputFile) {
-                await writeFile(outputFile, JSON.stringify({ files: results, summary: { total: results.length, flagged: flaggedCount, avgComplexity, threshold } }, null, 2));
+                await safeWriteOutputFile(outputFile, JSON.stringify({ files: results, summary: { total: results.length, flagged: flaggedCount, avgComplexity, threshold } }, null, 2));
                 output.printSuccess(`Results written to ${outputFile}`);
             }
             return { success: true, data: { files: results, flaggedCount } };
@@ -907,7 +920,7 @@ const symbolsCommand = {
             symbols.sort((a, b) => a.file.localeCompare(b.file) || a.name.localeCompare(b.name));
             if (formatType === 'json') {
                 if (outputFile) {
-                    await writeFile(outputFile, JSON.stringify(symbols, null, 2));
+                    await safeWriteOutputFile(outputFile, JSON.stringify(symbols, null, 2));
                     output.printSuccess(`Results written to ${outputFile}`);
                 }
                 else {
@@ -941,7 +954,7 @@ const symbolsCommand = {
                 output.writeln(output.dim(`  ... and ${symbols.length - 30} more symbols`));
             }
             if (outputFile) {
-                await writeFile(outputFile, JSON.stringify(symbols, null, 2));
+                await safeWriteOutputFile(outputFile, JSON.stringify(symbols, null, 2));
                 output.printSuccess(`Results written to ${outputFile}`);
             }
             return { success: true, data: symbols };
@@ -1043,7 +1056,7 @@ const importsCommand = {
                     fileImports: Object.fromEntries(fileImports),
                 };
                 if (outputFile) {
-                    await writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
+                    await safeWriteOutputFile(outputFile, JSON.stringify(jsonOutput, null, 2));
                     output.printSuccess(`Results written to ${outputFile}`);
                 }
                 else {
@@ -1081,7 +1094,7 @@ const importsCommand = {
                 output.writeln(output.dim(`  ... and ${sortedImports.length - 20} more imports`));
             }
             if (outputFile) {
-                await writeFile(outputFile, JSON.stringify({
+                await safeWriteOutputFile(outputFile, JSON.stringify({
                     imports: Object.fromEntries(sortedImports),
                     fileImports: Object.fromEntries(fileImports),
                 }, null, 2));
@@ -1378,7 +1391,8 @@ const boundariesCommand = {
     ],
     action: async (ctx) => {
         const targetDir = ctx.args[0] || ctx.cwd;
-        const numPartitions = ctx.flags.partitions || 2;
+        const rawPartitions = ctx.flags.partitions || 2;
+        const numPartitions = Number.isFinite(rawPartitions) ? Math.max(1, Math.min(rawPartitions, 100)) : 2;
         const outputFile = ctx.flags.output;
         const format = ctx.flags.format || 'text';
         output.printInfo(`Analyzing code boundaries in: ${output.highlight(targetDir)}`);
@@ -1406,7 +1420,7 @@ const boundariesCommand = {
                     circularDependencies: result.circularDependencies,
                 };
                 if (outputFile) {
-                    await writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
+                    await safeWriteOutputFile(outputFile, JSON.stringify(jsonOutput, null, 2));
                     output.printSuccess(`Results written to ${outputFile}`);
                 }
                 else {
@@ -1420,7 +1434,7 @@ const boundariesCommand = {
                     highlightCycles: true,
                 });
                 if (outputFile) {
-                    await writeFile(outputFile, dotOutput);
+                    await safeWriteOutputFile(outputFile, dotOutput);
                     output.printSuccess(`DOT graph written to ${outputFile}`);
                     output.writeln(output.dim('Visualize with: dot -Tpng -o graph.png ' + outputFile));
                 }
@@ -1480,7 +1494,7 @@ const boundariesCommand = {
                 }
             }
             if (outputFile) {
-                await writeFile(outputFile, JSON.stringify(result, null, 2));
+                await safeWriteOutputFile(outputFile, JSON.stringify(result, null, 2));
                 output.printSuccess(`Full results written to ${outputFile}`);
             }
             return { success: true, data: result };
@@ -1558,7 +1572,7 @@ const modulesCommand = {
                     statistics: result.statistics,
                 };
                 if (outputFile) {
-                    await writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
+                    await safeWriteOutputFile(outputFile, JSON.stringify(jsonOutput, null, 2));
                     output.printSuccess(`Results written to ${outputFile}`);
                 }
                 else {
@@ -1573,7 +1587,7 @@ const modulesCommand = {
                     highlightCycles: true,
                 });
                 if (outputFile) {
-                    await writeFile(outputFile, dotOutput);
+                    await safeWriteOutputFile(outputFile, dotOutput);
                     output.printSuccess(`DOT graph written to ${outputFile}`);
                     output.writeln(output.dim('Visualize with: dot -Tpng -o modules.png ' + outputFile));
                 }
@@ -1614,7 +1628,7 @@ const modulesCommand = {
                 }
             }
             if (outputFile) {
-                await writeFile(outputFile, JSON.stringify(result, null, 2));
+                await safeWriteOutputFile(outputFile, JSON.stringify(result, null, 2));
                 output.printSuccess(`Full results written to ${outputFile}`);
             }
             return { success: true, data: result };
@@ -1682,7 +1696,8 @@ const dependenciesCommand = {
         const format = ctx.flags.format || 'text';
         const include = (ctx.flags.include || '.ts,.tsx,.js,.jsx,.mjs,.cjs').split(',');
         const exclude = (ctx.flags.exclude || 'node_modules,dist,build,.git').split(',');
-        const maxDepth = ctx.flags.depth || 10;
+        const rawDepth = ctx.flags.depth || 10;
+        const maxDepth = Number.isFinite(rawDepth) ? Math.max(1, Math.min(rawDepth, 50)) : 10;
         output.printInfo(`Building dependency graph for: ${output.highlight(targetDir)}`);
         output.writeln();
         const spinner = output.createSpinner({ text: 'Scanning files...', spinner: 'dots' });
@@ -1711,7 +1726,7 @@ const dependenciesCommand = {
                     circularDependencies: circularDeps,
                 };
                 if (outputFile) {
-                    await writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
+                    await safeWriteOutputFile(outputFile, JSON.stringify(jsonOutput, null, 2));
                     output.printSuccess(`Graph written to ${outputFile}`);
                 }
                 else {
@@ -1733,7 +1748,7 @@ const dependenciesCommand = {
                     highlightCycles: true,
                 });
                 if (outputFile) {
-                    await writeFile(outputFile, dotOutput);
+                    await safeWriteOutputFile(outputFile, dotOutput);
                     output.printSuccess(`DOT graph written to ${outputFile}`);
                     output.writeln(output.dim('Visualize with: dot -Tpng -o deps.png ' + outputFile));
                 }
@@ -1791,7 +1806,7 @@ const dependenciesCommand = {
                     metadata: graph.metadata,
                     circularDependencies: circularDeps,
                 };
-                await writeFile(outputFile, JSON.stringify(fullOutput, null, 2));
+                await safeWriteOutputFile(outputFile, JSON.stringify(fullOutput, null, 2));
                 output.printSuccess(`Full results written to ${outputFile}`);
             }
             return { success: true };
@@ -1865,7 +1880,7 @@ const circularCommand = {
             if (format === 'json') {
                 const jsonOutput = { cycles: filtered, total: cycles.length, filtered: filtered.length };
                 if (outputFile) {
-                    await writeFile(outputFile, JSON.stringify(jsonOutput, null, 2));
+                    await safeWriteOutputFile(outputFile, JSON.stringify(jsonOutput, null, 2));
                     output.printSuccess(`Results written to ${outputFile}`);
                 }
                 else {
@@ -1909,7 +1924,7 @@ const circularCommand = {
                 }
             }
             if (outputFile) {
-                await writeFile(outputFile, JSON.stringify({ cycles: filtered }, null, 2));
+                await safeWriteOutputFile(outputFile, JSON.stringify({ cycles: filtered }, null, 2));
                 output.printSuccess(`Results written to ${outputFile}`);
             }
             return { success: true, data: { cycles: filtered } };

package/packages/@monomind/cli/dist/src/commands/autopilot.js

@@ -151,8 +151,11 @@ const configCommand = {
             state.maxIterations = validateNumber(maxIter, 1, 1000, state.maxIterations);
         if (timeout)
             state.timeoutMinutes = validateNumber(timeout, 1, 1440, state.timeoutMinutes);
-        if (sources)
-            state.taskSources = validateTaskSources(sources.split(',').map(s => s.trim()).filter(Boolean));
+        if (sources) {
+            // Cap total sources string length before splitting to prevent O(n) split on huge input
+            const cappedSources = sources.length > 512 ? sources.slice(0, 512) : sources;
+            state.taskSources = validateTaskSources(cappedSources.split(',').map(s => s.trim()).filter(Boolean));
+        }
         saveState(state);
         appendLog({ ts: Date.now(), event: 'config-updated', maxIterations: state.maxIterations, timeoutMinutes: state.timeoutMinutes, taskSources: state.taskSources });
         output.writeln(`Config updated: maxIterations=${state.maxIterations}, timeout=${state.timeoutMinutes}min, sources=${state.taskSources.join(',')}`);
@@ -248,12 +251,17 @@ const historyCommand = {
         { name: 'json', type: 'boolean', description: 'Output as JSON' },
     ],
     action: async (ctx) => {
-        const query = (ctx.flags?.query || '');
+        const rawQuery = (ctx.flags?.query || '');
         const limit = validateNumber(ctx.flags?.limit, 1, 100, 10);
-        if (!query) {
+        if (!rawQuery) {
             output.writeln('Usage: autopilot history --query "search terms" [--limit N]');
             return { success: false, message: 'Missing --query' };
         }
+        if (rawQuery.length > 1024) {
+            output.writeln('Error: --query too long (max 1024 characters)');
+            return { success: false, message: 'Query too long' };
+        }
+        const query = rawQuery;
         const learning = await tryLoadLearning();
         if (!learning) {
             output.writeln('Learning not available. No history to search.');

package/packages/@monomind/cli/dist/src/commands/benchmark.js

@@ -5,7 +5,7 @@
  * @module v1/cli/commands/benchmark
  */
 import { output } from '../output.js';
-import { writeFileSync, renameSync, readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { writeFileSync, renameSync, readFileSync, existsSync, mkdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { BenchmarkRunner } from '../benchmarks/benchmark-runner.js';
 // ============================================================================
@@ -63,9 +63,12 @@ const neuralCommand = {
         { command: 'monomind benchmark neural -d 768 -n 5000', description: 'Higher dimension, more vectors' },
     ],
     action: async (ctx) => {
-        const iterations = parseInt(ctx.flags.iterations || '100', 10);
-        const dimension = parseInt(ctx.flags.dimension || '384', 10);
-        const numVectors = parseInt(ctx.flags.vectors || '1000', 10);
+        const iterationsRaw = parseInt(ctx.flags.iterations || '100', 10);
+        const iterations = Number.isFinite(iterationsRaw) ? Math.max(1, Math.min(iterationsRaw, 10_000)) : 100;
+        const dimensionRaw = parseInt(ctx.flags.dimension || '384', 10);
+        const dimension = Number.isFinite(dimensionRaw) ? Math.max(1, Math.min(dimensionRaw, 4096)) : 384;
+        const numVectorsRaw = parseInt(ctx.flags.vectors || '1000', 10);
+        const numVectors = Number.isFinite(numVectorsRaw) ? Math.max(1, Math.min(numVectorsRaw, 100_000)) : 1000;
         const outputFormat = ctx.flags.output || 'text';
         output.writeln();
         output.writeln(output.bold('Neural Operations Benchmark'));
@@ -228,7 +231,8 @@ const memoryCommand = {
         { command: 'monomind benchmark memory', description: 'Run memory benchmarks' },
     ],
     action: async (ctx) => {
-        const iterations = parseInt(ctx.flags.iterations || '100', 10);
+        const iterationsRaw = parseInt(ctx.flags.iterations || '100', 10);
+        const iterations = Number.isFinite(iterationsRaw) ? Math.max(1, Math.min(iterationsRaw, 10_000)) : 100;
         const outputFormat = ctx.flags.output || 'text';
         output.writeln();
         output.writeln(output.bold('Memory Operations Benchmark'));
@@ -384,7 +388,15 @@ const allCommand = {
             if (!existsSync(resultsDir)) {
                 mkdirSync(resultsDir, { recursive: true });
             }
-            const savePath = saveFile.startsWith('/') ? saveFile : join(resultsDir, saveFile);
+            // Path traversal guard: resolve within resultsDir regardless of whether saveFile is absolute
+            const { resolve: resolvePath, basename } = await import('node:path');
+            const safeName = basename(saveFile);
+            const savePath = resolvePath(resultsDir, safeName);
+            const resolvedResultsDir = resolvePath(resultsDir);
+            if (!savePath.startsWith(resolvedResultsDir + '/') && savePath !== resolvedResultsDir) {
+                output.writeln(output.error(`Save path must be within ${resultsDir}`));
+                return { success: false, message: 'Invalid save path' };
+            }
             const saveTmp2 = savePath + '.tmp';
             writeFileSync(saveTmp2, JSON.stringify({
                 timestamp: new Date().toISOString(),
@@ -416,14 +428,30 @@ const regressionCommand = {
         { command: 'monomind benchmark regression -b agent-spawn -a output.txt --pin-baseline', description: 'Evaluate and pin results as new baseline' },
     ],
     action: async (ctx) => {
-        const suiteDir = ctx.flags.suite || '.monomind/benchmarks/definitions';
+        const suiteDirRaw = ctx.flags.suite || '.monomind/benchmarks/definitions';
         const benchmarkId = ctx.flags['benchmark-id'];
         const agentOutputFile = ctx.flags['agent-output'];
         const pinBaseline = ctx.flags['pin-baseline'] === true;
         const outputFormat = ctx.flags.output || 'text';
+        // Validate benchmarkId to prevent path traversal in baseline file names
+        if (benchmarkId !== undefined) {
+            if (!/^[a-zA-Z0-9_-]{1,128}$/.test(benchmarkId)) {
+                output.writeln(output.error('Invalid benchmark-id: must contain only alphanumeric, dash, or underscore characters (max 128).'));
+                return { success: false, message: 'Invalid benchmark-id' };
+            }
+        }
         const runner = new BenchmarkRunner();
         const baselinesDir = join(process.cwd(), '.monomind', 'benchmarks', 'baselines');
-        const definitions = runner.loadBenchmarks(join(process.cwd(), suiteDir));
+        // Path traversal guard for suiteDir
+        const { resolve: resolvePath2 } = await import('node:path');
+        const projectRoot = resolvePath2(process.cwd());
+        const resolvedSuiteDir = resolvePath2(process.cwd(), suiteDirRaw);
+        if (!resolvedSuiteDir.startsWith(projectRoot + '/') && resolvedSuiteDir !== projectRoot) {
+            output.writeln(output.error(`Suite directory must be within the project: ${projectRoot}`));
+            return { success: false, message: 'Invalid suite directory' };
+        }
+        const suiteDir = suiteDirRaw;
+        const definitions = runner.loadBenchmarks(resolvedSuiteDir);
         if (definitions.length === 0) {
             output.writeln(output.dim(`No benchmark definitions found in ${suiteDir}`));
             output.writeln(output.dim('Create JSON files there to define quality benchmarks.'));
@@ -446,6 +474,15 @@ const regressionCommand = {
             output.writeln(output.error(`Agent output file not found: ${agentOutputFile}`));
             return { success: false, message: 'Agent output file not found' };
         }
+        const MAX_AGENT_OUTPUT_BYTES = 10 * 1024 * 1024; // 10 MB
+        try {
+            const agentOutputStat = statSync(agentOutputFile);
+            if (agentOutputStat.size > MAX_AGENT_OUTPUT_BYTES) {
+                output.writeln(output.error(`Agent output file too large: ${agentOutputFile} (max 10 MB)`));
+                return { success: false, message: 'Agent output file too large' };
+            }
+        }
+        catch { /* existsSync already passed; ignore stat failure */ }
         const agentOutput = readFileSync(agentOutputFile, 'utf-8');
         const targetDefs = benchmarkId
             ? definitions.filter((d) => d.benchmarkId === benchmarkId)
@@ -473,8 +510,14 @@ const regressionCommand = {
             output.writeln();
         }
         // Baseline comparison
+        const MAX_BASELINE_BYTES = 5 * 1024 * 1024; // 5 MB
         const baselinePath = join(baselinesDir, `${benchmarkId ?? 'all'}.json`);
         if (existsSync(baselinePath)) {
+            const baselineStat = statSync(baselinePath);
+            if (baselineStat.size > MAX_BASELINE_BYTES) {
+                output.writeln(output.error(`Baseline file too large (max 5 MB)`));
+                return { success: false, message: 'Baseline file too large' };
+            }
             const baseline = JSON.parse(readFileSync(baselinePath, 'utf-8'));
             const hasRegression = runner.detectRegression(results, baseline);
             if (hasRegression) {

package/packages/@monomind/cli/dist/src/commands/browse.js

@@ -214,13 +214,16 @@ const waitCommand = {
         const { client, sessionId } = await ensureConnected(_port);
         const browser = await getBrowser();
         if (ctx.flags.ms) {
-            await new Promise((r) => setTimeout(r, ctx.flags.ms));
+            const rawMs = ctx.flags.ms;
+            const waitMs = Number.isFinite(rawMs) ? Math.max(0, Math.min(rawMs, 60_000)) : 0; // cap at 60s
+            await new Promise((r) => setTimeout(r, waitMs));
             output.printSuccess(`Waited ${ctx.flags.ms}ms`);
             return { success: true };
         }
         if (ctx.flags.fn) {
             const expr = ctx.flags.fn;
-            const timeout = ctx.flags.timeout ?? 30000;
+            const rawTimeout = ctx.flags.timeout ?? 30000;
+            const timeout = Number.isFinite(rawTimeout) ? Math.max(100, Math.min(rawTimeout, 300_000)) : 30000; // cap at 5min
             const interval = 200;
             const deadline = Date.now() + timeout;
             while (Date.now() < deadline) {

package/packages/@monomind/cli/dist/src/commands/claims.js

@@ -35,7 +35,7 @@ function safeParseJson(content) {
 function loadClaimsConfig() {
     const configPaths = getClaimsConfigPaths();
     for (const configPath of configPaths) {
-        if (fs.existsSync(configPath)) {
+        if (fs.existsSync(configPath) && fs.statSync(configPath).size <= 1024 * 1024) {
             const content = fs.readFileSync(configPath, 'utf-8');
             return { config: safeParseJson(content), path: configPath };
         }
@@ -153,13 +153,19 @@ const checkCommand = {
         { command: 'monomind claims check -c admin:delete -u user123', description: 'Check user permission' },
     ],
     action: async (ctx) => {
-        const claim = ctx.flags.claim;
-        const user = ctx.flags.user || 'current';
-        const resource = ctx.flags.resource;
+        const claim = (ctx.flags.claim || '').slice(0, 256);
+        const user = (ctx.flags.user || 'current').slice(0, 128);
+        const resource = (ctx.flags.resource || '').slice(0, 256);
         if (!claim) {
             output.printError('Claim is required');
             return { success: false, exitCode: 1 };
         }
+        // Block prototype-polluting user or resource keys.
+        const PROTO_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+        if (PROTO_KEYS.has(user)) {
+            output.printError(`Forbidden user key: "${user}"`);
+            return { success: false, exitCode: 1 };
+        }
         output.writeln();
         output.writeln(output.bold('Claim Check'));
         output.writeln(output.dim('─'.repeat(40)));
@@ -189,7 +195,7 @@ const checkCommand = {
                 defaultClaims: ['swarm:create', 'swarm:status', 'agent:spawn', 'agent:list', 'memory:read', 'memory:write', 'task:create'],
             };
             for (const configPath of claimsConfigPaths) {
-                if (fs.existsSync(configPath)) {
+                if (fs.existsSync(configPath) && fs.statSync(configPath).size <= 1024 * 1024) {
                     const content = fs.readFileSync(configPath, 'utf-8');
                     claimsConfig = { ...claimsConfig, ...safeParseJson(content) };
                     policySource = configPath;
@@ -283,9 +289,9 @@ const grantCommand = {
         { command: 'monomind claims grant -c agent:spawn -r developer', description: 'Grant to role' },
     ],
     action: async (ctx) => {
-        const claim = ctx.flags.claim;
-        const user = ctx.flags.user;
-        const role = ctx.flags.role;
+        const claim = (ctx.flags.claim || '').slice(0, 256);
+        const user = (ctx.flags.user || '').slice(0, 128);
+        const role = (ctx.flags.role || '').slice(0, 64);
         if (!claim) {
             output.printError('Claim is required');
             return { success: false, exitCode: 1 };
@@ -294,6 +300,12 @@ const grantCommand = {
             output.printError('Either user or role is required');
             return { success: false, exitCode: 1 };
         }
+        // Block prototype-polluting user or role keys.
+        const PROTO_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+        if ((user && PROTO_KEYS.has(user)) || (role && PROTO_KEYS.has(role))) {
+            output.printError('Forbidden user or role key');
+            return { success: false, exitCode: 1 };
+        }
         try {
             const { config, path: configPath } = loadClaimsConfig();
             if (user) {
@@ -343,9 +355,9 @@ const revokeCommand = {
         { command: 'monomind claims revoke -c admin:* -r guest', description: 'Revoke from role' },
     ],
     action: async (ctx) => {
-        const claim = ctx.flags.claim;
-        const user = ctx.flags.user;
-        const role = ctx.flags.role;
+        const claim = (ctx.flags.claim || '').slice(0, 256);
+        const user = (ctx.flags.user || '').slice(0, 128);
+        const role = (ctx.flags.role || '').slice(0, 64);
         if (!claim) {
             output.printError('Claim is required');
             return { success: false, exitCode: 1 };
@@ -354,6 +366,12 @@ const revokeCommand = {
             output.printError('Either user or role is required');
             return { success: false, exitCode: 1 };
         }
+        // Block prototype-polluting user or role keys.
+        const PROTO_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+        if ((user && PROTO_KEYS.has(user)) || (role && PROTO_KEYS.has(role))) {
+            output.printError('Forbidden user or role key');
+            return { success: false, exitCode: 1 };
+        }
         try {
             const { config, path: configPath } = loadClaimsConfig();
             let removed = false;