monomind 2.1.0 → 2.1.4

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, renameSync } 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] };
@@ -58,6 +70,7 @@ export class OrgDaemon {
                 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),
                 queryFn: this.opts.queryFn,
             }).then(() => { runtime.status = 'ended'; })
                 .catch((err) => {
@@ -87,36 +100,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 +203,137 @@ 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`));
+    }
+    questionsPath(org) {
+        return join(this.root, ORG_DIR, org, 'questions.json');
+    }
+    readQuestions(org) {
+        try {
+            return JSON.parse(readFileSync(this.questionsPath(org), 'utf8'));
+        }
+        catch {
+            return { questions: [] };
+        }
+    }
+    writeQuestions(org, data) {
+        const dest = this.questionsPath(org);
+        mkdirSync(join(this.root, ORG_DIR, org), { recursive: true });
+        const tmp = `${dest}.${process.pid}.tmp`;
+        writeFileSync(tmp, JSON.stringify(data, null, 2));
+        renameSync(tmp, dest);
+    }
+    /** Agent-initiated human question (ask_human tool). Persists to questions.json (survives
+     *  process/dashboard restarts) and emits a 'question' BusEvent so the dashboard's SSE
+     *  stream and global inbox pick it up in real time. Returns a receipt string for the tool call. */
+    async askHuman(org, role, question) {
+        const running = this.orgs.get(org);
+        const questionId = `q-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        const data = this.readQuestions(org);
+        data.questions.push({ questionId, role, question, ts: Date.now(), answer: null, answeredAt: null });
+        this.writeQuestions(org, data);
+        running?.bus.emit({ type: 'question', from: role, data: { questionId, question } });
+        return `Question recorded (id ${questionId}) — a human will answer it; you'll receive the answer as a new message.`;
+    }
+    /** Delivers a human's answer to a pending ask_human question. If the org is still
+     *  running, pushes straight into the role's live mailbox (picked up on its very next
+     *  generator tick — see Mailbox.stream()). If the org has since stopped, queues the
+     *  answer via the same offline fallback deliver()/receiveRemote() already use
+     *  (inbox.ts + autoWake) and it's delivered when the org next starts. */
+    async answerQuestion(org, role, questionId, answer) {
+        const data = this.readQuestions(org);
+        const idx = data.questions.findIndex(q => q.questionId === questionId);
+        if (idx === -1)
+            return { ok: false, error: `question "${questionId}" not found for org "${org}"` };
+        if (data.questions[idx].answer !== null)
+            return { ok: false, error: `question "${questionId}" already answered` };
+        data.questions[idx] = { ...data.questions[idx], answer, answeredAt: Date.now() };
+        this.writeQuestions(org, data);
+        const running = this.orgs.get(org);
+        if (running) {
+            // Org IS running — deliver or report a real error, but never fall through to the
+            // offline queue+autoWake path below: autoWake() no-ops when this.orgs already has
+            // the org (see its own guard), so a role-specific delivery failure here (mailbox
+            // closed, role unknown) would otherwise queue the answer forever with no real error
+            // and no delivery. Mirrors deliver()'s existing "shutting down" error for the same
+            // mid-shutdown-mailbox-closed race.
+            const agent = running.agents.get(role);
+            if (!agent)
+                return { ok: false, error: `role "${role}" not found in org "${org}"` };
+            if (agent.mailbox.isClosed)
+                return { ok: false, error: `role "${role}" in org "${org}" is shutting down — answer not delivered` };
+            running.bus.emit({ type: 'status', from: role, msg: 'question answered', data: { questionId } });
+            agent.mailbox.push(`[answer from human] question: ${data.questions[idx].question}\n\nanswer: ${answer}`);
+            return { ok: true };
+        }
+        // Org not running at all — queue for delivery on next start, matching deliver()'s
+        // existing offline fallback exactly (inbox.ts + autoWake).
+        if (!this.hasOrgDef(org))
+            return { ok: false, error: `org "${org}" not found (no saved definition)` };
+        queueMessage(this.root, org, {
+            fromQualified: 'human', toRole: role,
+            subject: `answer:${questionId}`,
+            body: `question: ${data.questions[idx].question}\n\nanswer: ${answer}`,
+            ts: Date.now(),
+        });
+        this.autoWake(org);
+        return { ok: true };
+    }
+    /** 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 +347,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,9 +1,9 @@
 // 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
+ * (src/ui/server.mjs, POST /api/mastermind/event) so the existing
  * dashboard shows org activity. Best-effort: failures are dropped.
  *
  * Events are translated into the dashboard's native vocabulary
@@ -16,7 +16,7 @@ import { basename, extname } from 'node:path';
  * 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
+ * NOT enough (verified against 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.
@@ -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;
         }
     };
+    // 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,29 @@ 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 'question': {
+            const q = e.data ?? {};
+            return { ...base, type: 'org:question', from: e.from, questionId: q.questionId, question: q.question };
+        }
         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