monomind 1.11.13 → 1.12.0

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

@@ -7,6 +7,11 @@
 import { output } from '../output.js';
 import { existsSync, readFileSync, statSync } from 'fs';
 import { join, dirname } from 'path';
+const MAX_DOCTOR_PKG_BYTES = 1024 * 1024; // 1 MB — package.json / settings.json
+const MAX_DOCTOR_CONFIG_BYTES = 10 * 1024 * 1024; // 10 MB — monomind.config.json / MCP configs
+const MAX_DOCTOR_GITIGNORE_BYTES = 512 * 1024; // 512 KB — .gitignore
+const MAX_DOCTOR_PID_BYTES = 64; // 64 bytes — daemon PID file
+const MAX_DOCTOR_HELPER_BYTES = 2 * 1024 * 1024; // 2 MB — hook helper .cjs bundles
 import { fileURLToPath } from 'url';
 import { execSync, exec } from 'child_process';
 import { homedir } from 'os';
@@ -67,7 +72,7 @@ async function checkConfigFile() {
         '.monomind.json'
     ];
     for (const configPath of jsonPaths) {
-        if (existsSync(configPath)) {
+        if (existsSync(configPath) && statSync(configPath).size <= MAX_DOCTOR_CONFIG_BYTES) {
             try {
                 const content = readFileSync(configPath, 'utf8');
                 JSON.parse(content);
@@ -95,7 +100,7 @@ async function checkConfigFile() {
 async function checkDaemonStatus() {
     try {
         const pidFile = '.monomind/daemon.pid';
-        if (existsSync(pidFile)) {
+        if (existsSync(pidFile) && statSync(pidFile).size <= MAX_DOCTOR_PID_BYTES) {
             const pid = readFileSync(pidFile, 'utf8').trim();
             try {
                 process.kill(parseInt(pid, 10), 0); // Check if process exists
@@ -184,7 +189,7 @@ async function checkMcpServers() {
         '.mcp.json'
     ];
     for (const configPath of mcpConfigPaths) {
-        if (existsSync(configPath)) {
+        if (existsSync(configPath) && statSync(configPath).size <= MAX_DOCTOR_CONFIG_BYTES) {
             try {
                 const content = JSON.parse(readFileSync(configPath, 'utf8'));
                 const servers = content.mcpServers || content.servers || {};
@@ -202,7 +207,7 @@ async function checkMcpServers() {
             }
         }
     }
-    return { name: 'MCP Servers', status: 'warn', message: 'No MCP config found', fix: 'claude mcp add monomind npx @monomind/cli@v1alpha mcp start' };
+    return { name: 'MCP Servers', status: 'warn', message: 'No MCP config found', fix: 'claude mcp add monomind -- npx -y monomind@latest mcp start' };
 }
 // Check disk space (async with proper env inheritance)
 async function checkDiskSpace() {
@@ -260,11 +265,11 @@ async function checkVersionFreshness() {
             for (;;) {
                 const candidate = join(dir, 'package.json');
                 try {
-                    if (existsSync(candidate)) {
+                    if (existsSync(candidate) && statSync(candidate).size <= MAX_DOCTOR_PKG_BYTES) {
                         const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
                         if (pkg.version &&
                             typeof pkg.name === 'string' &&
-                            (pkg.name === '@monomind/cli' || pkg.name === 'monomind')) {
+                            (pkg.name === '@monomind/cli' || pkg.name === 'monomind' || pkg.name === '@monoes/monomindcli')) {
                             currentVersion = pkg.version;
                             break;
                         }
@@ -287,10 +292,10 @@ async function checkVersionFreshness() {
         const isNpx = process.argv[1]?.includes('_npx') ||
             process.env.npm_execpath?.includes('npx') ||
             process.cwd().includes('_npx');
-        // Query npm for latest version (using alpha tag since that's what we publish to)
+        // Query npm for latest version of the published umbrella package
         let latestVersion = currentVersion;
         try {
-            const npmInfo = await runCommand('npm view @monomind/cli@alpha version', 5000);
+            const npmInfo = await runCommand('npm view monomind version', 5000);
             latestVersion = npmInfo.trim();
         }
         catch {
@@ -322,8 +327,8 @@ async function checkVersionFreshness() {
             (latest.major === current.major && latest.minor === current.minor && latest.patch === current.patch && latest.prerelease > current.prerelease));
         if (isOutdated) {
             const fix = isNpx
-                ? 'rm -rf ~/.npm/_npx/* && npx -y @monomind/cli@latest'
-                : 'npm update @monomind/cli';
+                ? 'rm -rf ~/.npm/_npx/* && npx -y monomind@latest doctor'
+                : 'npm update -g monomind';
             return {
                 name: 'Version Freshness',
                 status: 'warn',
@@ -387,18 +392,39 @@ async function installClaudeCode() {
 async function checkMonograph() {
     try {
         const __filename = fileURLToPath(import.meta.url);
+        const _base = dirname(__filename);
+        let _globalRoot = '';
+        try {
+            _globalRoot = execSync('npm root -g', { encoding: 'utf8', timeout: 3000 }).trim();
+        }
+        catch { /* no npm */ }
         const candidates = [
-            join(dirname(__filename), '..', '..', 'node_modules', '@monomind', 'monograph', 'package.json'),
-            join(dirname(__filename), '..', '..', '..', '..', 'node_modules', '@monomind', 'monograph', 'package.json'),
+            // local dev monorepo paths (both old @monomind and published @monoes scope)
+            join(_base, '..', '..', 'node_modules', '@monomind', 'monograph', 'package.json'),
+            join(_base, '..', '..', '..', '..', 'node_modules', '@monomind', 'monograph', 'package.json'),
+            join(_base, '..', '..', 'node_modules', '@monoes', 'monograph', 'package.json'),
+            join(_base, '..', '..', '..', '..', 'node_modules', '@monoes', 'monograph', 'package.json'),
+            // global install paths
+            ...(_globalRoot ? [
+                join(_globalRoot, '@monomind', 'monograph', 'package.json'),
+                join(_globalRoot, '@monoes', 'monograph', 'package.json'),
+            ] : []),
         ];
-        if (candidates.some(p => existsSync(p))) {
-            return { name: 'Monograph', status: 'pass', message: 'available (knowledge graph engine)' };
+        const found = candidates.find(p => existsSync(p) && statSync(p).size <= MAX_DOCTOR_PKG_BYTES);
+        if (found) {
+            try {
+                const pkg = JSON.parse(readFileSync(found, 'utf-8'));
+                return { name: 'Monograph', status: 'pass', message: `v${pkg.version || '?'} available (knowledge graph engine)` };
+            }
+            catch {
+                return { name: 'Monograph', status: 'pass', message: 'available (knowledge graph engine)' };
+            }
         }
         return {
             name: 'Monograph',
             status: 'warn',
             message: 'Package not found (knowledge graph disabled)',
-            fix: 'npm install in project root'
+            fix: 'npm install -g monomind@latest  # reinstall to get @monoes/monograph'
         };
     }
     catch {
@@ -406,9 +432,45 @@ async function checkMonograph() {
             name: 'Monograph',
             status: 'warn',
             message: 'Package check failed (knowledge graph may be unavailable)',
-            fix: 'npm install in project root'
+            fix: 'npm install -g monomind@latest'
+        };
+    }
+}
+// Check @monoes/memory (optional HNSW vector search package)
+async function checkMonoesMemory() {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const _base = dirname(__filename);
+        let _globalRoot = '';
+        try {
+            _globalRoot = execSync('npm root -g', { encoding: 'utf8', timeout: 3000 }).trim();
+        }
+        catch { /* no npm */ }
+        const candidates = [
+            join(_base, '..', '..', 'node_modules', '@monoes', 'memory', 'package.json'),
+            join(_base, '..', '..', '..', '..', 'node_modules', '@monoes', 'memory', 'package.json'),
+            ...(_globalRoot ? [join(_globalRoot, '@monoes', 'memory', 'package.json')] : []),
+        ];
+        const found = candidates.find(p => existsSync(p) && statSync(p).size <= MAX_DOCTOR_PKG_BYTES);
+        if (found) {
+            try {
+                const pkg = JSON.parse(readFileSync(found, 'utf-8'));
+                return { name: 'Vector Memory', status: 'pass', message: `@monoes/memory v${pkg.version || '?'} (HNSW search enabled)` };
+            }
+            catch {
+                return { name: 'Vector Memory', status: 'pass', message: '@monoes/memory available (HNSW search enabled)' };
+            }
+        }
+        return {
+            name: 'Vector Memory',
+            status: 'warn',
+            message: '@monoes/memory not installed (vector search disabled — using fallback)',
+            fix: 'npm install @monoes/memory'
         };
     }
+    catch {
+        return { name: 'Vector Memory', status: 'warn', message: 'Vector memory check failed' };
+    }
 }
 // Check agentic-flow v1 integration (filesystem-based to avoid slow WASM/DB init)
 // Resolve the path to the bundled (npm-installed) copy of a helper file.
@@ -420,10 +482,10 @@ function _resolveBundledHelper(relativePath) {
         let dir = dirname(thisFile);
         for (;;) {
             const candidate = join(dir, 'package.json');
-            if (existsSync(candidate)) {
+            if (existsSync(candidate) && statSync(candidate).size <= MAX_DOCTOR_PKG_BYTES) {
                 try {
                     const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
-                    if (pkg.name === '@monomind/cli' || pkg.name === 'monomind') {
+                    if (pkg.name === '@monomind/cli' || pkg.name === 'monomind' || pkg.name === '@monoes/monomindcli') {
                         const helperPath = join(dir, relativePath);
                         return existsSync(helperPath) ? helperPath : null;
                     }
@@ -451,11 +513,15 @@ async function _detectStaleHelpers() {
         const local = join(process.cwd(), '.claude', 'helpers', name);
         if (!existsSync(local))
             continue;
+        if (statSync(local).size > MAX_DOCTOR_HELPER_BYTES)
+            continue; // skip oversized helper
         const bundled = _resolveBundledHelper(join('.claude', 'helpers', name));
         if (!bundled) {
             missing.push(name);
             continue;
         }
+        if (statSync(bundled).size > MAX_DOCTOR_HELPER_BYTES)
+            continue; // skip oversized bundled
         try {
             const hashLocal = crypto.createHash('sha256').update(readFileSync(local)).digest('hex');
             const hashBundled = crypto.createHash('sha256').update(readFileSync(bundled)).digest('hex');
@@ -513,6 +579,9 @@ async function checkAgenticFlow() {
                 fix: 'npm install agentic-flow@latest'
             };
         }
+        if (statSync(pkgJsonPath).size > MAX_DOCTOR_PKG_BYTES) {
+            return { name: 'agentic-flow', status: 'warn', message: 'package.json too large to parse' };
+        }
         const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
         const version = pkg.version || 'unknown';
         const exports = pkg.exports || {};
@@ -524,7 +593,7 @@ async function checkAgenticFlow() {
         return {
             name: 'agentic-flow',
             status: 'pass',
-            message: `v${version} (${features.join(', ')})`
+            message: `v${version}${features.length ? ' (' + features.join(', ') + ')' : ' (installed)'}`
         };
     }
     catch {
@@ -579,6 +648,61 @@ async function checkMonoesIntegration() {
         };
     }
 }
+// Patterns that must be covered by .gitignore to prevent leaking session data / machine paths.
+// Uses the surgical approach: ignore specific sensitive subdirs and file globs inside .monomind/
+// rather than the entire directory, so safe content (orgs/, test-fixtures/) can still be tracked.
+const REQUIRED_GITIGNORE_PATTERNS = [
+    { pattern: '.monomind/sessions/', reason: 'session files contain cwd and machine paths' },
+    { pattern: '.monomind/data/', reason: 'intelligence data with edit file paths' },
+    { pattern: '.monomind/metrics/', reason: 'metrics with file path references' },
+    { pattern: '.monomind/knowledge/', reason: 'knowledge chunks with local file content' },
+    { pattern: '.monomind/*.json', reason: 'root-level runtime JSON (control, registry, routing)' },
+    { pattern: '.monomind/*.jsonl', reason: 'root-level event logs (decisions, routing-feedback)' },
+    { pattern: '**/.monomind/sessions/', reason: 'nested session files in sub-packages' },
+    { pattern: '**/.monomind/*.json', reason: 'nested runtime JSON in sub-packages' },
+    { pattern: 'data/sessions/', reason: 'session files with machine paths' },
+    { pattern: 'data/mastermind-*.json', reason: 'mastermind session data' },
+    { pattern: 'data/mastermind-*.jsonl', reason: 'mastermind event logs' },
+    { pattern: '**/.claude-flow/', reason: 'claude-flow runtime data with paths' },
+    { pattern: '.hive-mind/', reason: 'hive-mind state with session info' },
+    { pattern: '.swarm/', reason: 'swarm state files' },
+];
+// Check whether a gitignore file covers all required monomind runtime patterns
+async function checkGitignoreCoverage() {
+    const gitignorePath = join(process.cwd(), '.gitignore');
+    if (!existsSync(gitignorePath)) {
+        return {
+            name: 'Gitignore Coverage',
+            status: 'warn',
+            message: 'No .gitignore found — all monomind runtime paths are unprotected',
+            fix: 'echo ".monomind/\\n**/.monomind/" >> .gitignore',
+        };
+    }
+    if (statSync(gitignorePath).size > MAX_DOCTOR_GITIGNORE_BYTES) {
+        return { name: 'Gitignore Coverage', status: 'warn', message: '.gitignore too large to parse' };
+    }
+    const content = readFileSync(gitignorePath, 'utf-8');
+    const lines = content.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
+    const missing = REQUIRED_GITIGNORE_PATTERNS.filter(({ pattern }) => {
+        // A pattern is "covered" if the gitignore contains it exactly, or a parent glob covers it
+        const base = pattern.replace(/\*\*\//g, '').replace(/\*/g, '');
+        return !lines.some(l => l === pattern ||
+            l === pattern.replace(/\/$/, '') ||
+            // e.g. "**/.monomind/" covers ".monomind/"
+            (l.includes('**') && base && l.replace(/\*\*\//g, '').replace(/\*/g, '') === base));
+    });
+    if (missing.length === 0) {
+        return { name: 'Gitignore Coverage', status: 'pass', message: 'All monomind runtime paths are gitignored' };
+    }
+    const missingList = missing.map(m => m.pattern).join(', ');
+    const fixLines = missing.map(m => m.pattern).join('\\n');
+    return {
+        name: 'Gitignore Coverage',
+        status: 'warn',
+        message: `${missing.length} runtime path(s) not in .gitignore: ${missingList}`,
+        fix: `printf "${fixLines}\\n" >> .gitignore`,
+    };
+}
 async function checkGuidanceGates() {
     const settingsPath = join(process.cwd(), '.claude', 'settings.json');
     const gatesHandlerPath = join(process.cwd(), '.claude', 'helpers', 'handlers', 'gates-handler.cjs');
@@ -599,6 +723,9 @@ async function checkGuidanceGates() {
         };
     }
     try {
+        if (statSync(settingsPath).size > MAX_DOCTOR_CONFIG_BYTES) {
+            return { name: 'Guidance Gates', status: 'warn', message: 'settings.json too large to parse' };
+        }
         const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
         const preToolUse = settings?.hooks?.PreToolUse ?? [];
         const hasPreWrite = preToolUse.some(e => e.matcher === 'Write|Edit|MultiEdit' && e.hooks.some(h => h.command?.includes('pre-write')));
@@ -671,7 +798,7 @@ export const doctorCommand = {
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, helpers, monoes, gates)',
+            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph, memory-pkg, helpers, agentic-flow, monoes, gates, gitignore)',
             type: 'string'
         },
         {
@@ -714,10 +841,12 @@ export const doctorCommand = {
             checkDiskSpace,
             checkBuildTools,
             checkMonograph,
+            checkMonoesMemory,
             checkHelpersFresh,
             checkAgenticFlow,
             checkMonoesIntegration,
             checkGuidanceGates,
+            checkGitignoreCoverage,
         ];
         const componentMap = {
             'version': checkVersionFreshness,
@@ -734,10 +863,12 @@ export const doctorCommand = {
             'disk': checkDiskSpace,
             'typescript': checkBuildTools,
             'monograph': checkMonograph,
+            'memory-pkg': checkMonoesMemory,
             'helpers': checkHelpersFresh,
             'agentic-flow': checkAgenticFlow,
             'monoes': checkMonoesIntegration,
             'gates': checkGuidanceGates,
+            'gitignore': checkGitignoreCoverage,
         };
         let checksToRun = allChecks;
         if (component && componentMap[component]) {

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

@@ -461,6 +461,19 @@ const abTestCommand = {
                     output.writeln(output.error(`Tasks file not found: ${tasksPath}`));
                     return { success: false, message: `File not found: ${tasksPath}` };
                 }
+                // Size guard: a multi-MB tasks file would be buffered in full before
+                // JSON.parse runs. Cap at 10 MB — any legitimate task list is far smaller.
+                const { statSync, lstatSync } = await import('node:fs');
+                const tasksLstat = lstatSync(tasksPath);
+                if (tasksLstat.isSymbolicLink()) {
+                    output.writeln(output.error(`Symlinks are not allowed as task files: ${tasksPath}`));
+                    return { success: false, message: 'Symlink not allowed as tasks file' };
+                }
+                const MAX_TASKS_FILE_BYTES = 10 * 1024 * 1024; // 10 MB
+                if (tasksLstat.size > MAX_TASKS_FILE_BYTES) {
+                    output.writeln(output.error(`Tasks file too large (max 10 MB): ${tasksPath}`));
+                    return { success: false, message: 'Tasks file too large' };
+                }
                 const tasksJson = await readFile(tasksPath, 'utf-8');
                 customTasks = JSON.parse(tasksJson);
                 output.writeln(`  Custom tasks: ${output.bold(String(customTasks.length))} loaded from ${tasksPath}`);
@@ -542,7 +555,7 @@ const setupCommand = {
         output.writeln(output.bold('Guidance Gates Setup'));
         output.writeln(output.dim('─'.repeat(50)));
         output.writeln();
-        const { readFileSync, writeFileSync, existsSync } = await import('node:fs');
+        const { readFileSync, writeFileSync, existsSync, statSync } = await import('node:fs');
         const { join } = await import('node:path');
         const settingsPath = join(projectDir, '.claude', 'settings.json');
         const gatesHandlerPath = join(projectDir, '.claude', 'helpers', 'handlers', 'gates-handler.cjs');
@@ -553,7 +566,7 @@ const setupCommand = {
         }
         // Load or create settings.json
         let settings = {};
-        if (existsSync(settingsPath)) {
+        if (existsSync(settingsPath) && statSync(settingsPath).size <= 1024 * 1024) {
             try {
                 settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
             }

package/packages/@monomind/cli/dist/src/commands/hive-mind.js

@@ -10,7 +10,14 @@ import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { spawn as childSpawn, execSync } from 'child_process';
 import { mkdir, writeFile } from 'fs/promises';
-import { join } from 'path';
+import { join, resolve as resolvePath, sep } from 'path';
+// Input length caps
+const MAX_OBJECTIVE_LEN = 2_000;
+const MAX_TASK_DESC_LEN = 4_000;
+const MAX_MESSAGE_LEN = 2_000;
+const MAX_KEY_LEN = 256;
+const MAX_VALUE_LEN = 65_536;
+const MAX_AGENT_ID_LEN = 128;
 // Hive topologies
 const TOPOLOGIES = [
     { value: 'hierarchical', label: 'Hierarchical', hint: 'Queen-led with worker agents' },
@@ -177,11 +184,21 @@ async function spawnClaudeCodeInstance(swarmId, swarmName, objective, workers, f
             `Consensus: ${output.highlight(flags.consensus || 'byzantine')}`,
             `MCP Tools: ${output.success('Full Monomind integration enabled')}`
         ]);
-        // Ensure sessions directory exists
-        const sessionsDir = join('.hive-mind', 'sessions');
+        // Ensure sessions directory exists (anchor to process.cwd() so relative paths
+        // don't escape when the caller changes directory)
+        const baseDir = resolvePath(process.cwd());
+        const sessionsDir = resolvePath(baseDir, '.hive-mind', 'sessions');
+        // Guard: sessions directory must stay inside cwd
+        if (!sessionsDir.startsWith(baseDir + sep) && sessionsDir !== baseDir) {
+            throw new Error('Sessions directory path traversal detected');
+        }
         await mkdir(sessionsDir, { recursive: true });
         const safeSwarmId = swarmId.replace(/[^a-zA-Z0-9_-]/g, '_');
         const promptFile = join(sessionsDir, `hive-mind-prompt-${safeSwarmId}.txt`);
+        // Guard: prompt file must stay inside sessions directory
+        if (!resolvePath(promptFile).startsWith(sessionsDir + sep)) {
+            throw new Error('Prompt file path traversal detected');
+        }
         await writeFile(promptFile, hiveMindPrompt, 'utf8');
         output.writeln();
         output.printSuccess(`Hive Mind prompt saved to: ${promptFile}`);
@@ -295,10 +312,14 @@ async function spawnClaudeCodeInstance(swarmId, swarmName, objective, workers, f
         spinner.fail('Failed to prepare Claude Code coordination');
         const errorMessage = error instanceof Error ? error.message : String(error);
         output.printError(`Error: ${errorMessage}`);
-        // Try to save prompt as fallback
+        // Try to save prompt as fallback — write inside cwd to avoid path issues
         try {
             const safeSwarmIdFallback = swarmId.replace(/[^a-zA-Z0-9_-]/g, '_');
-            const promptFile = `hive-mind-prompt-${safeSwarmIdFallback}-fallback.txt`;
+            const fallbackDir = resolvePath(process.cwd());
+            const promptFile = join(fallbackDir, `hive-mind-prompt-${safeSwarmIdFallback}-fallback.txt`);
+            if (!resolvePath(promptFile).startsWith(fallbackDir + sep)) {
+                throw new Error('Fallback path traversal');
+            }
             const workerGroups = groupWorkersByType(workers);
             const hiveMindPrompt = generateHiveMindPrompt(swarmId, swarmName, objective, workers, workerGroups, flags);
             await writeFile(promptFile, hiveMindPrompt, 'utf8');
@@ -502,12 +523,13 @@ const spawnCommand = {
     ],
     action: async (ctx) => {
         // Parse count with fallback to default
-        const count = ctx.flags.count || 1;
+        const rawCount = ctx.flags.count || 1;
+        const count = Number.isFinite(rawCount) ? Math.max(1, Math.min(rawCount, 50)) : 1;
         const role = ctx.flags.role || 'worker';
         const agentType = ctx.flags.type || 'worker';
         const prefix = ctx.flags.prefix || 'hive-worker';
         const launchClaude = ctx.flags.claude;
-        let objective = ctx.flags.objective || ctx.args.join(' ');
+        let objective = (ctx.flags.objective || ctx.args.join(' ')).slice(0, MAX_OBJECTIVE_LEN);
         output.printInfo(`Spawning ${count} ${role} agent(s)...`);
         try {
             const result = await callMCPTool('hive-mind_spawn', {
@@ -761,12 +783,13 @@ const taskCommand = {
         { command: 'monomind hive-mind task -d "Security review" -p critical -c', description: 'Critical task with consensus' }
     ],
     action: async (ctx) => {
-        let description = ctx.flags.description || ctx.args.join(' ');
+        let description = (ctx.flags.description || ctx.args.join(' ')).slice(0, MAX_TASK_DESC_LEN);
         if (!description && ctx.interactive) {
             description = await input({
                 message: 'Task description:',
                 validate: (v) => v.length > 0 || 'Description is required'
             });
+            description = description.slice(0, MAX_TASK_DESC_LEN);
         }
         if (!description) {
             output.printError('Task description is required');
@@ -888,7 +911,7 @@ const joinCommand = {
         { name: 'role', short: 'r', description: 'Agent role (worker, specialist, scout)', type: 'string', default: 'worker' }
     ],
     action: async (ctx) => {
-        const agentId = ctx.args[0] || ctx.flags['agent-id'] || ctx.flags.agentId;
+        const agentId = (ctx.args[0] || ctx.flags['agent-id'] || ctx.flags.agentId || '').slice(0, MAX_AGENT_ID_LEN);
         if (!agentId) {
             output.printError('Agent ID is required. Use --agent-id or -a flag, or provide as argument.');
             return { success: false, exitCode: 1 };
@@ -914,7 +937,7 @@ const leaveCommand = {
     description: 'Remove an agent from the hive mind',
     options: [{ name: 'agent-id', short: 'a', description: 'Agent ID to remove', type: 'string' }],
     action: async (ctx) => {
-        const agentId = ctx.args[0] || ctx.flags['agent-id'] || ctx.flags.agentId;
+        const agentId = (ctx.args[0] || ctx.flags['agent-id'] || ctx.flags.agentId || '').slice(0, MAX_AGENT_ID_LEN);
         if (!agentId) {
             output.printError('Agent ID required.');
             return { success: false, exitCode: 1 };
@@ -986,13 +1009,13 @@ const broadcastCommand = {
         { name: 'from', short: 'f', description: 'Sender agent ID', type: 'string' }
     ],
     action: async (ctx) => {
-        const message = ctx.args.join(' ') || ctx.flags.message;
+        const message = (ctx.args.join(' ') || ctx.flags.message || '').slice(0, MAX_MESSAGE_LEN);
         if (!message) {
             output.printError('Message required. Use --message or -m flag.');
             return { success: false, exitCode: 1 };
         }
         try {
-            const result = await callMCPTool('hive-mind_broadcast', { message, priority: ctx.flags.priority, fromId: ctx.flags.from });
+            const result = await callMCPTool('hive-mind_broadcast', { message, priority: ctx.flags.priority, fromId: typeof ctx.flags.from === 'string' ? ctx.flags.from.slice(0, MAX_AGENT_ID_LEN) : undefined });
             if (!result.success) {
                 output.printError(result.error || 'Failed');
                 return { success: false, exitCode: 1 };
@@ -1017,8 +1040,8 @@ const memorySubCommand = {
     ],
     action: async (ctx) => {
         const action = ctx.flags.action || 'list';
-        const key = ctx.flags.key;
-        const value = ctx.flags.value;
+        const key = typeof ctx.flags.key === 'string' ? ctx.flags.key.slice(0, MAX_KEY_LEN) : undefined;
+        const value = typeof ctx.flags.value === 'string' ? ctx.flags.value.slice(0, MAX_VALUE_LEN) : undefined;
         if ((action === 'get' || action === 'delete') && !key) {
             output.printError('Key required for get/delete.');
             return { success: false, exitCode: 1 };

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

@@ -27,8 +27,10 @@ function readCoverageFromDisk() {
         const summaryPath = join(cwd, relPath);
         if (existsSync(summaryPath)) {
             try {
-                const raw = JSON.parse(readFileSync(summaryPath, 'utf-8'));
-                return parseCoverageSummaryJson(raw, relPath);
+                if (statSync(summaryPath).size <= 4_194_304) {
+                    const raw = JSON.parse(readFileSync(summaryPath, 'utf-8'));
+                    return parseCoverageSummaryJson(raw, relPath);
+                }
             }
             catch {
                 // malformed, try next
@@ -40,8 +42,10 @@ function readCoverageFromDisk() {
         const lcovPath = join(cwd, relPath);
         if (existsSync(lcovPath)) {
             try {
-                const raw = readFileSync(lcovPath, 'utf-8');
-                return parseLcovInfo(raw, relPath);
+                if (statSync(lcovPath).size <= 8_388_608) {
+                    const raw = readFileSync(lcovPath, 'utf-8');
+                    return parseLcovInfo(raw, relPath);
+                }
             }
             catch {
                 // malformed, try next
@@ -52,8 +56,10 @@ function readCoverageFromDisk() {
     const nycPath = join(cwd, '.nyc_output', 'out.json');
     if (existsSync(nycPath)) {
         try {
-            const raw = JSON.parse(readFileSync(nycPath, 'utf-8'));
-            return parseCoverageSummaryJson(raw, '.nyc_output/out.json');
+            if (statSync(nycPath).size <= 4_194_304) {
+                const raw = JSON.parse(readFileSync(nycPath, 'utf-8'));
+                return parseCoverageSummaryJson(raw, '.nyc_output/out.json');
+            }
         }
         catch {
             // malformed
@@ -1785,9 +1791,11 @@ const intelligenceCommand = {
                 try {
                     const pStat = statSync(persistence.patternsFile);
                     patternsFileSize = pStat.size;
-                    const pData = JSON.parse(readFileSync(persistence.patternsFile, 'utf-8'));
-                    if (Array.isArray(pData))
-                        patternsFileEntries = pData.length;
+                    if (patternsFileSize <= 4_194_304) {
+                        const pData = JSON.parse(readFileSync(persistence.patternsFile, 'utf-8'));
+                        if (Array.isArray(pData))
+                            patternsFileEntries = pData.length;
+                    }
                 }
                 catch { /* ignore */ }
             }
@@ -1796,9 +1804,12 @@ const intelligenceCommand = {
             let lastAdaptationFromDisk = null;
             if (persistence.statsExist) {
                 try {
-                    const sData = JSON.parse(readFileSync(persistence.statsFile, 'utf-8'));
-                    trajectoriesFromDisk = sData?.trajectoriesRecorded ?? 0;
-                    lastAdaptationFromDisk = sData?.lastAdaptation ?? null;
+                    const sStat = statSync(persistence.statsFile);
+                    if (sStat.size <= 524_288) {
+                        const sData = JSON.parse(readFileSync(persistence.statsFile, 'utf-8'));
+                        trajectoriesFromDisk = sData?.trajectoriesRecorded ?? 0;
+                        lastAdaptationFromDisk = sData?.lastAdaptation ?? null;
+                    }
                 }
                 catch { /* ignore */ }
             }
@@ -3375,10 +3386,12 @@ const statuslineCommand = {
             for (const lPath of learningJsonPaths) {
                 if (fs.existsSync(lPath)) {
                     try {
-                        const data = JSON.parse(fs.readFileSync(lPath, 'utf-8'));
-                        if (data.intelligence?.score !== undefined) {
-                            intelligencePct = Math.min(100, Math.floor(data.intelligence.score));
-                            break;
+                        if (fs.statSync(lPath).size <= 524_288) {
+                            const data = JSON.parse(fs.readFileSync(lPath, 'utf-8'));
+                            if (data.intelligence?.score !== undefined) {
+                                intelligencePct = Math.min(100, Math.floor(data.intelligence.score));
+                                break;
+                            }
                         }
                     }
                     catch { /* ignore */ }
@@ -3500,9 +3513,11 @@ const statuslineCommand = {
         const settingsPath = path.join(process.cwd(), '.claude', 'settings.json');
         if (fs.existsSync(settingsPath)) {
             try {
-                const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-                if (settings.hooks) {
-                    hooksStats.enabled = Object.values(settings.hooks).filter((h) => h && typeof h === 'object').length;
+                if (fs.statSync(settingsPath).size <= 524_288) {
+                    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+                    if (settings.hooks) {
+                        hooksStats.enabled = Object.values(settings.hooks).filter((h) => h && typeof h === 'object').length;
+                    }
                 }
             }
             catch { /* ignore */ }
@@ -3585,12 +3600,14 @@ const statuslineCommand = {
         const vectorsPath = path.join(process.cwd(), '.monomind', 'vectors.json');
         if (fs.existsSync(vectorsPath) && agentdbStats.vectorCount === 0) {
             try {
-                const data = JSON.parse(fs.readFileSync(vectorsPath, 'utf-8'));
-                if (Array.isArray(data)) {
-                    agentdbStats.vectorCount = data.length;
-                }
-                else if (data.vectors) {
-                    agentdbStats.vectorCount = Object.keys(data.vectors).length;
+                if (fs.statSync(vectorsPath).size <= 8_388_608) {
+                    const data = JSON.parse(fs.readFileSync(vectorsPath, 'utf-8'));
+                    if (Array.isArray(data)) {
+                        agentdbStats.vectorCount = data.length;
+                    }
+                    else if (data.vectors) {
+                        agentdbStats.vectorCount = Object.keys(data.vectors).length;
+                    }
                 }
             }
             catch { /* ignore */ }

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

@@ -99,7 +99,7 @@ const initAction = async (ctx) => {
                 const { spawn } = await import('child_process');
                 const pidFile = path.join(ctx.cwd, '.monomind', 'monograph-watch.pid');
                 let alreadyRunning = false;
-                if (fs.existsSync(pidFile)) {
+                if (fs.existsSync(pidFile) && fs.statSync(pidFile).size <= 32) {
                     const existingPid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
                     if (!isNaN(existingPid)) {
                         try {
@@ -738,9 +738,14 @@ const upgradeCommand = {
             // Try to read control URL for dashboard progress events (best-effort)
             let controlUrl = 'http://localhost:4242';
             try {
-                const ctrlCfg = JSON.parse(fs.readFileSync(path.join(process.cwd(), '.monomind', 'control.json'), 'utf-8'));
-                if (ctrlCfg.url)
-                    controlUrl = ctrlCfg.url;
+                const ctrlPath = path.join(process.cwd(), '.monomind', 'control.json');
+                if (fs.existsSync(ctrlPath) && fs.statSync(ctrlPath).size <= 4096) {
+                    const ctrlCfg = JSON.parse(fs.readFileSync(ctrlPath, 'utf-8'));
+                    // Only allow localhost/127.0.0.1 URLs to prevent SSRF via attacker-controlled control.json
+                    if (typeof ctrlCfg.url === 'string' && /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(ctrlCfg.url)) {
+                        controlUrl = ctrlCfg.url;
+                    }
+                }
             }
             catch { }
             const emitUpgradeProgress = async (projDir, status, current, total) => {