monomind 2.1.9 → 2.3.0

package/packages/@monomind/cli/dist/src/memory/intelligence.js

@@ -454,8 +454,10 @@ class LocalReasoningBank {
             // ReasoningBank via intelligence.ts's public API, so no separate
             // models.json bridge is needed.
         }
-        catch {
+        catch (e) {
             // Ignore load errors, start fresh
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[intelligence] failed to load patterns.json, starting fresh:', e);
         }
     }
     /**
@@ -680,8 +682,10 @@ function loadPersistedStats() {
             }
         }
     }
-    catch {
+    catch (e) {
         // Ignore load errors, start fresh
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] failed to load stats.json, starting fresh:', e);
     }
 }
 /**
@@ -693,8 +697,10 @@ function savePersistedStats() {
         const path = getStatsPath();
         writeFileSync(path, JSON.stringify(globalStats, null, 2), 'utf-8');
     }
-    catch {
+    catch (e) {
         // Ignore save errors
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] failed to save stats.json:', e);
     }
 }
 // ============================================================================
@@ -762,7 +768,11 @@ async function _doInitializeIntelligence(config) {
                     }
                 }
             }
-            catch { /* neural patterns file unreadable — skip */ }
+            catch (e) {
+                /* neural patterns file unreadable — skip */
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[intelligence] failed to seed patterns.json into ReasoningBank:', e);
+            }
         }
         // Seed SONA routing patterns into the ReasoningBank so keyword-based
         // routing knowledge from .swarm/sona-patterns.json participates in
@@ -890,7 +900,9 @@ export async function recordStep(step) {
         globalStats.trajectoriesRecorded++;
         return true;
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] recordStep failed:', e);
         return false;
     }
 }
@@ -923,7 +935,9 @@ export async function recordTrajectory(steps, verdict) {
         savePersistedStats();
         return true;
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] recordTrajectory failed:', e);
         return false;
     }
 }
@@ -980,7 +994,9 @@ export async function findSimilarPatterns(query, options) {
             similarity: r.similarity ?? r.confidence ?? 0.5
         }));
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] findSimilarPatterns failed:', e);
         return [];
     }
 }
@@ -1030,7 +1046,9 @@ export async function endTrajectoryWithVerdict(verdict) {
         savePersistedStats();
         return result;
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] endTrajectoryWithVerdict failed:', e);
         return null;
     }
 }
@@ -1052,7 +1070,9 @@ export async function distillLearning() {
         savePersistedStats();
         return result;
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] distillLearning failed:', e);
         return null;
     }
 }
@@ -1184,7 +1204,9 @@ function loadSonaRoutingPatterns() {
         }
         return results;
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[intelligence] failed to load .swarm/sona-patterns.json:', e);
         return [];
     }
 }

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

@@ -148,7 +148,10 @@ async function getBackend(dbPath) {
                     };
                     _embedder = embeddingGenerator;
                 }
