monomind 2.2.0 → 2.3.0

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

@@ -4,13 +4,13 @@ import { join, resolve } from 'node:path';
 import { output } from '../output.js';
 import { OrgDaemon } from '../orgrt/daemon.js';
 import { startOrgServer } from '../orgrt/server.js';
-import { ORG_DIR } from '../orgrt/types.js';
+import { ORG_DIR, OrgDefSchema } from '../orgrt/types.js';
 const log = (text) => { console.log(text); };
 /** Org names are used to build filesystem paths under .monomind/orgs — reject
  * anything that isn't a plain identifier to prevent path traversal (e.g.
  * `monomind org stop '../../../../tmp/x'`). */
 const ORG_NAME_RE = /^[a-z0-9][a-z0-9_-]*$/i;
-function validateOrgName(name) {
+export function validateOrgName(name) {
     if (!name)
         return { ok: false, result: { success: false, message: 'org name required' } };
     if (!ORG_NAME_RE.test(name)) {
@@ -30,7 +30,7 @@ const ORG_ARTIFACT_SUFFIXES = [
     '-plugins', '-adapters', '-join-requests', '-bootstrap', '-project-workspaces',
     '-approval-comments', '-skills',
 ];
-function listOrgConfigFiles(orgsDir) {
+export function listOrgConfigFiles(orgsDir) {
     return readdirSync(orgsDir)
         .filter(f => f.endsWith('.json') && !f.startsWith('._') && !ORG_ARTIFACT_SUFFIXES.some(suf => f.includes(suf)));
 }
@@ -53,6 +53,32 @@ const runAction = async (ctx) => {
     const taskFlag = ctx.flags['task'];
     if (Array.isArray(taskFlag))
         return { success: false, message: '--task was passed more than once — pass it exactly once' };
+    // Fail before any side effects (inbox server) when the org doesn't exist.
+    const orgsDir = join(ctx.cwd, ORG_DIR);
+    if (!existsSync(join(orgsDir, `${name}.json`))) {
+        const known = existsSync(orgsDir) ? listOrgConfigFiles(orgsDir).map(f => f.replace(/\.json$/, '')) : [];
+        log(output.error(`Org not found: ${name}${known.length ? ` — available: ${known.join(', ')}` : ' — create one with /mastermind:createorg'}`));
+        return { success: false, message: 'org not found' };
+    }
+    if (ctx.flags['dryRun'] === true) {
+        // Validate + preview each role's actual briefing without spawning sessions.
+        try {
+            const def = OrgDefSchema.parse(JSON.parse(readFileSync(join(orgsDir, `${name}.json`), 'utf8')));
+            const { buildRolePrompt } = await import('../orgrt/session.js');
+            const roster = def.roles.map(r => r.id);
+            const perRole = Math.floor((def.run_config.budget_tokens ?? 1_000_000) / def.roles.length);
+            log(output.info(`DRY RUN — org ${name}: ${def.roles.length} roles, ${perRole} tokens each, goal: ${taskFlag ?? def.goal}`));
+            for (const role of def.roles) {
+                log(output.info(`\n─── ${role.id} (${role.title || role.type})${role.adapter_config?.model ? ` [${role.adapter_config.model}]` : ''} ───`));
+                log(buildRolePrompt(role, { name: def.name, goal: taskFlag ?? def.goal }, roster));
+            }
+            return { success: true, message: 'dry run complete — no sessions started' };
+        }
+        catch (err) {
+            log(output.error(`Config invalid: ${err instanceof Error ? err.message : String(err)}`));
+            return { success: false, message: 'invalid org config' };
+        }
+    }
     const crossProcess = ctx.flags['crossProcess'] !== false;
     const daemon = new OrgDaemon(ctx.cwd, { crossProcess });
     let srv;
@@ -60,7 +86,20 @@ const runAction = async (ctx) => {
         srv = await startOrgServer(daemon, 0);
         daemon.setInboxUrl(`http://127.0.0.1:${srv.port}`);
     }
-    const running = await daemon.startOrg(name, taskFlag);
+    let running;
+    try {
+        running = await daemon.startOrg(name, taskFlag);
+    }
+    catch (err) {
+        // Don't leave the inbox server holding the event loop open on a failed start.
+        srv?.close();
+        await daemon.stopAll().catch(() => { });
+        const detail = err instanceof Error ? err.message : String(err);
+        const hint = err instanceof Error && err.name === 'ZodError'
+            ? ` — run "monomind org validate ${name}" for details` : '';
+        log(output.error(`Could not start org ${name}: ${detail}${hint}`));
+        return { success: false, message: 'org start failed' };
+    }
     log(output.info(`org ${name} running (${running.def.roles.length} agents, run ${running.run}) — Ctrl-C or "monomind org stop ${name}" to stop`));
     // stopfile poll lets `org stop` work from another terminal;
     // clear any stale stopfile from a previous run before polling
@@ -79,18 +118,41 @@ const runAction = async (ctx) => {
     srv?.close();
     return { success: true, message: `org ${name} stopped` };
 };
+/** True when runtime.json records a running org whose recorded pid is still alive. */
+const isOrgRunning = (cwd, name) => {
+    try {
+        const rt = JSON.parse(readFileSync(join(cwd, ORG_DIR, name, 'runtime.json'), 'utf8'));
+        if (rt.status !== 'running' || !rt.pid)
+            return false;
+        process.kill(rt.pid, 0); // throws if the pid is gone (crashed daemon left a stale file)
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
 const stopAction = async (ctx) => {
     const validated = validateOrgName(ctx.args[0]);
     if (!validated.ok)
         return validated.result;
     const name = validated.name;
+    if (!existsSync(join(ctx.cwd, ORG_DIR, `${name}.json`))) {
+        log(output.error(`Org not found: ${name}`));
+        return { success: false, message: 'org not found' };
+    }
     const { writeFileSync, mkdirSync } = await import('node:fs');
     mkdirSync(join(ctx.cwd, ORG_DIR, name), { recursive: true });
     writeFileSync(join(ctx.cwd, ORG_DIR, name, 'stop'), new Date().toISOString());
     return { success: true, message: `stop requested for ${name} (daemon exits within 2s)` };
 };
 const statusAction = async (ctx) => {
-    const name = ctx.args[0];
+    let name;
+    if (ctx.args[0]) {
+        const validated = validateOrgName(ctx.args[0]);
+        if (!validated.ok)
+            return validated.result;
+        name = validated.name;
+    }
     const orgDir = join(ctx.cwd, ORG_DIR);
     const targets = name ? [name] : (existsSync(orgDir)
         ? listOrgConfigFiles(orgDir).map(f => f.replace(/\.json$/, ''))
@@ -107,6 +169,17 @@ const statusAction = async (ctx) => {
                 continue;
             }
         }
+        // A "running" record whose pid is gone means the daemon died without its
+        // stopOrg cleanup — surface that instead of reporting it as still running.
+        if (state.status === 'running' && state.pid) {
+            try {
+                process.kill(state.pid, 0);
+            }
+            catch {
+                log(output.warning(`${t}: crashed (runtime.json says running but pid ${state.pid} is gone)${state.run ? ` — run ${state.run}` : ''} — close it out with "monomind org mark-complete ${t}"`));
+                continue;
+            }
+        }
         log(output.info(`${t}: ${state.status}${state.run ? ` (run ${state.run}, pid ${state.pid})` : ''}`));
     }
     return { success: true };
@@ -198,8 +271,27 @@ const listAction = async (ctx) => {
         return { success: true };
     }
     log(output.info(`Found ${configs.length} org(s):`));
-    for (const f of configs)
-        log(output.info(`  • ${f.replace('.json', '')}`));
+    for (const f of configs) {
+        const stem = f.replace(/\.json$/, '');
+        let detail = '';
+        try {
+            const def = JSON.parse(readFileSync(join(orgsDir, f), 'utf8'));
+            const roles = Array.isArray(def.roles) ? def.roles.length : 0;
+            const sched = def.schedule ? `every ${def.schedule}` : 'manual';
+            let status = 'never run';
+            try {
+                status = JSON.parse(readFileSync(join(orgsDir, stem, 'runtime.json'), 'utf8')).status ?? status;
+            }
+            catch { /* no runtime state yet */ }
+            const goal = typeof def.goal === 'string' && def.goal
+                ? ` — ${def.goal.length > 60 ? `${def.goal.slice(0, 57)}...` : def.goal}` : '';
+            detail = `  (${roles} role${roles === 1 ? '' : 's'}, ${sched}, ${status})${goal}`;
+        }
+        catch {
+            detail = '  (unreadable config — run `monomind org validate`)';
+        }
+        log(output.info(`  • ${stem}${detail}`));
+    }
     return { success: true };
 };
 const deleteAction = async (ctx) => {
@@ -225,6 +317,10 @@ const deleteAction = async (ctx) => {
         log(output.error(`Org not found: ${orgName}`));
         return { success: false, message: 'org not found' };
     }
+    if (isOrgRunning(cwd, orgName) && ctx.flags['force'] !== true) {
+        log(output.error(`Org "${orgName}" is currently running — stop it first (monomind org stop ${orgName}) or pass --force.`));
+        return { success: false, message: 'org is running' };
+    }
     let removed = 0;
     for (const suf of ['', ...ORG_ARTIFACT_SUFFIXES]) {
         for (const ext of ['.json', '.jsonl']) {
@@ -298,6 +394,7 @@ export const orgCommand = {
             options: [
                 { name: 'task', description: 'Override the org goal for this run', type: 'string' },
                 { name: 'cross-process', description: 'Discover and message orgs hosted by other monomind processes on this machine (default true)', type: 'boolean', default: true },
+                { name: 'dry-run', description: 'Validate and print each role\'s briefing without starting any agent sessions', type: 'boolean' },
             ],
             examples: [{ command: 'monomind org run growth --task "weekly report"', description: 'Run the growth org once with a task' }],
             action: runAction,
@@ -316,10 +413,95 @@ export const orgCommand = {
             options: [{ name: 'times', short: 'n', description: 'Iterations', type: 'number', default: 5 }],
             action: testLoopAction,
         },
+        {
+            name: 'logs', description: 'Show (or follow) the formatted event log of an org run',
+            options: [
+                { name: 'run', description: 'Run id (default: latest)', type: 'string' },
+                { name: 'role', description: 'Only events from/to this role', type: 'string' },
+                { name: 'follow', short: 'f', description: 'Keep tailing until Ctrl-C', type: 'boolean' },
+            ],
+            examples: [{ command: 'monomind org logs growth --follow', description: 'Live-tail the latest run' }],
+            action: async (ctx) => {
+                const v = validateOrgName(ctx.args[0]);
+                if (!v.ok)
+                    return v.result;
+                const { logsAction } = await import('./org-observe.js');
+                return logsAction(ctx, v.name);
+            },
+        },
+        {
+            name: 'report', description: 'Summarize an org run: outcome, per-role activity, tokens, assets, crashes',
+            options: [
+                { name: 'run', description: 'Run id (default: latest)', type: 'string' },
+                { name: 'all', description: 'List all recorded runs from history', type: 'boolean' },
+            ],
+            examples: [{ command: 'monomind org report growth', description: 'Report on the latest run' }],
+            action: async (ctx) => {
+                const v = validateOrgName(ctx.args[0]);
+                if (!v.ok)
+                    return v.result;
+                const { reportAction } = await import('./org-observe.js');
+                return reportAction(ctx, v.name);
+            },
+        },
+        {
+            name: 'questions', description: 'List pending ask_human questions from an org\'s agents',
+            options: [{ name: 'all', description: 'Include answered questions', type: 'boolean' }],
+            examples: [{ command: 'monomind org questions growth', description: 'Show unanswered questions' }],
+            action: async (ctx) => {
+                const v = validateOrgName(ctx.args[0]);
+                if (!v.ok)
+                    return v.result;
+                const { questionsAction } = await import('./org-observe.js');
+                return questionsAction(ctx, v.name);
+            },
+        },
+        {
+            name: 'answer', description: 'Answer a pending ask_human question (live if the org is running, queued otherwise)',
+            examples: [{ command: 'monomind org answer growth q-123-ab "yes, ship it"', description: 'Answer question q-123-ab' }],
+            action: async (ctx) => {
+                const v = validateOrgName(ctx.args[0]);
+                if (!v.ok)
+                    return v.result;
+                const { answerAction } = await import('./org-observe.js');
+                return answerAction(ctx, v.name);
+            },
+        },
+        {
+            name: 'create', description: 'Scaffold an org config from a starter template',
+            options: [
+                { name: 'template', description: 'content-team | dev-team | research-pod', type: 'string' },
+                { name: 'goal', description: 'Org goal (defaults to the template\'s placeholder)', type: 'string' },
+                { name: 'schedule', description: 'Daemon schedule, e.g. 30m or 2h', type: 'string' },
+                { name: 'force', description: 'Overwrite an existing org config', type: 'boolean' },
+            ],
+            examples: [{ command: 'monomind org create blog --template content-team --goal "3 posts/week"', description: 'Create a content org' }],
+            action: async (ctx) => {
+                const v = validateOrgName(ctx.args[0]);
+                if (!v.ok)
+                    return v.result;
+                const { createAction } = await import('./org-observe.js');
+                return createAction(ctx, v.name);
+            },
+        },
+        {
+            name: 'validate', description: 'Validate org config(s) against the runtime schema and structural invariants',
+            examples: [
+                { command: 'monomind org validate growth', description: 'Validate one org config' },
+                { command: 'monomind org validate', description: 'Validate every org config in the project' },
+            ],
+            action: async (ctx) => {
+                const { validateAction } = await import('./org-observe.js');
+                return validateAction(ctx);
+            },
+        },
         { name: 'list', description: 'List all orgs in the current project', action: listAction },
         {
             name: 'delete', description: 'Delete an org and all its data',
-            options: [{ name: 'yes', short: 'y', description: 'Skip confirmation', type: 'boolean' }],
+            options: [
+                { name: 'yes', short: 'y', description: 'Skip confirmation', type: 'boolean' },
+                { name: 'force', description: 'Delete even if the org appears to be running', type: 'boolean' },
+            ],
             action: deleteAction,
         },
         { name: 'mark-complete', description: 'Manually close a stale/crashed run', action: markCompleteAction },
@@ -329,7 +511,7 @@ export const orgCommand = {
         // index.ts's dispatcher never prints result.message on a failed action —
         // it only exits with result.exitCode — so this must log itself or bare
         // `monomind org` exits silently with code 1 and zero output.
-        const message = 'usage: monomind org <run|stop|status|serve|test-loop|list|delete|mark-complete>';
+        const message = 'usage: monomind org <run|stop|status|serve|test-loop|logs|report|questions|answer|create|validate|list|delete|mark-complete>';
         log(output.error(message));
         return { success: false, message };
     },

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

@@ -535,7 +535,10 @@ const bottleneckCommand = {
         try {
             config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
         }
-        catch { /* no config */ }
+        catch (e) {
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[performance-bottleneck] failed to parse monomind.config.json:', e);
+        }
         const perf = (config.performance ?? {});
         const hnsw = (perf.hnsw ?? {});
         if (!hnsw.quantization) {

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

@@ -224,7 +224,10 @@ function setupCursor(activateScriptPath, repoPath) {
         try {
             settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
         }
-        catch { /* keep empty */ }
+        catch (e) {
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[setupCursor] failed to parse existing .cursor/settings.json, overwriting with empty:', e);
+        }
     }
     const hooks = settings['hooks'] ?? {};
     const sessionStart = hooks['SessionStart'] ?? [];

package/packages/@monomind/cli/dist/src/commands/security-scan.js

@@ -141,10 +141,16 @@ export const scanCommand = {
                                 }
                             }
                         }
-                        catch { /* JSON parse failed */ }
+                        catch (e) { /* JSON parse failed */
+                            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                                console.error('[security-scan] failed to parse npm audit output:', e);
+                        }
                     }
                 }
-                catch { /* npm audit failed */ }
+                catch (e) { /* npm audit failed */
+                    if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                        console.error('[security-scan] dependency check failed:', e);
+                }
             }
             if (scanType === 'all' || scanType === 'code') {
                 spinner.setText('Scanning for hardcoded secrets...');

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

@@ -90,7 +90,10 @@ function loadConfig(cwd) {
         const content = fs.readFileSync(configPath, 'utf-8');
         return parseSimpleYaml(content);
     }
-    catch {
+    catch (e) {
+        // Caller falls back to hardcoded defaults (topology/maxAgents) as if no config existed
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[loadConfig] failed to read/parse .monomind/config.yaml, falling back to defaults:', e);
         return null;
     }
 }

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

@@ -339,8 +339,9 @@ const initCommand = {
                 };
                 writeJsonFileAtomic(stateFile, store);
             }
-            catch {
-                // Ignore errors writing state file
+            catch (e) {
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[swarm-init] failed to persist swarm state file:', e);
             }
             if (ctx.flags.format === 'json') {
                 output.printJson(result);

package/packages/@monomind/cli/dist/src/index.js

@@ -25,7 +25,9 @@ function getPackageVersion() {
         const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
         return pkg.version || '3.0.0';
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[index] getPackageVersion failed, using fallback:', e);
         return '3.0.0';
     }
 }
@@ -472,7 +474,11 @@ export class CLI {
             });
             void _swarmCheckpointer;
         }
-        catch { /* optional — monomind/memory may not be installed */ }
+        catch (e) {
+            // optional — monomind/memory may not be installed
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[index] SwarmCheckpointer init failed:', e);
+        }
         // Task 30: Build unified agent registry — extras (canonical) first, dev copies second.
         // Deduplication is slug-based; agency-agents wins on conflict.
         // Extra paths are read from MONOMIND_EXTRA_AGENT_PATHS env var (colon-separated)
@@ -486,7 +492,11 @@ export class CLI {
             mkdirSync(outDir, { recursive: true });
             buildUnifiedRegistry(roots, join(outDir, 'registry.json'));
         }
-        catch { /* optional — registry build failures must never block startup */ }
+        catch (e) {
+            // optional — registry build failures must never block startup
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[index] agent registry build failed:', e);
+        }
         // Task 04: CapabilityMetadata validation moved to `monomind doctor -c registry`
         // (see doctor-project-checks.ts:checkAgentRegistry). Printing this from a
         // fire-and-forget startup task raced process exit — short-lived commands

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

@@ -926,8 +926,10 @@ async function writeSettings(targetDir, options, result) {
                 result.skipped.push('.claude/settings.json');
             }
         }
-        catch {
+        catch (e) {
             // Existing file is corrupt — overwrite
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[writeSettings] existing settings.json unparseable, overwriting with generated defaults:', e);
             atomicWriteFile(settingsPath, JSON.stringify(generated, null, 2));
             result.created.files.push('.claude/settings.json');
         }
@@ -2000,8 +2002,10 @@ async function writeClaudeMd(targetDir, options, result) {
                 result.created.files.push('~/.claude/CLAUDE.md');
             }
         }
-        catch {
+        catch (e) {
             // Non-critical — global CLAUDE.md is best-effort
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[writeClaudeMd] failed to write/append ~/.claude/CLAUDE.md:', e);
         }
         // Also inject the token-display hook into ~/.claude/settings.json
         const globalSettingsPath = path.join(globalClaudeDir, 'settings.json');
@@ -2014,7 +2018,11 @@ async function writeClaudeMd(targetDir, options, result) {
                 try {
                     globalSettings = JSON.parse(fs.readFileSync(globalSettingsPath, 'utf-8'));
                 }
-                catch { /* malformed JSON — start fresh */ }
+                catch (e) {
+                    // malformed JSON — start fresh
+                    if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                        console.error('[writeClaudeMd] ~/.claude/settings.json unparseable, starting fresh:', e);
+                }
             }
             // Inject SessionStart token hook if not already present
             const hooks = globalSettings.hooks ?? {};
@@ -2031,8 +2039,10 @@ async function writeClaudeMd(targetDir, options, result) {
                 result.created.files.push('~/.claude/settings.json (added token hook)');
             }
         }
-        catch {
+        catch (e) {
             // Non-critical — global settings hook is best-effort
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[writeClaudeMd] failed to inject token hook into ~/.claude/settings.json:', e);
         }
     }
 }
@@ -2163,7 +2173,11 @@ function _registerMonomindProject(dir) {
                 reg = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
             }
         }
-        catch { }
+        catch (e) {
+            // Unparseable registry — proceeding with an empty list will overwrite it below, losing previously registered projects
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[_registerMonomindProject] ~/.monomind-projects.json unparseable, resetting:', e);
+        }
         if (!Array.isArray(reg.projects))
             reg.projects = [];
         const abs = path.resolve(dir);

package/packages/@monomind/cli/dist/src/knowledge/document-pipeline.js

@@ -159,8 +159,9 @@ export async function ingestDocument(filePath, scope = 'shared', rootDir = proce
                 if (storeResult?.success)
                     indexed++;
             }
-            catch {
-                // chunk not stored — don't count as indexed
+            catch (e) {
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error(`[ingestDocument] failed to store chunk ${chunk.chunkIndex} of ${resolved}:`, e);
             }
         }
     }

package/packages/@monomind/cli/dist/src/mcp-tools/agent-tools.d.ts

@@ -24,6 +24,7 @@ interface AgentStore {
     version: string;
 }
 export declare function loadAgentStore(): AgentStore;
+export declare function loadAgentStoreOrNull(): AgentStore | null;
 export declare const agentTools: MCPTool[];
 export {};
 //# sourceMappingURL=agent-tools.d.ts.map

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

@@ -30,21 +30,35 @@ const MAX_AGENT_STORE_BYTES = 50 * 1024 * 1024;
 // (e.g. hive-mind-tools.ts) can reuse this hardened loader instead of
 // maintaining their own weaker copy (missing the size cap / __proto__ guard).
 export function loadAgentStore() {
+    return loadAgentStoreOrNull() ?? { agents: {}, version: '3.0.0' };
+}
+// Like loadAgentStore(), but distinguishes "file doesn't exist yet" (returns
+// the empty default store — safe to build on and save) from "file exists but
+// failed to read/parse, or is corrupt/oversized" (returns null). Handlers
+// that are about to mutate-and-save MUST use this instead of loadAgentStore()
+// and bail out on null, or a transient read failure silently wipes every
+// previously-spawned agent on the next save (the exact bug found and fixed
+// in task-tools.ts's task_assign earlier this session — same pattern here).
+// Exported for other tool modules with their own mutate-and-save paths
+// against the same agent store file — see hive-mind-tools.ts.
+export function loadAgentStoreOrNull() {
     try {
         const path = getAgentPath();
         migrateLegacyStoreFile(path, join(AGENT_DIR, AGENT_FILE));
         if (existsSync(path)) {
             if (statSync(path).size > MAX_AGENT_STORE_BYTES)
-                return { agents: {}, version: '3.0.0' };
+                return null;
             const data = readFileSync(path, 'utf-8');
             const parsed = JSON.parse(data);
             if (parsed && typeof parsed === 'object' && Object.prototype.hasOwnProperty.call(parsed, '__proto__'))
-                return { agents: {}, version: '3.0.0' };
+                return null;
             return parsed;
         }
     }
-    catch {
-        // Return empty store on error
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[loadAgentStore] failed to read/parse agent store — refusing to proceed to avoid overwriting it with an empty one:', e);
+        return null;
     }
     return { agents: {}, version: '3.0.0' };
 }
@@ -126,7 +140,10 @@ export const agentTools = [
             required: ['agentType'],
         },
         handler: async (input) => {
-            const store = loadAgentStore();
+            const store = loadAgentStoreOrNull();
+            if (!store) {
+                return { success: false, error: 'Agent store is unreadable/corrupt — refusing to spawn to avoid overwriting real agent data. Retry, or check the store file if this persists.' };
+            }
             // Cap agentId: used as the JSON object key in store.agents[agentId].
             // An oversized key inflates the on-disk store for every spawned agent.
             // Cap agentType/domain: persisted as AgentRecord field values.
@@ -215,7 +232,10 @@ export const agentTools = [
             if (!agentId || typeof agentId !== 'string' || ['__proto__', 'constructor', 'prototype'].includes(agentId)) {
                 return { success: false, agentId, error: 'Invalid agent ID' };
             }
-            const store = loadAgentStore();
+            const store = loadAgentStoreOrNull();
+            if (!store) {
+                return { success: false, agentId, error: 'Agent store is unreadable/corrupt — refusing to terminate to avoid overwriting real agent data.' };
+            }
             if (Object.hasOwn(store.agents, agentId)) {
                 store.agents[agentId].status = 'terminated';
                 saveAgentStore(store);
@@ -277,25 +297,35 @@ export const agentTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                status: { type: 'string', description: 'Filter by status' },
+                status: { type: 'string', description: 'Filter by status (pass "all" or omit to include every status)' },
                 domain: { type: 'string', description: 'Filter by domain' },
+                agentType: { type: 'string', description: 'Filter by agent type' },
                 includeTerminated: { type: 'boolean', description: 'Include terminated agents' },
             },
         },
         handler: async (input) => {
             const store = loadAgentStore();
             let agents = Object.values(store.agents);
-            // Filter by status
-            if (input.status) {
+            // Filter by status. 'all' (the CLI's `--all` flag sends this literal
+            // string) means "no status filter" — it used to be treated as a real
+            // status value to match against, which no agent ever has, so `--all`
+            // silently returned zero agents instead of every agent.
+            if (input.status && input.status !== 'all') {
                 agents = agents.filter(a => a.status === input.status);
             }
-            else if (!input.includeTerminated) {
+            else if (input.status !== 'all' && !input.includeTerminated) {
                 agents = agents.filter(a => a.status !== 'terminated');
             }
             // Filter by domain
             if (input.domain) {
                 agents = agents.filter(a => a.domain === input.domain);
             }
+            // Filter by agent type — the CLI's `--type` flag has sent this since
+            // it was added, but this handler never read it, so `--type` was a
+            // silent no-op that returned every agent regardless of the filter.
+            if (input.agentType) {
+                agents = agents.filter(a => a.agentType === input.agentType);
+            }
             return {
                 agents: agents.map(a => ({
                     agentId: a.agentId,
@@ -310,6 +340,7 @@ export const agentTools = [
                 filters: {
                     status: input.status,
                     domain: input.domain,
+                    agentType: input.agentType,
                     includeTerminated: input.includeTerminated,
                 },
             };
@@ -329,9 +360,15 @@ export const agentTools = [
             required: ['action'],
         },
         handler: async (input) => {
-            const store = loadAgentStore();
-            const agents = Object.values(store.agents).filter(a => a.status !== 'terminated');
             const action = input.action || 'status'; // Default to status
+            const store = loadAgentStoreOrNull();
+            if (!store) {
+                // 'scale'/'drain' would otherwise build on an empty store and save it,
+                // wiping every real agent; 'status' reporting all-zeros on a corrupt
+                // store would also be misleading, so all three branches bail here.
+                return { action, error: 'Agent store is unreadable/corrupt — refusing to proceed to avoid overwriting real agent data.' };
+            }
+            const agents = Object.values(store.agents).filter(a => a.status !== 'terminated');
             if (action === 'status') {
                 const byType = {};
                 const byStatus = {};
@@ -404,13 +441,16 @@ export const agentTools = [
             }
             if (action === 'drain') {
                 const agentType = input.agentType;
+                // Scope "remaining" to the same population drain operated over — when
+                // filtered by agentType, agents.length (all non-terminated agents,
+                // any type) minus drained (only that type's count) mixed two
+                // different populations and produced a meaningless total.
+                const scoped = agentType ? agents.filter(a => a.agentType === agentType) : agents;
                 let drained = 0;
-                for (const agent of agents) {
-                    if (!agentType || agent.agentType === agentType) {
-                        if (agent.status === 'idle') {
-                            store.agents[agent.agentId].status = 'terminated';
-                            drained++;
-                        }
+                for (const agent of scoped) {
+                    if (agent.status === 'idle') {
+                        store.agents[agent.agentId].status = 'terminated';
+                        drained++;
                     }
                 }
                 saveAgentStore(store);
@@ -418,7 +458,7 @@ export const agentTools = [
                     action,
                     agentType: agentType || 'all',
                     drained,
-                    remaining: agents.length - drained,
+                    remaining: scoped.length - drained,
                 };
             }
             return { action, error: 'Unknown action' };
@@ -521,7 +561,10 @@ export const agentTools = [
             if (!agentId || typeof agentId !== 'string' || ['__proto__', 'constructor', 'prototype'].includes(agentId)) {
                 return { success: false, agentId, error: 'Invalid agent ID' };
             }
-            const store = loadAgentStore();
+            const store = loadAgentStoreOrNull();
+            if (!store) {
+                return { success: false, agentId, error: 'Agent store is unreadable/corrupt — refusing to update to avoid overwriting real agent data.' };
+            }
             const agent = Object.hasOwn(store.agents, agentId) ? store.agents[agentId] : undefined;
             if (agent) {
                 if (input.status)