monomind 2.0.1 → 2.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Monomind - Power toolkit for Claude Code. Autonomous agent orgs, codebase knowledge graph, keyword-routed specialist prompts, and 80+ slash commands. One init, then walk away.",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/.claude/commands/mastermind/runorg.md

@@ -1,5 +1,9 @@
 <!-- Start a saved org as a persistent autonomous agent organization. The boss agent coordinates all roles; agents pick up tasks from a shared board and run until stopped. -->
 
+> **DEPRECATED (2026-07): superseded by `monomind org run <name>` (SDK org runtime v2).**
+> This prompt-orchestrated path has no delivery guarantees and no ground-truth event stream.
+> It remains only for orgs not yet migrated. New orgs MUST use the daemon.
+
 **If $ARGUMENTS is empty:** List saved orgs and display the following.
 
 ---

package/packages/@monomind/cli/.claude/helpers/control-start.cjs

@@ -105,6 +105,39 @@ function probeStatus(p) {
   });
 }
 
+const LOCK_FILE = path.join(CWD, '.monomind', 'control.lock');
+
+/**
+ * Atomically claim the spawn lock. Concurrent hook events (a busy session can
+ * fire dozens of control-starts at once) must not each spawn a server — the
+ * loser processes exit and let the winner's server come up. A stale lock
+ * (dead pid or older than 30s) is broken and re-claimed.
+ */
+function claimSpawnLock() {
+  try { fs.mkdirSync(path.dirname(LOCK_FILE), { recursive: true }); } catch { /* ignore */ }
+  try {
+    fs.writeFileSync(LOCK_FILE, String(process.pid), { flag: 'wx' });
+    return true;
+  } catch {
+    try {
+      const stat = fs.statSync(LOCK_FILE);
+      const holder = Number(fs.readFileSync(LOCK_FILE, 'utf-8'));
+      if (Date.now() - stat.mtimeMs < 30_000 && isPidAlive(holder)) return false;
+      fs.unlinkSync(LOCK_FILE);
+      fs.writeFileSync(LOCK_FILE, String(process.pid), { flag: 'wx' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+function releaseSpawnLock() {
+  try {
+    if (Number(fs.readFileSync(LOCK_FILE, 'utf-8')) === process.pid) fs.unlinkSync(LOCK_FILE);
+  } catch { /* ignore */ }
+}
+
 async function main() {
   // If already running, do nothing
   const status = readStatus();
@@ -125,6 +158,21 @@ async function main() {
     }
   }
 
+  if (!claimSpawnLock()) {
+    process.stdout.write('[control] another control-start is already spawning the server — skipping\n');
+    process.exit(0);
+  }
+
+  // Test hook: exercise the full flow without leaving a real detached server
+  // behind (the test suite spawns this script dozens of times per run — real
+  // spawns leaked hundreds of orphan servers on isolated ports).
+  if (process.env.MONOMIND_CONTROL_NO_SPAWN === '1') {
+    writeStatus(process.pid, DEFAULT_PORT);
+    process.stdout.write(`[control] started Neural Control Room on port ${DEFAULT_PORT} (pid ${process.pid}) [no-spawn]\n`);
+    releaseSpawnLock();
+    process.exit(0);
+  }
+
   const { cmd, args, usePort } = findCliPath();
   // server.mjs accepts port as second positional arg; CLI uses 'ui --no-open --port N'
   const allArgs = usePort
@@ -159,9 +207,9 @@ async function main() {
     });
   }
 
-  // Give the server up to ~3 s to start, then confirm the actual port.
+  // Give the server up to ~10 s to start, then confirm the actual port.
   async function confirmPort() {
-    for (let attempt = 0; attempt < 6; attempt++) {
+    for (let attempt = 0; attempt < 20; attempt++) {
       await new Promise(r => setTimeout(r, 500));
       for (let delta = 0; delta <= 10; delta++) {
         const p = DEFAULT_PORT + delta;
@@ -174,11 +222,15 @@ async function main() {
         }
       }
     }
-    // Server didn't respond in time — leave control.json as-is (best-effort)
-    process.stdout.write('[control] server did not respond within 3 s — control.json may have wrong port\n');
+    // Server never became reachable on any expected port — kill the child
+    // rather than leave an orphan bound to some port nothing will ever read.
+    // The next session-start simply retries.
+    try { process.kill(child.pid, 'SIGTERM'); } catch { /* already gone */ }
+    try { fs.unlinkSync(STATUS_FILE); } catch { /* ignore */ }
+    process.stdout.write('[control] server did not respond within 10 s — killed orphan, will retry next session\n');
   }
 
-  confirmPort().catch(() => {}).finally(() => process.exit(0));
+  confirmPort().catch(() => {}).finally(() => { releaseSpawnLock(); process.exit(0); });
 }
 
 main().catch(() => process.exit(0));

package/packages/@monomind/cli/dist/src/index.js

@@ -418,13 +418,14 @@ export class CLI {
      * to the live runtime.
      */
     async initSubsystems() {
-        // Start the @monomind/hooks WorkerManager (performance/health/swarm/git/learning/
-        // adr/ddd/security/patterns/cache/progress) — previously implemented but never invoked
-        try {
-            const { workerManager } = await import('@monomind/hooks');
-            await workerManager.start();
-        }
-        catch { /* optional */ }
+        // NOTE: the @monomind/hooks WorkerManager is intentionally NOT started
+        // here. Workers run from the session-restore hook (6h staleness gate) and
+        // on demand via `monomind hooks worker run <name>`. Starting it on every
+        // CLI invocation scheduled staggered 1-10s timers that usually died with
+        // the process — but long-lived commands (browse: Chrome launch + CDP work)
+        // outlived the stagger, so the consolidate worker fired mid-command,
+        // loaded the onnxruntime embedding model, and its thread pool crashed the
+        // process at exit ("mutex lock failed: Invalid argument" from libc++).
         // GAP-007: SwarmCheckpointer — write checkpoint files so crashed swarms can resume
         try {
             const { SwarmCheckpointer } = await import('@monoes/memory');

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

@@ -0,0 +1,23 @@
+import type { BusEvent } from './types.js';
+type Listener = (e: BusEvent) => void;
+/**
+ * Ground-truth event log for one org run. Append-only JSONL + in-process fanout.
+ * Every message, tool decision, asset, and usage record flows through here.
+ */
+export declare class OrgBus {
+    readonly org: string;
+    readonly run: string;
+    readonly dir: string;
+    private listeners;
+    private seq;
+    private pending;
+    readonly file: string;
+    constructor(org: string, run: string, dir: string);
+    subscribe(fn: Listener): () => void;
+    emit(partial: Omit<BusEvent, 'id' | 'ts' | 'org' | 'run'>): BusEvent;
+    /** await all queued disk writes (tests, shutdown) */
+    flush(): Promise<void>;
+    static readHistory(dir: string): BusEvent[];
+}
+export {};
+//# sourceMappingURL=bus.d.ts.map

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

@@ -0,0 +1,64 @@
+// packages/@monomind/cli/src/orgrt/bus.ts
+import { appendFile, mkdir } from 'node:fs/promises';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Ground-truth event log for one org run. Append-only JSONL + in-process fanout.
+ * Every message, tool decision, asset, and usage record flows through here.
+ */
+export class OrgBus {
+    org;
+    run;
+    dir;
+    listeners = new Set();
+    seq = 0;
+    pending = Promise.resolve();
+    file;
+    constructor(org, run, dir) {
+        this.org = org;
+        this.run = run;
+        this.dir = dir;
+        this.file = join(dir, 'bus.jsonl');
+    }
+    subscribe(fn) {
+        this.listeners.add(fn);
+        return () => this.listeners.delete(fn);
+    }
+    emit(partial) {
+        const e = {
+            id: `${this.run}-${Date.now()}-${this.seq++}`,
+            ts: Date.now(),
+            org: this.org,
+            run: this.run,
+            ...partial,
+        };
+        // serialize writes; never block emitters
+        this.pending = this.pending.then(async () => {
+            await mkdir(this.dir, { recursive: true });
+            await appendFile(this.file, JSON.stringify(e) + '\n', 'utf8');
+        }).catch(() => { });
+        for (const fn of this.listeners) {
+            try {
+                fn(e);
+            }
+            catch { /* listener errors never break the bus */ }
+        }
+        return e;
+    }
+    /** await all queued disk writes (tests, shutdown) */
+    flush() { return this.pending; }
+    static readHistory(dir) {
+        const f = join(dir, 'bus.jsonl');
+        if (!existsSync(f))
+            return [];
+        return readFileSync(f, 'utf8').trim().split('\n').filter(Boolean)
+            .map(l => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        } })
+            .filter((e) => e !== null);
+    }
+}
+//# sourceMappingURL=bus.js.map

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

@@ -0,0 +1,41 @@
+import { OrgBus } from './bus.js';
+import { PolicyEngine } from './policy.js';
+import { Mailbox } from './mailbox.js';
+import { type OrgDef, type BusEvent } from './types.js';
+import type { query } from '@anthropic-ai/claude-agent-sdk';
+interface AgentRuntime {
+    mailbox: Mailbox;
+    policy: PolicyEngine;
+    done: Promise<void>;
+}
+export interface RunningOrg {
+    def: OrgDef;
+    run: string;
+    bus: OrgBus;
+    agents: Map<string, AgentRuntime>;
+    busEvents: () => BusEvent[];
+}
+export interface DaemonOpts {
+    queryFn?: typeof query;
+    forward?: boolean;
+    controlJson?: string;
+}
+export declare class OrgDaemon {
+    private root;
+    private opts;
+    private orgs;
+    private globalSubscribers;
+    constructor(root: string, opts?: DaemonOpts);
+    /** subscribe to events from ALL running orgs (dashboard server uses this) */
+    subscribe(fn: (e: BusEvent) => void): () => void;
+    listOrgs(): RunningOrg[];
+    getOrg(name: string): RunningOrg | undefined;
+    startOrg(name: string, taskOverride?: string): Promise<RunningOrg>;
+    /** Route a message. to = "role" (same org) or "org:role" (cross-org). Returns a receipt string. */
+    deliver(fromOrg: string, fromRole: string, to: string, subject: string, body: string): Promise<string>;
+    stopOrg(name: string): Promise<void>;
+    stopAll(): Promise<void>;
+    private persistState;
+}
+export {};
+//# sourceMappingURL=daemon.d.ts.map

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

@@ -0,0 +1,101 @@
+// 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 { 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 { OrgDefSchema, ORG_DIR } from './types.js';
+export class OrgDaemon {
+    root;
+    opts;
+    orgs = new Map();
+    globalSubscribers = new Set();
+    constructor(root, opts = {}) {
+        this.root = root;
+        this.opts = opts;
+    }
+    /** subscribe to events from ALL running orgs (dashboard server uses this) */
+    subscribe(fn) {
+        this.globalSubscribers.add(fn);
+        return () => this.globalSubscribers.delete(fn);
+    }
+    listOrgs() { return [...this.orgs.values()]; }
+    getOrg(name) { return this.orgs.get(name); }
+    async startOrg(name, taskOverride) {
+        if (this.orgs.has(name))
+            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)}`;
+        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);
+        const collected = [];
+        bus.subscribe(e => { collected.push(e); for (const fn of this.globalSubscribers)
+            fn(e); });
+        if (this.opts.forward !== false)
+            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({
+                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 });
+        }
+        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);
+        return running;
+    }
+    /** 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 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(', ')})`;
+        }
+        const evt = { from: cross ? `${fromOrg}:${fromRole}` : fromRole, to: cross ? to : targetRole, 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}`;
+    }
+    async stopOrg(name) {
+        const org = this.orgs.get(name);
+        if (!org)
+            return;
+        for (const a of org.agents.values())
+            a.mailbox.close();
+        await Promise.allSettled([...org.agents.values()].map(a => a.done));
+        org.bus.emit({ type: 'status', msg: 'org stopped' });
+        await org.bus.flush();
+        this.persistState(name, 'stopped', org.run);
+        this.orgs.delete(name);
+    }
+    async stopAll() {
+        await Promise.all([...this.orgs.keys()].map(n => this.stopOrg(n)));
+    }
+    persistState(name, status, run) {
+        const p = join(this.root, ORG_DIR, name, 'runtime.json');
+        writeFileSync(p, JSON.stringify({ status, run, pid: process.pid, updated: new Date().toISOString() }, null, 2));
+    }
+}
+//# sourceMappingURL=daemon.js.map

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

@@ -0,0 +1,11 @@
+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.
+ */
+export declare function attachForwarder(bus: OrgBus, controlJsonPath?: string): {
+    settle: () => Promise<void>;
+    unsubscribe: () => void;
+};
+//# sourceMappingURL=forwarder.d.ts.map

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

@@ -0,0 +1,37 @@
+// packages/@monomind/cli/src/orgrt/forwarder.ts
+import { readFileSync, existsSync } from 'node:fs';
+/**
+ * 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.
+ */
+export function attachForwarder(bus, controlJsonPath = '.monomind/control.json') {
+    let chain = Promise.resolve();
+    const baseUrl = () => {
+        try {
+            if (!existsSync(controlJsonPath))
+                return null;
+            const c = JSON.parse(readFileSync(controlJsonPath, 'utf8'));
+            return typeof c.url === 'string' ? c.url : `http://localhost:${c.port ?? 4242}`;
+        }
+        catch {
+            return null;
+        }
+    };
+    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(() => { });
+        }).catch(() => { });
+    });
+    return { settle: () => chain, unsubscribe };
+}
+//# sourceMappingURL=forwarder.js.map

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

