monomind 2.0.3 → 2.1.3

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

@@ -1,22 +1,29 @@
 // packages/@monomind/cli/src/orgrt/daemon.ts
 // monolean: single-process inter-org — upgrade path = daemon-to-daemon HTTP when multi-host is real
-import { readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { readFileSync, mkdirSync, writeFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { OrgBus } from './bus.js';
 import { PolicyEngine } from './policy.js';
 import { Mailbox } from './mailbox.js';
 import { runAgentSession } from './session.js';
 import { attachForwarder } from './forwarder.js';
+import { BrokerLease, lookupOrg } from './broker.js';
+import { queueMessage, drainInbox } from './inbox.js';
 import { OrgDefSchema, ORG_DIR } from './types.js';
 export class OrgDaemon {
     root;
     opts;
     orgs = new Map();
+    waking = new Set();
     globalSubscribers = new Set();
+    leases = new Map();
+    forwarders = new Map();
     constructor(root, opts = {}) {
         this.root = root;
         this.opts = opts;
     }
+    /** Publish this daemon's inbox so orgs started AFTER this call register with the broker. */
+    setInboxUrl(url) { this.opts.inboxUrl = url; }
     /** subscribe to events from ALL running orgs (dashboard server uses this) */
     subscribe(fn) {
         this.globalSubscribers.add(fn);
@@ -29,66 +36,242 @@ export class OrgDaemon {
             throw new Error(`org ${name} already running`);
         const defPath = join(this.root, ORG_DIR, `${name}.json`);
         const def = OrgDefSchema.parse(JSON.parse(readFileSync(defPath, 'utf8')));
-        const run = `run-${new Date().toISOString().replace(/[-:T]/g, '').slice(0, 15)}`;
+        // random suffix: second-precision stamps collide across processes (two CLI
+        // invocations in the same second would share a run dir and its bus.jsonl)
+        const run = `run-${new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14)}-${Math.random().toString(36).slice(2, 6)}`;
         const dir = join(this.root, ORG_DIR, name, run);
         mkdirSync(dir, { recursive: true });
         const cwd = join(this.root, ORG_DIR, name, 'workspace');
         mkdirSync(cwd, { recursive: true });
         const bus = new OrgBus(name, run, dir);
+        // Bounded in-memory tail: bus.jsonl on disk is the full durable record;
+        // this buffer only backs busEvents() (test-loop, /api/history) and would
+        // otherwise grow without limit for a long-running scheduled org — each
+        // Write's captured content snapshot alone can be up to 200KB (policy.ts).
+        const MAX_COLLECTED = 5000;
         const collected = [];
-        bus.subscribe(e => { collected.push(e); for (const fn of this.globalSubscribers)
-            fn(e); });
+        bus.subscribe(e => {
+            collected.push(e);
+            if (collected.length > MAX_COLLECTED)
+                collected.splice(0, collected.length - MAX_COLLECTED);
+            for (const fn of this.globalSubscribers)
+                fn(e);
+        });
         if (this.opts.forward !== false)
-            attachForwarder(bus, this.opts.controlJson ?? join(this.root, '.monomind/control.json'));
+            this.forwarders.set(name, attachForwarder(bus, this.opts.controlJson ?? join(this.root, '.monomind/control.json')));
         const running = { def, run, bus, agents: new Map(), busEvents: () => [...collected] };
         this.orgs.set(name, running);
         const perRoleBudget = Math.floor((def.run_config.budget_tokens ?? 1_000_000) / def.roles.length);
         for (const role of def.roles) {
             const mailbox = new Mailbox();
             const policy = new PolicyEngine(role.id, { maxTokens: perRoleBudget, ...(role.policy ?? {}) }, bus, cwd);
-            const done = runAgentSession({
+            const runtime = { mailbox, policy, status: 'running', done: Promise.resolve() };
+            runtime.done = runAgentSession({
                 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),
                 queryFn: this.opts.queryFn,
-            }).catch(() => { });
-            running.agents.set(role.id, { mailbox, policy, done });
+            }).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 },
+                });
+            });
+            running.agents.set(role.id, runtime);
         }
         const boss = def.roles.find(r => r.type === 'boss' || r.reports_to === null) ?? def.roles[0];
         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.`);
         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) {
+            const lease = new BrokerLease(name, this.opts.inboxUrl, this.opts.brokerDir);
+            lease.start();
+            this.leases.set(name, lease);
+        }
+        // Drain any messages that arrived while the org was offline
+        const queued = drainInbox(this.root, name);
+        for (const msg of queued) {
+            const agent = running.agents.get(msg.toRole);
+            if (agent && !agent.mailbox.isClosed) {
+                bus.emit({ type: 'xorg', from: msg.fromQualified, to: `${name}:${msg.toRole}`, subject: msg.subject, msg: msg.body });
+                agent.mailbox.push(`[message from ${msg.fromQualified}] subject: ${msg.subject}\n\n${msg.body}`);
+            }
+        }
+        if (queued.length)
+            bus.emit({ type: 'status', msg: `drained ${queued.length} queued message(s) from inbox` });
         return running;
     }
+    /**
+     * Resolves an org_send `to` address ("role" for same-org, "org:role" for
+     * cross-org) into its parts. Centralizes the one addressing rule that
+     * matters (an "own-org:role" self-prefix is intra-org, not cross-org) so
+     * deliver()/deliverRemote() don't each re-derive it — the qualified `to`
+     * string returned is always the canonical display form for that address.
+     */
+    resolveAddress(fromOrg, to) {
+        const cross = to.includes(':');
+        if (!cross)
+            return { cross: false, orgName: fromOrg, role: to, qualified: to };
+        const [orgName, role] = to.split(':', 2);
+        if (orgName === fromOrg)
+            return { cross: false, orgName, role, qualified: role }; // self-prefixed — still intra-org
+        return { cross: true, orgName, role, qualified: to };
+    }
     /** Route a message. to = "role" (same org) or "org:role" (cross-org). Returns a receipt string. */
     async deliver(fromOrg, fromRole, to, subject, body) {
-        const cross = to.includes(':');
-        const [targetOrgName, targetRole] = cross ? to.split(':', 2) : [fromOrg, to];
+        const { cross, orgName: targetOrgName, role: targetRole, qualified: toQualified } = this.resolveAddress(fromOrg, to);
         const targetOrg = this.orgs.get(targetOrgName);
         const src = this.orgs.get(fromOrg);
         if (!targetOrg || !targetOrg.agents.has(targetRole)) {
-            src?.bus.emit({ type: 'audit', from: fromRole, to, msg: `undeliverable: ${subject}`, reason: 'unknown recipient' });
-            return `ERROR: unknown recipient "${to}" (known: ${[...(targetOrg?.agents.keys() ?? this.orgs.keys())].join(', ')})`;
+            if (cross && this.opts.crossProcess)
+                return this.deliverRemote(fromOrg, fromRole, targetOrgName, targetRole, toQualified, subject, body, src);
+            // Queue + auto-wake: if the org definition exists locally but isn't running, spool the message and start it
+            if (cross && this.hasOrgDef(targetOrgName)) {
+                queueMessage(this.root, targetOrgName, { fromQualified: `${fromOrg}:${fromRole}`, toRole: targetRole, subject, body, ts: Date.now() });
+                src?.bus.emit({ type: 'xorg', from: `${fromOrg}:${fromRole}`, to: toQualified, subject, msg: body, data: { queued: true } });
+                this.autoWake(targetOrgName);
+                return `queued for ${toQualified} (org starting)`;
+            }
+            src?.bus.emit({ type: 'audit', from: fromRole, to: toQualified, msg: `undeliverable: ${subject}`, reason: 'unknown recipient' });
+            return `ERROR: unknown recipient "${toQualified}" (known: ${[...(targetOrg?.agents.keys() ?? this.orgs.keys())].join(', ')})`;
         }
-        const evt = { from: cross ? `${fromOrg}:${fromRole}` : fromRole, to: cross ? to : targetRole, subject, msg: body };
+        const targetAgent = targetOrg.agents.get(targetRole);
+        if (targetAgent.mailbox.isClosed) {
+            // The org is mid-shutdown: mailboxes close before the org is removed
+            // from `this.orgs`, so a message can arrive in that window. push() would
+            // silently no-op — report the real outcome instead of a false "delivered".
+            src?.bus.emit({ type: 'audit', from: fromRole, to: toQualified, msg: `undeliverable: ${subject}`, reason: 'target mailbox closed (org shutting down)' });
+            return `ERROR: recipient "${toQualified}" is shutting down — message not delivered`;
+        }
+        const evt = { from: cross ? `${fromOrg}:${fromRole}` : fromRole, to: toQualified, subject, msg: body };
         src?.bus.emit({ type: cross ? 'xorg' : 'message', ...evt });
         if (cross && targetOrg !== src)
             targetOrg.bus.emit({ type: 'xorg', ...evt });
-        targetOrg.agents.get(targetRole).mailbox.push(`[message from ${evt.from}] subject: ${subject}\n\n${body}`);
-        return `delivered to ${to}`;
+        targetAgent.mailbox.push(`[message from ${evt.from}] subject: ${subject}\n\n${body}`);
+        return `delivered to ${toQualified}`;
+    }
+    /** Cross-process leg of deliver(): ask the machine-local broker who hosts targetOrgName, then POST over HTTP.
+     *  `to` here is always the fully-qualified "org:role" display form (resolveAddress already normalized it). */
+    async deliverRemote(fromOrg, fromRole, targetOrgName, targetRole, to, subject, body, src) {
+        const remote = lookupOrg(targetOrgName, this.opts.brokerDir);
+        if (!remote) {
+            // No remote host either — queue + auto-wake if the org def exists locally
+            if (this.hasOrgDef(targetOrgName)) {
+                queueMessage(this.root, targetOrgName, { fromQualified: `${fromOrg}:${fromRole}`, toRole: targetRole, subject, body, ts: Date.now() });
+                src?.bus.emit({ type: 'xorg', from: `${fromOrg}:${fromRole}`, to, subject, msg: body, data: { queued: true } });
+                this.autoWake(targetOrgName);
+                return `queued for ${to} (org starting)`;
+            }
+            src?.bus.emit({ type: 'audit', from: fromRole, to, msg: `undeliverable: ${subject}`, reason: 'unknown recipient' });
+            return `ERROR: unknown recipient "${to}" (no local org, and no process on this machine has org "${targetOrgName}" registered)`;
+        }
+        try {
+            const res = await fetch(`${remote.url}/api/xdeliver`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ fromOrg, fromRole, toOrg: targetOrgName, toRole: targetRole, subject, body }),
+                signal: AbortSignal.timeout(10_000),
+            });
+            const data = await res.json().catch(() => ({}));
+            if (res.ok && data.ok) {
+                src?.bus.emit({ type: 'xorg', from: `${fromOrg}:${fromRole}`, to, subject, msg: body });
+                return data.receipt ?? `delivered to ${to} (remote)`;
+            }
+            src?.bus.emit({ type: 'audit', from: fromRole, to, msg: `remote delivery rejected: ${data.error ?? res.status}`, reason: 'remote-delivery-rejected' });
+            return `ERROR: remote org "${to}" rejected delivery: ${data.error ?? res.status}`;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            src?.bus.emit({ type: 'audit', from: fromRole, to, msg: `remote delivery failed: ${message}`, reason: 'remote-delivery-failed' });
+            return `ERROR: remote org "${targetOrgName}" unreachable: ${message}`;
+        }
+    }
+    /** Inbound handler for cross-process delivery — called by the server's POST /api/xdeliver route
+     *  when ANOTHER process's deliverRemote() reaches this daemon. Pushes straight into the target
+     *  agent's mailbox; the agent picks it up on its own next turn (see Mailbox — never interrupts). */
+    receiveRemote(toOrg, toRole, fromQualified, subject, body) {
+        const org = this.orgs.get(toOrg);
+        if (!org) {
+            // Org not running — queue the message and auto-wake if the def exists
+            if (this.hasOrgDef(toOrg)) {
+                queueMessage(this.root, toOrg, { fromQualified, toRole, subject, body, ts: Date.now() });
+                this.autoWake(toOrg);
+                return { ok: true, receipt: `queued for ${toOrg}:${toRole} (org waking)` };
+            }
+            return { ok: false, error: `org "${toOrg}" not hosted here` };
+        }
+        const agent = org.agents.get(toRole);
+        if (!agent)
+            return { ok: false, error: `role "${toRole}" not found in org "${toOrg}"` };
+        if (agent.mailbox.isClosed)
+            return { ok: false, error: `role "${toRole}" in org "${toOrg}" is shutting down` };
+        org.bus.emit({ type: 'xorg', from: fromQualified, to: `${toOrg}:${toRole}`, subject, msg: body });
+        agent.mailbox.push(`[message from ${fromQualified}] subject: ${subject}\n\n${body}`);
+        return { ok: true, receipt: `delivered to ${toOrg}:${toRole} (remote)` };
+    }
+    hasOrgDef(name) {
+        return existsSync(join(this.root, ORG_DIR, `${name}.json`));
+    }
+    /** Start an offline org in the background so queued messages get drained.
+     *  Fire-and-forget — errors are logged but don't propagate to the sender. */
+    autoWake(name) {
+        if (this.orgs.has(name) || this.waking.has(name))
+            return;
+        this.waking.add(name);
+        this.startOrg(name)
+            .catch(err => { console.error(`auto-wake org "${name}" failed:`, err instanceof Error ? err.message : err); })
+            .finally(() => { this.waking.delete(name); });
     }
     async stopOrg(name) {
         const org = this.orgs.get(name);
         if (!org)
-            return;
+            return; // already stopped, or another concurrent stopOrg() call is handling it
+        // Remove immediately (not at the end) so a concurrent stopOrg(name) call —
+        // e.g. stopAll() racing a scheduler-triggered stop on SIGINT — sees the org
+        // is already gone and no-ops instead of re-running the whole shutdown and
+        // double-emitting 'org stopped' (duplicate org:complete/session:complete).
+        this.orgs.delete(name);
+        this.leases.get(name)?.stop();
+        this.leases.delete(name);
         for (const a of org.agents.values())
             a.mailbox.close();
-        await Promise.allSettled([...org.agents.values()].map(a => a.done));
+        // Bounded: a genuinely hung agent session (stuck mid-tool-call, not just
+        // idle) must not make stopOrg() hang forever — callers like the scheduler
+        // already race their own timeout around a run, and this wait re-blocking
+        // unboundedly on the same never-resolving promises defeated that bound.
+        const stopWaitMs = this.opts.stopWaitMs ?? 15_000;
+        const allDone = Promise.allSettled([...org.agents.values()].map(a => a.done)).then(() => false);
+        const timedOut = await Promise.race([allDone, new Promise(r => setTimeout(() => r(true), stopWaitMs))]);
+        if (timedOut) {
+            org.bus.emit({
+                type: 'audit', msg: `org stop timed out after ${stopWaitMs}ms waiting for agent sessions to finish — proceeding anyway`,
+                reason: 'stop-timeout',
+            });
+        }
         org.bus.emit({ type: 'status', msg: 'org stopped' });
         await org.bus.flush();
+        // 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,
+        // leaving the run stuck showing "running" forever.
+        const forwarder = this.forwarders.get(name);
+        if (forwarder) {
+            await forwarder.settle();
+            forwarder.unsubscribe();
+            this.forwarders.delete(name);
+        }
         this.persistState(name, 'stopped', org.run);
-        this.orgs.delete(name);
     }
     async stopAll() {
         await Promise.all([...this.orgs.keys()].map(n => this.stopOrg(n)));

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

@@ -1,11 +1,16 @@
 import type { OrgBus } from './bus.js';
-/**
- * Forwards every bus event to the running mastermind control server
- * (dist/src/ui/server.mjs, POST /api/mastermind/event) so the existing
- * dashboard SSE stream shows org activity. Best-effort: failures are dropped.
- */
+import type { BusEvent } from './types.js';
 export declare function attachForwarder(bus: OrgBus, controlJsonPath?: string): {
     settle: () => Promise<void>;
     unsubscribe: () => void;
 };
+/**
+ * Companion dashboard events a single bus event needs beyond its primary
+ * translate() mapping. Currently: org-started -> session:start (registers
+ * the run in the client's session list) and org-stopped -> session:complete.
+ * Exported for tests.
+ */
+export declare function companionEvents(e: BusEvent): Record<string, unknown>[];
+/** BusEvent → dashboard-native mastermind event. Exported for tests. */
+export declare function translate(e: BusEvent): Record<string, unknown>;
 //# sourceMappingURL=forwarder.d.ts.map

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

@@ -1,10 +1,43 @@
 // packages/@monomind/cli/src/orgrt/forwarder.ts
 import { readFileSync, existsSync } from 'node:fs';
+import { basename, extname, dirname, join } from 'node:path';
 /**
  * Forwards every bus event to the running mastermind control server
  * (dist/src/ui/server.mjs, POST /api/mastermind/event) so the existing
- * dashboard SSE stream shows org activity. Best-effort: failures are dropped.
+ * dashboard shows org activity. Best-effort: failures are dropped.
+ *
+ * Events are translated into the dashboard's native vocabulary
+ * (org:start / org:comms / org:agent:online|offline / org:artifact /
+ * org:checkpoint / org:complete) so the Orgs panel and Chat tab render
+ * them; every payload carries org + runId so the server routes it to the
+ * run file. Event kinds without a native rendering (tool/usage/audit) are
+ * forwarded as raw org:<type> — they still land in the run file and SSE.
+ *
+ * companionEvents() additionally emits session:start/session:complete: the
+ * dashboard's client-side Chat tab only lists a run in its session dropdown
+ * once it has seen a session:start for that session id — org:start alone is
+ * NOT enough (verified against dist/src/ui/orgs.html's handleMmEvent, which
+ * creates the chatSessions entry solely on session:start). Companions are
+ * sent before the primary translate() payload for the same bus event so the
+ * client-side session record exists before anything tries to append to it.
+ *
+ * sessionId() below joins org/run with "__", not ":" — server.mjs's
+ * per-session persistence (data/sessions/<id>.jsonl + _index.json, the store
+ * GET /api/mastermind/sessions reads on page load) validates the session id
+ * against /^(?!.*\.\.)[a-zA-Z0-9_][a-zA-Z0-9_.-]*$/, which rejects colons. A
+ * colon-joined id silently fails that check — the event still lands in the
+ * raw mastermind-events.jsonl log, but the run never persists to the session
+ * index, so a fresh dashboard load never lists it (only a client that was
+ * already connected via SSE when session:start fired would show it).
  */
+function sessionId(org, run) { return `${org}__${run}`; }
+function classifyStatus(msg) {
+    if (msg.startsWith('org started'))
+        return 'started';
+    if (msg === 'org stopped')
+        return 'stopped';
+    return 'other';
+}
 export function attachForwarder(bus, controlJsonPath = '.monomind/control.json') {
     let chain = Promise.resolve();
     const baseUrl = () => {
@@ -18,20 +51,117 @@ export function attachForwarder(bus, controlJsonPath = '.monomind/control.json')
             return null;
         }
     };
+    // dist/src/ui/server.mjs's startServer() writes a per-process auth credential
+    // to 'dashboard-token' next to control.json (same .monomind dir) and requires
+    // it via a header on every non-GET request. Read fresh each POST since the
+    // credential rotates whenever the server restarts.
+    const readAuthCredential = () => {
+        try {
+            return readFileSync(join(dirname(controlJsonPath), 'dashboard-token'), 'utf8').trim();
+        }
+        catch {
+            return null;
+        }
+    };
+    const post = async (url, payload) => {
+        const credential = readAuthCredential();
+        await fetch(`${url}/api/mastermind/event`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(credential ? { 'x-monomind-token': credential } : {}),
+            },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(3000),
+        }).then(r => { r.body?.cancel(); }).catch(() => { });
+    };
     const unsubscribe = bus.subscribe((e) => {
         chain = chain.then(async () => {
             const url = baseUrl();
             if (!url)
                 return;
-            const payload = { ...e, type: `org:${e.type}`, session: `${e.org}:${e.run}`, domain: 'ops' };
-            await fetch(`${url}/api/mastermind/event`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify(payload),
-                signal: AbortSignal.timeout(3000),
-            }).then(r => { r.body?.cancel(); }).catch(() => { });
+            for (const payload of companionEvents(e))
+                await post(url, payload);
+            await post(url, translate(e));
         }).catch(() => { });
     });
     return { settle: () => chain, unsubscribe };
 }
+const TEXTUAL_EXT = new Set(['.md', '.txt', '.json', '.ts', '.tsx', '.js', '.jsx', '.mjs',
+    '.py', '.sh', '.yaml', '.yml', '.html', '.css', '.xml', '.log', '.csv']);
+function guessMimeType(path) {
+    if (!path)
+        return 'application/octet-stream';
+    return TEXTUAL_EXT.has(extname(path).toLowerCase()) ? 'text/plain' : 'application/octet-stream';
+}
+/**
+ * Companion dashboard events a single bus event needs beyond its primary
+ * translate() mapping. Currently: org-started -> session:start (registers
+ * the run in the client's session list) and org-stopped -> session:complete.
+ * Exported for tests.
+ */
+export function companionEvents(e) {
+    if (e.type !== 'status')
+        return [];
+    const base = { session: sessionId(e.org, e.run), org: e.org, ts: e.ts };
+    const msg = e.msg ?? '';
+    const kind = classifyStatus(msg);
+    if (kind === 'started') {
+        const goal = e.data?.goal;
+        return [{ ...base, type: 'session:start', prompt: goal && goal.length ? goal : e.org }];
+    }
+    if (kind === 'stopped') {
+        return [{ ...base, type: 'session:complete', status: 'complete', domains: ['ops'] }];
+    }
+    return [];
+}
+/** BusEvent → dashboard-native mastermind event. Exported for tests. */
+export function translate(e) {
+    const base = {
+        org: e.org,
+        runId: e.run,
+        session: sessionId(e.org, e.run),
+        domain: 'ops',
+        ts: e.ts,
+    };
+    switch (e.type) {
+        case 'chat':
+            return { ...base, type: 'org:comms', from: e.from, to: 'all', msg: e.msg };
+        case 'message':
+        case 'xorg':
+            return {
+                ...base, type: 'org:comms', from: e.from, to: e.to,
+                msg: e.subject ? `[${e.subject}] ${e.msg ?? ''}` : e.msg,
+            };
+        case 'asset': {
+            // content (when PolicyEngine captured a Write snapshot) rides along so the
+            // dashboard can diff this exact version later instead of only ever seeing
+            // whatever is currently on disk at `path`.
+            const content = e.data?.content;
+            return {
+                ...base, type: 'org:artifact', from: e.from,
+                artifact: {
+                    label: basename(e.path ?? 'asset'), type: 'file', path: e.path, mimeType: guessMimeType(e.path),
+                    ...(content !== undefined ? { content } : {}),
+                },
+            };
+        }
+        case 'status': {
+            const msg = e.msg ?? '';
+            const kind = classifyStatus(msg);
+            if (kind === 'started')
+                return { ...base, type: 'org:start', goal: e.data?.goal ?? '' };
+            if (kind === 'stopped')
+                return { ...base, type: 'org:complete' };
+            if (msg === 'session starting')
+                return { ...base, type: 'org:agent:online', role: e.from, title: e.from, agent_type: e.from };
+            if (msg === 'session ended' || msg.startsWith('session error'))
+                return { ...base, type: 'org:agent:offline', from: e.from, reason: msg };
+            return { ...base, type: 'org:checkpoint', progress: msg, from: e.from };
+        }
+        default:
+            // tool / usage / audit — no native widget; keep raw for run file + SSE
+            return { ...e, ...base, type: `org:${e.type}` };
+    }
+}
 //# sourceMappingURL=forwarder.js.map

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

@@ -0,0 +1,11 @@
+export interface QueuedMessage {
+    fromQualified: string;
+    toRole: string;
+    subject: string;
+    body: string;
+    ts: number;
+}
+export declare function queueMessage(root: string, orgName: string, msg: QueuedMessage): void;
+export declare function drainInbox(root: string, orgName: string): QueuedMessage[];
+export declare function inboxCount(root: string, orgName: string): number;
+//# sourceMappingURL=inbox.d.ts.map

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

@@ -0,0 +1,56 @@
+// packages/@monomind/cli/src/orgrt/inbox.ts
+// Persistent message queue for offline orgs. Messages that can't be delivered
+// (target org not running) are spooled here and drained when the org starts.
+import { appendFileSync, readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { ORG_DIR } from './types.js';
+function inboxPath(root, orgName) {
+    return join(root, ORG_DIR, orgName, 'inbox.jsonl');
+}
+export function queueMessage(root, orgName, msg) {
+    const dir = join(root, ORG_DIR, orgName);
+    mkdirSync(dir, { recursive: true });
+    appendFileSync(inboxPath(root, orgName), JSON.stringify(msg) + '\n');
+}
+export function drainInbox(root, orgName) {
+    const path = inboxPath(root, orgName);
+    if (!existsSync(path))
+        return [];
+    // Rename-then-read: if the process crashes after rename but before we finish
+    // reading, the .draining file survives for manual recovery. A plain
+    // read-then-truncate would lose messages on a mid-drain crash.
+    const draining = `${path}.draining`;
+    try {
+        renameSync(path, draining);
+    }
+    catch {
+        return [];
+    }
+    const raw = readFileSync(draining, 'utf8').trim();
+    if (!raw) {
+        writeFileSync(draining, '');
+        renameSync(draining, path);
+        return [];
+    }
+    // Clear the draining file — messages are now the caller's responsibility
+    writeFileSync(draining, '');
+    renameSync(draining, path);
+    const msgs = [];
+    for (const line of raw.split('\n')) {
+        try {
+            msgs.push(JSON.parse(line));
+        }
+        catch { /* skip corrupt lines */ }
+    }
+    return msgs;
+}
+export function inboxCount(root, orgName) {
+    const path = inboxPath(root, orgName);
+    if (!existsSync(path))
+        return 0;
+    const raw = readFileSync(path, 'utf8').trim();
+    if (!raw)
+        return 0;
+    return raw.split('\n').length;
+}
+//# sourceMappingURL=inbox.js.map

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

@@ -7,7 +7,11 @@ export type Decision = {
     behavior: 'deny';
     message: string;
 };
-/** tiny glob→RegExp: supports ** (any depth) and * (single segment). */
+/**
+ * tiny glob→RegExp: `**\/` matches zero-or-more leading directories (so
+ * `**\/*.md` matches both `README.md` and `docs/README.md`, standard glob
+ * semantics), bare `**` matches any depth, `*` matches one path segment.
+ */
 export declare function globToRegExp(glob: string): RegExp;
 export declare class PolicyEngine {
     readonly role: string;

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

@@ -3,11 +3,44 @@ import { relative, resolve } from 'node:path';
 const WRITE_TOOLS = new Set(['Write', 'Edit', 'NotebookEdit']);
 const READ_TOOLS = new Set(['Read', 'Glob', 'Grep']);
 const WEB_TOOLS = new Set(['WebFetch', 'WebSearch']);
-/** tiny glob→RegExp: supports ** (any depth) and * (single segment). */
+/** Cap for inline content snapshots on 'asset' events (bytes, UTF-16 chars) — keeps
+ *  bus.jsonl / the dashboard's per-session event log from bloating on large writes. */
+const SNAPSHOT_MAX_CHARS = 200_000;
+const REGEX_METACHARS = new Set('.+^${}()|[]\\'.split(''));
+/**
+ * tiny glob→RegExp: `**\/` matches zero-or-more leading directories (so
+ * `**\/*.md` matches both `README.md` and `docs/README.md`, standard glob
+ * semantics), bare `**` matches any depth, `*` matches one path segment.
+ */
 export function globToRegExp(glob) {
-    const esc = glob.replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*\*/g, ' ').replace(/\*/g, '[^/]*').replace(/ /g, '.*');
-    return new RegExp(`^${esc}$`);
+    let out = '';
+    let i = 0;
+    while (i < glob.length) {
+        if (glob.startsWith('**/', i)) {
+            out += '(?:.*/)?';
+            i += 3;
+            continue;
+        }
+        if (glob.startsWith('**', i)) {
+            out += '.*';
+            i += 2;
+            continue;
+        }
+        const c = glob[i];
+        if (c === '*') {
+            out += '[^/]*';
+            i++;
+            continue;
+        }
+        if (REGEX_METACHARS.has(c)) {
+            out += '\\' + c;
+            i++;
+            continue;
+        }
+        out += c;
+        i++;
+    }
+    return new RegExp(`^${out}$`);
 }
 export class PolicyEngine {
     role;
@@ -34,7 +67,19 @@ export class PolicyEngine {
         const allow = () => {
             this.bus.emit({ type: 'tool', from: this.role, tool, decision: 'allow', data: { input: summarize(input) } });
             if (WRITE_TOOLS.has(tool) && typeof input.file_path === 'string') {
-                this.bus.emit({ type: 'asset', from: this.role, path: String(input.file_path) });
+                // Snapshot the full resulting content when we actually have it at decide()
+                // time. Write's `content` param IS the complete post-write file — capture
+                // it inline on the event so the dashboard can diff this version against a
+                // later one without re-reading disk (which only ever holds the CURRENT
+                // version). Edit only carries old_string/new_string fragments, not the
+                // resulting whole file, so there is nothing accurate to snapshot there —
+                // the event still records the write (path, from), just without content.
+                const content = tool === 'Write' && typeof input.content === 'string'
+                    && input.content.length <= SNAPSHOT_MAX_CHARS ? input.content : undefined;
+                this.bus.emit({
+                    type: 'asset', from: this.role, path: String(input.file_path),
+                    ...(content !== undefined ? { data: { content } } : {}),
+                });
             }
             return { behavior: 'allow', updatedInput: input };
         };
@@ -46,8 +91,16 @@ export class PolicyEngine {
             return deny(`tool ${tool} not in allowlist for role ${this.role}`);
         if (WRITE_TOOLS.has(tool) || READ_TOOLS.has(tool)) {
             const globs = WRITE_TOOLS.has(tool) ? (this.policy.fileWrite ?? ['**']) : (this.policy.fileRead ?? ['**']);
+            const unrestricted = globs.length === 1 && globs[0] === '**';
             const p = typeof input.file_path === 'string' ? input.file_path
                 : typeof input.path === 'string' ? input.path : null;
+            if (p === null && !unrestricted) {
+                // Grep/Glob's `path` argument is optional in the SDK (defaults to cwd,
+                // i.e. searches everything) — without this check, a path-less call
+                // sailed straight through to allow() and bypassed fileRead/fileWrite
+                // scoping entirely. Deny rather than guess which files it would touch.
+                return deny(`${tool} has no path argument, but role ${this.role}'s ${WRITE_TOOLS.has(tool) ? 'write' : 'read'} scope is restricted — refusing an unscoped call`);
+            }
             if (p !== null) {
                 const rel = relative(this.cwd, resolve(this.cwd, p));
                 if (rel.startsWith('..'))