monomind 2.7.12 → 2.7.14

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

@@ -1,16 +0,0 @@
-import type { OrgBus } from './bus.js';
-import type { BusEvent } from './types.js';
-export declare function attachForwarder(bus: OrgBus, controlJsonPath?: string): {
-    settle: () => Promise<void>;
-    unsubscribe: () => void;
-};
-/**
- * Companion dashboard events a single bus event needs beyond its primary
- * translate() mapping. Currently: org-started -> session:start (registers
- * the run in the client's session list) and org-stopped -> session:complete.
- * Exported for tests.
- */
-export declare function companionEvents(e: BusEvent): Record<string, unknown>[];
-/** BusEvent → dashboard-native mastermind event. Exported for tests. */
-export declare function translate(e: BusEvent): Record<string, unknown>;
-//# sourceMappingURL=forwarder.d.ts.map

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

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

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

@@ -1,11 +0,0 @@
-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

@@ -1,91 +0,0 @@
-// 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, renameSync, unlinkSync, 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');
-}
-function parseLines(raw) {
-    const msgs = [];
-    for (const line of raw.trim().split('\n')) {
-        if (!line)
-            continue;
-        try {
-            msgs.push(JSON.parse(line));
-        }
-        catch { /* skip corrupt lines */ }
-    }
-    return msgs;
-}
-export function drainInbox(root, orgName) {
-    const path = inboxPath(root, orgName);
-    const draining = `${path}.draining`;
-    const msgs = [];
-    // Recover a .draining file left behind by a mid-drain crash. Without this the
-    // rename below would overwrite it and lose exactly the messages the rename-then-read
-    // scheme exists to protect.
-    if (existsSync(draining)) {
-        try {
-            msgs.push(...parseLines(readFileSync(draining, 'utf8')));
-            unlinkSync(draining);
-        }
-        catch (e) {
-            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                console.error('[inbox] drainInbox recovery of .draining failed:', e);
-            return msgs; // don't rename over a file we couldn't consume
-        }
-    }
-    if (!existsSync(path))
-        return msgs;
-    // Rename-then-read: if the process crashes after rename but before we finish
-    // reading, the .draining file survives (and is recovered above on the next
-    // drain). A plain read-then-truncate would lose messages on a mid-drain crash.
-    try {
-        renameSync(path, draining);
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[inbox] drainInbox rename failed:', e);
-        return msgs;
-    }
-    let raw = '';
-    try {
-        raw = readFileSync(draining, 'utf8');
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[inbox] drainInbox read failed:', e);
-        return msgs;
-    }
-    msgs.push(...parseLines(raw));
-    // Unlink the drained snapshot rather than truncating it and renaming it back over
-    // `path`. A sender that appended between the rename above and this point created a
-    // fresh `path` (queueMessage mkdir+appends), and renaming the emptied snapshot back
-    // would clobber it — destroying messages whose sender already got a "queued" receipt.
-    // Those messages now simply stay in `path` and are picked up by the next drain.
-    try {
-        unlinkSync(draining);
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[inbox] drainInbox unlink failed:', e);
-    }
-    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/mailbox.d.ts

@@ -1,49 +0,0 @@
-/** 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 static readonly MAX_QUEUE;
-    private queue;
-    private wake;
-    private closed;
-    /** Bumped when a new stream() starts; stale generators see the mismatch and exit. */
-    private generation;
-    push(text: string): void;
-    close(): void;
-    get isClosed(): boolean;
-    /**
-     * Detach the current waker WITHOUT resolving it. Called between sessions
-     * (maxTurns restart, crash backoff): the dead session's generator may still
-     * be parked on `wake` inside an abandoned next() — if a push() during that
-     * window resolved it, the stale generator would shift() the message and
-     * yield it into a promise nobody reads (silent loss, after deliver()
-     * already returned a "delivered" receipt). With the waker dropped, such a
-     * push only queues; the replacement session's stream() drains it. The
-     * parked stale generator is never resumed and becomes garbage with its
-     * session.
-     */
-    detach(): void;
-    /**
-     * One live generator at a time: each stream() call bumps `generation`, and
-     * a stale generator that ever resumes exits immediately without touching
-     * the queue. Values are shift()ed at yield time — once the consumer's
-     * next() resolves with a message it counts as delivered (matching SDK
-     * behavior: a session may consume a message and end without ever resuming
-     * the generator; redelivering would duplicate work and can livelock the
-     * restart loop).
-     */
-    stream(sessionId?: string): AsyncGenerator<OrgUserMessage>;
-}
-//# sourceMappingURL=mailbox.d.ts.map

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