@@ -0,0 +1,25 @@
+/** Shape the SDK expects for streaming-input user messages. */
+export interface OrgUserMessage {
+    type: 'user';
+    message: {
+        role: 'user';
+        content: string;
+    };
+    parent_tool_use_id: null;
+    session_id: string;
+}
+/**
+ * Async message queue feeding one persistent SDK session.
+ * push() from the daemon (deliveries from other agents / the user);
+ * stream() is passed as the `prompt` of query() to keep the session open.
+ */
+export declare class Mailbox {
+    private queue;
+    private wake;
+    private closed;
+    push(text: string): void;
+    close(): void;
+    get isClosed(): boolean;
+    stream(sessionId?: string): AsyncGenerator<OrgUserMessage>;
+}
+//# sourceMappingURL=mailbox.d.ts.map

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

@@ -0,0 +1,39 @@
+/**
+ * Async message queue feeding one persistent SDK session.
+ * push() from the daemon (deliveries from other agents / the user);
+ * stream() is passed as the `prompt` of query() to keep the session open.
+ */
+export class Mailbox {
+    queue = [];
+    wake = null;
+    closed = false;
+    push(text) {
+        if (this.closed)
+            return;
+        this.queue.push(text);
+        this.wake?.();
+        this.wake = null;
+    }
+    close() {
+        this.closed = true;
+        this.wake?.();
+        this.wake = null;
+    }
+    get isClosed() { return this.closed; }
+    async *stream(sessionId = '') {
+        while (true) {
+            while (this.queue.length > 0) {
+                yield {
+                    type: 'user',
+                    message: { role: 'user', content: this.queue.shift() },
+                    parent_tool_use_id: null,
+                    session_id: sessionId,
+                };
+            }
+            if (this.closed)
+                return;
+            await new Promise(r => { this.wake = r; });
+        }
+    }
+}
+//# sourceMappingURL=mailbox.js.map

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