-                catch { /* embeddings unavailable — store and search without vectors */ }
+                catch (e) {
+                    if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                        console.error('[memory-bridge] embedding model failed to load — store and search without vectors:', e);
+                }
                 const backend = new LanceDBBackend({
                     // Always route through getDbPath's traversal guard — dbPath here can
                     // originate from a caller/tool-supplied value, and getDbPath(undefined)
@@ -212,7 +215,10 @@ export async function bridgeStoreEntry(options) {
                 embedding = await _embedder(value);
                 embeddingInfo = { dimensions: embedding.length, model: BRIDGE_EMBEDDING_MODEL };
             }
-            catch { /* store without embedding */ }
+            catch (e) {
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[memory-bridge] embedding generation failed — storing entry without embedding:', e);
+            }
         }
         const mod = await import('@monoes/memory');
         const entry = mod.createDefaultEntry({
@@ -233,7 +239,10 @@ export async function bridgeStoreEntry(options) {
                 if (existing)
                     await backend.delete(existing.id);
             }
-            catch { /* non-fatal */ }
+            catch (e) {
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[memory-bridge] upsert failed to delete existing entry — may create a duplicate:', e);
+            }
         }
         // Dedup gate: skip if a near-duplicate already exists
         const automemCfg = getAutomemConfig();
@@ -644,7 +653,10 @@ export async function bridgeSessionEnd(options) {
             try {
                 data = JSON.parse(existing.content);
             }
-            catch { /* use empty */ }
+            catch (e) {
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[memory-bridge] session content failed to parse — ending session with empty prior state:', e);
+            }
             await backend.update(existing.id, {
                 content: JSON.stringify({
                     ...data,

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

@@ -238,8 +238,32 @@ export async function storeEntry(options) {
         }
         const fileBuffer = fs.readFileSync(dbPath);
         const db = new SQL.Database(fileBuffer);
-        const id = `entry_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        // memory_entries has no UNIQUE constraint on (key, namespace) — only
+        // `id TEXT PRIMARY KEY`. `INSERT OR REPLACE` only replaces a row when
+        // its PRIMARY KEY collides, so generating a fresh id on every call (as
+        // this used to do unconditionally) meant upsert never actually matched
+        // the existing row for a given key+namespace — it silently inserted a
+        // duplicate instead of replacing it. When upserting, look up the
+        // existing row's real id first and reuse it so the replace actually
+        // collides; only mint a new id when no existing row is found.
+        let id = `entry_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+        let existingCreatedAt = null;
+        if (upsert) {
+            // Only match active rows — a soft-deleted row's key+namespace should
+            // not be resurrected by an unrelated upsert; that would both restore
+            // history a delete intentionally cleared and mask the deletion.
+            const existingIdResult = db.exec("SELECT id, created_at FROM memory_entries WHERE key = ? AND namespace = ? AND status = 'active' LIMIT 1", [key, namespace]);
+            const existingRow = existingIdResult[0]?.values?.[0];
+            const existingId = existingRow?.[0];
+            if (typeof existingId === 'string') {
+                id = existingId;
+                const createdAt = existingRow?.[1];
+                if (typeof createdAt === 'number')
+                    existingCreatedAt = createdAt;
+            }
+        }
         const now = Date.now();
+        const createdAt = existingCreatedAt ?? now;
         let embeddingJson = null;
         let embeddingDimensions = null;
         let embeddingModel = null;
@@ -270,7 +294,7 @@ export async function storeEntry(options) {
             embeddingModel,
             tags.length > 0 ? JSON.stringify(tags) : null,
             '{}',
-            now,
+            createdAt,
             now,
             ttl ? now + (ttl * 1000) : null
         ]);

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

@@ -110,8 +110,9 @@ async function activateControllerRegistry(dbPath, verbose) {
             console.log(`ControllerRegistry: ${activated.length} controllers activated`);
         }
     }
-    catch {
-        // ControllerRegistry activation is best-effort
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[activateControllers] ControllerRegistry activation failed:', e);
     }
     return { activated, failed, initTimeMs: performance.now() - startTime };
 }

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

@@ -57,6 +57,8 @@ export async function ensureSchemaColumns(dbPath) {
                 }
                 catch (e) {
                     // Column might already exist or other error - continue
+                    if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                        console.error(`[ensureSchemaColumns] failed to add column '${col.name}':`, e);
                 }
             }
         }

package/packages/@monomind/cli/dist/src/monovector/command-outcomes.js

@@ -41,7 +41,10 @@ export async function recordCommand(baseDir, cmd) {
             await fs.writeFile(path, lines.slice(-MAX_COMMAND_RECORDS).join('\n') + '\n', 'utf8');
         }
     }
-    catch { /* non-fatal */ }
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[recordCommand] failed to record command outcome:', e);
+    }
 }
 /**
  * Derive a measured success signal from recent command outcomes.

package/packages/@monomind/cli/dist/src/orgrt/bus.js

@@ -36,7 +36,10 @@ export class OrgBus {
         this.pending = this.pending.then(async () => {
             await mkdir(this.dir, { recursive: true });
             await appendFile(this.file, JSON.stringify(e) + '\n', 'utf8');
-        }).catch(() => { });
+        }).catch((err) => {
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[org-bus] event write failed:', err);
+        });
         for (const fn of this.listeners) {
             try {
                 fn(e);

package/packages/@monomind/cli/dist/src/orgrt/daemon.js

@@ -10,6 +10,7 @@ import { attachForwarder } from './forwarder.js';
 import { BrokerLease, lookupOrg } from './broker.js';
 import { queueMessage, drainInbox } from './inbox.js';
 import { OrgDefSchema, ORG_DIR } from './types.js';
+import { summarizeRun, readRunEvents, readHistory, historyFile } from './reporting.js';
 export class OrgDaemon {
     root;
     opts;
@@ -66,33 +67,74 @@ export class OrgDaemon {
             const mailbox = new Mailbox();
             const policy = new PolicyEngine(role.id, { maxTokens: perRoleBudget, ...(role.policy ?? {}) }, bus, cwd);
             const runtime = { mailbox, policy, status: 'running', done: Promise.resolve() };
-            runtime.done = runAgentSession({
+            const sessionOpts = {
                 org: name, role, bus, policy, mailbox, cwd, def,
                 maxTurns: def.run_config.max_turns_per_message,
                 deliver: (from, to, subject, body) => this.deliver(name, from, to, subject, body),
-                askHuman: (role, question) => this.askHuman(name, role, question),
+                askHuman: (r, question) => this.askHuman(name, r, question),
+                onComplete: (r, outcome, summary) => {
+                    bus.emit({ type: 'status', from: r, reason: 'org-complete', msg: `run outcome: ${outcome}`, data: { outcome, summary } });
+                },
                 queryFn: this.opts.queryFn,
-            }).then(() => { runtime.status = 'ended'; })
-                .catch((err) => {
-                const message = err instanceof Error ? err.message : String(err);
-                runtime.status = 'crashed';
-                runtime.error = message;
-                // runAgentSession already emits a 'status' event for the raw error; emit an
-                // 'audit' event too so dashboards/alerts that filter on actionable failures
-                // (not routine status chatter) can surface a dead agent instead of a run that
-                // silently never progresses.
-                bus.emit({
-                    type: 'audit', from: role.id,
-                    msg: `agent "${role.id}" crashed: ${message}`,
-                    reason: 'agent-session-crash',
-                    data: { agentId: role.id, error: message },
-                });
-            });
+            };
+            // Supervised session: transient crashes (provider blips, network) restart
+            // with backoff; a crash with the mailbox already closed, or one that
+            // exhausts the retry budget, is terminal. runAgentSession already emits a
+            // 'status' event for the raw error; the terminal 'audit' event is for
+            // dashboards/alerts that filter on actionable failures (not routine
+            // status chatter) so a dead agent surfaces instead of a run that
+            // silently never progresses.
+            const BACKOFFS_MS = [1000, 5000, 15000];
+            runtime.done = (async () => {
+                for (let attempt = 0;; attempt++) {
+                    try {
+                        await runAgentSession(sessionOpts);
+                        runtime.status = 'ended';
+                        return;
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        const crash = () => {
+                            runtime.status = 'crashed';
+                            runtime.error = message;
+                            bus.emit({
+                                type: 'audit', from: role.id,
+                                msg: `agent "${role.id}" crashed: ${message}`,
+                                reason: 'agent-session-crash',
+                                data: { agentId: role.id, error: message, restarts: attempt },
+                            });
+                        };
+                        if (mailbox.isClosed || attempt >= BACKOFFS_MS.length) {
+                            crash();
+                            return;
+                        }
+                        bus.emit({
+                            type: 'status', from: role.id, reason: 'agent-restart',
+                            msg: `agent "${role.id}" crashed (${message}) — restarting in ${BACKOFFS_MS[attempt]}ms (attempt ${attempt + 1}/${BACKOFFS_MS.length})`,
+                        });
+                        await new Promise(r => { const t = setTimeout(r, BACKOFFS_MS[attempt]); t.unref?.(); });
+                        if (mailbox.isClosed) {
+                            crash();
+                            return;
+                        } // org stopped during backoff — never recovered
+                    }
+                }
+            })();
             running.agents.set(role.id, runtime);
         }
         const boss = def.roles.find(r => r.type === 'boss' || r.reports_to === null) ?? def.roles[0];
+        // Cross-run memory: brief the coordinator on the previous run so scheduled
+        // orgs accumulate instead of starting cold every interval.
+        const prev = readHistory(this.root, name).at(-1);
+        const prevBrief = prev
+            ? `\n\nPrevious run (${prev.run}${prev.endedAt ? `, ${new Date(prev.endedAt).toISOString()}` : ''}): ` +
+                (prev.outcome
+                    ? `outcome "${prev.outcome.status}" — ${prev.outcome.summary}`
+                    : `no recorded outcome (${prev.messages} messages, ${prev.assets.length} assets${prev.crashes.length ? `, ${prev.crashes.length} crashed agent(s)` : ''})`) +
+                `\nBuild on that work — do not redo what is already done.`
+            : '';
         running.agents.get(boss.id).mailbox.push(`Org "${name}" started (run ${run}).\nGoal: ${taskOverride ?? def.goal}\n` +
-            `Coordinate your team via org_send. Report completion by ending your turn.`);
+            `Coordinate your team via org_send. When the goal is achieved (or clearly can't be), record it with org_complete, then end your turn.${prevBrief}`);
         bus.emit({ type: 'status', msg: `org started (${def.roles.length} agents)`, data: { goal: taskOverride ?? def.goal } });
         this.persistState(name, 'running', run);
         if (this.opts.crossProcess && this.opts.inboxUrl) {
@@ -336,6 +378,19 @@ export class OrgDaemon {
         }
         org.bus.emit({ type: 'status', msg: 'org stopped' });
         await org.bus.flush();
+        // Append this run's summary to <org>/history.jsonl — read back from the
+        // flushed bus.jsonl (the full durable record) rather than the bounded
+        // in-memory buffer, so long runs summarize completely.
+        try {
+            const events = readRunEvents(this.root, name, org.run);
+            if (events.length) {
+                const { appendFileSync } = await import('node:fs');
+                appendFileSync(historyFile(this.root, name), JSON.stringify(summarizeRun(events)) + '\n', 'utf8');
+            }
+        }
+        catch (err) {
+            console.error(`org ${name}: could not write run history:`, err instanceof Error ? err.message : err);
+        }
         // the "org stopped" event above triggers the forwarder's final org:complete /
         // session:complete POST — without waiting for it here, the CLI process can exit
         // (and kill the in-flight fetch) before that last event reaches the dashboard,

package/packages/@monomind/cli/dist/src/orgrt/inbox.js

@@ -23,7 +23,9 @@ export function drainInbox(root, orgName) {
     try {
         renameSync(path, draining);
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[inbox] drainInbox rename failed:', e);
         return [];
     }
     const raw = readFileSync(draining, 'utf8').trim();

package/packages/@monomind/cli/dist/src/orgrt/reporting.d.ts

@@ -0,0 +1,40 @@
+import type { BusEvent } from './types.js';
+export interface RoleStats {
+    messagesSent: number;
+    toolsAllowed: number;
+    toolsDenied: number;
+    tokens: number;
+    costUsd: number;
+    crashed: boolean;
+}
+export interface RunSummary {
+    org: string;
+    run: string;
+    startedAt: number | null;
+    endedAt: number | null;
+    durationMs: number | null;
+    events: number;
+    messages: number;
+    xorgMessages: number;
+    assets: string[];
+    crashes: string[];
+    outcome: {
+        status: string;
+        summary: string;
+        by: string;
+    } | null;
+    roles: Record<string, RoleStats>;
+    totalTokens: number;
+    totalCostUsd: number;
+}
+/** Aggregate one run's bus events into a summary. */
+export declare function summarizeRun(events: BusEvent[]): RunSummary;
+/** run directories for an org, newest first (by name — run-YYYYMMDDHHMMSS-xxxx sorts naturally). */
+export declare function listRunDirs(cwd: string, org: string): string[];
+export declare function readRunEvents(cwd: string, org: string, run: string): BusEvent[];
+/** history.jsonl — one RunSummary line per completed run, appended by the daemon at stopOrg. */
+export declare function historyFile(cwd: string, org: string): string;
+export declare function readHistory(cwd: string, org: string): RunSummary[];
+/** One bus event as a compact human-readable log line. */
+export declare function formatEvent(e: BusEvent): string;
+//# sourceMappingURL=reporting.d.ts.map

