monomind 2.1.0 → 2.1.3

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

@@ -1,6 +1,6 @@
 // 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';
@@ -8,11 +8,13 @@ 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();
@@ -42,9 +44,19 @@ export class OrgDaemon {
         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)
             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] };
@@ -87,36 +99,80 @@ export class OrgDaemon {
             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) {
-        let cross = to.includes(':');
-        let [targetOrgName, targetRole] = cross ? to.split(':', 2) : [fromOrg, to];
-        // "own-org:role" is intra-org — agents often self-prefix; don't tag it xorg
-        if (cross && targetOrgName === fromOrg) {
-            cross = false;
-            to = targetRole;
-        }
+        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)) {
             if (cross && this.opts.crossProcess)
-                return this.deliverRemote(fromOrg, fromRole, targetOrgName, targetRole, to, subject, body, src);
-            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(', ')})`;
+                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 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: cross ? to : targetRole, subject, msg: body };
+        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. */
+    /** 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)`;
         }
@@ -146,24 +202,63 @@ export class OrgDaemon {
      *  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)
+        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 /
@@ -177,7 +272,6 @@ export class OrgDaemon {
             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.js

@@ -1,6 +1,6 @@
 // packages/@monomind/cli/src/orgrt/forwarder.ts
 import { readFileSync, existsSync } from 'node:fs';
-import { basename, extname } from 'node:path';
+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
@@ -31,6 +31,13 @@ import { basename, extname } from 'node:path';
  * 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 = () => {
@@ -44,10 +51,26 @@ 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' },
+            headers: {
+                'Content-Type': 'application/json',
+                ...(credential ? { 'x-monomind-token': credential } : {}),
+            },
             body: JSON.stringify(payload),
             signal: AbortSignal.timeout(3000),
         }).then(r => { r.body?.cancel(); }).catch(() => { });
@@ -82,11 +105,12 @@ export function companionEvents(e) {
         return [];
     const base = { session: sessionId(e.org, e.run), org: e.org, ts: e.ts };
     const msg = e.msg ?? '';
-    if (msg.startsWith('org started')) {
+    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 (msg === 'org stopped') {
+    if (kind === 'stopped') {
         return [{ ...base, type: 'session:complete', status: 'complete', domains: ['ops'] }];
     }
     return [];
@@ -109,16 +133,25 @@ export function translate(e) {
                 ...base, type: 'org:comms', from: e.from, to: e.to,
                 msg: e.subject ? `[${e.subject}] ${e.msg ?? ''}` : e.msg,
             };
-        case 'asset':
+        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) },
+                artifact: {
+                    label: basename(e.path ?? 'asset'), type: 'file', path: e.path, mimeType: guessMimeType(e.path),
+                    ...(content !== undefined ? { content } : {}),
+                },
             };
+        }
         case 'status': {
             const msg = e.msg ?? '';
-            if (msg.startsWith('org started'))
+            const kind = classifyStatus(msg);
+            if (kind === 'started')
                 return { ...base, type: 'org:start', goal: e.data?.goal ?? '' };
-            if (msg === 'org stopped')
+            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 };

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('..'))

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

@@ -3,6 +3,7 @@ export interface OrgServer {
     port: number;
     close: () => void;
 }
-/** Daemon-owned live view: WS fanout of every bus event + tiny REST surface. */
-export declare function startOrgServer(daemon: OrgDaemon, port: number): Promise<OrgServer>;
+/** Minimal HTTP listener for cross-process org message delivery.
+ *  Binds an ephemeral port (pass 0) so the daemon can register it with the broker. */
+export declare function startOrgServer(daemon: OrgDaemon, port?: number): Promise<OrgServer>;
 //# sourceMappingURL=server.d.ts.map

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

@@ -1,38 +1,12 @@
 // packages/@monomind/cli/src/orgrt/server.ts
+// monolean: stripped to xdeliver-only — live UI, WS fanout, and redundant REST
+// endpoints deleted; the control server at :4242 handles all of those.
 import http from 'node:http';
