monomind 2.2.0 → 2.3.0

package/packages/@monomind/cli/dist/src/mcp-tools/task-tools.d.ts

@@ -4,5 +4,25 @@
  * Tool definitions for task management with file persistence.
  */
 import { type MCPTool } from './types.js';
+interface TaskRecord {
+    taskId: string;
+    type: string;
+    description: string;
+    priority: 'low' | 'normal' | 'high' | 'critical';
+    status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+    progress: number;
+    assignedTo: string[];
+    tags: string[];
+    createdAt: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    result?: Record<string, unknown>;
+}
+interface TaskStore {
+    tasks: Record<string, TaskRecord>;
+    version: string;
+}
+export declare function loadTaskStore(): TaskStore;
 export declare const taskTools: MCPTool[];
+export {};
 //# sourceMappingURL=task-tools.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/task-tools.js

@@ -23,7 +23,7 @@ function ensureTaskDir() {
     }
 }
 const MAX_TASK_STORE_BYTES = 50 * 1024 * 1024;
-function loadTaskStore() {
+export function loadTaskStore() {
     try {
         const path = getTaskPath();
         if (existsSync(path)) {
@@ -36,8 +36,9 @@ function loadTaskStore() {
             return parsed;
         }
     }
-    catch {
-        // Return empty store on error
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[loadTaskStore] failed to read/parse task store:', e);
     }
     return { tasks: {}, version: '3.0.0' };
 }
@@ -273,8 +274,9 @@ export const taskTools = [
                         writeFileSync(tmpAgent1, JSON.stringify(agentStore, null, 2), 'utf-8');
                         renameSync(tmpAgent1, agentStorePath);
                     }
-                    catch {
-                        // Best-effort agent sync
+                    catch (e) {
+                        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                            console.error('[task_complete] agent store sync failed:', e);
                     }
                 }
                 return {
@@ -372,15 +374,30 @@ export const taskTools = [
                 return { taskId, error: 'Task not found' };
             }
             const previouslyAssigned = [...task.assignedTo];
-            // Load agent store to sync worker state
+            // Load agent store to sync worker state. Distinguish "file doesn't
+            // exist yet" (safe to proceed with an empty store) from "file exists
+            // but failed to read/parse" (a real store that's momentarily corrupt
+            // or oversized) — the latter must NOT fall through to the unconditional
+            // write-back below, or a transient read failure silently wipes out
+            // every agent's real on-disk state.
             const agentStorePath = join(getMonomindDataRoot(), 'agents', 'store.json');
             let agentStore = { agents: {} };
+            let agentStoreReadFailed = false;
             try {
-                if (existsSync(agentStorePath) && statSync(agentStorePath).size <= MAX_TASK_STORE_BYTES) {
-                    agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
+                if (existsSync(agentStorePath)) {
+                    if (statSync(agentStorePath).size <= MAX_TASK_STORE_BYTES) {
+                        agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
+                    }
+                    else {
+                        agentStoreReadFailed = true;
+                    }
                 }
             }
-            catch { /* ignore */ }
+            catch (e) {
+                agentStoreReadFailed = true;
+                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                    console.error('[task_assign] failed to read agent store — skipping agent-store sync to avoid overwriting it with an empty one:', e);
+            }
             // Reject IDs that would mutate Object.prototype when used as a key in
             // the JSON-loaded plain object `agentStore.agents`.
             const FORBIDDEN_AGENT_IDS = new Set(['__proto__', 'constructor', 'prototype']);
@@ -422,19 +439,24 @@ export const taskTools = [
                 }
             }
             saveTaskStore(store);
-            // Save agent store
-            const agentDir = join(getMonomindDataRoot(), 'agents');
-            if (!existsSync(agentDir)) {
-                mkdirSync(agentDir, { recursive: true });
+            // Save agent store — skipped when the read above failed, so a
+            // transient corrupt/oversized store.json is left alone instead of
+            // being overwritten with an empty one.
+            if (!agentStoreReadFailed) {
+                const agentDir = join(getMonomindDataRoot(), 'agents');
+                if (!existsSync(agentDir)) {
+                    mkdirSync(agentDir, { recursive: true });
+                }
+                const tmpAgent2 = `${agentStorePath}.${process.pid}.${Date.now()}.tmp`;
+                writeFileSync(tmpAgent2, JSON.stringify(agentStore, null, 2), 'utf-8');
+                renameSync(tmpAgent2, agentStorePath);
             }
-            const tmpAgent2 = `${agentStorePath}.${process.pid}.${Date.now()}.tmp`;
-            writeFileSync(tmpAgent2, JSON.stringify(agentStore, null, 2), 'utf-8');
-            renameSync(tmpAgent2, agentStorePath);
             return {
                 taskId: task.taskId,
                 assignedTo: task.assignedTo,
                 previouslyAssigned,
                 status: task.status,
+                ...(agentStoreReadFailed ? { agentStoreSyncSkipped: true } : {}),
             };
         },
     },

package/packages/@monomind/cli/dist/src/mcp-tools/terminal-tools.d.ts

@@ -4,5 +4,7 @@
  * Terminal session management with real command execution.
  */
 import type { MCPTool } from './types.js';
+/** Returns a copy of `env` with secret-shaped variable names removed. */
+export declare function filterSecretEnvVars(env: NodeJS.ProcessEnv): Record<string, string>;
 export declare const terminalTools: MCPTool[];
 //# sourceMappingURL=terminal-tools.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/terminal-tools.js

@@ -1,9 +1,10 @@
 import { getProjectCwd } from './types.js';
-import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
+import { writeJsonFileAtomic } from '../utils/json-file.js';
 // Storage paths
 const STORAGE_DIR = '.monomind';
 const TERMINAL_DIR = 'terminals';
@@ -24,7 +25,7 @@ const TERMINAL_FILE = 'store.json';
 // is layered on *after* the filtered process.env below).
 const SECRET_ENV_NAME_PATTERN = /(KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|_AUTH$|^AUTH_|PRIVATE_KEY|ACCESS_KEY)/i;
 /** Returns a copy of `env` with secret-shaped variable names removed. */
-function filterSecretEnvVars(env) {
+export function filterSecretEnvVars(env) {
     const filtered = {};
     for (const [k, v] of Object.entries(env)) {
         if (v === undefined)
@@ -41,32 +42,39 @@ function getTerminalDir() {
 function getTerminalPath() {
     return join(getTerminalDir(), TERMINAL_FILE);
 }
-function ensureTerminalDir() {
-    const dir = getTerminalDir();
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-}
 const MAX_TERMINAL_STORE_BYTES = 10 * 1024 * 1024; // 10 MB
-function loadTerminalStore() {
+// Same hardened-loader convention as agent-tools.ts's loadAgentStoreOrNull:
+// handlers that mutate and save must use the null-aware variant, since
+// treating a corrupt/oversized store as empty and then saving that back
+// would silently wipe every real session. Also guards against a __proto__
+// key in the parsed JSON (agent-tools.ts's loader does the same). Can't
+// delegate to utils/json-file.ts's readJsonFileSync here — it collapses
+// "file absent" and "file corrupt" into the same fallback value, but this
+// loader must tell them apart (absent → empty default is safe to build on
+// and save; corrupt → null, refuse to save over it).
+function loadTerminalStoreOrNull() {
     try {
         const path = getTerminalPath();
-        if (existsSync(path) && statSync(path).size <= MAX_TERMINAL_STORE_BYTES) {
-            return JSON.parse(readFileSync(path, 'utf-8'));
-        }
+        if (!existsSync(path))
+            return { sessions: {}, version: '3.0.0' };
+        if (statSync(path).size > MAX_TERMINAL_STORE_BYTES)
+            return null;
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        if (parsed && typeof parsed === 'object' && Object.prototype.hasOwnProperty.call(parsed, '__proto__'))
+            return null;
+        return parsed;
     }
-    catch {
-        // Return empty store
+    catch (e) {
+        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+            console.error('[loadTerminalStore] terminal store unreadable/corrupt:', e);
+        return null;
     }
-    return { sessions: {}, version: '3.0.0' };
+}
+function loadTerminalStore() {
+    return loadTerminalStoreOrNull() ?? { sessions: {}, version: '3.0.0' };
 }
 function saveTerminalStore(store) {
-    ensureTerminalDir();
-    // Unique tmp filename so concurrent handler invocations cannot clobber each
-    // other's .tmp mid-write (which would produce a partial JSON on rename).
-    const tmpPath = `${getTerminalPath()}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(tmpPath, JSON.stringify(store, null, 2), 'utf-8');
-    renameSync(tmpPath, getTerminalPath());
+    writeJsonFileAtomic(getTerminalPath(), store);
 }
 export const terminalTools = [
     {
@@ -82,7 +90,10 @@ export const terminalTools = [
             },
         },
         handler: async (input) => {
-            const store = loadTerminalStore();
+            const store = loadTerminalStoreOrNull();
+            if (!store) {
+                return { success: false, error: 'Terminal store is unreadable/corrupt — refusing to create a session to avoid overwriting real session data.' };
+            }
             const MAX_SESSIONS = 1000;
             if (Object.keys(store.sessions).length >= MAX_SESSIONS) {
                 return { success: false, error: 'Session limit reached' };
@@ -167,7 +178,10 @@ export const terminalTools = [
             required: ['command'],
         },
         handler: async (input) => {
-            const store = loadTerminalStore();
+            const store = loadTerminalStoreOrNull();
+            if (!store) {
+                return { success: false, error: 'Terminal store is unreadable/corrupt — refusing to execute to avoid overwriting real session data.' };
+            }
             const sessionId = input.sessionId;
             // Cap command: the metacharacter regex check at line 220 is O(n), and the
             // raw command is stored verbatim in session history (up to 200 entries).
@@ -313,7 +327,10 @@ export const terminalTools = [
             required: ['sessionId'],
         },
         handler: async (input) => {
-            const store = loadTerminalStore();
+            const store = loadTerminalStoreOrNull();
+            if (!store) {
+                return { success: false, error: 'Terminal store is unreadable/corrupt — refusing to close a session to avoid overwriting real session data.' };
+            }
             const sessionId = input.sessionId;
             const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
             if (!sessionId || FORBIDDEN_KEYS.has(sessionId)) {

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

@@ -70,8 +70,10 @@ export class EWCConsolidator {
             this.initialized = true;
             return true;
         }
-        catch {
+        catch (e) {
             // Start fresh if no persisted state
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[ewc-consolidation] failed to load persisted state, starting fresh:', e);
             this.initialized = true;
             return true;
         }
@@ -544,8 +546,10 @@ export class EWCConsolidator {
             fs.writeFileSync(tmp, JSON.stringify(state, null, 2));
             fs.renameSync(tmp, this.config.storagePath);
         }
-        catch {
+        catch (e) {
             // Silently fail - persistence is best-effort
+            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
+                console.error('[ewc-consolidation] failed to persist state:', e);
         }
     }
     /**

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,