monomind 2.2.0 → 2.3.1

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

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

@@ -0,0 +1,57 @@
+// packages/@monomind/cli/src/orgrt/templates.ts
+// Starter org configs for `monomind org create <name> --template <t>`.
+// Each validates against OrgDefSchema; goal is a placeholder the user edits
+// (or supplies via --goal).
+import { OrgDefSchema } from './types.js';
+export const ORG_TEMPLATES = {
+    'content-team': {
+        goal: 'Produce and publish high-quality content on a steady cadence',
+        roles: [
+            { id: 'editor-in-chief', title: 'Editor in Chief', type: 'boss', reports_to: null,
+                responsibilities: ['Own the content calendar and quality bar', 'Assign pieces to the writer and route drafts to review', 'Approve final drafts for publishing'] },
+            { id: 'writer', title: 'Staff Writer', type: 'specialist', reports_to: 'editor-in-chief',
+                responsibilities: ['Draft articles from assigned briefs', 'Incorporate review feedback', 'Hand finished drafts to the reviewer'] },
+            { id: 'reviewer', title: 'Content Reviewer', type: 'reviewer', reports_to: 'editor-in-chief',
+                responsibilities: ['Review drafts for accuracy, clarity, and tone', 'Return actionable feedback to the writer', 'Flag anything needing human judgment via ask_human'] },
+        ],
+    },
+    'dev-team': {
+        goal: 'Deliver features and fixes from a continuously groomed backlog',
+        roles: [
+            { id: 'tech-lead', title: 'Tech Lead', type: 'boss', reports_to: null,
+                responsibilities: ['Break the goal into concrete tasks and assign them', 'Arbitrate design questions', 'Merge only work that passed review and tests'] },
+            { id: 'developer', title: 'Developer', type: 'specialist', reports_to: 'tech-lead',
+                responsibilities: ['Implement assigned tasks with tests', 'Keep changes small and focused', 'Send diffs to the reviewer before reporting done'] },
+            { id: 'code-reviewer', title: 'Code Reviewer', type: 'reviewer', reports_to: 'tech-lead',
+                responsibilities: ['Review diffs for correctness and maintainability', 'Verify claimed test results', 'Reject unverified work'] },
+            { id: 'qa', title: 'QA Engineer', type: 'specialist', reports_to: 'tech-lead',
+                responsibilities: ['Exercise delivered features end-to-end', 'File precise reproduction steps for defects'] },
+        ],
+    },
+    'research-pod': {
+        goal: 'Produce a recurring intelligence brief on a defined topic',
+        roles: [
+            { id: 'lead-analyst', title: 'Lead Analyst', type: 'boss', reports_to: null,
+                responsibilities: ['Define research questions for each cycle', 'Synthesize findings into the final brief', 'Decide what merits deeper follow-up'] },
+            { id: 'researcher', title: 'Researcher', type: 'researcher', reports_to: 'lead-analyst',
+                responsibilities: ['Gather primary sources on assigned questions', 'Separate observed facts from inference', 'Deliver structured findings with citations'] },
+            { id: 'fact-checker', title: 'Fact Checker', type: 'reviewer', reports_to: 'lead-analyst',
+                responsibilities: ['Verify claims in draft briefs against sources', 'Flag unverifiable claims for removal or hedging'] },
+        ],
+    },
+};
+export function buildFromTemplate(templateName, orgName, goal) {
+    const t = ORG_TEMPLATES[templateName];
+    if (!t)
+        return null;
+    // Parse through the schema so a template can never produce an unrunnable config.
+    return OrgDefSchema.parse({
+        name: orgName,
+        goal: goal ?? t.goal,
+        status: 'stopped',
+        schedule: null,
+        run_config: { max_concurrent_agents: 4, budget_tokens: 1_000_000, memory_namespace: `org:${orgName}`, max_turns_per_message: 30 },
+        roles: t.roles,
+    });
+}
+//# sourceMappingURL=templates.js.map

package/packages/@monomind/cli/dist/src/services/config-file-manager.js

@@ -194,7 +194,16 @@ export class ConfigFileManager {
                 const parsed = JSON.parse(fs.readFileSync(targetPath, 'utf-8'));
                 onDisk = sanitizeConfigObject(parsed);
             }
-            catch { /* fall through to defaults */ }
+            catch (e) {
+                // The file exists but failed to parse — do NOT fall through to
+                // cloneDefaultConfig() and write that back. This config can hold
+                // provider API keys (see this method's doc comment above); silently
+                // "recovering" a momentarily-corrupt file by overwriting it with
+                // defaults-plus-the-new-key discards every real credential in it.
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[config-file-manager] failed to parse existing config file:', e);
+                throw new Error(`Config file exists but is unreadable/corrupt: ${targetPath}. Refusing to overwrite it — fix or remove the file manually, then retry.`);
+            }
         }
         setNestedValue(onDisk, key, sanitisedValue);
         this.writeAtomic(targetPath, onDisk);

package/packages/@monomind/cli/dist/src/transfer/storage/gcs.js

@@ -257,7 +257,9 @@ export async function listGCSObjects(prefix, config) {
             updated: obj.updated || new Date().toISOString(),
         }));
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[GCS] listGCSObjects failed:', e);
         return [];
     }
 }
@@ -275,7 +277,9 @@ export async function deleteFromGCS(uri, config) {
         execFileSync('gcloud', rmArgs, { encoding: 'utf-8', stdio: 'pipe' });
         return true;
     }
-    catch {
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[GCS] deleteFromGCS failed:', e);
         return false;
     }
 }

package/packages/@monomind/cli/dist/src/ui/orgs.html

