monomind 2.1.9 → 2.3.0

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

@@ -59,21 +59,21 @@ export const routeCommand = {
             output.writeln();
             output.printBox([
                 `Task: ${result.task}`,
-                `Top Agent: ${output.highlight(result.topAgent)}`,
-                `Confidence: ${(result.confidence * 100).toFixed(1)}%`,
+                `Top Agent: ${output.highlight(result.primaryAgent.type)}`,
+                `Confidence: ${(result.primaryAgent.confidence * 100).toFixed(1)}%`,
                 `Method: ${result.routing?.method ?? 'keyword'}`
             ].join('\n'), 'Routing Decision');
-            if (result.recommendations.length > 0) {
+            const recommendations = [result.primaryAgent, ...(result.alternativeAgents || [])];
+            if (recommendations.length > 0) {
                 output.writeln();
                 output.writeln(output.bold('Agent Recommendations'));
                 output.printTable({
                     columns: [
-                        { key: 'agent', header: 'Agent', width: 20 },
+                        { key: 'type', header: 'Agent', width: 20 },
                         { key: 'confidence', header: 'Confidence', width: 12, align: 'right', format: (v) => `${(Number(v) * 100).toFixed(1)}%` },
-                        { key: 'reason', header: 'Reason', width: 35 },
-                        { key: 'estimatedTime', header: 'Est. Time', width: 12, format: (v) => v ? String(v) : 'N/A' }
+                        { key: 'reason', header: 'Reason', width: 35 }
                     ],
-                    data: result.recommendations.slice(0, topK)
+                    data: recommendations.slice(0, topK)
                 });
             }
             return { success: true, data: result };
@@ -447,7 +447,12 @@ export const metricsCommand = {
         output.writeln(output.bold(`Learning Metrics Dashboard (${period})`));
         output.writeln();
         try {
-            // Call MCP tool for metrics
+            // Call MCP tool for metrics. The real handler (hooks-routing.ts) only
+            // returns a subset of these fields depending on whether any memory
+            // entries exist yet — patterns/agents/commands/performance are all
+            // Partial, not fully populated objects. Fields that aren't tracked yet
+            // are genuinely absent (not present as null), each with a `_note`
+            // string explaining what would populate them.
             const result = await callMCPTool('hooks_metrics', {
                 period,
                 includev1: v1Dashboard,
@@ -457,6 +462,11 @@ export const metricsCommand = {
                 output.printJson(result);
                 return { success: true, data: result };
             }
+            const pct = (v) => typeof v === 'number' ? `${(v * 100).toFixed(1)}%` : 'N/A';
+            if (result._note) {
+                output.writeln(output.dim(result._note));
+                output.writeln();
+            }
             // Patterns section
             output.writeln(output.bold('📊 Pattern Learning'));
             output.printTable({
@@ -465,12 +475,14 @@ export const metricsCommand = {
                     { key: 'value', header: 'Value', width: 20, align: 'right' }
                 ],
                 data: [
-                    { metric: 'Total Patterns', value: result.patterns.total },
-                    { metric: 'Successful', value: output.success(String(result.patterns.successful)) },
-                    { metric: 'Failed', value: output.error(String(result.patterns.failed)) },
-                    { metric: 'Avg Confidence', value: `${(result.patterns.avgConfidence * 100).toFixed(1)}%` }
+                    { metric: 'Total Patterns', value: result.patterns.total ?? 0 },
+                    { metric: 'Successful', value: typeof result.patterns.successful === 'number' ? output.success(String(result.patterns.successful)) : 'N/A' },
+                    { metric: 'Failed', value: typeof result.patterns.failed === 'number' ? output.error(String(result.patterns.failed)) : 'N/A' },
+                    { metric: 'Avg Confidence', value: pct(result.patterns.avgConfidence) }
                 ]
             });
+            if (result.patterns._note)
+                output.writeln(output.dim(`  ${result.patterns._note}`));
             output.writeln();
             // Agent routing section
             output.writeln(output.bold('🤖 Agent Routing'));
@@ -480,11 +492,13 @@ export const metricsCommand = {
                     { key: 'value', header: 'Value', width: 20, align: 'right' }
                 ],
                 data: [
-                    { metric: 'Routing Accuracy', value: `${(result.agents.routingAccuracy * 100).toFixed(1)}%` },
-                    { metric: 'Total Routes', value: result.agents.totalRoutes },
-                    { metric: 'Top Agent', value: output.highlight(result.agents.topAgent) }
+                    { metric: 'Routing Accuracy', value: pct(result.agents.routingAccuracy) },
+                    { metric: 'Total Routes', value: result.agents.totalRoutes ?? 0 },
+                    { metric: 'Top Agent', value: result.agents.topAgent ? output.highlight(result.agents.topAgent) : 'N/A' }
                 ]
             });
+            if (result.agents._note)
+                output.writeln(output.dim(`  ${result.agents._note}`));
             output.writeln();
             // Command execution section
             output.writeln(output.bold('⚡ Command Execution'));
@@ -494,11 +508,13 @@ export const metricsCommand = {
                     { key: 'value', header: 'Value', width: 20, align: 'right' }
                 ],
                 data: [
-                    { metric: 'Total Executed', value: result.commands.totalExecuted },
-                    { metric: 'Success Rate', value: `${(result.commands.successRate * 100).toFixed(1)}%` },
-                    { metric: 'Avg Risk Score', value: result.commands.avgRiskScore.toFixed(2) }
+                    { metric: 'Total Executed', value: result.commands.totalExecuted ?? 0 },
+                    { metric: 'Success Rate', value: pct(result.commands.successRate) },
+                    { metric: 'Avg Risk Score', value: typeof result.commands.avgRiskScore === 'number' ? result.commands.avgRiskScore.toFixed(2) : 'N/A' }
                 ]
             });
+            if (result.commands._note)
+                output.writeln(output.dim(`  ${result.commands._note}`));
             if (v1Dashboard && result.performance) {
                 const p = result.performance;
                 output.writeln();

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

@@ -146,7 +146,10 @@ export const intelligenceCommand = {
                             patternsFileEntries = pData.length;
                     }
                 }
-                catch { /* ignore */ }
+                catch (e) {
+                    if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                        console.error('[hooks-intelligence] patterns.json read/parse failed:', e);
+                }
             }
             // Read stats.json for trajectory data
             let trajectoriesFromDisk = 0;
@@ -160,7 +163,10 @@ export const intelligenceCommand = {
                         lastAdaptationFromDisk = sData?.lastAdaptation ?? null;
                     }
                 }