@@ -0,0 +1,24 @@
+import type { OrgBus } from './bus.js';
+import type { RolePolicy } from './types.js';
+export type Decision = {
+    behavior: 'allow';
+    updatedInput: Record<string, unknown>;
+} | {
+    behavior: 'deny';
+    message: string;
+};
+/** tiny glob→RegExp: supports ** (any depth) and * (single segment). */
+export declare function globToRegExp(glob: string): RegExp;
+export declare class PolicyEngine {
+    readonly role: string;
+    readonly policy: RolePolicy;
+    private bus;
+    private cwd;
+    private used;
+    constructor(role: string, policy: RolePolicy, bus: OrgBus, cwd: string);
+    addUsage(tokens: number): void;
+    get usage(): number;
+    get overBudget(): boolean;
+    decide(tool: string, input: Record<string, unknown>): Promise<Decision>;
+}
+//# sourceMappingURL=policy.d.ts.map

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

@@ -0,0 +1,86 @@
+// packages/@monomind/cli/src/orgrt/policy.ts
+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). */
+export function globToRegExp(glob) {
+    const esc = glob.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, ' ').replace(/\*/g, '[^/]*').replace(/ /g, '.*');
+    return new RegExp(`^${esc}$`);
+}
+export class PolicyEngine {
+    role;
+    policy;
+    bus;
+    cwd;
+    used = 0;
+    constructor(role, policy, bus, cwd) {
+        this.role = role;
+        this.policy = policy;
+        this.bus = bus;
+        this.cwd = cwd;
+    }
+    addUsage(tokens) { this.used += tokens; }
+    get usage() { return this.used; }
+    get overBudget() {
+        return this.policy.maxTokens != null && this.used >= this.policy.maxTokens;
+    }
+    async decide(tool, input) {
+        const deny = (reason) => {
+            this.bus.emit({ type: 'tool', from: this.role, tool, decision: 'deny', reason, data: { input: summarize(input) } });
+            return { behavior: 'deny', message: `[org-policy] ${reason}` };
+        };
+        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) });
+            }
+            return { behavior: 'allow', updatedInput: input };
+        };
+        if (this.overBudget)
+            return deny(`token budget exhausted (${this.used}/${this.policy.maxTokens})`);
+        if (this.policy.denyTools?.includes(tool))
+            return deny(`tool ${tool} is denied for role ${this.role}`);
+        if (this.policy.allowTools && !this.policy.allowTools.includes(tool) && !tool.startsWith('mcp__org__'))
+            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 p = typeof input.file_path === 'string' ? input.file_path
+                : typeof input.path === 'string' ? input.path : null;
+            if (p !== null) {
+                const rel = relative(this.cwd, resolve(this.cwd, p));
+                if (rel.startsWith('..'))
+                    return deny(`path escapes org workdir: ${p}`);
+                if (!globs.some(g => globToRegExp(g).test(rel)))
+                    return deny(`path ${rel} outside ${WRITE_TOOLS.has(tool) ? 'write' : 'read'} scope`);
+            }
+        }
+        if (WEB_TOOLS.has(tool) && this.policy.webAllow !== undefined) {
+            if (this.policy.webAllow.length === 0)
+                return deny(`web access disabled for role ${this.role}`);
+            if (tool === 'WebFetch') {
+                const host = safeHost(String(input.url ?? ''));
+                if (!host || !this.policy.webAllow.some(d => host === d || host.endsWith(`.${d}`)))
+                    return deny(`domain ${host ?? '?'} not in research allowlist`);
+            }
+            // WebSearch has no URL up front; allowed if webAllow is non-empty
+        }
+        return allow();
+    }
+}
+function safeHost(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return null;
+    }
+}
+function summarize(input) {
+    const out = {};
+    for (const [k, v] of Object.entries(input))
+        out[k] = typeof v === 'string' && v.length > 200 ? v.slice(0, 200) + '…' : v;
+    return out;
+}
+//# sourceMappingURL=policy.js.map

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

