monomind 1.11.14 → 1.13.0

package/packages/@monomind/cli/dist/src/mcp-tools/neural-tools.js

@@ -147,7 +147,12 @@ export const neuralTools = [
         },
         handler: async (input) => {
             const store = loadNeuralStore();
-            const modelId = input.modelId || `model-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+            // Cap modelId to prevent DoS via oversized object keys written to the neural store JSON.
+            const MAX_MODEL_ID_LEN = 256;
+            const rawModelId = input.modelId || `model-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+            const modelId = typeof rawModelId === 'string' && rawModelId.length > MAX_MODEL_ID_LEN
+                ? rawModelId.slice(0, MAX_MODEL_ID_LEN)
+                : rawModelId;
             const RESERVED_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
             if (RESERVED_KEYS.has(modelId)) {
                 return { success: false, error: 'Invalid modelId' };
@@ -160,8 +165,19 @@ export const neuralTools = [
             if (Object.keys(store.models ?? {}).length >= MAX_MODELS) {
                 return { success: false, error: `Model store full (max ${MAX_MODELS}). Delete old models first.` };
             }
-            const modelType = input.modelType;
-            const epochs = input.epochs || 10;
+            // Runtime-validate modelType against the allowed enum. The JSON schema
+            // declares an enum but callers that bypass schema validation (e.g. direct
+            // MCP calls) can pass arbitrary strings, which would be stored verbatim.
+            const VALID_MODEL_TYPES = new Set(['moe', 'transformer', 'classifier', 'embedding']);
+            const rawModelType = input.modelType;
+            if (!rawModelType || !VALID_MODEL_TYPES.has(rawModelType)) {
+                return { success: false, error: `Invalid modelType "${rawModelType}". Must be one of: moe, transformer, classifier, embedding` };
+            }
+            const modelType = rawModelType;
+            // Cap epochs to prevent storing absurdly large numbers in the JSON store.
+            const MAX_EPOCHS = 10000;
+            const rawEpochs = typeof input.epochs === 'number' && Number.isFinite(input.epochs) ? input.epochs : 10;
+            const epochs = Math.max(1, Math.min(Math.floor(rawEpochs), MAX_EPOCHS));
             const model = {
                 id: modelId,
                 name: `${modelType}-model`,
@@ -225,7 +241,7 @@ export const neuralTools = [
                 try {
                     const patternsPath = join(getNeuralDir(), PATTERNS_FILE);
                     let existing = [];
-                    if (existsSync(patternsPath)) {
+                    if (existsSync(patternsPath) && statSync(patternsPath).size <= MAX_NEURAL_STORE_BYTES) {
                         const raw = readFileSync(patternsPath, 'utf-8');
                         const parsed = JSON.parse(raw);
                         if (Array.isArray(parsed))
@@ -282,7 +298,12 @@ export const neuralTools = [
         },
         handler: async (input) => {
             const store = loadNeuralStore();
-            const modelId = input.modelId;
+            // Cap modelId to prevent O(n) hash/compare cost on absurdly long keys.
+            const MAX_MODEL_ID_LEN_PRED = 256;
+            const rawModelIdPred = input.modelId;
+            const modelId = typeof rawModelIdPred === 'string' && rawModelIdPred.length > MAX_MODEL_ID_LEN_PRED
+                ? rawModelIdPred.slice(0, MAX_MODEL_ID_LEN_PRED)
+                : rawModelIdPred;
             const inputText = typeof input.input === 'string' ? input.input.slice(0, 16 * 1024) : '';
             const topK = Math.max(1, Math.min(input.topK || 3, 50));
             const RESERVED_KEYS_PRED = new Set(['__proto__', 'constructor', 'prototype']);
@@ -309,7 +330,7 @@ export const neuralTools = [
             const cliPatternsRaw = [];
             try {
                 const cliPath = join(getNeuralDir(), PATTERNS_FILE);
-                if (existsSync(cliPath)) {
+                if (existsSync(cliPath) && statSync(cliPath).size <= MAX_NEURAL_STORE_BYTES) {
                     const raw = JSON.parse(readFileSync(cliPath, 'utf-8'));
                     if (Array.isArray(raw)) {
                         const mcpIds = new Set(mcpPatterns.map(p => p.id));
@@ -412,7 +433,12 @@ export const neuralTools = [
                     return { success: false, error: `Pattern store full (max ${MAX_PATTERNS}). Run neural_compress first.` };
                 }
                 const patternId = `pattern-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-                const patternName = input.name || 'Unnamed pattern';
+                // Cap name length to prevent DoS in generateEmbedding (hash path is O(n))
+                const MAX_PATTERN_NAME_LENGTH = 16 * 1024; // 16 KB
+                const rawPatternName = input.name || 'Unnamed pattern';
+                const patternName = typeof rawPatternName === 'string' && rawPatternName.length > MAX_PATTERN_NAME_LENGTH
+                    ? rawPatternName.slice(0, MAX_PATTERN_NAME_LENGTH)
+                    : rawPatternName;
                 // Generate embedding from pattern name/content
                 const embedding = await generateEmbedding(patternName, 384);
                 const pattern = {
@@ -437,7 +463,12 @@ export const neuralTools = [
                 };
             }
             if (action === 'search') {
-                const query = input.query;
+                // Cap query length to prevent DoS in generateEmbedding (hash path is O(n))
+                const MAX_SEARCH_QUERY_LENGTH = 16 * 1024; // 16 KB — matches neural_predict cap
+                const rawQuery = input.query;
+                const query = typeof rawQuery === 'string' && rawQuery.length > MAX_SEARCH_QUERY_LENGTH
+                    ? rawQuery.slice(0, MAX_SEARCH_QUERY_LENGTH)
+                    : rawQuery;
                 // Generate query embedding for real similarity search
                 const queryEmbedding = await generateEmbedding(query, 384);
                 // Calculate REAL cosine similarity against stored patterns
@@ -606,7 +637,11 @@ export const neuralTools = [
         handler: async (input) => {
             const store = loadNeuralStore();
             if (input.modelId) {
-                const modelId = input.modelId;
+                const MAX_MODEL_ID_LEN_STATUS = 256;
+                const rawModelIdStatus = input.modelId;
+                const modelId = typeof rawModelIdStatus === 'string' && rawModelIdStatus.length > MAX_MODEL_ID_LEN_STATUS
+                    ? rawModelIdStatus.slice(0, MAX_MODEL_ID_LEN_STATUS)
+                    : rawModelIdStatus;
                 if (NEURAL_RESERVED_KEYS.has(modelId)) {
                     return { success: false, error: 'Invalid modelId' };
                 }

package/packages/@monomind/cli/dist/src/mcp-tools/performance-tools.js

@@ -12,7 +12,7 @@
  * Note: Some optimization suggestions are illustrative
  */
 import { getProjectCwd } from './types.js';
-import { existsSync, readFileSync, writeFileSync, renameSync, unlinkSync, readdirSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, statSync, writeFileSync, renameSync, unlinkSync, readdirSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import * as os from 'node:os';
 // Storage paths
@@ -32,10 +32,11 @@ function ensurePerfDir() {
         mkdirSync(dir, { recursive: true });
     }
 }
+const MAX_PERF_STORE_BYTES = 50 * 1024 * 1024; // 50 MB
 function loadPerfStore() {
     try {
         const path = getPerfPath();
-        if (existsSync(path)) {
+        if (existsSync(path) && statSync(path).size <= MAX_PERF_STORE_BYTES) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
@@ -226,8 +227,20 @@ export const performanceTools = [
         },
         handler: async (input) => {
             const store = loadPerfStore();
-            const suite = input.suite || 'all';
-            const iterations = input.iterations || 100;
+            // Validate suite against enum to prevent uncapped string from being stored
+            // as a benchmark key on disk.
+            const VALID_SUITES = new Set(['all', 'memory', 'neural', 'swarm', 'io']);
+            const rawSuite = input.suite || 'all';
+            const suite = VALID_SUITES.has(rawSuite) ? rawSuite : 'all';
+            // Cap iterations to prevent event-loop blocking DoS.  The `neural`
+            // suite runs an O(n³) 64×64 matrix multiply per iteration; at 10 000
+            // iterations it already completes in milliseconds.  Uncapped, a caller
+            // could pass iterations=9_999_999 and block the process for minutes.
+            const MAX_BENCHMARK_ITERATIONS = 10_000;
+            const rawIterations = typeof input.iterations === 'number' ? input.iterations : 100;
+            const iterations = Number.isFinite(rawIterations) && rawIterations > 0
+                ? Math.min(Math.floor(rawIterations), MAX_BENCHMARK_ITERATIONS)
+                : 100;
             const warmup = input.warmup !== false;
             // REAL benchmark functions
             const benchmarkFunctions = {
@@ -356,7 +369,11 @@ export const performanceTools = [
             },
         },
         handler: async (input) => {
-            const target = input.target || 'all';
+            // Validate target against enum to prevent arbitrary string from being
+            // stored in the perf store and echoed in the response.
+            const VALID_PROFILE_TARGETS = new Set(['all', 'memory', 'io', 'cpu']);
+            const rawTarget = input.target || 'all';
+            const target = VALID_PROFILE_TARGETS.has(rawTarget) ? rawTarget : 'all';
             const durationSec = Math.min(input.duration || 1, 10);
             const durationMs = durationSec * 1000;
             const cpuBefore = process.cpuUsage();
@@ -457,7 +474,11 @@ export const performanceTools = [
             },
         },
         handler: async (input) => {
-            const target = input.target || 'all';
+            // Validate target against enum — the value is echoed in the response and
+            // stored to the perf store; an unvalidated string could inflate disk state.
+            const VALID_OPT_TARGETS = new Set(['all', 'memory', 'latency', 'throughput']);
+            const rawOptTarget = input.target || 'all';
+            const target = VALID_OPT_TARGETS.has(rawOptTarget) ? rawOptTarget : 'all';
             const aggressive = input.aggressive === true;
             // Snapshot system state BEFORE optimizations
             const loadBefore = os.loadavg();
@@ -559,8 +580,15 @@ export const performanceTools = [
             },
         },
         handler: async (input) => {
-            const metric = input.metric || 'all';
-            const aggregation = input.aggregation || 'avg';
+            // Validate metric and aggregation against their enums.  Both values are
+            // later used as property index keys on plain objects — an attacker who
+            // passes "__proto__" or "constructor" could cause prototype pollution.
+            const VALID_METRICS = new Set(['cpu', 'memory', 'latency', 'throughput', 'all']);
+            const VALID_AGGREGATIONS = new Set(['avg', 'min', 'max', 'p50', 'p95', 'p99']);
+            const rawMetric = input.metric || 'all';
+            const metric = VALID_METRICS.has(rawMetric) ? rawMetric : 'all';
+            const rawAggregation = input.aggregation || 'avg';
+            const aggregation = VALID_AGGREGATIONS.has(rawAggregation) ? rawAggregation : 'avg';
             // Get REAL system metrics
             const memUsage = process.memoryUsage();
             const loadAvg = os.loadavg();
@@ -641,11 +669,18 @@ export const performanceTools = [
                     timestamp: new Date().toISOString(),
                 };
             }
-            const selectedMetric = allMetrics[metric];
+            // Use Object.hasOwn to prevent prototype chain traversal when indexing
+            // by caller-supplied metric/aggregation strings.
+            const selectedMetric = Object.hasOwn(allMetrics, metric)
+                ? allMetrics[metric]
+                : allMetrics.cpu;
+            const aggValue = Object.hasOwn(selectedMetric, aggregation)
+                ? selectedMetric[aggregation]
+                : undefined;
             return {
                 _real: ['cpu', 'memory'].includes(metric),
                 metric,
-                value: selectedMetric[aggregation],
+                value: aggValue,
                 unit: selectedMetric.unit,
                 details: selectedMetric,
                 timestamp: new Date().toISOString(),

package/packages/@monomind/cli/dist/src/mcp-tools/progress-tools.js

@@ -5,7 +5,7 @@
  *
  * @module @monomind/cli/mcp-tools/progress
  */
-import { existsSync, readdirSync, readFileSync, writeFileSync, renameSync, mkdirSync } from 'fs';
+import { existsSync, readdirSync, readFileSync, writeFileSync, renameSync, mkdirSync, statSync } from 'fs';
 import { join, basename, dirname } from 'path';
 import { fileURLToPath } from 'url';
 // Get project root - handles both src and dist paths
@@ -53,6 +53,9 @@ function countFilesAndLines(dir, ext = '.ts') {
                 else if (entry.isFile() && entry.name.endsWith(ext)) {
                     files++;
                     try {
+                        // Skip files > 1 MB to avoid loading generated/minified bundles into memory.
+                        if (statSync(fullPath).size > 1024 * 1024)
+                            continue;
                         const content = readFileSync(fullPath, 'utf-8');
                         lines += content.split('\n').length;
                     }
@@ -120,7 +123,7 @@ async function calculateProgress() {
     // Count CLI commands (from commands/index.ts)
     let cliCommands = 28; // Default to known count
     const commandsIndexPath = join(PACKAGES_DIR, '@monomind/cli/src/commands/index.ts');
-    if (existsSync(commandsIndexPath)) {
+    if (existsSync(commandsIndexPath) && statSync(commandsIndexPath).size <= 1024 * 1024) {
         try {
             const content = readFileSync(commandsIndexPath, 'utf-8');
             const matches = content.match(/export const commands.*\[([^\]]+)\]/s);
@@ -133,7 +136,7 @@ async function calculateProgress() {
     // Count MCP tools
     let mcpTools = 100; // Approximate
     const toolsIndexPath = join(PACKAGES_DIR, '@monomind/cli/src/mcp-tools/index.ts');
-    if (existsSync(toolsIndexPath)) {
+    if (existsSync(toolsIndexPath) && statSync(toolsIndexPath).size <= 1024 * 1024) {
         try {
             const content = readFileSync(toolsIndexPath, 'utf-8');
             mcpTools = (content.match(/export.*Tools/g) || []).length * 10 || 100;
@@ -143,7 +146,7 @@ async function calculateProgress() {
     // Count hooks subcommands (count const *Command definitions)
     let hooksSubcommands = 27; // Default to documented count
     const hooksPath = join(PACKAGES_DIR, '@monomind/cli/src/commands/hooks.ts');
-    if (existsSync(hooksPath)) {
+    if (existsSync(hooksPath) && statSync(hooksPath).size <= 1024 * 1024) {
         try {
             const content = readFileSync(hooksPath, 'utf-8');
             // Count command definitions like "const fooCommand: Command = {"

package/packages/@monomind/cli/dist/src/mcp-tools/request-tracker.js

@@ -4,6 +4,10 @@
  * Used by system_metrics to report real request counts.
  */
 const MAX_TRACKED_TOOLS = 500;
+const MAX_TOOL_NAME_LEN = 256;
+// Keys that would corrupt Object.prototype or its constructor if used as plain
+// object property keys without Object.hasOwn() protection.
+const FORBIDDEN_TOOL_NAMES = new Set(['__proto__', 'constructor', 'prototype']);
 let counts = {
     total: 0,
     success: 0,
@@ -17,7 +21,17 @@ export function trackRequest(toolName, success) {
         counts.success++;
     else
         counts.errors++;
-    if (Object.keys(counts.byTool).length < MAX_TRACKED_TOOLS || toolName in counts.byTool) {
+    // Guard against prototype pollution via toolName.
+    // The previous `toolName in counts.byTool` check traversed the prototype
+    // chain, so "__proto__" was always truthy and could corrupt Object.prototype.
+    // Use Object.hasOwn() instead, and reject forbidden key names outright.
+    if (typeof toolName !== 'string' ||
+        toolName.length === 0 ||
+        toolName.length > MAX_TOOL_NAME_LEN ||
+        FORBIDDEN_TOOL_NAMES.has(toolName)) {
+        return; // Drop invalid tool names silently
+    }
+    if (Object.keys(counts.byTool).length < MAX_TRACKED_TOOLS || Object.hasOwn(counts.byTool, toolName)) {
         counts.byTool[toolName] = (counts.byTool[toolName] || 0) + 1;
     }
 }

package/packages/@monomind/cli/dist/src/mcp-tools/security-tools.js

@@ -17,6 +17,21 @@ const require = createRequire(import.meta.url);
 let monofenceInstance = null;
 // Track if we've attempted install this session
 let installAttempted = false;
+// ── Security input bounds ─────────────────────────────────────────────────────
+// MonoFence runs multiple regex patterns over the entire input string (O(n × P)
+// complexity where P is the pattern count).  Uncapped input enables ReDoS-style
+// denial-of-service.  64 KB is more than enough for any real threat-scan
+// payload while preventing CPU exhaustion from megabyte-scale inputs.
+const MAX_SECURITY_INPUT_LEN = 64 * 1024; // 64 KB
+const MAX_SECURITY_K = 100;
+const MAX_SECURITY_VERDICT_LEN = 512;
+const MAX_SECURITY_THREAT_TYPE_LEN = 256;
+const MAX_SECURITY_MITIGATION_STRATEGY_LEN = 512;
+function capSecurityInput(raw, fieldName = 'input') {
+    if (typeof raw !== 'string')
+        throw new Error(`${fieldName} must be a string`);
+    return raw.length > MAX_SECURITY_INPUT_LEN ? raw.slice(0, MAX_SECURITY_INPUT_LEN) : raw;
+}
 /**
  * Get or create MonoFence instance (throws if unavailable)
  */
@@ -79,7 +94,13 @@ const monofenceScanTool = {
         required: ['input'],
     },
     handler: async (args) => {
-        const input = args.input;
+        let input;
+        try {
+            input = capSecurityInput(args.input);
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: e.message }) }], isError: true };
+        }
         const quick = args.quick;
         try {
             const defender = await getMonoFence();
@@ -153,9 +174,16 @@ const monofenceAnalyzeTool = {
         required: ['input'],
     },
     handler: async (args) => {
-        const input = args.input;
+        let input;
+        try {
+            input = capSecurityInput(args.input);
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: e.message }) }], isError: true };
+        }
         const searchSimilar = args.searchSimilar !== false;
-        const k = args.k || 5;
+        const rawK = args.k || 5;
+        const k = Number.isFinite(rawK) && rawK > 0 ? Math.min(Math.floor(rawK), MAX_SECURITY_K) : 5;
         try {
             const defender = await getMonoFence();
             const result = await defender.detect(input);
@@ -282,11 +310,23 @@ const monofenceLearnTool = {
         required: ['input', 'wasAccurate'],
     },
     handler: async (args) => {
-        const input = args.input;
+        let input;
+        try {
+            input = capSecurityInput(args.input);
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: e.message }) }], isError: true };
+        }
         const wasAccurate = args.wasAccurate;
-        const verdict = args.verdict;
-        const threatType = args.threatType;
-        const mitigationStrategy = args.mitigationStrategy;
+        const rawVerdict = args.verdict;
+        const verdict = typeof rawVerdict === 'string' && rawVerdict.length > MAX_SECURITY_VERDICT_LEN
+            ? rawVerdict.slice(0, MAX_SECURITY_VERDICT_LEN) : rawVerdict;
+        const rawThreatType = args.threatType;
+        const threatType = typeof rawThreatType === 'string' && rawThreatType.length > MAX_SECURITY_THREAT_TYPE_LEN
+            ? rawThreatType.slice(0, MAX_SECURITY_THREAT_TYPE_LEN) : rawThreatType;
+        const rawMitigationStrategy = args.mitigationStrategy;
+        const mitigationStrategy = typeof rawMitigationStrategy === 'string' && rawMitigationStrategy.length > MAX_SECURITY_MITIGATION_STRATEGY_LEN
+            ? rawMitigationStrategy.slice(0, MAX_SECURITY_MITIGATION_STRATEGY_LEN) : rawMitigationStrategy;
         const mitigationSuccess = args.mitigationSuccess;
         try {
             const defender = await getMonoFence();
@@ -344,7 +384,13 @@ const monofenceIsSafeTool = {
         required: ['input'],
     },
     handler: async (args) => {
-        const input = args.input;
+        let input;
+        try {
+            input = capSecurityInput(args.input);
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: e.message }) }], isError: true };
+        }
         try {
             await getMonoFence(); // triggers auto-install if package is missing
             const { isSafe } = await import('monofence-ai');
@@ -384,7 +430,13 @@ const monofenceHasPIITool = {
         required: ['input'],
     },
     handler: async (args) => {
-        const input = args.input;
+        let input;
+        try {
+            input = capSecurityInput(args.input);
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: e.message }) }], isError: true };
+        }
         try {
             const defender = await getMonoFence();
             const hasPII = defender.hasPII(input);

package/packages/@monomind/cli/dist/src/mcp-tools/session-tools.js

@@ -131,6 +131,19 @@ export const sessionTools = [
         },
         handler: async (input) => {
             const sessionId = `session-${Date.now()}-${randomBytes(6).toString('hex')}`;
+            // Cap name and description: both are persisted verbatim to the session
+            // JSON file on disk.  Without a cap, an attacker can inflate the session
+            // store by supplying a very long name or description.
+            const MAX_SESSION_NAME_LEN = 256;
+            const MAX_SESSION_DESC_LEN = 4 * 1024;
+            const rawSessionName = input.name;
+            const sessionName = typeof rawSessionName === 'string' && rawSessionName.length > MAX_SESSION_NAME_LEN
+                ? rawSessionName.slice(0, MAX_SESSION_NAME_LEN)
+                : rawSessionName;
+            const rawSessionDesc = input.description;
+            const sessionDesc = typeof rawSessionDesc === 'string' && rawSessionDesc.length > MAX_SESSION_DESC_LEN
+                ? rawSessionDesc.slice(0, MAX_SESSION_DESC_LEN)
+                : rawSessionDesc;
             // Load related data based on options
             const data = loadRelatedStores({
                 includeMemory: input.includeMemory,
@@ -146,8 +159,8 @@ export const sessionTools = [
             };
             const session = {
                 sessionId,
-                name: input.name,
-                description: input.description,
+                name: sessionName,
+                description: sessionDesc,
                 savedAt: new Date().toISOString(),
                 stats,
                 data: Object.keys(data).length > 0 ? data : undefined,
@@ -211,17 +224,25 @@ export const sessionTools = [
                         const { storeEntry } = await import('../memory/memory-initializer.js');
                         const memoryData = session.data.memory;
                         if (memoryData.entries) {
+                            // Cap individual key and value lengths before writing to the DB.
+                            // A malicious or corrupted session file could contain arbitrarily
+                            // long strings; without caps these flow straight into the HNSW
+                            // embedder and SQL layer, causing OOM or DoS.
+                            const MAX_RESTORE_KEY = 1_000;
+                            const MAX_RESTORE_VALUE = 100_000;
+                            const MAX_RESTORE_NS = 200;
                             for (const entry of Object.values(memoryData.entries)) {
-                                const key = entry.key || entry.id || '';
-                                const value = entry.value || entry.content || '';
-                                if (key && value) {
-                                    await storeEntry({
-                                        key,
-                                        value,
-                                        namespace: entry.namespace || 'restored',
-                                        upsert: true,
-                                    });
-                                }
+                                let key = entry.key || entry.id || '';
+                                let value = entry.value || entry.content || '';
+                                if (!key || !value)
+                                    continue;
+                                if (key.length > MAX_RESTORE_KEY)
+                                    key = key.slice(0, MAX_RESTORE_KEY);
+                                if (value.length > MAX_RESTORE_VALUE)
+                                    value = value.slice(0, MAX_RESTORE_VALUE);
+                                const rawNs = entry.namespace || 'restored';
+                                const namespace = rawNs.length > MAX_RESTORE_NS ? rawNs.slice(0, MAX_RESTORE_NS) : rawNs;
+                                await storeEntry({ key, value, namespace, upsert: true });
                             }
                         }
                     }
@@ -353,14 +374,24 @@ export const sessionTools = [
             const session = loadSession(sessionId);
             if (session) {
                 const path = getSessionPath(sessionId);
-                const stat = statSync(path);
+                // Guard against TOCTOU: the file could be deleted between loadSession()
+                // and statSync().  Catch ENOENT (and any other fs error) so the MCP
+                // handler never throws an unhandled exception; callers get a clean
+                // response instead of a server-side crash.
+                let fileSize = 0;
+                try {
+                    fileSize = statSync(path).size;
+                }
+                catch {
+                    // File deleted or inaccessible after loadSession succeeded
+                }
                 return {
                     sessionId: session.sessionId,
                     name: session.name,
                     description: session.description,
                     savedAt: session.savedAt,
                     stats: session.stats,
-                    fileSize: stat.size,
+                    fileSize,
                     hasData: {
                         memory: !!session.data?.memory,
                         tasks: !!session.data?.tasks,

package/packages/@monomind/cli/dist/src/mcp-tools/swarm-tools.js

@@ -64,7 +64,13 @@ export const swarmTools = [
         handler: async (input) => {
             const topology = input.topology || 'hierarchical-mesh';
             const maxAgents = Math.min(Math.max(input.maxAgents || 8, 1), 50);
-            const strategy = input.strategy || 'specialized';
+            // Cap strategy and config string fields: all are persisted in the swarm
+            // JSON store.  topology is already validated against VALID_TOPOLOGIES so
+            // an invalid long value is rejected; the others have no validation.
+            const MAX_SWARM_FIELD_LEN = 256;
+            const rawStrategy = input.strategy || 'specialized';
+            const strategy = typeof rawStrategy === 'string' && rawStrategy.length > MAX_SWARM_FIELD_LEN
+                ? rawStrategy.slice(0, MAX_SWARM_FIELD_LEN) : rawStrategy;
             const config = (input.config || {});
             if (!VALID_TOPOLOGIES.has(topology)) {
                 return {
@@ -85,9 +91,15 @@ export const swarmTools = [
                     topology,
                     maxAgents,
                     strategy,
-                    communicationProtocol: config.communicationProtocol || 'message-bus',
+                    communicationProtocol: (() => {
+                        const raw = config.communicationProtocol || 'message-bus';
+                        return typeof raw === 'string' && raw.length > MAX_SWARM_FIELD_LEN ? raw.slice(0, MAX_SWARM_FIELD_LEN) : raw;
+                    })(),
                     autoScaling: config.autoScaling ?? true,
-                    consensusMechanism: config.consensusMechanism || 'majority',
+                    consensusMechanism: (() => {
+                        const raw = config.consensusMechanism || 'majority';
+                        return typeof raw === 'string' && raw.length > MAX_SWARM_FIELD_LEN ? raw.slice(0, MAX_SWARM_FIELD_LEN) : raw;
+                    })(),
                 },
                 createdAt: now,
                 updatedAt: now,

package/packages/@monomind/cli/dist/src/mcp-tools/system-tools.js

@@ -9,7 +9,7 @@
  * - os module for system information
  */
 import { getProjectCwd } from './types.js';
-import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import * as os from 'node:os';
@@ -43,10 +43,11 @@ function ensureSystemDir() {
         mkdirSync(dir, { recursive: true });
     }
 }
+const MAX_SYSTEM_STORE_BYTES = 50 * 1024 * 1024; // 50 MB
 function loadMetrics() {
     try {
         const path = getMetricsPath();
-        if (existsSync(path)) {
+        if (existsSync(path) && statSync(path).size <= MAX_SYSTEM_STORE_BYTES) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
@@ -128,7 +129,9 @@ export const systemTools = [
         },
         handler: async (input) => {
             const store = loadMetrics();
-            const category = input.category || 'all';
+            const VALID_CATEGORIES = new Set(['all', 'cpu', 'memory', 'agents', 'tasks', 'requests']);
+            const rawCategory = input.category || 'all';
+            const category = VALID_CATEGORIES.has(rawCategory) ? rawCategory : 'all';
             // Get REAL system metrics via Node.js APIs
             const memUsage = process.memoryUsage();
             const loadAvg = os.loadavg();
@@ -182,7 +185,7 @@ export const systemTools = [
             if (_metricsSource === 'none') {
                 try {
                     const agentStorePath = join(getProjectCwd(), STORAGE_DIR, 'agents', 'store.json');
-                    if (existsSync(agentStorePath)) {
+                    if (existsSync(agentStorePath) && statSync(agentStorePath).size <= MAX_SYSTEM_STORE_BYTES) {
                         const agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
                         const agents = Object.values(agentStore.agents || {});
                         agentCounts = {
@@ -195,7 +198,7 @@ export const systemTools = [
                 catch { /* agent store not available */ }
                 try {
                     const taskStorePath = join(getProjectCwd(), STORAGE_DIR, 'tasks', 'store.json');
-                    if (existsSync(taskStorePath)) {
+                    if (existsSync(taskStorePath) && statSync(taskStorePath).size <= MAX_SYSTEM_STORE_BYTES) {
                         const taskStore = JSON.parse(readFileSync(taskStorePath, 'utf-8'));
                         const tasks = Object.values(taskStore.tasks || {});
                         taskCounts = {
@@ -438,7 +441,11 @@ export const systemTools = [
             if (!input.confirm) {
                 return { success: false, error: 'Reset requires confirmation' };
             }
-            const component = input.component || 'metrics';
+            // Validate component against the allowed set to prevent unbounded string
+            // reflection in the response message.
+            const VALID_COMPONENTS = new Set(['all', 'metrics', 'agents', 'tasks']);
+            const rawComponent = input.component || 'metrics';
+            const component = VALID_COMPONENTS.has(rawComponent) ? rawComponent : 'metrics';
             // Reset metrics to defaults
             const defaultMetrics = {
                 startTime: new Date().toISOString(),
@@ -530,7 +537,7 @@ export const systemTools = [
             const storePath = join(getProjectCwd(), '.monomind', 'tasks', 'store.json');
             let tasks = [];
             try {
-                if (existsSync(storePath)) {
+                if (existsSync(storePath) && statSync(storePath).size <= MAX_SYSTEM_STORE_BYTES) {
                     const data = readFileSync(storePath, 'utf-8');
                     const store = JSON.parse(data);
                     tasks = Object.values(store.tasks || {});