-                catch { /* ignore */ }
+                catch (e) {
+                    if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                        console.error('[hooks-intelligence] stats.json read/parse failed:', e);
+                }
             }
             // Merge local stats with any we can get from MCP
             let mcpResult = null;

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

@@ -313,7 +313,7 @@ const sessionRestoreCommand = {
                 data: [
                     { item: 'Tasks', count: result.restoredState.tasksRestored },
                     { item: 'Agents', count: result.restoredState.agentsRestored },
-                    { item: 'Memory Entries', count: result.restoredState.memoryRestored }
+                    { item: 'Memory Bridge', count: result.restoredState.memoryBridgeInitialized ? 'ready' : 'unavailable' }
                 ]
             });
             if (result.warnings && result.warnings.length > 0) {

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

@@ -179,7 +179,7 @@ export const wizardCommand = {
                 }
                 const { execFileSync } = await import('child_process');
                 try {
-                    execFileSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['@monomind/cli@latest', 'embeddings', 'init', '--model', embeddingModel, '--no-download', '--force'], {
+                    execFileSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['monomind@latest', 'embeddings', 'init', '--model', embeddingModel, '--no-download', '--force'], {
                         stdio: 'pipe',
                         cwd: ctx.cwd,
                         timeout: 30000
@@ -199,7 +199,7 @@ export const wizardCommand = {
             if (enableGates) {
                 try {
                     const { execFileSync } = await import('child_process');
-                    execFileSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['@monomind/cli@latest', 'guidance', 'setup', '--project-dir', ctx.cwd], { stdio: 'pipe', cwd: ctx.cwd, timeout: 10000 });
+                    execFileSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['monomind@latest', 'guidance', 'setup', '--project-dir', ctx.cwd], { stdio: 'pipe', cwd: ctx.cwd, timeout: 10000 });
                     gatesEnabled = true;
                     output.writeln(output.success('  ✓ Enforcement gates wired'));
                 }

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

@@ -10,6 +10,7 @@ import { executeInit, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTI
 import { wizardCommand } from './init-wizard.js';
 import { upgradeCommand } from './init-upgrade.js';
 import { checkCommand, skillsCommand, hooksCommand } from './init-subcommands.js';
+import { initializeMemoryDatabase } from '../memory/memory-initializer.js';
 function isInitialized(cwd) {
     const claudePath = path.join(cwd, '.claude', 'settings.json');
     const monomindPath = path.join(cwd, '.monomind', 'config.yaml');
@@ -172,23 +173,30 @@ const initAction = async (ctx) => {
             output.printInfo('Starting services...');
             const { execSync } = await import('child_process');
             if (startAll) {
+                // In-process, not a subprocess: `npx @monomind/cli@latest memory init`
+                // (the previous approach) shelled out to a package name that has
+                // never been published — every fresh init silently 404'd here and
+                // fell into the catch block's "already exists" message even when no
+                // database existed at all. initializeMemoryDatabase() is the same
+                // function `monomind memory init` itself calls, run directly.
                 try {
                     output.writeln(output.dim('  Initializing memory database...'));
-                    execSync('npx @monomind/cli@latest memory init', {
-                        stdio: 'pipe',
-                        cwd: ctx.cwd,
-                        timeout: 30000
-                    });
-                    output.writeln(output.success('  ✓ Memory initialized'));
+                    const memResult = await initializeMemoryDatabase({ dbPath: path.join(ctx.cwd, '.swarm', 'memory.db') });
+                    if (memResult.success) {
+                        output.writeln(output.success('  ✓ Memory initialized'));
+                    }
+                    else {
+                        output.writeln(output.dim(`  Memory database init skipped (${memResult.error || 'unknown reason'})`));
+                    }
                 }
-                catch {
-                    output.writeln(output.dim('  Memory database already exists'));
+                catch (e) {
+                    output.writeln(output.dim(`  Memory database init skipped (${e instanceof Error ? e.message : String(e)})`));
                 }
             }
             if (startAll) {
                 try {
                     output.writeln(output.dim('  Initializing swarm...'));
-                    execSync('npx @monomind/cli@latest swarm init --topology hierarchical', {
+                    execSync('npx monomind@latest swarm init --topology hierarchical', {
                         stdio: 'pipe',
                         cwd: ctx.cwd,
                         timeout: 30000
@@ -199,6 +207,42 @@ const initAction = async (ctx) => {
                     output.writeln(output.dim('  Swarm initialization skipped'));
                 }
             }
+            if (startAll) {
+                // Seed .monomind/metrics/ immediately instead of waiting for the
+                // first Claude Code session-restore hook to run these workers —
+                // running `monomind doctor` right after `init` (before ever opening
+                // Claude Code) otherwise always shows "Worker Metrics"/"Security
+                // Audit" as unconfigured, even though nothing is actually broken.
+                try {
+                    output.writeln(output.dim('  Seeding worker metrics...'));
+                    const hooksMod = await import('@monomind/hooks').catch(() => null);
+                    if (hooksMod && hooksMod.createWorkerManager) {
+                        const manager = hooksMod.createWorkerManager(ctx.cwd);
+                        await manager.ensureMetricsDir();
+                        const seeded = [];
+                        for (const workerName of ['map', 'audit']) {
+                            try {
+                                const r = await manager.runWorker(workerName);
+                                if (r.success)
+                                    seeded.push(workerName);
+                            }
+                            catch { /* best-effort — doctor will report if this stays missing */ }
+                        }
+                        if (seeded.length > 0) {
+                            output.writeln(output.success(`  ✓ Worker metrics seeded (${seeded.join(', ')})`));
+                        }
+                        else {
+                            output.writeln(output.dim('  Worker metrics seeding skipped'));
+                        }
+                    }
+                    else {
+                        output.writeln(output.dim('  Worker metrics seeding skipped (@monomind/hooks unavailable)'));
+                    }
+                }
+                catch (e) {
+                    output.writeln(output.dim(`  Worker metrics seeding skipped (${e instanceof Error ? e.message : String(e)})`));
+                }
+            }
             output.writeln();
             output.printSuccess('All services started');
         }
@@ -216,7 +260,7 @@ const initAction = async (ctx) => {
             try {
                 output.writeln(output.dim(`  Model: ${embeddingModel}`));
                 output.writeln(output.dim('  Hyperbolic: Enabled (Poincaré ball)'));
-                execFileSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['@monomind/cli@latest', 'embeddings', 'init', '--model', embeddingModel, '--no-download', '--force'], {
+                execFileSync(process.platform === 'win32' ? 'npx.cmd' : 'npx', ['monomind@latest', 'embeddings', 'init', '--model', embeddingModel, '--no-download', '--force'], {
                     stdio: 'pipe',
                     cwd: ctx.cwd,
                     timeout: 30000

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

@@ -466,7 +466,10 @@ const toggleCommand = {
         try {
             disabled = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
         }
-        catch { /* fresh */ }
+        catch (e) {
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[mcp] failed to load mcp-disabled-tools.json, treating as fresh:', e);
+        }
         const enableArg = ctx.flags.enable;
         const disableArg = ctx.flags.disable;
         if (!enableArg && !disableArg) {

package/packages/@monomind/cli/dist/src/commands/memory-admin.js

@@ -330,7 +330,13 @@ export const configureCommand = {
             ]
         });
         output.writeln();
-        configManager.set(ctx.cwd, 'memory', config);
+        try {
+            configManager.set(ctx.cwd, 'memory', config);
+        }
+        catch (error) {
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
         output.printSuccess('Memory configuration updated');
         return { success: true, data: config };
     }

package/packages/@monomind/cli/dist/src/commands/org-observe.d.ts

@@ -0,0 +1,18 @@
+import type { CommandContext, CommandResult } from '../types.js';
+/** Validate org config(s) against OrgDefSchema — the exact parse `org run`/`org serve`
+ * perform — plus the structural invariants the runtime assumes but the schema can't
+ * express (single root role, resolvable reports_to, unique ids, parseable schedule). */
+export declare const validateAction: (ctx: CommandContext) => Promise<CommandResult>;
+/** `org logs <name> [--run id] [--role r] [--follow]` — formatted bus.jsonl tail. */
+export declare const logsAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
+/** `org report <name> [--run id] [--all]` — summarize a run (or list run history). */
+export declare const reportAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
+/** `org questions <name> [--all]` — list pending (or all) ask_human questions. */
+export declare const questionsAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
+/** `org answer <name> <question-id> <answer...>` — answer a pending ask_human question.
+ *  Delivers live via the hosting daemon's /api/answer-question when the org is running
+ *  (broker lookup); otherwise records the answer and queues it for the next run. */
+export declare const answerAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
+/** `org create <name> --template <t> [--goal g] [--schedule s]` — scaffold a config from a template. */
+export declare const createAction: (ctx: CommandContext, name: string) => Promise<CommandResult>;
+//# sourceMappingURL=org-observe.d.ts.map

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

@@ -0,0 +1,295 @@
+// packages/@monomind/cli/src/commands/org-observe.ts
+// Read-side org subcommands (logs / report) + template scaffolding (create).
+// Kept out of org.ts to respect the 500-line file ceiling.
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { output } from '../output.js';
+import { ORG_DIR, OrgDefSchema } from '../orgrt/types.js';
+import { formatEvent, listRunDirs, readHistory, readRunEvents, summarizeRun } from '../orgrt/reporting.js';
+import { ORG_TEMPLATES, buildFromTemplate } from '../orgrt/templates.js';
+import { parseSchedule } from '../orgrt/scheduler.js';
+import { listOrgConfigFiles, validateOrgName } from './org.js';
+const log = (text) => { console.log(text); };
+/** Validate org config(s) against OrgDefSchema — the exact parse `org run`/`org serve`
+ * perform — plus the structural invariants the runtime assumes but the schema can't
+ * express (single root role, resolvable reports_to, unique ids, parseable schedule). */
+export const validateAction = async (ctx) => {
+    const orgsDir = join(ctx.cwd || process.cwd(), ORG_DIR);
+    let files;
+    if (ctx.args[0]) {
+        const validated = validateOrgName(ctx.args[0]);
+        if (!validated.ok)
+            return validated.result;
+        files = [`${validated.name}.json`];
+    }
+    else {
+        if (!existsSync(orgsDir))
+            return { success: false, message: 'no orgs directory — create an org first with /mastermind:createorg' };
+        files = listOrgConfigFiles(orgsDir);
+        if (!files.length)
+            return { success: false, message: 'no org configs found' };
+    }
+    let failed = 0;
+    for (const f of files) {
+        const stem = f.replace(/\.json$/, '');
+        const path = join(orgsDir, f);
+        const errors = [];
+        const warnings = [];
+        if (!existsSync(path)) {
+            log(output.error(`${stem}: not found (${path})`));
+            failed++;
+            continue;
+        }
+        try {
+            const def = OrgDefSchema.parse(JSON.parse(readFileSync(path, 'utf8')));
+            const ids = def.roles.map(r => r.id);
+            const dupes = ids.filter((id, i) => ids.indexOf(id) !== i);
+            if (dupes.length)
+                errors.push(`duplicate role id(s): ${[...new Set(dupes)].join(', ')}`);
+            const roots = def.roles.filter(r => r.reports_to === null);
+            if (roots.length === 0)
+                errors.push('no root role — exactly one role must have reports_to: null');
+            if (roots.length > 1)
+                errors.push(`multiple root roles (${roots.map(r => r.id).join(', ')}) — exactly one may have reports_to: null`);
+            for (const r of def.roles) {
+                if (r.reports_to !== null && !ids.includes(r.reports_to))
+                    errors.push(`role "${r.id}": reports_to "${r.reports_to}" matches no role id`);
+                if (r.reports_to === r.id)
+                    errors.push(`role "${r.id}" reports to itself`);
+            }
+            if (def.schedule != null && parseSchedule(def.schedule) === null)
+                errors.push(`schedule "${def.schedule}" is not parseable — use "<N>s", "<N>m", or "<N>h"`);
+            if (def.name !== stem)
+                warnings.push(`def.name "${def.name}" differs from filename — the runtime addresses this org as "${stem}"`);
+        }
+        catch (err) {
+            errors.push(err instanceof Error ? err.message : String(err));
+        }
+        for (const w of warnings)
+            log(output.warning(`${stem}: ${w}`));
+        if (errors.length) {
+            failed++;
+            for (const e of errors)
+                log(output.error(`${stem}: ${e}`));
+        }
+        else {
+            log(output.success(`${stem}: valid${warnings.length ? ` (${warnings.length} warning(s))` : ''}`));
+        }
+    }
+    return failed
+        ? { success: false, message: `${failed} of ${files.length} org config(s) failed validation` }
+        : { success: true, message: `${files.length} org config(s) valid` };
+};
+const resolveRun = (cwd, name, runFlag) => {
+    if (typeof runFlag === 'string' && runFlag)
+        return runFlag;
+    return listRunDirs(cwd, name)[0] ?? null;
+};
+/** `org logs <name> [--run id] [--role r] [--follow]` — formatted bus.jsonl tail. */
+export const logsAction = async (ctx, name) => {
+    const run = resolveRun(ctx.cwd, name, ctx.flags['run']);
+    if (!run)
+        return { success: false, message: `no runs found for org ${name} — start one with: monomind org run ${name}` };
+    const file = join(ctx.cwd, ORG_DIR, name, run, 'bus.jsonl');
+    const roleFilter = typeof ctx.flags['role'] === 'string' ? ctx.flags['role'] : null;
+    const show = (e) => {
+        if (roleFilter && e.from !== roleFilter && e.to !== roleFilter)
+            return;
+        log(formatEvent(e));
+    };
+    log(output.info(`org ${name} — ${run}${roleFilter ? ` (role: ${roleFilter})` : ''}`));
+    let seenLines = 0;
+    const drain = () => {
+        if (!existsSync(file))
+            return;
+        const lines = readFileSync(file, 'utf8').split('\n').filter(Boolean);
+        for (const l of lines.slice(seenLines)) {
+            try {
+                show(JSON.parse(l));
+                seenLines++;
+            }
+            catch {
+                break;
+            } // partial line mid-append — retry it next tick
+        }
+    };
+    drain();
+    if (ctx.flags['follow'] !== true)
+        return { success: true };
+    log(output.info('following — Ctrl-C to stop'));
+    await new Promise(resolve => {
+        const iv = setInterval(drain, 500);
+        process.once('SIGINT', () => { clearInterval(iv); resolve(); });
+        process.once('SIGTERM', () => { clearInterval(iv); resolve(); });
+    });
+    return { success: true };
+};
+/** `org report <name> [--run id] [--all]` — summarize a run (or list run history). */
+export const reportAction = async (ctx, name) => {
+    if (ctx.flags['all'] === true) {
+        const history = readHistory(ctx.cwd, name);
+        if (!history.length)
+            return { success: false, message: `no run history for org ${name}` };
+        log(output.info(`org ${name} — ${history.length} recorded run(s):`));
+        for (const h of history) {
+            const dur = h.durationMs != null ? `${Math.round(h.durationMs / 1000)}s` : '?';
+            const outcome = h.outcome ? `${h.outcome.status}: ${h.outcome.summary.slice(0, 60)}` : 'no outcome recorded';
+            log(output.info(`  • ${h.run}  ${dur}  ${h.totalTokens} tokens  ${h.messages} msgs  — ${outcome}`));
+        }
+        return { success: true };
+    }
+    const run = resolveRun(ctx.cwd, name, ctx.flags['run']);
+    if (!run)
+        return { success: false, message: `no runs found for org ${name}` };
+    const events = readRunEvents(ctx.cwd, name, run);
+    if (!events.length)
+        return { success: false, message: `run ${run} has no recorded events` };
+    const s = summarizeRun(events);
+    // Per-role budget ceiling: same split the daemon applies (budget ÷ role count),
+    // with any explicit policy.maxTokens override. Missing/unreadable config → no ceilings.
+    let perRoleBudget = null;
+    const roleCeiling = new Map();
+    try {
+        const def = OrgDefSchema.parse(JSON.parse(readFileSync(join(ctx.cwd, ORG_DIR, `${name}.json`), 'utf8')));
+        perRoleBudget = Math.floor((def.run_config.budget_tokens ?? 1_000_000) / def.roles.length);
+        for (const r of def.roles) {
+            const max = r.policy?.maxTokens;
+            roleCeiling.set(r.id, max ?? perRoleBudget);
+        }
+    }
+    catch { /* config gone or invalid — report without budget context */ }
+    const budgetNote = (id, tokens) => {
+        const cap = roleCeiling.get(id);
+        if (!cap)
+            return '';
+        const pct = Math.round((tokens / cap) * 100);
+        return ` (${pct}% of ${cap}${pct >= 100 ? ' — EXHAUSTED' : pct >= 80 ? ' — near limit' : ''})`;
+    };
+    log(output.info(`ORG REPORT — ${name} / ${run}`));
+    log(output.info(`  Duration: ${s.durationMs != null ? `${Math.round(s.durationMs / 1000)}s` : '?'}   Events: ${s.events}   Messages: ${s.messages}${s.xorgMessages ? ` (+${s.xorgMessages} cross-org)` : ''}`));
+    log(output.info(`  Tokens: ${s.totalTokens}${perRoleBudget ? ` (budget: ${perRoleBudget}/role)` : ''}${s.totalCostUsd ? `   Cost: $${s.totalCostUsd.toFixed(4)}` : ''}`));
+    if (s.outcome)
+        log(output.success(`  Outcome: ${s.outcome.status} (by ${s.outcome.by}) — ${s.outcome.summary}`));
+    else
+        log(output.warning('  Outcome: not recorded (coordinator never called org_complete)'));
+    log(output.info('  Roles:'));
+    for (const [id, r] of Object.entries(s.roles)) {
+        log(output.info(`    ${r.crashed ? '✗' : '•'} ${id}: ${r.messagesSent} msgs, ${r.toolsAllowed} tools${r.toolsDenied ? ` (${r.toolsDenied} denied)` : ''}, ${r.tokens} tokens${budgetNote(id, r.tokens)}${r.crashed ? ' — CRASHED' : ''}`));
+    }
+    if (s.assets.length) {
+        log(output.info(`  Assets (${s.assets.length}):`));
+        for (const a of s.assets.slice(0, 20))
+            log(output.info(`    📄 ${a}`));
+        if (s.assets.length > 20)
+            log(output.info(`    … and ${s.assets.length - 20} more`));
+    }
+    return { success: true };
+};
+const readQuestions = (cwd, name) => {
+    try {
+        return JSON.parse(readFileSync(join(cwd, ORG_DIR, name, 'questions.json'), 'utf8')).questions ?? [];
+    }
+    catch {
+        return [];
+    }
+};
+/** `org questions <name> [--all]` — list pending (or all) ask_human questions. */
+export const questionsAction = async (ctx, name) => {
+    const all = readQuestions(ctx.cwd, name);
+    const shown = ctx.flags['all'] === true ? all : all.filter(q => q.answer === null);
+    if (!shown.length) {
+        log(output.info(all.length ? `No pending questions for org ${name} (${all.length} answered — use --all).` : `No questions recorded for org ${name}.`));
+        return { success: true };
+    }
+    for (const q of shown) {
+        const when = new Date(q.ts).toISOString().replace('T', ' ').slice(0, 16);
+        log(output.info(`${q.answer === null ? '❓' : '✓'} [${q.questionId}] ${when}  ${q.role}: ${q.question}`));
+        if (q.answer !== null)
+            log(output.info(`     ↳ ${q.answer}`));
+    }
+    if (shown.some(q => q.answer === null))
+        log(output.info(`\nAnswer with: monomind org answer ${name} <question-id> "your answer"`));
+    return { success: true };
+};
+/** `org answer <name> <question-id> <answer...>` — answer a pending ask_human question.
+ *  Delivers live via the hosting daemon's /api/answer-question when the org is running
+ *  (broker lookup); otherwise records the answer and queues it for the next run. */
+export const answerAction = async (ctx, name) => {
+    const questionId = ctx.args[1];
+    const answer = ctx.args.slice(2).join(' ').trim();
+    if (!questionId || !answer)
+        return { success: false, message: `usage: monomind org answer ${name} <question-id> "answer text"` };
+    const questions = readQuestions(ctx.cwd, name);
+    const q = questions.find(x => x.questionId === questionId);
+    if (!q) {
+        log(output.error(`Question "${questionId}" not found for org ${name} — list with: monomind org questions ${name}`));
+        return { success: false, message: 'question not found' };
+    }
+    if (q.answer !== null)
+        return { success: false, message: `question "${questionId}" was already answered` };
+    // Live path: the hosting daemon updates questions.json and pushes into the role's mailbox.
+    const { lookupOrg } = await import('../orgrt/broker.js');
+    const remote = lookupOrg(name);
+    if (remote) {
+        try {
+            const res = await fetch(`${remote.url}/api/answer-question`, {
+                method: 'POST', headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ org: name, role: q.role, questionId, answer }),
+                signal: AbortSignal.timeout(10_000),
+            });
+            const data = await res.json().catch(() => ({}));
+            if (res.ok && data.ok) {
+                log(output.success(`Answer delivered to ${name}:${q.role} (live).`));
+                return { success: true };
+            }
+            log(output.warning(`Live delivery rejected (${data.error ?? res.status}) — falling back to offline queue.`));
+        }
+        catch (err) {
+            log(output.warning(`Hosting daemon unreachable (${err instanceof Error ? err.message : 'error'}) — falling back to offline queue.`));
+        }
+    }
+    // Offline path: mirror daemon.answerQuestion's org-not-running branch.
+    const updated = questions.map(x => x.questionId === questionId ? { ...x, answer, answeredAt: Date.now() } : x);
+    const dest = join(ctx.cwd, ORG_DIR, name, 'questions.json');
+    const tmp = `${dest}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ questions: updated }, null, 2));
+    const { renameSync } = await import('node:fs');
+    renameSync(tmp, dest);
+    const { queueMessage } = await import('../orgrt/inbox.js');
+    queueMessage(ctx.cwd, name, {
+        fromQualified: 'human', toRole: q.role,
+        subject: `answer:${questionId}`,
+        body: `question: ${q.question}\n\nanswer: ${answer}`,
+        ts: Date.now(),
+    });
+    log(output.success(`Answer recorded — ${name}:${q.role} receives it when the org next runs.`));
+    return { success: true };
+};
+/** `org create <name> --template <t> [--goal g] [--schedule s]` — scaffold a config from a template. */
+export const createAction = async (ctx, name) => {
+    const templateName = typeof ctx.flags['template'] === 'string' ? ctx.flags['template'] : '';
+    if (!templateName) {
+        log(output.info(`Available templates: ${Object.keys(ORG_TEMPLATES).join(', ')}`));
+        return { success: false, message: 'usage: monomind org create <name> --template <template> [--goal "..."] [--schedule 30m]' };
+    }
+    const def = buildFromTemplate(templateName, name, typeof ctx.flags['goal'] === 'string' ? ctx.flags['goal'] : undefined);
+    if (!def) {
+        log(output.error(`Unknown template "${templateName}" — available: ${Object.keys(ORG_TEMPLATES).join(', ')}`));
+        return { success: false, message: 'unknown template' };
+    }
+    if (typeof ctx.flags['schedule'] === 'string')
+        def.schedule = ctx.flags['schedule'];
+    const file = join(ctx.cwd, ORG_DIR, `${name}.json`);
+    if (existsSync(file) && ctx.flags['force'] !== true) {
+        log(output.error(`Org "${name}" already exists — pass --force to overwrite.`));
+        return { success: false, message: 'org exists' };
+    }
+    OrgDefSchema.parse(def); // templates must always produce a runnable config
+    const { mkdirSync } = await import('node:fs');
+    mkdirSync(join(ctx.cwd, ORG_DIR), { recursive: true });
+    writeFileSync(file, JSON.stringify(def, null, 2) + '\n', 'utf8');
+    log(output.success(`Org "${name}" created from template "${templateName}" (${def.roles.length} roles).`));
+    log(output.info(`  Edit the goal/roles in ${file}, then: monomind org run ${name}`));
+    return { success: true };
+};
+//# sourceMappingURL=org-observe.js.map

package/packages/@monomind/cli/dist/src/commands/org.d.ts

@@ -1,4 +1,12 @@
-import type { Command } from '../types.js';
+import type { Command, CommandResult } from '../types.js';
+export declare function validateOrgName(name: string | undefined): {
+    ok: true;
+    name: string;
+} | {
+    ok: false;
+    result: CommandResult;
+};
+export declare function listOrgConfigFiles(orgsDir: string): string[];
 /** Remove a lingering stopfile so a fresh `org run` doesn't self-terminate. */
 export declare const clearStopfile: (cwd: string, name: string) => void;
 export declare const orgCommand: Command;