monomind 2.0.0 → 2.0.2

package/packages/@monomind/cli/dist/src/mcp-tools/quality/coverage-analysis/prioritize-gaps.d.ts

@@ -13,14 +13,14 @@ export declare const PrioritizeGapsInputSchema: z.ZodObject<{
         startLine: z.ZodNumber;
         endLine: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        id: string;
         type: "function" | "line" | "branch";
+        id: string;
         file: string;
         startLine: number;
         endLine: number;
     }, {
-        id: string;
         type: "function" | "line" | "branch";
+        id: string;
         file: string;
         startLine: number;
         endLine: number;
@@ -54,7 +54,7 @@ export declare const PrioritizeGapsInputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     limit: number;
     factors: ("complexity" | "change-frequency" | "defect-history" | "business-critical" | "dependency-count" | "test-difficulty")[];
-    groupBy: "none" | "type" | "file" | "risk";
+    groupBy: "type" | "none" | "file" | "risk";
     weights?: {
         complexity: number;
         changeFrequency: number;
@@ -64,8 +64,8 @@ export declare const PrioritizeGapsInputSchema: z.ZodObject<{
         testDifficulty: number;
     } | undefined;
     gaps?: {
-        id: string;
         type: "function" | "line" | "branch";
+        id: string;
         file: string;
         startLine: number;
         endLine: number;
@@ -82,15 +82,15 @@ export declare const PrioritizeGapsInputSchema: z.ZodObject<{
         testDifficulty?: number | undefined;
     } | undefined;
     gaps?: {
-        id: string;
         type: "function" | "line" | "branch";
+        id: string;
         file: string;
         startLine: number;
         endLine: number;
     }[] | undefined;
     targetPath?: string | undefined;
     factors?: ("complexity" | "change-frequency" | "defect-history" | "business-critical" | "dependency-count" | "test-difficulty")[] | undefined;
-    groupBy?: "none" | "type" | "file" | "risk" | undefined;
+    groupBy?: "type" | "none" | "file" | "risk" | undefined;
 }>;
 export type PrioritizeGapsInput = z.infer<typeof PrioritizeGapsInputSchema>;
 export interface PrioritizeGapsOutput {
@@ -176,14 +176,14 @@ export declare const toolDefinition: {
             startLine: z.ZodNumber;
             endLine: z.ZodNumber;
         }, "strip", z.ZodTypeAny, {
-            id: string;
             type: "function" | "line" | "branch";
+            id: string;
             file: string;
             startLine: number;
             endLine: number;
         }, {
-            id: string;
             type: "function" | "line" | "branch";
+            id: string;
             file: string;
             startLine: number;
             endLine: number;
@@ -217,7 +217,7 @@ export declare const toolDefinition: {
     }, "strip", z.ZodTypeAny, {
         limit: number;
         factors: ("complexity" | "change-frequency" | "defect-history" | "business-critical" | "dependency-count" | "test-difficulty")[];
-        groupBy: "none" | "type" | "file" | "risk";
+        groupBy: "type" | "none" | "file" | "risk";
         weights?: {
             complexity: number;
             changeFrequency: number;
@@ -227,8 +227,8 @@ export declare const toolDefinition: {
             testDifficulty: number;
         } | undefined;
         gaps?: {
-            id: string;
             type: "function" | "line" | "branch";
+            id: string;
             file: string;
             startLine: number;
             endLine: number;
@@ -245,15 +245,15 @@ export declare const toolDefinition: {
             testDifficulty?: number | undefined;
         } | undefined;
         gaps?: {
-            id: string;
             type: "function" | "line" | "branch";
+            id: string;
             file: string;
             startLine: number;
             endLine: number;
         }[] | undefined;
         targetPath?: string | undefined;
         factors?: ("complexity" | "change-frequency" | "defect-history" | "business-critical" | "dependency-count" | "test-difficulty")[] | undefined;
-        groupBy?: "none" | "type" | "file" | "risk" | undefined;
+        groupBy?: "type" | "none" | "file" | "risk" | undefined;
     }>;
     handler: typeof handler;
 };

package/packages/@monomind/cli/dist/src/mcp-tools/quality/security-compliance/detect-secrets.d.ts

@@ -15,16 +15,16 @@ export declare const DetectSecretsInputSchema: z.ZodObject<{
     scanHistory: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     targetPath: string;
-    secretTypes: ("password" | "api-key" | "private-key" | "token" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[];
     excludePatterns: string[];
+    secretTypes: ("password" | "token" | "api-key" | "private-key" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[];
     includeEntropy: boolean;
     entropyThreshold: number;
     verifySecrets: boolean;
     scanHistory: boolean;
 }, {
     targetPath: string;
-    secretTypes?: ("password" | "api-key" | "private-key" | "token" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[] | undefined;
     excludePatterns?: string[] | undefined;
+    secretTypes?: ("password" | "token" | "api-key" | "private-key" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[] | undefined;
     includeEntropy?: boolean | undefined;
     entropyThreshold?: number | undefined;
     verifySecrets?: boolean | undefined;
@@ -116,16 +116,16 @@ export declare const toolDefinition: {
         scanHistory: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         targetPath: string;
-        secretTypes: ("password" | "api-key" | "private-key" | "token" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[];
         excludePatterns: string[];
+        secretTypes: ("password" | "token" | "api-key" | "private-key" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[];
         includeEntropy: boolean;
         entropyThreshold: number;
         verifySecrets: boolean;
         scanHistory: boolean;
     }, {
         targetPath: string;
-        secretTypes?: ("password" | "api-key" | "private-key" | "token" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[] | undefined;
         excludePatterns?: string[] | undefined;
+        secretTypes?: ("password" | "token" | "api-key" | "private-key" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[] | undefined;
         includeEntropy?: boolean | undefined;
         entropyThreshold?: number | undefined;
         verifySecrets?: boolean | undefined;

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