monomind 2.1.9 → 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);
@@ -517,8 +518,8 @@ const statusCommand = {
             output.writeln(output.warning('No active swarm'));
             output.writeln();
             output.writeln(output.dim('Start a swarm with:'));
-            output.writeln(output.dim('  npx @monomind/cli@latest swarm init'));
-            output.writeln(output.dim('  npx @monomind/cli@latest swarm start'));
+            output.writeln(output.dim('  npx monomind@latest swarm init'));
+            output.writeln(output.dim('  npx monomind@latest swarm start'));
             output.writeln();
             return { success: true, data: status };
         }

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/init/settings-generator.js

@@ -229,8 +229,15 @@ function generateHooksConfig(config, graphify = true) {
                 matcher: 'Write|Edit|MultiEdit',
                 hooks: [
                     {
+                        // Was 'pre-edit' — not a registered hook-handler.cjs dispatch
+                        // command (only 'pre-write' is), so this silently no-op'd on
+                        // every default init: hook-handler.cjs's dispatcher falls through
+                        // to `else if (command) { console.log('[OK] Hook: ' + command); }`
+                        // for any unrecognized subcommand, meaning the secrets-detection
+                        // gate (gates-handler.cjs's handlePreWrite) never actually ran
+                        // for any project set up via a default `monomind init`.
                         type: 'command',
-                        command: hookHandlerCmd('pre-edit'),
+                        command: hookHandlerCmd('pre-write'),
                         timeout: config.timeout,
                     },
                 ],

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