package/packages/@monomind/cli/dist/src/orgrt/reporting.js

@@ -0,0 +1,127 @@
+// packages/@monomind/cli/src/orgrt/reporting.ts
+// Read-side aggregation over an org run's bus.jsonl — powers `org report`,
+// `org logs`, and the per-run summary line appended to <org>/history.jsonl.
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ORG_DIR } from './types.js';
+const roleStats = () => ({ messagesSent: 0, toolsAllowed: 0, toolsDenied: 0, tokens: 0, costUsd: 0, crashed: false });
+/** Aggregate one run's bus events into a summary. */
+export function summarizeRun(events) {
+    const s = {
+        org: events[0]?.org ?? '', run: events[0]?.run ?? '',
+        startedAt: events.length ? events[0].ts : null,
+        endedAt: events.length ? events[events.length - 1].ts : null,
+        durationMs: null, events: events.length,
+        messages: 0, xorgMessages: 0, assets: [], crashes: [], outcome: null,
+        roles: {}, totalTokens: 0, totalCostUsd: 0,
+    };
+    if (s.startedAt !== null && s.endedAt !== null)
+        s.durationMs = s.endedAt - s.startedAt;
+    const role = (id) => {
+        const key = id ?? '(system)';
+        return (s.roles[key] ??= roleStats());
+    };
+    for (const e of events) {
+        switch (e.type) {
+            case 'message':
+                s.messages++;
+                role(e.from).messagesSent++;
+                break;
+            case 'xorg':
+                s.xorgMessages++;
+                role(e.from?.includes(':') ? e.from.split(':')[1] : e.from).messagesSent++;
+                break;
+            case 'tool':
+                if (e.decision === 'deny')
+                    role(e.from).toolsDenied++;
+                else
+                    role(e.from).toolsAllowed++;
+                break;
+            case 'asset':
+                if (e.path && !s.assets.includes(e.path))
+                    s.assets.push(e.path);
+                break;
+            case 'usage': {
+                const tokens = Number(e.data?.tokens ?? 0);
+                const cost = Number(e.data?.cost_usd ?? 0);
+                const r = role(e.from);
+                r.tokens += tokens;
+                s.totalTokens += tokens;
+                if (Number.isFinite(cost)) {
+                    r.costUsd += cost;
+                    s.totalCostUsd += cost;
+                }
+                break;
+            }
+            case 'audit':
+                if (e.reason === 'agent-session-crash' && e.from) {
+                    s.crashes.push(e.from);
+                    role(e.from).crashed = true;
+                }
+                break;
+            case 'status': {
+                const d = e.data;
+                if (e.reason === 'org-complete' && d?.outcome)
+                    s.outcome = { status: d.outcome, summary: d.summary ?? '', by: e.from ?? '' };
+                break;
+            }
+        }
+    }
+    return s;
+}
+/** run directories for an org, newest first (by name — run-YYYYMMDDHHMMSS-xxxx sorts naturally). */
+export function listRunDirs(cwd, org) {
+    const base = join(cwd, ORG_DIR, org);
+    if (!existsSync(base))
+        return [];
+    return readdirSync(base).filter(d => d.startsWith('run-')).sort().reverse();
+}
+export function readRunEvents(cwd, org, run) {
+    const f = join(cwd, ORG_DIR, org, run, 'bus.jsonl');
+    if (!existsSync(f))
+        return [];
+    return readFileSync(f, 'utf8').split('\n').filter(Boolean)
+        .map(l => { try {
+        return JSON.parse(l);
+    }
+    catch {
+        return null;
+    } })
+        .filter((e) => e !== null);
+}
+/** history.jsonl — one RunSummary line per completed run, appended by the daemon at stopOrg. */
+export function historyFile(cwd, org) {
+    return join(cwd, ORG_DIR, org, 'history.jsonl');
+}
+export function readHistory(cwd, org) {
+    const f = historyFile(cwd, org);
+    if (!existsSync(f))
+        return [];
+    return readFileSync(f, 'utf8').split('\n').filter(Boolean)
+        .map(l => { try {
+        return JSON.parse(l);
+    }
+    catch {
+        return null;
+    } })
+        .filter((s) => s !== null);
+}
+/** One bus event as a compact human-readable log line. */
+export function formatEvent(e) {
+    const t = new Date(e.ts).toISOString().slice(11, 19);
+    const from = e.from ?? '·';
+    switch (e.type) {
+        case 'message':
+        case 'xorg':
+            return `${t} ${e.type === 'xorg' ? '⇄' : '→'} ${from} → ${e.to}: [${e.subject ?? ''}] ${trim(e.msg)}`;
+        case 'chat': return `${t} 💬 ${from}: ${trim(e.msg)}`;
+        case 'tool': return `${t} 🔧 ${from} ${e.tool} ${e.decision === 'deny' ? `DENIED (${e.reason})` : 'ok'}`;
+        case 'asset': return `${t} 📄 ${from} wrote ${e.path}`;
+        case 'usage': return `${t} 🪙 ${from} +${e.data?.tokens ?? 0} tokens`;
+        case 'audit': return `${t} ⚠️  ${from} ${e.msg ?? e.reason ?? ''}`;
+        case 'question': return `${t} ❓ ${from}: ${trim(e.msg)}`;
+        default: return `${t} ▪ ${from} ${e.type}: ${trim(e.msg ?? '')}`;
+    }
+}
+const trim = (s, n = 120) => !s ? '' : s.length > n ? `${s.slice(0, n - 1)}…` : s.replace(/\n/g, ' ');
+//# sourceMappingURL=reporting.js.map