@@ -1,75 +0,0 @@
-/**
- * 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 {
-    static MAX_QUEUE = 500;
-    queue = [];
-    wake = null;
-    closed = false;
-    /** Bumped when a new stream() starts; stale generators see the mismatch and exit. */
-    generation = 0;
-    push(text) {
-        if (this.closed)
-            return;
-        if (this.queue.length >= Mailbox.MAX_QUEUE) {
-            this.queue.shift();
-        }
-        this.queue.push(text);
-        this.wake?.();
-        this.wake = null;
-    }
-    close() {
-        this.closed = true;
-        this.wake?.();
-        this.wake = null;
-    }
-    get isClosed() { return this.closed; }
-    /**
-     * Detach the current waker WITHOUT resolving it. Called between sessions
-     * (maxTurns restart, crash backoff): the dead session's generator may still
-     * be parked on `wake` inside an abandoned next() — if a push() during that
-     * window resolved it, the stale generator would shift() the message and
-     * yield it into a promise nobody reads (silent loss, after deliver()
-     * already returned a "delivered" receipt). With the waker dropped, such a
-     * push only queues; the replacement session's stream() drains it. The
-     * parked stale generator is never resumed and becomes garbage with its
-     * session.
-     */
-    detach() { this.wake = null; }
-    /**
-     * One live generator at a time: each stream() call bumps `generation`, and
-     * a stale generator that ever resumes exits immediately without touching
-     * the queue. Values are shift()ed at yield time — once the consumer's
-     * next() resolves with a message it counts as delivered (matching SDK
-     * behavior: a session may consume a message and end without ever resuming
-     * the generator; redelivering would duplicate work and can livelock the
-     * restart loop).
-     */
-    async *stream(sessionId = '') {
-        const gen = ++this.generation;
-        // Drop (never resolve) any stale waker — see detach().
-        this.wake = null;
-        while (true) {
-            while (this.queue.length > 0) {
-                if (gen !== this.generation)
-                    return; // superseded — leave the queue for the live generator
-                yield {
-                    type: 'user',
-                    message: { role: 'user', content: this.queue.shift() },
-                    parent_tool_use_id: null,
-                    session_id: sessionId,
-                };
-                if (gen !== this.generation)
-                    return;
-            }
-            if (this.closed || gen !== this.generation)
-                return;
-            await new Promise(r => { this.wake = r; });
-            if (gen !== this.generation)
-                return;
-        }
-    }
-}
-//# sourceMappingURL=mailbox.js.map

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

@@ -1,26 +0,0 @@
-import { type OrgDef } from './types.js';
-/** The structural invariants the runtime assumes but the Zod schema can't
- * express: unique role ids, exactly one root (reports_to: null), every
- * non-root's reports_to resolving to another role (and not itself), and a
- * parseable schedule. Shared by `org validate` (validateAction) and
- * `migrateOrgFile`, which refuses to write a migrated config that still
- * fails these checks. */
-export declare function checkOrgStructure(def: Pick<OrgDef, 'roles' | 'schedule'>): string[];
-export declare function migrateOrgConfig(raw: Record<string, unknown>): {
-    def: Record<string, unknown>;
-    dropped: string[];
-    notes: string[];
-};
-/** Reads `cfgPath`, migrates it, and (unless already v2) backs up the
- * original to `backupPath` and overwrites `cfgPath` with the migrated def.
- * Throws on an unmigratable config (schema failure inside migrateOrgConfig,
- * or a structural violation caught here) — caller decides how to report it.
- * Refuses to write when the migrated def fails checkOrgStructure, so a v1
- * config with e.g. all-null reports_to fails cleanly instead of silently
- * writing a config the runtime can't start. */
-export declare function migrateOrgFile(cfgPath: string, backupPath: string): {
-    status: 'migrated' | 'already-v2';
-    dropped: string[];
-    notes: string[];
-};
-//# sourceMappingURL=migrate.d.ts.map

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