@@ -975,6 +975,7 @@ html, body {
           <div id="health-pane">
             <div id="health-grid" class="health-grid"></div>
             <div id="health-detail"></div>
+            <div id="health-history"></div>
           </div>
         </div>
 
@@ -1759,6 +1760,37 @@ function renderHealth() {
         HEALTH DATA UNAVAILABLE
       </div>`;
   }
+
+  loadRunHistory();
+}
+
+// Run history (history.jsonl, written by the daemon at each stopOrg): outcome,
+// duration, tokens per completed run — rendered under the health grid.
+async function loadRunHistory() {
+  const el = document.getElementById('health-history');
+  if (!el || !selectedOrg) return;
+  try {
+    const listOrg = allOrgs.find(o => o.name === selectedOrg) || {};
+    const r = await fetch(`/api/orgs/${encodeURIComponent(selectedOrg)}/history?dir=${encodeURIComponent(listOrg.projectDir || '')}`);
+    if (!r.ok) { el.innerHTML = ''; return; }
+    const runs = (await r.json()).runs || [];
+    if (!runs.length) { el.innerHTML = ''; return; }
+    const outcomeColor = s => s === 'achieved' ? 'var(--teal)' : s === 'partial' ? 'var(--amber, #d90)' : 'var(--red)';
+    el.innerHTML = `
+      <div style="margin-top:16px">
+        <div style="font-size:8px;letter-spacing:2px;color:var(--dim);margin-bottom:8px">RUN HISTORY (${runs.length})</div>
+        ${runs.slice(0, 10).map(h => `
+          <div style="font-size:9px;padding:5px 0;border-bottom:1px solid oklch(50% 0 0 / 0.1);display:flex;gap:10px;align-items:baseline">
+            <span style="color:var(--dim);white-space:nowrap">${esc(h.run || '?')}</span>
+            <span style="color:var(--muted);white-space:nowrap">${h.durationMs != null ? Math.round(h.durationMs / 1000) + 's' : '—'} · ${h.totalTokens || 0} tok</span>
+            ${h.outcome
+              ? `<span style="color:${outcomeColor(h.outcome.status)}">${esc(h.outcome.status.toUpperCase())}</span>
+                 <span style="color:var(--muted);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${esc(h.outcome.summary || '')}</span>`
+              : `<span style="color:var(--dim)">NO OUTCOME</span>`}
+            ${h.crashes && h.crashes.length ? `<span style="color:var(--red)">✗ ${h.crashes.length} crash</span>` : ''}
+          </div>`).join('')}
+      </div>`;
+  } catch (_) { el.innerHTML = ''; }
 }
 
 // ── CHAT TAB ──────────────────────────────────────────────────────

package/packages/@monomind/cli/dist/src/ui/server.mjs

@@ -5863,6 +5863,31 @@ new Sigma(g,document.getElementById('g'),{renderEdgeLabels:false,labelColor:{col
       return;
     }
 
+    // GET /api/orgs/:name/history — per-run outcome summaries (history.jsonl, newest first)
+    if (req.method === 'GET' && /^\/api\/orgs\/[^/]+\/history$/.test(url)) {
+      try {
+        const orgName = decodeURIComponent(url.split('/')[3]);
+        const _histQs = new URL(req.url, 'http://localhost').searchParams;
+        const root = path.resolve(_histQs.get('dir') || projectDir || process.cwd());
+        if (!orgName || orgName.length > 64 || !/^[a-z0-9][a-z0-9_-]*$/i.test(orgName)) {
+          res.writeHead(400); res.end('{"error":"invalid org name"}'); return;
+        }
+        const monoDir = _getGitMonomindDir(root) || path.join(root, '.monomind');
+        const histFile = path.join(monoDir, 'orgs', orgName, 'history.jsonl');
+        let runs = [];
+        if (fs.existsSync(histFile)) {
+          runs = fs.readFileSync(histFile, 'utf8').split('\n').filter(l => l.trim())
+            .map(l => { try { return JSON.parse(l); } catch(_) { return null; } })
+            .filter(Boolean).reverse().slice(0, 50);
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
+        res.end(JSON.stringify({ runs }));
+      } catch(err) {
+        res.writeHead(500); res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
     // GET /api/mastermind/metrics — aggregate system metrics from token-summary and swarm-activity
     if (req.method === 'GET' && url === '/api/mastermind/metrics') {
       try {

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

@@ -68,8 +68,10 @@ export function loadHistory() {
             });
         }
     }
-    catch {
+    catch (e) {
         // Corrupted file
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[update-executor] loadHistory failed:', e);
     }
     return [];
 }

package/packages/@monomind/cli/dist/src/update/rate-limiter.js

@@ -70,8 +70,10 @@ export function loadState() {
             return state;
         }
     }
-    catch {
+    catch (e) {
         // Corrupted file, reset
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[rate-limiter] update-state.json read/parse failed:', e);
     }
     return getDefaultState();
 }

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "type": "module",
   "description": "CLI engine for Monomind — an open-source MCP server that extends Claude Code with a codebase knowledge graph (tree-sitter + SQLite), persistent memory, multi-agent task coordination, and session hooks. MIT licensed, fully local.",
   "main": "dist/src/index.js",
@@ -105,7 +105,7 @@
   },
   "optionalDependencies": {
     "@huggingface/transformers": "^3.8.1",
-    "@monoes/memory": "^1.0.5",
+    "@monoes/memory": "^1.0.6",
     "@monomind/hooks": "*",
     "@monomind/mcp": "*",
     "@monomind/routing": "*",
@@ -119,4 +119,4 @@
   "overrides": {
     "onnxruntime-node": ">=1.27.0"
   }
-}
+}