-import { readFileSync, existsSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { WebSocketServer, WebSocket } from 'ws';
-/** Daemon-owned live view: WS fanout of every bus event + tiny REST surface. */
-export async function startOrgServer(daemon, port) {
-    const here = dirname(fileURLToPath(import.meta.url));
-    const htmlPath = ['live.html', '../orgrt/live.html']
-        .map(p => join(here, p)).find(existsSync) ?? join(here, 'live.html');
+/** Minimal HTTP listener for cross-process org message delivery.
+ *  Binds an ephemeral port (pass 0) so the daemon can register it with the broker. */
+export async function startOrgServer(daemon, port = 0) {
     const server = http.createServer((req, res) => {
-        const url = req.url ?? '/';
-        if (req.method === 'GET' && url === '/') {
-            res.writeHead(200, { 'Content-Type': 'text/html' });
-            res.end(readFileSync(htmlPath, 'utf8'));
-        }
-        else if (req.method === 'GET' && url === '/api/orgs') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(daemon.listOrgs().map(o => ({
-                name: o.def.name, run: o.run, goal: o.def.goal,
-                agents: [...o.agents.entries()].map(([id, a]) => ({
-                    id, usage: a.policy.usage, closed: a.mailbox.isClosed,
-                    status: a.status, error: a.error,
-                })),
-            }))));
-        }
-        else if (req.method === 'GET' && url.startsWith('/api/history/')) {
-            const name = decodeURIComponent(url.slice('/api/history/'.length));
-            const org = daemon.getOrg(name);
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(org ? org.busEvents() : []));
-        }
-        else if (req.method === 'POST' && url === '/api/xdeliver') {
-            // inbound cross-process delivery — see OrgDaemon.deliverRemote() on the sending side
+        if (req.method === 'POST' && req.url === '/api/xdeliver') {
             let body = '';
             req.on('data', c => { body += c; });
             req.on('end', () => {
@@ -58,15 +32,8 @@ export async function startOrgServer(daemon, port) {
             res.end('not found');
         }
     });
-    const wss = new WebSocketServer({ server, path: '/ws' });
-    const unsubscribe = daemon.subscribe(e => {
-        const line = JSON.stringify(e);
-        for (const c of wss.clients)
-            if (c.readyState === WebSocket.OPEN)
-                c.send(line);
-    });
     await new Promise(r => server.listen(port, r));
     const actual = server.address().port;
-    return { port: actual, close: () => { unsubscribe(); wss.close(); server.close(); } };
+    return { port: actual, close: () => { server.close(); } };
 }
 //# sourceMappingURL=server.js.map

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

@@ -18,6 +18,15 @@ export interface SessionOpts {
 }
 /** Role briefing given to each agent session (SDK systemPrompt option). */
 export declare function buildRolePrompt(role: OrgRole, def: Pick<OrgDef, 'name' | 'goal'>, roster: string[]): string;
-/** Runs one persistent agent session; resolves when the mailbox closes and the SDK stream ends. */
+/**
+ * Runs a role for the life of the org, transparently restarting the
+ * underlying SDK session whenever it ends on its own (`maxTurns` reached)
+ * while the mailbox is still open. `maxTurns` bounds a single SDK query()
+ * call's TOTAL turns, not "turns per incoming message" — since one query()
+ * call stays open across every mailbox message for as long as the mailbox
+ * itself stays open, without a restart the role would go permanently silent
+ * (no crash, no alert) once its lifetime turn count crossed the limit, while
+ * deliver() kept queuing new messages into a mailbox nobody was reading.
+ */
 export declare function runAgentSession(opts: SessionOpts): Promise<void>;
 //# sourceMappingURL=session.d.ts.map

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

@@ -16,8 +16,31 @@ export function buildRolePrompt(role, def, roster) {
         `When your current work is complete and no reply is needed, end your turn without further tool calls.`,
     ].filter(Boolean).join('\n\n');
 }
-/** Runs one persistent agent session; resolves when the mailbox closes and the SDK stream ends. */
+/**
+ * Runs a role for the life of the org, transparently restarting the
+ * underlying SDK session whenever it ends on its own (`maxTurns` reached)
+ * while the mailbox is still open. `maxTurns` bounds a single SDK query()
+ * call's TOTAL turns, not "turns per incoming message" — since one query()
+ * call stays open across every mailbox message for as long as the mailbox
+ * itself stays open, without a restart the role would go permanently silent
+ * (no crash, no alert) once its lifetime turn count crossed the limit, while
+ * deliver() kept queuing new messages into a mailbox nobody was reading.
+ */
 export async function runAgentSession(opts) {
+    const { mailbox } = opts;
+    // Always run at least once: a mailbox can be closed with queued items still
+    // pending (stream() drains the queue before honoring `closed`), which is a
+    // normal, valid starting state — checking isClosed before the first run
+    // would skip that drain entirely.
+    while (true) {
+        await runOneSession(opts);
+        if (mailbox.isClosed)
+            return;
+        opts.bus.emit({ type: 'status', from: opts.role.id, msg: 'session restarting (turn limit reached, mailbox still open)' });
+    }
+}
+/** One bounded SDK session for a role; resolves when the SDK stream ends (mailbox closed or maxTurns reached). */
+async function runOneSession(opts) {
     const { org, role, bus, policy, mailbox, cwd, deliver } = opts;
     const queryFn = opts.queryFn ?? query;
     const orgServer = createSdkMcpServer({