@monoes/monomindcli 2.9.22 → 2.9.24

package/dist/src/commands/org.js

@@ -1,16 +1,19 @@
 // packages/@monomind/cli/src/commands/org.ts
-import { readFileSync, writeFileSync, existsSync, unlinkSync, rmSync, readdirSync, mkdirSync } from 'node:fs';
-import { join, resolve, dirname } from 'node:path';
-import { homedir } from 'node:os';
 import { createHash } from 'node:crypto';
-import { output } from '../output.js';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
 import { OrgDaemon } from '../orgrt/daemon.js';
-import { resolveModel } from '../orgrt/session.js';
-import { startOrgServer } from '../orgrt/server.js';
-import { ORG_DIR, OrgDefSchema } from '../orgrt/types.js';
 import { migrateOrgFile } from '../orgrt/migrate.js';
 import { readHistory, readRunEvents, summarizeRun } from '../orgrt/reporting.js';
-const log = (text) => { console.log(text); };
+import { startOrgServer } from '../orgrt/server.js';
+import { resolveModel } from '../orgrt/session.js';
+import { ORG_DIR, OrgDefSchema } from '../orgrt/types.js';
+import { output } from '../output.js';
+import { MODEL_PRICING } from '../pricing/model-pricing.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'`). */
@@ -30,19 +33,37 @@ export function validateOrgName(name) {
  * exclude them when discovering real org configs) and deleteAction (which
  * must remove all of them when deleting an org). */
 const ORG_ARTIFACT_SUFFIXES = [
-    '-state', '-goals', '-threads', '-activity', '-approvals', '-members', '-secrets', '-budgets',
-    '-routines', '-issues', '-projects', '-workspaces', '-worktrees', '-environments',
-    '-plugins', '-adapters', '-join-requests', '-bootstrap', '-project-workspaces',
-    '-approval-comments', '-skills',
+    '-state',
+    '-goals',
+    '-threads',
+    '-activity',
+    '-approvals',
+    '-members',
+    '-secrets',
+    '-budgets',
+    '-routines',
+    '-issues',
+    '-projects',
+    '-workspaces',
+    '-worktrees',
+    '-environments',
+    '-plugins',
+    '-adapters',
+    '-join-requests',
+    '-bootstrap',
+    '-project-workspaces',
+    '-approval-comments',
+    '-skills',
 ];
 export function listOrgConfigFiles(orgsDir) {
     // endsWith, not includes: substring matching hid legitimate orgs whose NAME
     // merely contains an artifact suffix anywhere (e.g. "state-machine.json",
     // "issues-triage.json") — and anything hidden here is also invisible to
     // run/list/serve while `org delete <sibling>` would still remove its files.
-    return readdirSync(orgsDir)
-        .filter(f => f.endsWith('.json') && !f.startsWith('._') && !f.endsWith('.v1.json')
-        && !ORG_ARTIFACT_SUFFIXES.some(suf => f.endsWith(`${suf}.json`)));
+    return readdirSync(orgsDir).filter((f) => f.endsWith('.json') &&
+        !f.startsWith('._') &&
+        !f.endsWith('.v1.json') &&
+        !ORG_ARTIFACT_SUFFIXES.some((suf) => f.endsWith(`${suf}.json`)));
 }
 /** Remove a lingering stopfile so a fresh `org run` doesn't self-terminate. */
 export const clearStopfile = (cwd, name) => {
@@ -90,22 +111,24 @@ const runAction = async (ctx) => {
     // plain `as string` cast would let that array flow straight into the org's
     // goal and get stringified as "a,b" with no warning. Checked before any
     // side effects (starting the xdeliver listener) run.
-    const taskFlag = ctx.flags['task'];
+    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$/, '')) : [];
+        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) {
+    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 roster = def.roles.map((r) => r.id);
             const perRole = Math.floor((def.run_config.budget_tokens ?? 1_000_000) / def.roles.length);
             // Same KG entity glossary the live daemon injects — the preview must
             // match what sessions actually receive.
@@ -160,14 +183,23 @@ const runAction = async (ctx) => {
         log(output.dim(`  watch it with: monomind org logs ${name} --follow`));
         return { success: true, message: 'start requested' };
     }
-    const crossProcess = ctx.flags['crossProcess'] !== false;
+    const crossProcess = ctx.flags.crossProcess !== false;
     // P1-1: v1 deprecation warning. Detect v1-shaped configs and warn.
     // Gate on MONOMIND_V1_LEGACY=off to refuse v1 orgs entirely (patch-versioning-
     // compliant mechanism — no minor bump needed).
-    const V1_ORG_KEYS = ['topology', 'consensus', 'strategy', 'board_id', 'todo_col_id', 'doing_col_id', 'done_col_id', 'loop'];
+    const V1_ORG_KEYS = [
+        'topology',
+        'consensus',
+        'strategy',
+        'board_id',
+        'todo_col_id',
+        'doing_col_id',
+        'done_col_id',
+        'loop',
+    ];
     try {
         const rawCfg = JSON.parse(readFileSync(join(orgsDir, `${name}.json`), 'utf8'));
-        const isV1 = V1_ORG_KEYS.some(k => k in rawCfg);
+        const isV1 = V1_ORG_KEYS.some((k) => k in rawCfg);
         if (isV1) {
             const v1Legacy = process.env.MONOMIND_V1_LEGACY;
             if (v1Legacy === 'off') {
@@ -179,34 +211,51 @@ const runAction = async (ctx) => {
             log(output.dim(`  To silence: run "monomind org migrate ${name}". To block v1 orgs: set MONOMIND_V1_LEGACY=off.`));
         }
     }
-    catch { /* config parse errors surface below in cost estimate or daemon.startOrg */ }
+    catch {
+        /* config parse errors surface below in cost estimate or daemon.startOrg */
+    }
     // P0-17: Upfront cost estimate. `org run` and `/mastermind:autodev` spend real
     // provider tokens. Print an estimate before sessions start; honor --budget-usd
     // as a hard stop and --yes to skip the confirmation prompt. Rates are defaults
-    // (per 1M tokens, input+output blended, Aug 2026); override via the model id.
+    // (per 1M tokens, blended estimate, Aug 2026); override via the model id.
     //
     // No provider Usage API is queried (that needs Admin/Org API credentials most
-    // users won't have configured) — rates come from this hardcoded table, or from
-    // a user-editable ~/.monomind/rates.json override when present. Either way this
-    // is static data, not a live query, so a "stale rates" warning is always shown
-    // to make that limitation visible rather than implying live pricing.
+    // users won't have configured) — rates are derived from the canonical
+    // MODEL_PRICING table (src/pricing/model-pricing.ts), using each model's
+    // output-token price as the blended per-1M estimate (output tokens dominate
+    // role-turn cost). Models not yet tracked in that table (third-party/non-
+    // Anthropic providers) fall back to the manually maintained EXTRA table
+    // below. A user-editable ~/.monomind/rates.json override, when present,
+    // takes precedence over both. Either way this is static data, not a live
+    // query, so a "stale rates" warning is always shown to make that
+    // limitation visible rather than implying live pricing.
+    const DERIVED_RATE_PER_1M = Object.fromEntries(Object.entries(MODEL_PRICING).map(([model, price]) => [model, price.out * 1_000_000]));
+    // Models absent from MODEL_PRICING (not yet in the canonical pricing table).
+    const EXTRA_MODEL_RATE_PER_1M = {
+        'gpt-4': 10,
+        'glm-5.2': 2,
+        'glm-4': 2,
+        'kimi-latest': 3,
+        'kimi-k2': 3,
+        'kimi-code/k3': 3,
+        'kimi-code/k3-256k': 3,
+        'gemini-3.1-pro': 8,
+        'gemini-3.6-flash-high': 1,
+        'gpt-5.6-terra': 10,
+        'gpt-5.5': 10,
+    };
     const MODEL_RATE_PER_1M = {
-        'claude-opus-5': 75, 'claude-opus-4': 75,
-        'claude-sonnet-5': 15, 'claude-sonnet-4': 15, 'claude-sonnet-4-5': 15,
-        'gpt-5': 10, 'gpt-4': 10,
-        'glm-5.2': 2, 'glm-4': 2,
-        'kimi-latest': 3, 'kimi-k2': 3, 'kimi-code/k3': 3, 'kimi-code/k3-256k': 3,
-        'gemini-3.1-pro': 8, 'gemini-3.6-flash-high': 1,
-        'gpt-5.6-terra': 10, 'gpt-5.5': 10,
+        ...EXTRA_MODEL_RATE_PER_1M,
+        ...DERIVED_RATE_PER_1M,
     };
     const DEFAULT_RATE_PER_1M = 10;
     const AVG_TOKENS_PER_TURN = 2000;
-    const budgetUsd = ctx.flags['budgetUsd'];
-    const skipConfirm = ctx.flags['yes'] === true;
+    const budgetUsd = ctx.flags.budgetUsd;
+    const skipConfirm = ctx.flags.yes === true;
     // User-editable rate overrides: ~/.monomind/rates.json, e.g.
     //   { "claude-opus-5": 90, "my-custom-model": 5 }
     const ratesPath = join(homedir(), '.monomind', 'rates.json');
-    let userRates = {};
+    const userRates = {};
     let ratesFileUsed = false;
     try {
         const parsed = JSON.parse(readFileSync(ratesPath, 'utf8'));
@@ -218,7 +267,9 @@ const runAction = async (ctx) => {
             ratesFileUsed = Object.keys(userRates).length > 0;
         }
     }
-    catch { /* no rates.json (or invalid) — hardcoded defaults only */ }
+    catch {
+        /* no rates.json (or invalid) — hardcoded defaults only */
+    }
     try {
         const def = OrgDefSchema.parse(JSON.parse(readFileSync(join(orgsDir, `${name}.json`), 'utf8')));
         const defaultMaxTurns = def.run_config.max_turns_per_message ?? 30;
@@ -226,7 +277,7 @@ const runAction = async (ctx) => {
         // the schema default is effectively unlimited (DEFAULT_MAX_TURNS_PER_MESSAGE),
         // which would balloon the upfront figure into meaninglessness.
         const ESTIMATE_TURNS_CAP = 30;
-        let totalTokens = 0;
+        let _totalTokens = 0;
         const perRoleRows = def.roles.map((r) => {
             // Mirror the actual runtime's model resolution (session.ts resolveModel)
             // instead of a hardcoded 'claude-sonnet-5' fallback — otherwise every
@@ -236,7 +287,7 @@ const runAction = async (ctx) => {
             const rate = userRates[model] ?? MODEL_RATE_PER_1M[model] ?? DEFAULT_RATE_PER_1M;
             const roleTurns = Math.min(r.max_turns_per_message ?? defaultMaxTurns, ESTIMATE_TURNS_CAP);
             const tokens = roleTurns * AVG_TOKENS_PER_TURN;
-            totalTokens += tokens;
+            _totalTokens += tokens;
             return { id: r.id, model, tokens, cost: (tokens * rate) / 1_000_000 };
         });
         const estimate = perRoleRows.reduce((s, r) => s + r.cost, 0);
@@ -253,7 +304,10 @@ const runAction = async (ctx) => {
         }
         if (!skipConfirm && process.stdin.isTTY) {
             const { confirm } = await import('../prompt.js');
-            const ok = await confirm({ message: `Start ${def.roles.length}-role org? This will spend real provider tokens.`, default: true });
+            const ok = await confirm({
+                message: `Start ${def.roles.length}-role org? This will spend real provider tokens.`,
+                default: true,
+            });
             if (!ok) {
                 log(output.dim('Aborted — no tokens spent.'));
                 return { success: false, message: 'user declined cost-estimate prompt' };
@@ -267,7 +321,7 @@ const runAction = async (ctx) => {
             log(output.dim(`(cost estimate skipped: ${err instanceof Error ? err.message : String(err)})`));
         }
     }
-    const resumeFlag = ctx.flags['resume'] === true;
+    const resumeFlag = ctx.flags.resume === true;
     const daemon = new OrgDaemon(ctx.cwd, { crossProcess });
     let srv;
     if (crossProcess) {
@@ -281,14 +335,45 @@ const runAction = async (ctx) => {
     catch (err) {
         // Don't leave the inbox server holding the event loop open on a failed start.
         srv?.close();
-        await daemon.stopAll().catch(() => { });
+        await daemon.stopAll().catch(() => {
+            /* nothing started */
+        });
         const detail = err instanceof Error ? err.message : String(err);
         const hint = err instanceof Error && err.name === 'ZodError'
-            ? ` — run "monomind org validate ${name}" for details` : '';
+            ? ` — 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`));
+    // #206 follow-up: without this, an uncaught error in this process left
+    // runtime.json's status stuck at 'running' (finishStop never runs), and
+    // runOutcomeResult's status === 'crashed' branch — the one meant to
+    // surface *why* the run failed — could never actually fire for `org run`,
+    // since nothing here ever wrote 'crashed'. Mirrors serveAction's
+    // crashExit, but deliberately does NOT touch SIGINT/SIGTERM — those are
+    // already handled by the wait loop below as a graceful stop, and
+    // registering a second, competing handler here would race it.
+    process.on('uncaughtException', (err) => {
+        try {
+            console.error('[org run] uncaughtException:', err);
+        }
+        catch {
+            /* stderr gone */
+        }
+        daemon.persistCrashStateAll(`uncaughtException: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (err) => {
+        try {
+            console.error('[org run] unhandledRejection:', err);
+        }
+        catch {
+            /* stderr gone */
+        }
+        daemon.persistCrashStateAll(`unhandledRejection: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    });
     // P1-12: Print the dashboard URL so CLI users know where to look.
     // The dashboard is normally spawned by a Claude Code SessionStart hook
     // (.claude/helpers/control-start.cjs) — but `org run` doesn't require
@@ -314,7 +399,9 @@ const runAction = async (ctx) => {
                 stdio: 'ignore',
             });
         }
-        catch { /* best-effort — fall through to whatever control.json already has */ }
+        catch {
+            /* best-effort — fall through to whatever control.json already has */
+        }
     }
     if (existsSync(controlPath)) {
         try {
@@ -322,7 +409,9 @@ const runAction = async (ctx) => {
             const dashUrl = ctl.url || (ctl.port ? `http://localhost:${ctl.port}` : 'http://localhost:4242');
             log(output.dim(`  Dashboard: ${dashUrl}`));
         }
-        catch { /* non-critical */ }
+        catch {
+            /* non-critical */
+        }
     }
     else if (existsSync(controlStartPath)) {
         // control-start.cjs ran above (spawnSync'd synchronously with a 5s cap)
@@ -342,21 +431,75 @@ const runAction = async (ctx) => {
     // previous run before polling.
     clearStopfile(ctx.cwd, name);
     const stopfile = join(ctx.cwd, ORG_DIR, name, 'stop');
-    await new Promise(resolvePromise => {
+    // #206: a human explicitly running `monomind org stop` is a deliberate,
+    // successful action regardless of how the run itself ended — capture that
+    // BEFORE clearStopfile() below wipes the file, so it isn't lost.
+    let stoppedManually = false;
+    await new Promise((resolvePromise) => {
         const iv = setInterval(() => {
-            if (existsSync(stopfile) || !daemon.getOrg(name)) {
+            if (existsSync(stopfile)) {
+                stoppedManually = true;
+                clearInterval(iv);
+                resolvePromise();
+            }
+            else if (!daemon.getOrg(name)) {
                 clearInterval(iv);
                 resolvePromise();
             }
         }, 2000);
-        process.once('SIGINT', () => { clearInterval(iv); resolvePromise(); });
-        process.once('SIGTERM', () => { clearInterval(iv); resolvePromise(); });
+        process.once('SIGINT', () => {
+            clearInterval(iv);
+            resolvePromise();
+        });
+        process.once('SIGTERM', () => {
+            clearInterval(iv);
+            resolvePromise();
+        });
     });
     clearStopfile(ctx.cwd, name);
     await daemon.stopAll();
     srv?.close();
-    return { success: true, message: `org ${name} stopped` };
+    if (stoppedManually)
+        return { success: true, message: `org ${name} stopped` };
+    // #206: 'org run' used to exit 0 unconditionally here — a crashed or
+    // watchdog-stopped run was indistinguishable from a completed one to any
+    // script or supervisor (launchd/systemd) driving off the exit code. Re-read
+    // the daemon's final record (same runtime.json pattern isOrgRunning/
+    // statusAction already use below) and only report success for a run that
+    // actually finished its goal via org_complete.
+    let final = {};
+    try {
+        final = JSON.parse(readFileSync(join(ctx.cwd, ORG_DIR, name, 'runtime.json'), 'utf8'));
+    }
+    catch {
+        /* best-effort — falls through to the non-clean-stop case below */
+    }
+    return runOutcomeResult(name, final);
 };
+/** Decides `org run`'s exit-code-bearing CommandResult from the run's final
+ *  recorded state. Extracted (matching resolvedIdleNudgeCount's precedent for
+ *  the idle watchdog) so this decision is unit-testable without spinning up a
+ *  real daemon/org. Exit 0 ONLY for a clean, goal-driven end (closedBy:
+ *  'org-complete', set by daemon.ts's org-complete auto-stop path) — every
+ *  other outcome (idle-watchdog stop, boss-restart-exhausted, a process-level
+ *  crash) exits 1 so scripts/supervisors can tell success from failure. */
+export function runOutcomeResult(name, final) {
+    if (final.closedBy === 'org-complete') {
+        return { success: true, message: `org ${name} completed` };
+    }
+    if (final.status === 'crashed') {
+        return {
+            success: false,
+            message: `org ${name} crashed: ${final.error ?? 'unknown error'}`,
+            exitCode: 1,
+        };
+    }
+    return {
+        success: false,
+        message: `org ${name} stopped without completing (not via org_complete) — check 'monomind org status ${name}' or the run history for the reason`,
+        exitCode: 1,
+    };
+}
 /** True when runtime.json records a running org whose recorded pid is still alive. */
 const isOrgRunning = (cwd, name) => {
     try {
@@ -386,7 +529,9 @@ const stopAction = async (ctx) => {
     try {
         rt = JSON.parse(readFileSync(join(ctx.cwd, ORG_DIR, name, 'runtime.json'), 'utf8'));
     }
-    catch { /* never run */ }
+    catch {
+        /* never run */
+    }
     if (rt?.status !== 'running') {
         log(output.warning(`Org "${name}" is not running (runtime state: ${rt?.status ?? 'never run'}) — nothing to stop.`));
         return { success: false, message: 'org not running' };
@@ -466,12 +611,16 @@ const statusAction = async (ctx) => {
         }
     }
     const orgDir = join(ctx.cwd, ORG_DIR);
-    const targets = name ? [name] : (existsSync(orgDir)
-        ? listOrgConfigFiles(orgDir).map(f => f.replace(/\.json$/, ''))
-        : []);
+    const targets = name
+        ? [name]
+        : existsSync(orgDir)
+            ? listOrgConfigFiles(orgDir).map((f) => f.replace(/\.json$/, ''))
+            : [];
     for (const t of targets) {
         const rt = join(orgDir, t, 'runtime.json');
-        let state = { status: 'never run' };
+        let state = {
+            status: 'never run',
+        };
         if (existsSync(rt)) {
             try {
                 state = JSON.parse(readFileSync(rt, 'utf8'));
@@ -484,24 +633,29 @@ const statusAction = async (ctx) => {
         // 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.status === 'crashed') && state.pid) {
-            const pidGone = state.status === 'crashed' || (() => {
-                try {
-                    process.kill(state.pid, 0);
-                    return false;
-                }
-                catch {
-                    return true;
-                }
-            })();
+            const pidGone = state.status === 'crashed' ||
+                (() => {
+                    try {
+                        process.kill(state.pid, 0);
+                        return false;
+                    }
+                    catch {
+                        return true;
+                    }
+                })();
             if (pidGone) {
                 let heartbeatHint = '';
                 try {
                     const hb = JSON.parse(readFileSync(join(ctx.cwd, '.monomind', 'serve-heartbeat.json'), 'utf8'));
                     heartbeatHint = ` (last heartbeat: ${hb.updatedAt})`;
                 }
-                catch { /* no heartbeat file — daemon predates this change or was already cleaned up */ }
+                catch {
+                    /* no heartbeat file — daemon predates this change or was already cleaned up */
+                }
                 const closedBy = state.closedBy;
-                const label = closedBy === 'crash-handler' ? 'crashed (caught by crash handler)' : `crashed (runtime.json says ${state.status} but pid ${state.pid} is gone)`;
+                const label = closedBy === 'crash-handler'
+                    ? 'crashed (caught by crash handler)'
+                    : `crashed (runtime.json says ${state.status} but pid ${state.pid} is gone)`;
                 log(output.warning(`${t}: ${label}${heartbeatHint}${state.run ? ` — run ${state.run}` : ''} — close it out with "monomind org mark-complete ${t}"`));
                 continue;
             }
@@ -528,7 +682,7 @@ const statusAction = async (ctx) => {
                 const quietMs = Date.now() - lastTs;
                 const quietStr = fmtDuration(quietMs);
                 const toolCalls = Object.values(summary.roles).reduce((a, r) => a + r.toolsAllowed + r.toolsDenied, 0);
-                const rolesUp = Object.keys(summary.roles).filter(r => r !== '(system)').length;
+                const rolesUp = Object.keys(summary.roles).filter((r) => r !== '(system)').length;
                 log(`  elapsed: ${elapsedStr} | events: ${summary.events} | messages: ${summary.messages} | tools: ${toolCalls}`);
                 log(`  roles active: ${rolesUp} | tokens: ${fmtNum(summary.totalTokens)} | cost: $${summary.totalCostUsd.toFixed(2)}`);
                 log(`  quiet since: ${new Date(lastTs).toISOString().slice(11, 19)} (${quietStr} ago)`);
@@ -537,7 +691,7 @@ const statusAction = async (ctx) => {
             }
             // Previous cycle comparison from history
             const history = readHistory(ctx.cwd, t);
-            const prev = history.filter(h => h.run !== state.run).at(-1);
+            const prev = history.filter((h) => h.run !== state.run).at(-1);
             if (prev) {
                 const dur = prev.durationMs !== null ? fmtDuration(prev.durationMs) : '?';
                 const outcome = prev.outcome?.status ?? (prev.crashes.length ? 'crashed' : 'completed');
@@ -601,7 +755,9 @@ export const pollReloadfiles = async (cwd, daemon) => {
         try {
             unlinkSync(reloadFile);
         }
-        catch { /* already gone */ }
+        catch {
+            /* already gone */
+        }
         try {
             const result = daemon.reloadOrgDef(name);
             const parts = [];
@@ -653,11 +809,15 @@ export const pollRunfiles = async (cwd, daemon) => {
             if (typeof body.task === 'string' && body.task.trim())
                 task = body.task;
         }
-        catch { /* bare/empty runfile — start with the org's own goal */ }
+        catch {
+            /* bare/empty runfile — start with the org's own goal */
+        }
         try {
             unlinkSync(runfile);
         }
-        catch { /* already gone */ }
+        catch {
+            /* already gone */
+        }
         if (daemon.listRunning().includes(name))
             continue; // already running — request satisfied
         log(output.info(`org ${name}: run requested — starting now${task ? ' (with task)' : ''}`));
@@ -688,7 +848,9 @@ export const pollRunfiles = async (cwd, daemon) => {
  */
 const supervisorAction = async (ctx) => {
     const cwd = resolve(ctx.cwd || process.cwd());
-    const requested = String(ctx.flags.format ?? '').trim().toLowerCase();
+    const requested = String(ctx.flags.format ?? '')
+        .trim()
+        .toLowerCase();
     const format = requested || (process.platform === 'darwin' ? 'launchd' : 'systemd');
     if (format !== 'launchd' && format !== 'systemd') {
         log(output.error(`Unknown --format "${requested}" — expected launchd or systemd.`));
@@ -776,7 +938,7 @@ WantedBy=default.target
     return { success: true, message: `${format} unit emitted` };
 };
 const serveAction = async (ctx) => {
-    const crossProcess = ctx.flags['crossProcess'] !== false;
+    const crossProcess = ctx.flags.crossProcess !== false;
     const daemon = new OrgDaemon(ctx.cwd, { crossProcess });
     let srv;
     if (crossProcess) {
@@ -789,13 +951,21 @@ const serveAction = async (ctx) => {
         try {
             console.error(`[org serve] ${label}:`, err);
         }
-        catch { /* stderr gone */ }
-        daemon.persistCrashStateAll();
+        catch {
+            /* stderr gone */
+        }
+        daemon.persistCrashStateAll(`${label}: ${err instanceof Error ? err.message : String(err)}`);
         daemon.clearHeartbeat();
         process.exitCode = 1;
     };
-    process.on('uncaughtException', (err) => { crashExit('uncaughtException', err); process.exit(1); });
-    process.on('unhandledRejection', (err) => { crashExit('unhandledRejection', err); process.exit(1); });
+    process.on('uncaughtException', (err) => {
+        crashExit('uncaughtException', err);
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (err) => {
+        crashExit('unhandledRejection', err);
+        process.exit(1);
+    });
     // Termination diagnostics (#45). The two handlers above only cover errors
     // raised *inside* the daemon. A report of the daemon vanishing after hours
     // had a log holding nothing but its startup lines, because the ways a daemon
@@ -819,7 +989,9 @@ const serveAction = async (ctx) => {
         try {
             console.error(`[org serve] shutting down: ${reason}`);
         }
-        catch { /* stderr gone */ }
+        catch {
+            /* stderr gone */
+        }
     };
     for (const sig of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
         process.on(sig, () => {
@@ -828,7 +1000,9 @@ const serveAction = async (ctx) => {
                 daemon.persistCrashStateAll();
                 daemon.clearHeartbeat();
             }
-            catch { /* best effort */ }
+            catch {
+                /* best effort */
+            }
             // A daemon holds ref'd timers, so it will not drain on its own; an
             // explicit exit is required here and is the intended signal semantics.
             process.exit(sig === 'SIGTERM' || sig === 'SIGINT' ? 0 : 1);
@@ -842,7 +1016,9 @@ const serveAction = async (ctx) => {
     // Heartbeat: write every 30s so `org status` can tell "alive but busy" from
     // "daemon gone" without relying on pid liveness alone.
     daemon.writeHeartbeat();
-    const heartbeatInterval = setInterval(() => { daemon.writeHeartbeat(); }, 30_000);
+    const heartbeatInterval = setInterval(() => {
+        daemon.writeHeartbeat();
+    }, 30_000);
     heartbeatInterval.unref?.();
     log(output.info('org daemon serving — Ctrl-C to stop'));
     // schedule orgs whose definition declares an interval (e.g. "15m", "2h")
@@ -860,7 +1036,7 @@ const serveAction = async (ctx) => {
                     const { runPrechecks } = await import('../orgrt/prechecks.js');
                     const { ok, results } = await runPrechecks(checks, ctx.cwd);
                     if (!ok) {
-                        const failed = results.find(r => !r.passed);
+                        const failed = results.find((r) => !r.passed);
                         log(output.warning(`org ${name}: precheck "${failed?.name}" failed — skipping scheduled run`));
                         if (failed?.output)
                             log(output.warning(`  ${failed.output.slice(0, 200)}`));
@@ -887,9 +1063,10 @@ const serveAction = async (ctx) => {
             // (idempotent — it resolves `done` and flushes).
             const org = daemon.getOrg(name);
             const allDone = org
-                ? Promise.allSettled([...org.agents.values()].map(a => a.done))
+                ? Promise.allSettled([...org.agents.values()].map((a) => a.done))
                 : Promise.resolve([]);
-            const maxRun = org?.def?.run_config?.max_run;
+            const maxRun = org?.def
+                ?.run_config?.max_run;
             // Default to the full interval. The old `min(interval, 10min)` clamp
             // silently guillotined every org that didn't set max_run: real cycles
             // here run 75-93 minutes, so a 2h-scheduled org was being force-stopped
@@ -901,10 +1078,13 @@ const serveAction = async (ctx) => {
             // Set run_config.max_run to bound it tighter — or looser.
             const maxMs = parseSchedule(maxRun) ?? intervalMs;
             let timer;
-            await Promise.race([allDone, new Promise(r => {
+            await Promise.race([
+                allDone,
+                new Promise((r) => {
                     timer = setTimeout(r, maxMs);
                     timer.unref?.();
-                })]);
+                }),
+            ]);
             if (timer)
                 clearTimeout(timer);
         }
@@ -916,7 +1096,9 @@ const serveAction = async (ctx) => {
             // bound threw that work away; a minute is enough to finish an edit or a
             // test run and flush, and still well inside any sane interval.
             if (startedHere) {
-                await daemon.stopOrg(name, { drainMs: 60_000 }).catch(err => console.error(`org ${name}: stop failed:`, err));
+                await daemon
+                    .stopOrg(name, { drainMs: 60_000 })
+                    .catch((err) => console.error(`org ${name}: stop failed:`, err));
             }
         }
     });
@@ -948,13 +1130,22 @@ const serveAction = async (ctx) => {
             }
         }
     }
-    const stopPoll = setInterval(() => { void pollStopfiles(ctx.cwd, daemon); }, 2000);
+    const stopPoll = setInterval(() => {
+        void pollStopfiles(ctx.cwd, daemon);
+    }, 2000);
     stopPoll.unref?.();
-    const runPoll = setInterval(() => { void pollRunfiles(ctx.cwd, daemon); }, 2000);
+    const runPoll = setInterval(() => {
+        void pollRunfiles(ctx.cwd, daemon);
+    }, 2000);
     runPoll.unref?.();
-    const reloadPoll = setInterval(() => { void pollReloadfiles(ctx.cwd, daemon); }, 2000);
+    const reloadPoll = setInterval(() => {
+        void pollReloadfiles(ctx.cwd, daemon);
+    }, 2000);
     reloadPoll.unref?.();
-    await new Promise(r => { process.once('SIGINT', () => r()); process.once('SIGTERM', () => r()); });
+    await new Promise((r) => {
+        process.once('SIGINT', () => r());
+        process.once('SIGTERM', () => r());
+    });
     clearInterval(stopPoll);
     clearInterval(runPoll);
     clearInterval(reloadPoll);
@@ -968,9 +1159,10 @@ const serveAction = async (ctx) => {
 const testLoopAction = async (ctx) => {
     // non-literal specifier: test-loop.ts lands in a later task; keeps tsc clean until then
     const testLoopModule = '../orgrt/test-loop.js';
-    const { runTestLoop } = await import(testLoopModule);
-    const n = Number(ctx.flags['times'] ?? ctx.flags['n'] ?? 5);
-    const report = await runTestLoop(ctx.cwd, n);
+    const { runTestLoop } = (await import(testLoopModule));
+    const n = Number(ctx.flags.times ?? ctx.flags.n ?? 5);
+    const scenario = typeof ctx.flags.scenario === 'string' ? ctx.flags.scenario : undefined;
+    const report = await runTestLoop(ctx.cwd, n, scenario);
     log(output.info(report.summary));
     return { success: report.failed === 0, message: report.summary };
 };
@@ -1009,9 +1201,12 @@ const listAction = async (ctx) => {
                     }
                 }
             }
-            catch { /* no runtime state yet */ }
+            catch {
+                /* no runtime state yet */
+            }
             const goal = typeof def.goal === 'string' && def.goal
-                ? ` — ${def.goal.length > 60 ? `${def.goal.slice(0, 57)}...` : def.goal}` : '';
+                ? ` — ${def.goal.length > 60 ? `${def.goal.slice(0, 57)}...` : def.goal}`
+                : '';
             detail = `  (${roles} role${roles === 1 ? '' : 's'}, ${sched}, ${status})${goal}`;
         }
         catch {
@@ -1031,7 +1226,7 @@ const deleteAction = async (ctx) => {
         log(output.error(`Invalid org name: ${orgName}`));
         return { success: false, message: 'invalid org name' };
     }
-    const confirmed = ctx.flags['yes'] === true || ctx.args.includes('--yes') || ctx.args.includes('-y');
+    const confirmed = ctx.flags.yes === true || ctx.args.includes('--yes') || ctx.args.includes('-y');
     if (!confirmed) {
         log(output.warning(`This will permanently delete org "${orgName}" and all its data.`));
         log(output.warning('Pass --yes to confirm.'));
@@ -1044,7 +1239,7 @@ 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) {
+    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' };
     }
@@ -1058,27 +1253,37 @@ const deleteAction = async (ctx) => {
                     removed++;
                 }
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
         }
     }
     try {
         unlinkSync(join(orgsDir, '.stops', `${orgName}.stop`));
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
     const orgSubDir = join(orgsDir, orgName);
     try {
         if (existsSync(orgSubDir))
             rmSync(orgSubDir, { recursive: true, force: true });
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
     try {
         unlinkSync(join(cwd, '.monomind', 'loops', `${orgName}.md`));
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
     try {
         unlinkSync(join(orgsDir, `${orgName}-run.md`));
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
     log(output.success(`Org "${orgName}" deleted (${removed} file(s) removed).`));
     return { success: true };
 };
@@ -1096,7 +1301,11 @@ const clearStaleRuntime = (cwd, name) => {
         rt = JSON.parse(readFileSync(rtPath, 'utf8'));
     }
     catch (err) {
-        return { cleared: false, reason: 'unreadable', detail: err instanceof Error ? err.message : String(err) };
+        return {
+            cleared: false,
+            reason: 'unreadable',
+            detail: err instanceof Error ? err.message : String(err),
+        };
     }
     if (rt.status !== 'running' && rt.status !== 'crashed')
         return { cleared: false, reason: 'not-running' };
@@ -1105,11 +1314,19 @@ const clearStaleRuntime = (cwd, name) => {
             process.kill(rt.pid, 0);
             return { cleared: false, reason: 'alive', detail: String(rt.pid) };
         }
-        catch { /* pid is gone — this is exactly the stale case mark-complete exists for */ }
+        catch {
+            /* pid is gone — this is exactly the stale case mark-complete exists for */
+        }
     }
     // Same shape stopOrg's persistState() writes, so every reader (org status,
     // isOrgRunning, the mastermind-org* skills' jq checks) sees a stopped org.
-    writeFileSync(rtPath, JSON.stringify({ status: 'stopped', run: rt.run, pid: rt.pid, updated: new Date().toISOString(), closedBy: 'mark-complete' }, null, 2));
+    writeFileSync(rtPath, JSON.stringify({
+        status: 'stopped',
+        run: rt.run,
+        pid: rt.pid,
+        updated: new Date().toISOString(),
+        closedBy: 'mark-complete',
+    }, null, 2));
     return { cleared: true, run: rt.run };
 };
 const markCompleteAction = async (ctx) => {
@@ -1124,7 +1341,9 @@ const markCompleteAction = async (ctx) => {
     // 0 — a typo looked like a successful cleanup.
     const orgsDir = join(cwd, ORG_DIR);
     if (!existsSync(join(orgsDir, `${orgName}.json`))) {
-        const known = existsSync(orgsDir) ? listOrgConfigFiles(orgsDir).map(f => f.replace(/\.json$/, '')) : [];
+        const known = existsSync(orgsDir)
+            ? listOrgConfigFiles(orgsDir).map((f) => f.replace(/\.json$/, ''))
+            : [];
         log(output.error(`Org not found: ${orgName}${known.length ? ` — available: ${known.join(', ')}` : ''}`));
         return { success: false, message: 'org not found' };
     }
@@ -1149,14 +1368,18 @@ const markCompleteAction = async (ctx) => {
         if (ctl.url)
             ctrlUrl = ctl.url;
     }
-    catch { /* default */ }
+    catch {
+        /* default */
+    }
     try {
         // All dashboard /api routes are auth-gated — attach the local session token.
         let auth = '';
         try {
             auth = readFileSync(join(cwd, '.monomind', 'dashboard-token'), 'utf8').trim();
         }
-        catch { /* server may be pre-auth */ }
+        catch {
+            /* server may be pre-auth */
+        }
         // Bounded. Updating the dashboard is best-effort — the local state has
         // already been cleared by this point — but the fetch had no timeout, so a
         // dashboard that holds the port without answering (a wedged build from an
@@ -1222,27 +1445,69 @@ export const orgCommand = {
     description: 'SDK-based org runtime — run agent organizations as a controlled daemon',
     subcommands: [
         {
-            name: 'run', description: 'Start an org (foreground daemon)',
+            name: 'run',
+            description: 'Start an org (foreground daemon)',
             options: [
                 { name: 'task', description: 'Override the org goal for this run', type: 'string' },
-                { name: 'resume', description: 'Resume an org run from its persisted checkpoint instead of starting fresh', type: 'boolean' },
-                { 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' },
-                { name: 'budget-usd', description: 'Hard-stop the run if the upfront cost estimate exceeds this USD value (e.g. --budget-usd 5)', type: 'number' },
-                { name: 'yes', short: 'y', description: 'Skip the interactive cost-estimate confirmation prompt', type: 'boolean' },
+                {
+                    name: 'resume',
+                    description: 'Resume an org run from its persisted checkpoint instead of starting fresh',
+                    type: 'boolean',
+                },
+                {
+                    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',
+                },
+                {
+                    name: 'budget-usd',
+                    description: 'Hard-stop the run if the upfront cost estimate exceeds this USD value (e.g. --budget-usd 5)',
+                    type: 'number',
+                },
+                {
+                    name: 'yes',
+                    short: 'y',
+                    description: 'Skip the interactive cost-estimate confirmation prompt',
+                    type: 'boolean',
+                },
+            ],
+            examples: [
+                {
+                    command: 'monomind org run growth --task "weekly report"',
+                    description: 'Run the growth org once with a task',
+                },
             ],
-            examples: [{ command: 'monomind org run growth --task "weekly report"', description: 'Run the growth org once with a task' }],
             action: runAction,
         },
         { name: 'stop', description: 'Request a running org daemon to stop', action: stopAction },
-        { name: 'pause', description: 'Pause an org — current turns finish, no new cycles start', action: pauseAction },
+        {
+            name: 'pause',
+            description: 'Pause an org — current turns finish, no new cycles start',
+            action: pauseAction,
+        },
         { name: 'resume', description: 'Resume a paused org', action: resumeAction },
-        { name: 'reload', description: 'Hot-reload an org definition without stopping sessions', action: reloadAction },
+        {
+            name: 'reload',
+            description: 'Hot-reload an org definition without stopping sessions',
+            action: reloadAction,
+        },
         { name: 'status', description: 'Show runtime state of orgs', action: statusAction },
         {
-            name: 'serve', description: 'Start the daemon server only (hosts scheduled orgs)',
+            name: 'serve',
+            description: 'Start the daemon server only (hosts scheduled orgs)',
             options: [
-                { name: 'cross-process', description: 'Discover and message orgs hosted by other monomind processes on this machine (default true)', type: 'boolean', default: true },
+                {
+                    name: 'cross-process',
+                    description: 'Discover and message orgs hosted by other monomind processes on this machine (default true)',
+                    type: 'boolean',
+                    default: true,
+                },
             ],
             action: serveAction,
         },
@@ -1251,29 +1516,57 @@ export const orgCommand = {
             description: 'Print (or --install) a launchd/systemd unit that keeps `org serve` running',
             options: [
                 { name: 'format', description: 'launchd or systemd (default: platform)', type: 'string' },
-                { name: 'install', description: 'Write the unit into the per-user location', type: 'boolean' },
+                {
+                    name: 'install',
+                    description: 'Write the unit into the per-user location',
+                    type: 'boolean',
+                },
             ],
             action: supervisorAction,
         },
         {
-            name: 'test-loop', description: 'Run the org e2e verification loop N times',
-            options: [{ name: 'times', short: 'n', description: 'Iterations', type: 'number', default: 5 }],
+            name: 'test-loop',
+            description: 'Run the org e2e verification loop N times',
+            options: [
+                { name: 'times', short: 'n', description: 'Iterations', type: 'number', default: 5 },
+                {
+                    name: 'scenario',
+                    description: 'Run a declarative scenario file (.monomind/scenarios/<file>) instead of the built-in fixture — structural dry-run only',
+                    type: 'string',
+                },
+            ],
             action: testLoopAction,
         },
         {
-            name: 'logs', description: 'Show (or follow) the formatted event log of an org run',
+            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: 'filter-tool', description: 'Filter events by tool name (e.g., Write, Edit)', type: 'string' },
+                {
+                    name: 'filter-tool',
+                    description: 'Filter events by tool name (e.g., Write, Edit)',
+                    type: 'string',
+                },
                 { name: 'filter-role', description: 'Filter events by role ID', type: 'string' },
-                { name: 'tools-only', description: 'Show only tool events (exclude messages/status/audit)', type: 'boolean' },
-                { name: 'audit-filter', description: 'Filter audit events by decision (allow|deny)', type: 'string' },
+                {
+                    name: 'tools-only',
+                    description: 'Show only tool events (exclude messages/status/audit)',
+                    type: 'boolean',
+                },
+                {
+                    name: 'audit-filter',
+                    description: 'Filter audit events by decision (allow|deny)',
+                    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' },
-                { command: 'monomind org logs growth --tools-only', description: 'Show only tool call events' },
+                {
+                    command: 'monomind org logs growth --tools-only',
+                    description: 'Show only tool call events',
+                },
             ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
@@ -1284,16 +1577,36 @@ export const orgCommand = {
             },
         },
         {
-            name: 'watch', description: 'Live-tail one role\'s assistant chat text (any runtime) — a filtered, friendlier `logs --follow`',
+            name: 'watch',
+            description: "Live-tail one role's assistant chat text (any runtime) — a filtered, friendlier `logs --follow`",
             options: [
                 { name: 'run', description: 'Run id (default: latest)', type: 'string' },
-                { name: 'follow', description: 'Set --follow=false to print current output once and exit instead of live-tailing', type: 'boolean', default: true },
-                { name: 'verbose', description: 'Also interleave status events (restart/crash/state-change) into the transcript', type: 'boolean' },
-                { name: 'stats', description: 'Print a running token/cost line as usage events arrive', type: 'boolean' },
+                {
+                    name: 'follow',
+                    description: 'Set --follow=false to print current output once and exit instead of live-tailing',
+                    type: 'boolean',
+                    default: true,
+                },
+                {
+                    name: 'verbose',
+                    description: 'Also interleave status events (restart/crash/state-change) into the transcript',
+                    type: 'boolean',
+                },
+                {
+                    name: 'stats',
+                    description: 'Print a running token/cost line as usage events arrive',
+                    type: 'boolean',
+                },
             ],
             examples: [
-                { command: 'monomind org watch growth researcher', description: 'Watch the researcher role\'s live output' },
-                { command: 'monomind org watch growth researcher --verbose --stats', description: 'Also show restarts/crashes and a running token/cost total' },
+                {
+                    command: 'monomind org watch growth researcher',
+                    description: "Watch the researcher role's live output",
+                },
+                {
+                    command: 'monomind org watch growth researcher --verbose --stats',
+                    description: 'Also show restarts/crashes and a running token/cost total',
+                },
             ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
@@ -1304,16 +1617,23 @@ export const orgCommand = {
             },
         },
         {
-            name: 'report', description: 'Summarize an org run: outcome, per-role activity, tokens, assets, crashes',
+            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' },
                 { name: 'by-role', description: 'Show per-role cost breakdown', type: 'boolean' },
                 { name: 'audit', description: 'Show tool audit trail', type: 'boolean' },
-                { name: 'tool', description: 'Filter tool audit by tool name (with --audit)', type: 'string' },
+                {
+                    name: 'tool',
+                    description: 'Filter tool audit by tool name (with --audit)',
+                    type: 'string',
+                },
                 { name: 'format', description: 'Output format (mermaid for flowchart)', type: 'string' },
             ],
-            examples: [{ command: 'monomind org report growth', description: 'Report on the latest run' }],
+            examples: [
+                { command: 'monomind org report growth', description: 'Report on the latest run' },
+            ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
                 if (!v.ok)
@@ -1323,11 +1643,18 @@ export const orgCommand = {
             },
         },
         {
-            name: 'memory', description: 'Inspect an org\'s cross-run memory and knowledge graph (stats | search <query> | rules | rollback <run-ref>)',
+            name: 'memory',
+            description: "Inspect an org's cross-run memory and knowledge graph (stats | search <query> | rules | rollback <run-ref>)",
             examples: [
                 { command: 'monomind org memory growth stats', description: 'KG size and namespaces' },
-                { command: 'monomind org memory growth search "launch checklist"', description: 'Search org memory + KG' },
-                { command: 'monomind org memory growth rollback run:m4x2', description: 'Delete everything one run wrote to the KG' },
+                {
+                    command: 'monomind org memory growth search "launch checklist"',
+                    description: 'Search org memory + KG',
+                },
+                {
+                    command: 'monomind org memory growth rollback run:m4x2',
+                    description: 'Delete everything one run wrote to the KG',
+                },
             ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
@@ -1341,7 +1668,9 @@ export const orgCommand = {
                 try {
                     if (sub === 'stats') {
                         const [stats, glossary, backend] = await Promise.all([
-                            kg.kgStats({ dbPath }), kg.kgGlossary({ dbPath, limit: 15 }), bridge.bridgeGetBackendStats(dbPath),
+                            kg.kgStats({ dbPath }),
+                            kg.kgGlossary({ dbPath, limit: 15 }),
+                            bridge.bridgeGetBackendStats(dbPath),
                         ]);
                         log(output.info(`Knowledge graph: ${stats.nodes} entities, ${stats.edges} relations, ${stats.rules} rules`));
                         if (glossary.length)
@@ -1349,21 +1678,33 @@ export const orgCommand = {
                         const byNs = backend?.entriesByNamespace ?? {};
                         for (const [ns, count] of Object.entries(byNs))
                             log(output.info(`  ${ns}: ${count} entries`));
-                        return { success: true, message: 'org memory stats', data: { ...stats, namespaces: byNs } };
+                        return {
+                            success: true,
+                            message: 'org memory stats',
+                            data: { ...stats, namespaces: byNs },
+                        };
                     }
                     if (sub === 'search') {
                         const q = ctx.args.slice(2).join(' ');
                         if (!q)
                             return { success: false, message: 'usage: org memory <org> search <query>' };
                         const [mem, graph] = await Promise.all([
-                            bridge.bridgeSearchEntries({ query: q, namespace: `org:${v.name}`, limit: 5, dbPath }),
+                            bridge.bridgeSearchEntries({
+                                query: q,
+                                namespace: `org:${v.name}`,
+                                limit: 5,
+                                dbPath,
+                            }),
                             kg.kgSearch({ query: q, dbPath, limit: 8 }),
                         ]);
                         for (const r of mem?.results ?? [])
                             log(output.info(`[${r.score.toFixed(2)}] ${r.key}: ${r.content.slice(0, 160)}`));
                         if (graph.context)
                             log(output.info(`\nKnowledge graph:\n${graph.context}`));
-                        return { success: true, message: `${(mem?.results ?? []).length} memories, ${graph.triplets.length} triplets` };
+                        return {
+                            success: true,
+                            message: `${(mem?.results ?? []).length} memories, ${graph.triplets.length} triplets`,
+                        };
                     }
                     if (sub === 'rules') {
                         const rules = await kg.kgListRules({ dbPath, limit: 50 });
@@ -1374,26 +1715,36 @@ export const orgCommand = {
                     if (sub === 'rollback') {
                         const ref = ctx.args[2];
                         if (!ref)
-                            return { success: false, message: 'usage: org memory <org> rollback <origin-ref> (e.g. run:m4x2)' };
+                            return {
+                                success: false,
+                                message: 'usage: org memory <org> rollback <origin-ref> (e.g. run:m4x2)',
+                            };
                         const res = await kg.kgRollback({ originRef: ref, dbPath });
                         log(output.info(`Rolled back ${ref}: ${res.deleted} deleted, ${res.retained} retained (shared with other origins)`));
                         return { success: res.success, message: `rollback ${ref}`, data: res };
                     }
-                    return { success: false, message: `unknown subcommand "${sub}" — use stats | search | rules | rollback` };
+                    return {
+                        success: false,
+                        message: `unknown subcommand "${sub}" — use stats | search | rules | rollback`,
+                    };
                 }
                 finally {
-                    await bridge.shutdownBridge().catch(() => { });
+                    await bridge.shutdownBridge().catch(() => {
+                        /* best effort */
+                    });
                 }
             },
         },
         {
-            name: 'costs', description: 'Show per-role cost tracking from runtime.json',
-            options: [
-                { name: 'run', description: 'Run ID (defaults to latest)', type: 'string' },
-            ],
+            name: 'costs',
+            description: 'Show per-role cost tracking from runtime.json',
+            options: [{ name: 'run', description: 'Run ID (defaults to latest)', type: 'string' }],
             examples: [
                 { command: 'monomind org costs growth', description: 'Show cost breakdown for latest run' },
-                { command: 'monomind org costs growth --run run-20240130-123456', description: 'Show cost breakdown for specific run' },
+                {
+                    command: 'monomind org costs growth --run run-20240130-123456',
+                    description: 'Show cost breakdown for specific run',
+                },
             ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
@@ -1404,15 +1755,29 @@ export const orgCommand = {
             },
         },
         {
-            name: 'inbox', description: 'Deliver an inbound cross-org message (live to a running org, queued to inbox.jsonl otherwise) — remote.ts shells out to this over SSH',
+            name: 'inbox',
+            description: 'Deliver an inbound cross-org message (live to a running org, queued to inbox.jsonl otherwise) — remote.ts shells out to this over SSH',
             options: [
-                { name: 'json', description: 'JSON payload: {"from":"orgA:role","subject":"...","body":"..."}', type: 'string' },
-                { name: 'to', description: 'Target role (default: the org\'s coordinator)', type: 'string' },
-                { name: 'from', description: 'Sender, qualified "org:role" (alternative to --json)', type: 'string' },
+                {
+                    name: 'json',
+                    description: 'JSON payload: {"from":"orgA:role","subject":"...","body":"..."}',
+                    type: 'string',
+                },
+                { name: 'to', description: "Target role (default: the org's coordinator)", type: 'string' },
+                {
+                    name: 'from',
+                    description: 'Sender, qualified "org:role" (alternative to --json)',
+                    type: 'string',
+                },
                 { name: 'subject', description: 'Subject (alternative to --json)', type: 'string' },
                 { name: 'body', description: 'Body (alternative to --json)', type: 'string' },
             ],
-            examples: [{ command: 'monomind org inbox growth --json \'{"from":"sales:boss","subject":"leads","body":"..."}\'', description: 'Deliver a message to the growth org' }],
+            examples: [
+                {
+                    command: 'monomind org inbox growth --json \'{"from":"sales:boss","subject":"leads","body":"..."}\'',
+                    description: 'Deliver a message to the growth org',
+                },
+            ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
                 if (!v.ok)
@@ -1422,9 +1787,15 @@ export const orgCommand = {
             },
         },
         {
-            name: 'flow', description: 'Export org flow as Mermaid diagram',
+            name: 'flow',
+            description: 'Export org flow as Mermaid diagram',
             options: [{ name: 'run', description: 'Run ID (defaults to latest)', type: 'string' }],
-            examples: [{ command: 'monomind org flow growth --run run-20250130120000', description: 'Export Mermaid flowchart' }],
+            examples: [
+                {
+                    command: 'monomind org flow growth --run run-20250130120000',
+                    description: 'Export Mermaid flowchart',
+                },
+            ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
                 if (!v.ok)
@@ -1434,9 +1805,12 @@ export const orgCommand = {
             },
         },
         {
-            name: 'questions', description: 'List pending ask_human questions from an org\'s agents',
+            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' }],
+            examples: [
+                { command: 'monomind org questions growth', description: 'Show unanswered questions' },
+            ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
                 if (!v.ok)
@@ -1446,8 +1820,14 @@ export const orgCommand = {
             },
         },
         {
-            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' }],
+            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)
@@ -1457,8 +1837,14 @@ export const orgCommand = {
             },
         },
         {
-            name: 'approve', description: 'Approve a pending tool/action approval',
-            examples: [{ command: 'monomind org approve growth coder "Bash"', description: 'Approve Bash tool for coder role' }],
+            name: 'approve',
+            description: 'Approve a pending tool/action approval',
+            examples: [
+                {
+                    command: 'monomind org approve growth coder "Bash"',
+                    description: 'Approve Bash tool for coder role',
+                },
+            ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
                 if (!v.ok)
@@ -1468,8 +1854,14 @@ export const orgCommand = {
             },
         },
         {
-            name: 'deny', description: 'Deny a pending tool/action approval',
-            examples: [{ command: 'monomind org deny growth coder "Bash"', description: 'Deny Bash tool for coder role' }],
+            name: 'deny',
+            description: 'Deny a pending tool/action approval',
+            examples: [
+                {
+                    command: 'monomind org deny growth coder "Bash"',
+                    description: 'Deny Bash tool for coder role',
+                },
+            ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
                 if (!v.ok)
@@ -1479,7 +1871,8 @@ export const orgCommand = {
             },
         },
         {
-            name: 'gates', description: 'List decision gates from an org\'s agents',
+            name: 'gates',
+            description: "List decision gates from an org's agents",
             options: [{ name: 'all', description: 'Include resolved gates', type: 'boolean' }],
             examples: [
                 { command: 'monomind org gates growth', description: 'Show pending gates' },
@@ -1494,8 +1887,14 @@ export const orgCommand = {
             },
         },
         {
-            name: 'gate-approve', description: 'Approve a pending decision gate',
-            examples: [{ command: 'monomind org gate-approve growth gate-123-ab "ship it"', description: 'Approve gate with resolution' }],
+            name: 'gate-approve',
+            description: 'Approve a pending decision gate',
+            examples: [
+                {
+                    command: 'monomind org gate-approve growth gate-123-ab "ship it"',
+                    description: 'Approve gate with resolution',
+                },
+            ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
                 if (!v.ok)
@@ -1505,8 +1904,14 @@ export const orgCommand = {
             },
         },
         {
-            name: 'gate-reject', description: 'Reject a pending decision gate',
-            examples: [{ command: 'monomind org gate-reject growth gate-123-ab "not ready"', description: 'Reject gate with reason' }],
+            name: 'gate-reject',
+            description: 'Reject a pending decision gate',
+            examples: [
+                {
+                    command: 'monomind org gate-reject growth gate-123-ab "not ready"',
+                    description: 'Reject gate with reason',
+                },
+            ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
                 if (!v.ok)
@@ -1516,8 +1921,14 @@ export const orgCommand = {
             },
         },
         {
-            name: 'replay', description: 'Time-travel debugging: replay from a checkpoint',
-            examples: [{ command: 'monomind org replay growth run-20250130120000-abc', description: 'Replay from checkpoint' }],
+            name: 'replay',
+            description: 'Time-travel debugging: replay a run\'s bus events (does not resume live execution — use "org run --resume" for that)',
+            examples: [
+                {
+                    command: 'monomind org replay growth run-20250130120000-abc',
+                    description: "Replay a checkpoint's events for inspection",
+                },
+            ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
                 if (!v.ok)
@@ -1527,8 +1938,14 @@ export const orgCommand = {
             },
         },
         {
-            name: 'resume-from', description: 'Resume from checkpoint (alias for replay)',
-            examples: [{ command: 'monomind org resume-from growth run-20250130120000-abc', description: 'Resume from checkpoint' }],
+            name: 'resume-from',
+            description: "Resume live execution from the org's persisted checkpoint (restores mailbox/policy/session state; subject to TTL and checksum validation)",
+            examples: [
+                {
+                    command: 'monomind org resume-from growth',
+                    description: 'Resume growth from its last checkpoint',
+                },
+            ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
                 if (!v.ok)
@@ -1538,8 +1955,14 @@ export const orgCommand = {
             },
         },
         {
-            name: 'branch', description: 'Create a branch from checkpoint for what-if experiments',
-            examples: [{ command: 'monomind org branch growth run-20250130 abc-branch', description: 'Create branch from checkpoint' }],
+            name: 'branch',
+            description: "Snapshot a run's event log for replay",
+            examples: [
+                {
+                    command: 'monomind org branch growth run-20250130 abc-branch',
+                    description: "Snapshot a run's checkpoint into a new run for replay",
+                },
+            ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
                 if (!v.ok)
@@ -1549,8 +1972,14 @@ export const orgCommand = {
             },
         },
         {
-            name: 'decisions', description: 'Show Rifft-style decision traces',
-            examples: [{ command: 'monomind org decisions growth --run run-20250130', description: 'Show decision traces' }],
+            name: 'decisions',
+            description: 'Show Rifft-style decision traces',
+            examples: [
+                {
+                    command: 'monomind org decisions growth --run run-20250130',
+                    description: 'Show decision traces',
+                },
+            ],
             action: async (ctx) => {
                 const v = validateOrgName(ctx.args[0]);
                 if (!v.ok)
@@ -1560,14 +1989,34 @@ export const orgCommand = {
             },
         },
         {
-            name: 'create', description: 'Scaffold an org config from a starter template',
+            name: 'create',
+            description: 'Scaffold an org config from a starter template',
             options: [
-                { name: 'template', description: 'content-team | dev-team | research-pod | kg-extraction | advisor-orchestrator', type: 'string' },
-                { name: 'goal', description: 'Org goal (defaults to the template\'s placeholder)', type: 'string' },
+                {
+                    name: 'template',
+                    description: 'content-team | dev-team | research-pod | kg-extraction | advisor-orchestrator',
+                    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' },
+                {
+                    name: 'yes',
+                    short: 'y',
+                    description: 'Skip the per-role model confirmation prompt (TTY only)',
+                    type: 'boolean',
+                },
+            ],
+            examples: [
+                {
+                    command: 'monomind org create blog --template content-team --goal "3 posts/week"',
+                    description: 'Create a content org',
+                },
             ],
-            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)
@@ -1577,10 +2026,14 @@ export const orgCommand = {
             },
         },
         {
-            name: 'validate', description: 'Validate org config(s) against the runtime schema and structural invariants',
+            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' },
+                {
+                    command: 'monomind org validate',
+                    description: 'Validate every org config in the project',
+                },
             ],
             action: async (ctx) => {
                 const { validateAction } = await import('./org-observe.js');
@@ -1588,22 +2041,39 @@ export const orgCommand = {
             },
         },
         {
-            name: 'migrate', description: 'Convert a v1 org config (topology/board/loop) to the v2 daemon shape',
-            examples: [{ command: 'monomind org migrate growth', description: 'Migrate one org; original saved as growth.v1.json' }],
+            name: 'migrate',
+            description: 'Convert a v1 org config (topology/board/loop) to the v2 daemon shape',
+            examples: [
+                {
+                    command: 'monomind org migrate growth',
+                    description: 'Migrate one org; original saved as growth.v1.json',
+                },
+            ],
             action: migrateAction,
         },
         { name: 'list', description: 'List all orgs in the current project', action: listAction },
         {
-            name: 'delete', description: 'Delete an org and all its data',
+            name: 'delete',
+            description: 'Delete an org and all its data',
             options: [
                 { name: 'yes', short: 'y', description: 'Skip confirmation', type: 'boolean' },
-                { name: 'force', description: 'Delete even if the org appears to be running', 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 },
+        {
+            name: 'mark-complete',
+            description: 'Manually close a stale/crashed run',
+            action: markCompleteAction,
+        },
+    ],
+    examples: [
+        { command: 'monomind org run my-org', description: 'Run an org under full daemon control' },
     ],
-    examples: [{ command: 'monomind org run my-org', description: 'Run an org under full daemon control' }],
     action: async () => {
         // 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