package/packages/@monomind/cli/dist/src/orgrt/session.d.ts

@@ -13,6 +13,8 @@ export interface SessionOpts {
     cwd: string;
     deliver: DeliverFn;
     askHuman?: (role: string, question: string) => Promise<string>;
+    /** Coordinator-only: records the run's outcome (daemon persists it to run history). */
+    onComplete?: (role: string, outcome: 'achieved' | 'partial' | 'failed', summary: string) => void;
     def?: OrgDef;
     maxTurns?: number;
     queryFn?: typeof query;

package/packages/@monomind/cli/dist/src/orgrt/session.js

@@ -4,17 +4,20 @@ import { query, tool, createSdkMcpServer } from '@anthropic-ai/claude-agent-sdk'
 import { resolveProviderEnv } from './provider.js';
 /** Role briefing given to each agent session (SDK systemPrompt option). */
 export function buildRolePrompt(role, def, roster) {
+    const isCoordinator = role.reports_to == null;
     return [
         `You are agent "${role.id}" (${role.title || role.type}) in the org "${def.name}".`,
         `Org goal: ${def.goal}`,
-        role.reports_to ? `You report to "${role.reports_to}".` : `You are the coordinator of this org.`,
+        isCoordinator ? `You are the coordinator of this org.` : `You report to "${role.reports_to}".`,
         role.responsibilities?.length ? `Your responsibilities:\n- ${role.responsibilities.join('\n- ')}` : '',
         `## Communication protocol`,
         `The ONLY way to communicate with other agents is the org_send tool.`,
         `Roster: ${roster.join(', ')}. Address another org's agent as "<org-name>:<role-id>".`,
         `If you need a human decision, call ask_human with your question, then end your turn — you'll receive the human's answer as a new message when it arrives. Do not call ask_human for anything you can resolve yourself.`,
         `When you receive a message, act on it, then org_send your result to the requester.`,
-        `When your current work is complete and no reply is needed, end your turn without further tool calls.`,
+        isCoordinator
+            ? `When the org's goal for this run is achieved (or clearly can't be), call org_complete exactly once with the outcome and a concise summary of what was done — it is recorded in the org's run history and briefed to the next run. Then end your turn.`
+            : `When your current work is complete and no reply is needed, end your turn without further tool calls.`,
     ].filter(Boolean).join('\n\n');
 }
 /**
@@ -44,10 +47,15 @@ export async function runAgentSession(opts) {
 async function runOneSession(opts) {
     const { org, role, bus, policy, mailbox, cwd, deliver } = opts;
     const queryFn = opts.queryFn ?? query;
+    const isCoordinator = role.reports_to == null;
     const orgServer = createSdkMcpServer({
         name: 'org',
         version: '1.0.0',
         tools: [
+            ...(isCoordinator && opts.onComplete ? [tool('org_complete', 'Record the outcome of this run. Call exactly once, when the goal is achieved or clearly cannot be. The outcome and summary are persisted to the org run history and briefed to the next run.', { outcome: z.enum(['achieved', 'partial', 'failed']), summary: z.string() }, async (args) => {
+                    opts.onComplete(role.id, args.outcome, args.summary);
+                    return { content: [{ type: 'text', text: `outcome "${args.outcome}" recorded` }] };
+                })] : []),
             tool('org_send', 'Send a message to another agent (role id) or another org ("org:role"). This is the only inter-agent channel.', { to: z.string(), subject: z.string(), message: z.string() }, async (args) => {
                 const receipt = await deliver(role.id, args.to, args.subject, args.message);
                 return { content: [{ type: 'text', text: receipt }] };

package/packages/@monomind/cli/dist/src/orgrt/templates.d.ts

@@ -0,0 +1,16 @@
+import { type OrgDef } from './types.js';
+interface TemplateRole {
+    id: string;
+    title: string;
+    type: string;
+    reports_to: string | null;
+    responsibilities: string[];
+}
+interface Template {
+    goal: string;
+    roles: TemplateRole[];
+}
+export declare const ORG_TEMPLATES: Record<string, Template>;
+export declare function buildFromTemplate(templateName: string, orgName: string, goal?: string): OrgDef | null;
+export {};
+//# sourceMappingURL=templates.d.ts.map