@@ -1,118 +0,0 @@
-// packages/@monomind/cli/src/orgrt/migrate.ts
-/** v1 → v2 org config conversion. Pure transform + validation, plus the file
- * IO orchestration for the `org migrate` subcommand — kept out of org.ts to
- * stay under the 500-line file cap; org.ts's migrateAction is a thin wrapper
- * that only does the name-validation / isOrgRunning guard and delegates here. */
-import { existsSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
-import { OrgDefSchema } from './types.js';
-import { parseSchedule } from './scheduler.js';
-const V1_TOP_LEVEL_KEYS = [
-    'topology', 'consensus', 'strategy', 'maxAgents', 'communication',
-    'board_id', 'todo_col_id', 'doing_col_id', 'done_col_id', 'loop',
-    'version', 'channels', 'differentiation', 'outputDir', 'runBehavior', 'created',
-];
-const V1_ROLE_KEYS = ['agent_type', 'delegates_to', 'board_id'];
-/** The structural invariants the runtime assumes but the Zod schema can't
- * express: unique role ids, exactly one root (reports_to: null), every
- * non-root's reports_to resolving to another role (and not itself), and a
- * parseable schedule. Shared by `org validate` (validateAction) and
- * `migrateOrgFile`, which refuses to write a migrated config that still
- * fails these checks. */
-export function checkOrgStructure(def) {
-    const errors = [];
-    const ids = def.roles.map(r => r.id);
-    const dupes = ids.filter((id, i) => ids.indexOf(id) !== i);
-    if (dupes.length)
-        errors.push(`duplicate role id(s): ${[...new Set(dupes)].join(', ')}`);
-    const roots = def.roles.filter(r => r.reports_to === null);
-    if (roots.length === 0)
-        errors.push('no root role — exactly one role must have reports_to: null');
-    if (roots.length > 1)
-        errors.push(`multiple root roles (${roots.map(r => r.id).join(', ')}) — exactly one may have reports_to: null`);
-    for (const r of def.roles) {
-        if (r.reports_to !== null && !ids.includes(r.reports_to))
-            errors.push(`role "${r.id}": reports_to "${r.reports_to}" matches no role id`);
-        if (r.reports_to === r.id)
-            errors.push(`role "${r.id}" reports to itself`);
-    }
-    if (def.schedule != null && parseSchedule(def.schedule) === null)
-        errors.push(`schedule "${def.schedule}" is not parseable — use "<N>s", "<N>m", or "<N>h"`);
-    return errors;
-}
-export function migrateOrgConfig(raw) {
-    const def = { ...raw };
-    const dropped = [];
-    const notes = [];
-    // v1 loop → v2 schedule ("<N>m"); only when no v2 schedule already set
-    const loop = def['loop'];
-    if (loop && typeof loop.poll_interval_minutes === 'number' && def['schedule'] == null) {
-        def['schedule'] = `${loop.poll_interval_minutes}m`;
-        notes.push(`loop.poll_interval_minutes=${loop.poll_interval_minutes} → schedule "${def['schedule']}"`);
-    }
-    for (const k of V1_TOP_LEVEL_KEYS) {
-        if (k in def) {
-            delete def[k];
-            dropped.push(k);
-        }
-    }
-    if (Array.isArray(def['roles'])) {
-        const roleKeysDropped = new Set();
-        def['roles'] = def['roles'].map(role => {
-            const r = { ...role };
-            // Legacy serialization artifact: some v1 writers stringified a missing
-            // manager as the literal "undefined". Treat it as unset (schema
-            // defaults to null); structural validation still enforces one root.
-            if (r['reports_to'] === 'undefined') {
-                delete r['reports_to'];
-                notes.push(`role ${String(r['id'])}: reports_to "undefined" → unset`);
-            }
-            if (typeof r['agent_type'] === 'string') {
-                if (r['type'] == null || r['type'] === 'specialist') {
-                    r['type'] = r['agent_type'];
-                    notes.push(`role ${String(r['id'])}: agent_type → type`);
-                }
-            }
-            for (const k of V1_ROLE_KEYS) {
-                if (k in r) {
-                    delete r[k];
-                    roleKeysDropped.add(`roles[].${k}`);
-                }
-            }
-            return r;
-        });
-        dropped.push(...roleKeysDropped);
-    }
-    if (def['schedule'] === undefined)
-        def['schedule'] = null;
-    if (typeof def['status'] !== 'string')
-        def['status'] = 'stopped';
-    // Throws ZodError on an unmigratable config — caller surfaces it.
-    OrgDefSchema.parse(def);
-    return { def, dropped, notes };
-}
-/** Reads `cfgPath`, migrates it, and (unless already v2) backs up the
- * original to `backupPath` and overwrites `cfgPath` with the migrated def.
- * Throws on an unmigratable config (schema failure inside migrateOrgConfig,
- * or a structural violation caught here) — caller decides how to report it.
- * Refuses to write when the migrated def fails checkOrgStructure, so a v1
- * config with e.g. all-null reports_to fails cleanly instead of silently
- * writing a config the runtime can't start. */
-export function migrateOrgFile(cfgPath, backupPath) {
-    const raw = JSON.parse(readFileSync(cfgPath, 'utf8'));
-    const result = migrateOrgConfig(raw);
-    const def = result.def;
-    const structuralErrors = checkOrgStructure(def);
-    if (structuralErrors.length) {
-        throw new Error(`migrated config still fails structural validation: ${structuralErrors.join('; ')}`);
-    }
-    if (result.dropped.length === 0 && result.notes.length === 0) {
-        return { status: 'already-v2', dropped: [], notes: [] };
-    }
-    if (!existsSync(backupPath))
-        writeFileSync(backupPath, JSON.stringify(raw, null, 2));
-    const tmpPath = `${cfgPath}.tmp`;
-    writeFileSync(tmpPath, JSON.stringify(result.def, null, 2));
-    renameSync(tmpPath, cfgPath);
-    return { status: 'migrated', dropped: result.dropped, notes: result.notes };
-}
-//# sourceMappingURL=migrate.js.map

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

@@ -1,28 +0,0 @@
-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: `**\/` 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;
-    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