@@ -0,0 +1,9 @@
+import type { ProviderConfig } from './types.js';
+/**
+ * Builds the child-process env for one agent session.
+ * Default (no provider block) = subscription: remove the API key var so the
+ * spawned Claude Code engine uses the user's `claude login` credentials.
+ * Never stores secrets in org JSON — only env var NAMES.
+ */
+export declare function resolveProviderEnv(cfg: ProviderConfig | undefined, parentEnv?: Record<string, string | undefined>): Record<string, string>;
+//# sourceMappingURL=provider.d.ts.map

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

@@ -0,0 +1,54 @@
+const KEY_VAR = ['ANTHROPIC', 'API', 'KEY'].join('_');
+/**
+ * Builds the child-process env for one agent session.
+ * Default (no provider block) = subscription: remove the API key var so the
+ * spawned Claude Code engine uses the user's `claude login` credentials.
+ * Never stores secrets in org JSON — only env var NAMES.
+ */
+export function resolveProviderEnv(cfg, parentEnv = process.env) {
+    const env = {};
+    for (const [k, v] of Object.entries(parentEnv))
+        if (v !== undefined)
+            env[k] = v;
+    const kind = cfg?.kind ?? 'subscription';
+    switch (kind) {
+        case 'subscription':
+            delete env[KEY_VAR];
+            delete env.ANTHROPIC_BASE_URL;
+            delete env.ANTHROPIC_AUTH_TOKEN;
+            break;
+        case 'api-key': {
+            const name = cfg?.apiKeyEnv ?? KEY_VAR;
+            const key = parentEnv[name];
+            if (!key)
+                throw new Error(`provider api-key: env var ${name} is not set`);
+            env[KEY_VAR] = key;
+            break;
+        }
+        case 'base-url': {
+            if (!cfg?.baseUrl)
+                throw new Error('provider base-url: baseUrl is required');
+            env.ANTHROPIC_BASE_URL = cfg.baseUrl;
+            delete env[KEY_VAR];
+            if (cfg.authTokenEnv) {
+                const tok = parentEnv[cfg.authTokenEnv];
+                if (!tok)
+                    throw new Error(`provider base-url: env var ${cfg.authTokenEnv} is not set`);
+                env.ANTHROPIC_AUTH_TOKEN = tok;
+            }
+            break;
+        }
+        case 'bedrock':
+            env.CLAUDE_CODE_USE_BEDROCK = '1';
+            delete env[KEY_VAR];
+            delete env.ANTHROPIC_AUTH_TOKEN;
+            break;
+        case 'vertex':
+            env.CLAUDE_CODE_USE_VERTEX = '1';
+            delete env[KEY_VAR];
+            delete env.ANTHROPIC_AUTH_TOKEN;
+            break;
+    }
+    return env;
+}
+//# sourceMappingURL=provider.js.map

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

@@ -0,0 +1,23 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import type { OrgBus } from './bus.js';
+import type { PolicyEngine } from './policy.js';
+import type { Mailbox } from './mailbox.js';
+import type { OrgDef, OrgRole } from './types.js';
+export type DeliverFn = (from: string, to: string, subject: string, body: string) => Promise<string>;
+export interface SessionOpts {
+    org: string;
+    role: OrgRole;
+    bus: OrgBus;
+    policy: PolicyEngine;
+    mailbox: Mailbox;
+    cwd: string;
+    deliver: DeliverFn;
+    def?: OrgDef;
+    maxTurns?: number;
+    queryFn?: typeof query;
+}
+/** 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. */
+export declare function runAgentSession(opts: SessionOpts): Promise<void>;
+//# sourceMappingURL=session.d.ts.map

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

@@ -0,0 +1,78 @@
+// packages/@monomind/cli/src/orgrt/session.ts
+import { z } from 'zod';
+import { query, tool, createSdkMcpServer } from '@anthropic-ai/claude-agent-sdk';
+import { resolveProviderEnv } from './provider.js';
+/** Role briefing given to each agent session (SDK systemPrompt option). */
+export function buildRolePrompt(role, def, roster) {
+    return [
+        `You are agent "${role.id}" (${role.title || role.type}) in the org "${def.name}".`,
+        `Org goal: ${def.goal}`,
+        role.reports_to ? `You report to "${role.reports_to}".` : `You are the coordinator of this org.`,
+        role.responsibilities?.length ? `Your responsibilities:\n- ${role.responsibilities.join('\n- ')}` : '',
+        `## Communication protocol`,
+        `The ONLY way to communicate with other agents is the org_send tool.`,
+        `Roster: ${roster.join(', ')}. Address another org's agent as "<org-name>:<role-id>".`,
+        `When you receive a message, act on it, then org_send your result to the requester.`,
+        `When your current work is complete and no reply is needed, end your turn without further tool calls.`,
+    ].filter(Boolean).join('\n\n');
+}
+/** Runs one persistent agent session; resolves when the mailbox closes and the SDK stream ends. */
+export async function runAgentSession(opts) {
+    const { org, role, bus, policy, mailbox, cwd, deliver } = opts;
+    const queryFn = opts.queryFn ?? query;
+    const orgServer = createSdkMcpServer({
+        name: 'org',
+        version: '1.0.0',
+        tools: [
+            tool('org_send', 'Send a message to another agent (role id) or another org ("org:role"). This is the only inter-agent channel.', { to: z.string(), subject: z.string(), message: z.string() }, async (args) => {
+                const receipt = await deliver(role.id, args.to, args.subject, args.message);
+                return { content: [{ type: 'text', text: receipt }] };
+            }),
+        ],
+    });
+    bus.emit({ type: 'status', from: role.id, msg: 'session starting' });
+    try {
+        const stream = queryFn({
+            prompt: mailbox.stream(),
+            options: {
+                systemPrompt: buildRolePrompt(role, (opts.def ?? { name: org, goal: '' }), opts.def?.roles.map(r => r.id) ?? [role.id]),
+                model: role.adapter_config?.model,
+                cwd,
+                env: resolveProviderEnv(role.provider),
+                mcpServers: { org: orgServer },
+                maxTurns: opts.maxTurns ?? 30,
+                permissionMode: 'default',
+                canUseTool: async (toolName, input) => policy.decide(toolName, input),
+                // test seam: lets the scripted fake SDK (test-loop.ts) drive org_send and
+                // tool calls through the real deliver/policy paths; the real SDK ignores it
+                _orgTest: {
+                    deliver: (to, subject, body) => deliver(role.id, to, subject, body),
+                    callTool: (name, input) => policy.decide(name, input),
+                },
+            },
+        });
+        for await (const m of stream) {
+            if (m.type === 'assistant') {
+                const text = (m.message?.content ?? [])
+                    .filter((b) => b.type === 'text').map((b) => b.text).join('\n');
+                if (text.trim())
+                    bus.emit({ type: 'chat', from: role.id, msg: text });
+            }
+            else if (m.type === 'result') {
+                const tokens = (m.usage?.input_tokens ?? 0) + (m.usage?.output_tokens ?? 0);
+                policy.addUsage(tokens);
+                bus.emit({ type: 'usage', from: role.id, data: { tokens, cost_usd: m.total_cost_usd, subtype: m.subtype } });
+                if (policy.overBudget) {
+                    bus.emit({ type: 'status', from: role.id, msg: 'token budget exhausted — closing session' });
+                    mailbox.close();
+                }
+            }
+        }
+        bus.emit({ type: 'status', from: role.id, msg: 'session ended' });
+    }
+    catch (err) {
+        bus.emit({ type: 'status', from: role.id, msg: `session error: ${err.message}` });
+        throw err;
+    }
+}
+//# sourceMappingURL=session.js.map

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -80,7 +80,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc --noEmitOnError false || true && mkdir -p dist/src/browser/dashboard && cp src/browser/dashboard/ui.html dist/src/browser/dashboard/ui.html",
+    "build": "tsc --noEmitOnError false || true && mkdir -p dist/src/browser/dashboard && cp src/browser/dashboard/ui.html dist/src/browser/dashboard/ui.html && mkdir -p dist/src/orgrt && cp src/orgrt/live.html dist/src/orgrt/",
     "test": "vitest run",
     "test:pattern-store": "npx tsx src/transfer/store/tests/standalone-test.ts",
     "prepublishOnly": "cp ../../../README.md ./README.md",