monomind 2.0.3 → 2.1.3

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

@@ -23,6 +23,7 @@ export function resolveProviderEnv(cfg, parentEnv = process.env) {
             if (!key)
                 throw new Error(`provider api-key: env var ${name} is not set`);
             env[KEY_VAR] = key;
+            delete env.ANTHROPIC_AUTH_TOKEN; // leftover parent token would override the key in the engine
             break;
         }
         case 'base-url': {

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

@@ -0,0 +1,13 @@
+/** "15m" | "2h" | "45s" | minutes as number | null → interval ms or null */
+export declare function parseSchedule(s: string | number | null | undefined): number | null;
+/** Fires runFn(name, intervalMs) every intervalMs per org. Real timer loop — no ScheduleWakeup, no prompts. */
+export declare class OrgScheduler {
+    private runFn;
+    private timers;
+    private running;
+    constructor(runFn: (name: string, intervalMs: number) => Promise<void>);
+    add(name: string, intervalMs: number): void;
+    remove(name: string): void;
+    stop(): void;
+}
+//# sourceMappingURL=scheduler.d.ts.map

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

@@ -0,0 +1,48 @@
+// packages/@monomind/cli/src/orgrt/scheduler.ts
+/** "15m" | "2h" | "45s" | minutes as number | null → interval ms or null */
+export function parseSchedule(s) {
+    if (s == null)
+        return null;
+    if (typeof s === 'number')
+        return s * 60_000;
+    const m = /^(\d+)\s*(s|m|h)$/.exec(s.trim());
+    if (!m)
+        return null;
+    const n = Number(m[1]);
+    return m[2] === 's' ? n * 1000 : m[2] === 'm' ? n * 60_000 : n * 3_600_000;
+}
+/** Fires runFn(name, intervalMs) every intervalMs per org. Real timer loop — no ScheduleWakeup, no prompts. */
+export class OrgScheduler {
+    runFn;
+    timers = new Map();
+    running = new Set();
+    constructor(runFn) {
+        this.runFn = runFn;
+    }
+    add(name, intervalMs) {
+        this.remove(name);
+        this.timers.set(name, setInterval(async () => {
+            if (this.running.has(name))
+                return; // skip if previous iteration still running
+            this.running.add(name);
+            try {
+                await this.runFn(name, intervalMs);
+            }
+            catch (err) {
+                console.error(`[org-scheduler] ${name}: scheduled run failed:`, err);
+            }
+            finally {
+                this.running.delete(name);
+            }
+        }, intervalMs));
+    }
+    remove(name) {
+        const t = this.timers.get(name);
+        if (t)
+            clearInterval(t);
+        this.timers.delete(name);
+    }
+    stop() { for (const name of [...this.timers.keys()])
+        this.remove(name); }
+}
+//# sourceMappingURL=scheduler.js.map

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

@@ -0,0 +1,9 @@
+import type { OrgDaemon } from './daemon.js';
+export interface OrgServer {
+    port: number;
+    close: () => void;
+}
+/** Minimal HTTP listener for cross-process org message delivery.
+ *  Binds an ephemeral port (pass 0) so the daemon can register it with the broker. */
+export declare function startOrgServer(daemon: OrgDaemon, port?: number): Promise<OrgServer>;
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1,39 @@
+// packages/@monomind/cli/src/orgrt/server.ts
+// monolean: stripped to xdeliver-only — live UI, WS fanout, and redundant REST
+// endpoints deleted; the control server at :4242 handles all of those.
+import http from 'node:http';
+/** Minimal HTTP listener for cross-process org message delivery.
+ *  Binds an ephemeral port (pass 0) so the daemon can register it with the broker. */
+export async function startOrgServer(daemon, port = 0) {
+    const server = http.createServer((req, res) => {
+        if (req.method === 'POST' && req.url === '/api/xdeliver') {
+            let body = '';
+            req.on('data', c => { body += c; });
+            req.on('end', () => {
+                try {
+                    const payload = JSON.parse(body || '{}');
+                    if (!payload.toOrg || !payload.toRole || !payload.fromOrg || !payload.fromRole) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: false, error: 'toOrg, toRole, fromOrg, fromRole are required' }));
+                        return;
+                    }
+                    const result = daemon.receiveRemote(payload.toOrg, payload.toRole, `${payload.fromOrg}:${payload.fromRole}`, payload.subject ?? '', payload.body ?? '');
+                    res.writeHead(result.ok ? 200 : 404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(result));
+                }
+                catch (err) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : 'bad request' }));
+                }
+            });
+        }
+        else {
+            res.writeHead(404);
+            res.end('not found');
+        }
+    });
+    await new Promise(r => server.listen(port, r));
+    const actual = server.address().port;
+    return { port: actual, close: () => { server.close(); } };
+}
+//# sourceMappingURL=server.js.map

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

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

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

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

package/packages/@monomind/cli/dist/src/orgrt/test-loop.d.ts

@@ -0,0 +1,12 @@
+interface IterationResult {
+    checks: Record<string, boolean>;
+    events: number;
+}
+export interface LoopReport {
+    iterations: IterationResult[];
+    failed: number;
+    summary: string;
+}
+export declare function runTestLoop(root: string, times: number): Promise<LoopReport>;
+export {};
+//# sourceMappingURL=test-loop.d.ts.map

package/packages/@monomind/cli/dist/src/orgrt/test-loop.js

@@ -0,0 +1,108 @@
+// packages/@monomind/cli/src/orgrt/test-loop.ts
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { OrgDaemon } from './daemon.js';
+import { startOrgServer } from './server.js';
+import { OrgBus } from './bus.js';
+import { queueMessage } from './inbox.js';
+import { ORG_DIR } from './types.js';
+/**
+ * Scripted fake SDK used by the verification loop (no API cost, deterministic).
+ * boss: on kickoff, delegates to coder, then pings the partner org's boss.
+ * coder: "writes" a report (Write allowed by policy), attempts Bash (denied), replies to boss.
+ * It drives the SAME production code paths via the _orgTest seam:
+ * callTool → policy.decide → bus; deliver → daemon.deliver → mailboxes + bus;
+ * assistant/result → chat/usage events.
+ */
+const scriptedQuery = (roleId) => ({ prompt, options }) => (async function* () {
+    const seam = options._orgTest;
+    for await (const m of prompt) {
+        const text = String(m.message.content);
+        // Trigger ONLY on the daemon kickoff message (starts with `Org "`). A bare
+        // includes('started') also matches the xorg body "alpha started its run",
+        // making the partner boss re-deliver to itself forever — an unbroken
+        // microtask chain that starves the event loop (waitFor's timer never fires).
+        if (roleId === 'boss' && text.startsWith('Org "') && text.includes('started')) {
+            yield { type: 'assistant', message: { content: [{ type: 'text', text: 'Kicking off: delegating to coder.' }] } };
+            await seam.deliver('coder', 'task', 'produce out/report.md');
+            await seam.deliver('partner:boss', 'fyi', 'alpha started its run');
+        }
+        else if (roleId === 'coder') {
+            await seam.callTool('Write', { file_path: join(options.cwd, 'out/report.md'), content: '# report' });
+            await seam.callTool('Bash', { command: 'echo should-be-denied' }); // policy MUST deny
+            yield { type: 'assistant', message: { content: [{ type: 'text', text: 'Report written.' }] } };
+            await seam.deliver('boss', 're: task', 'done — out/report.md');
+        }
+        else {
+            yield { type: 'assistant', message: { content: [{ type: 'text', text: `ack: ${text.slice(0, 40)}` }] } };
+        }
+        yield { type: 'result', subtype: 'success', usage: { input_tokens: 5, output_tokens: 5 } };
+    }
+})();
+function writeFixtures(root) {
+    const dir = join(root, ORG_DIR);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, 'alpha.json'), JSON.stringify({
+        name: 'alpha', goal: 'produce a report',
+        roles: [
+            { id: 'boss', title: 'Boss', type: 'boss', reports_to: null },
+            { id: 'coder', title: 'Coder', type: 'specialist', reports_to: 'boss',
+                policy: { denyTools: ['Bash'], fileWrite: ['out/**'] } },
+        ],
+    }));
+    writeFileSync(join(dir, 'partner.json'), JSON.stringify({
+        name: 'partner', goal: 'receive handoffs',
+        roles: [{ id: 'boss', title: 'Boss', type: 'boss', reports_to: null }],
+    }));
+}
+async function waitFor(pred, ms = 5000) {
+    const t0 = Date.now();
+    while (Date.now() - t0 < ms) {
+        if (pred())
+            return true;
+        await new Promise(r => setTimeout(r, 50));
+    }
+    return pred();
+}
+export async function runTestLoop(root, times) {
+    writeFixtures(root);
+    const iterations = [];
+    for (let i = 0; i < times; i++) {
+        const queryFn = (args) => {
+            const roleId = /You are agent "([^"]+)"/.exec(args.options.systemPrompt)?.[1] ?? 'unknown';
+            return scriptedQuery(roleId)(args);
+        };
+        const daemon = new OrgDaemon(root, { queryFn: queryFn, forward: false });
+        // xdeliver server for cross-process delivery (tested via the xorg check)
+        const srv = await startOrgServer(daemon, 0);
+        daemon.setInboxUrl(`http://127.0.0.1:${srv.port}`);
+        // Queue a message for partner:boss BEFORE starting it — verifies inbox drain on startup
+        queueMessage(root, 'partner', { fromQualified: 'external:system', toRole: 'boss', subject: 'pre-start', body: 'queued while offline', ts: Date.now() });
+        const alpha = await daemon.startOrg('alpha');
+        const partner = await daemon.startOrg('partner');
+        await waitFor(() => alpha.busEvents().some(e => e.type === 'message' && e.from === 'coder' && e.to === 'boss'));
+        await daemon.stopAll();
+        srv.close();
+        const evs = alpha.busEvents();
+        const has = (pred) => evs.some(pred);
+        const persistedCount = OrgBus.readHistory(join(root, ORG_DIR, 'alpha', alpha.run)).length;
+        const partnerEvs = partner.busEvents();
+        const checks = {
+            chat: has(e => e.type === 'chat'),
+            message: has(e => e.type === 'message' && e.from === 'boss' && e.to === 'coder'),
+            tool: has(e => e.type === 'tool' && e.decision === 'allow' && e.tool === 'Write'),
+            policyDeny: has(e => e.type === 'tool' && e.decision === 'deny' && e.tool === 'Bash'),
+            asset: has(e => e.type === 'asset' && (e.path ?? '').endsWith('out/report.md')),
+            xorg: has(e => e.type === 'xorg' && e.to === 'partner:boss'),
+            usage: has(e => e.type === 'usage'),
+            persisted: persistedCount === evs.length,
+            inboxDrain: partnerEvs.some(e => e.type === 'xorg' && e.from === 'external:system' && e.subject === 'pre-start'),
+        };
+        iterations.push({ checks, events: evs.length });
+    }
+    const failed = iterations.filter(it => Object.values(it.checks).some(v => !v)).length;
+    const summary = `org e2e: ${times - failed}/${times} passed` +
+        (failed ? ` — failing checks: ${JSON.stringify(iterations.filter(it => Object.values(it.checks).some(v => !v)).map(it => it.checks))}` : '');
+    return { iterations, failed, summary };
+}
+//# sourceMappingURL=test-loop.js.map

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

@@ -8,14 +8,14 @@ export declare const ProviderSchema: z.ZodObject<{
     /** env var NAME holding the auth token for base-url providers */
     authTokenEnv: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    kind: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex";
-    baseUrl?: string | undefined;
+    kind: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex";
     apiKeyEnv?: string | undefined;
+    baseUrl?: string | undefined;
     authTokenEnv?: string | undefined;
 }, {
-    baseUrl?: string | undefined;
-    kind?: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex" | undefined;
+    kind?: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex" | undefined;
     apiKeyEnv?: string | undefined;
+    baseUrl?: string | undefined;
     authTokenEnv?: string | undefined;
 }>;
 export declare const RolePolicySchema: z.ZodObject<{
@@ -65,14 +65,14 @@ export declare const RoleSchema: z.ZodObject<{
         /** env var NAME holding the auth token for base-url providers */
         authTokenEnv: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
-        kind: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex";
-        baseUrl?: string | undefined;
+        kind: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex";
         apiKeyEnv?: string | undefined;
+        baseUrl?: string | undefined;
         authTokenEnv?: string | undefined;
     }, {
-        baseUrl?: string | undefined;
-        kind?: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex" | undefined;
+        kind?: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex" | undefined;
         apiKeyEnv?: string | undefined;
+        baseUrl?: string | undefined;
         authTokenEnv?: string | undefined;
     }>>;
     policy: z.ZodOptional<z.ZodObject<{
@@ -122,14 +122,14 @@ export declare const RoleSchema: z.ZodObject<{
         /** env var NAME holding the auth token for base-url providers */
         authTokenEnv: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
-        kind: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex";
-        baseUrl?: string | undefined;
+        kind: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex";
         apiKeyEnv?: string | undefined;
+        baseUrl?: string | undefined;
         authTokenEnv?: string | undefined;
     }, {
-        baseUrl?: string | undefined;
-        kind?: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex" | undefined;
+        kind?: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex" | undefined;
         apiKeyEnv?: string | undefined;
+        baseUrl?: string | undefined;
         authTokenEnv?: string | undefined;
     }>>;
     policy: z.ZodOptional<z.ZodObject<{
@@ -179,14 +179,14 @@ export declare const RoleSchema: z.ZodObject<{
         /** env var NAME holding the auth token for base-url providers */
         authTokenEnv: z.ZodOptional<z.ZodString>;
     }, "strict", z.ZodTypeAny, {
-        kind: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex";
-        baseUrl?: string | undefined;
+        kind: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex";
         apiKeyEnv?: string | undefined;
+        baseUrl?: string | undefined;
         authTokenEnv?: string | undefined;
     }, {
-        baseUrl?: string | undefined;
-        kind?: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex" | undefined;
+        kind?: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex" | undefined;
         apiKeyEnv?: string | undefined;
+        baseUrl?: string | undefined;
         authTokenEnv?: string | undefined;
     }>>;
     policy: z.ZodOptional<z.ZodObject<{
@@ -268,14 +268,14 @@ export declare const OrgDefSchema: z.ZodObject<{
             /** env var NAME holding the auth token for base-url providers */
             authTokenEnv: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
-            kind: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex";
-            baseUrl?: string | undefined;
+            kind: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex";
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }, {
-            baseUrl?: string | undefined;
-            kind?: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex" | undefined;
+            kind?: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex" | undefined;
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }>>;
         policy: z.ZodOptional<z.ZodObject<{
@@ -325,14 +325,14 @@ export declare const OrgDefSchema: z.ZodObject<{
             /** env var NAME holding the auth token for base-url providers */
             authTokenEnv: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
-            kind: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex";
-            baseUrl?: string | undefined;
+            kind: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex";
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }, {
-            baseUrl?: string | undefined;
-            kind?: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex" | undefined;
+            kind?: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex" | undefined;
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }>>;
         policy: z.ZodOptional<z.ZodObject<{
@@ -382,14 +382,14 @@ export declare const OrgDefSchema: z.ZodObject<{
             /** env var NAME holding the auth token for base-url providers */
             authTokenEnv: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
-            kind: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex";
-            baseUrl?: string | undefined;
+            kind: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex";
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }, {
-            baseUrl?: string | undefined;
-            kind?: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex" | undefined;
+            kind?: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex" | undefined;
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }>>;
         policy: z.ZodOptional<z.ZodObject<{
@@ -471,14 +471,14 @@ export declare const OrgDefSchema: z.ZodObject<{
             /** env var NAME holding the auth token for base-url providers */
             authTokenEnv: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
-            kind: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex";
-            baseUrl?: string | undefined;
+            kind: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex";
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }, {
-            baseUrl?: string | undefined;
-            kind?: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex" | undefined;
+            kind?: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex" | undefined;
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }>>;
         policy: z.ZodOptional<z.ZodObject<{
@@ -528,14 +528,14 @@ export declare const OrgDefSchema: z.ZodObject<{
             /** env var NAME holding the auth token for base-url providers */
             authTokenEnv: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
-            kind: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex";
-            baseUrl?: string | undefined;
+            kind: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex";
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }, {
-            baseUrl?: string | undefined;
-            kind?: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex" | undefined;
+            kind?: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex" | undefined;
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }>>;
         policy: z.ZodOptional<z.ZodObject<{
@@ -585,14 +585,14 @@ export declare const OrgDefSchema: z.ZodObject<{
             /** env var NAME holding the auth token for base-url providers */
             authTokenEnv: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
-            kind: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex";
-            baseUrl?: string | undefined;
+            kind: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex";
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }, {
-            baseUrl?: string | undefined;
-            kind?: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex" | undefined;
+            kind?: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex" | undefined;
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }>>;
         policy: z.ZodOptional<z.ZodObject<{
@@ -674,14 +674,14 @@ export declare const OrgDefSchema: z.ZodObject<{
             /** env var NAME holding the auth token for base-url providers */
             authTokenEnv: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
-            kind: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex";
-            baseUrl?: string | undefined;
+            kind: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex";
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }, {
-            baseUrl?: string | undefined;
-            kind?: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex" | undefined;
+            kind?: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex" | undefined;
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }>>;
         policy: z.ZodOptional<z.ZodObject<{
@@ -731,14 +731,14 @@ export declare const OrgDefSchema: z.ZodObject<{
             /** env var NAME holding the auth token for base-url providers */
             authTokenEnv: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
-            kind: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex";
-            baseUrl?: string | undefined;
+            kind: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex";
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }, {
-            baseUrl?: string | undefined;
-            kind?: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex" | undefined;
+            kind?: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex" | undefined;
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }>>;
         policy: z.ZodOptional<z.ZodObject<{
@@ -788,14 +788,14 @@ export declare const OrgDefSchema: z.ZodObject<{
             /** env var NAME holding the auth token for base-url providers */
             authTokenEnv: z.ZodOptional<z.ZodString>;
         }, "strict", z.ZodTypeAny, {
-            kind: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex";
-            baseUrl?: string | undefined;
+            kind: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex";
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }, {
-            baseUrl?: string | undefined;
-            kind?: "api-key" | "subscription" | "base-url" | "bedrock" | "vertex" | undefined;
+            kind?: "api-key" | "base-url" | "bedrock" | "subscription" | "vertex" | undefined;
             apiKeyEnv?: string | undefined;
+            baseUrl?: string | undefined;
             authTokenEnv?: string | undefined;
         }>>;
         policy: z.ZodOptional<z.ZodObject<{

package/packages/@monomind/cli/dist/src/output.d.ts

@@ -4,35 +4,35 @@
  */
 import type { TableOptions, ProgressOptions, SpinnerOptions } from './types.js';
 declare const COLORS: {
-    readonly reset: "\u001B[0m";
-    readonly bold: "\u001B[1m";
-    readonly dim: "\u001B[2m";
-    readonly italic: "\u001B[3m";
-    readonly underline: "\u001B[4m";
-    readonly black: "\u001B[30m";
-    readonly red: "\u001B[31m";
-    readonly green: "\u001B[32m";
-    readonly yellow: "\u001B[33m";
-    readonly blue: "\u001B[34m";
-    readonly magenta: "\u001B[35m";
-    readonly cyan: "\u001B[36m";
-    readonly white: "\u001B[37m";
-    readonly gray: "\u001B[90m";
-    readonly brightRed: "\u001B[91m";
-    readonly brightGreen: "\u001B[92m";
-    readonly brightYellow: "\u001B[93m";
-    readonly brightBlue: "\u001B[94m";
-    readonly brightMagenta: "\u001B[95m";
-    readonly brightCyan: "\u001B[96m";
-    readonly brightWhite: "\u001B[97m";
-    readonly bgBlack: "\u001B[40m";
-    readonly bgRed: "\u001B[41m";
-    readonly bgGreen: "\u001B[42m";
-    readonly bgYellow: "\u001B[43m";
-    readonly bgBlue: "\u001B[44m";
-    readonly bgMagenta: "\u001B[45m";
-    readonly bgCyan: "\u001B[46m";
-    readonly bgWhite: "\u001B[47m";
+    readonly reset: '\u001B[0m';
+    readonly bold: '\u001B[1m';
+    readonly dim: '\u001B[2m';
+    readonly italic: '\u001B[3m';
+    readonly underline: '\u001B[4m';
+    readonly black: '\u001B[30m';
+    readonly red: '\u001B[31m';
+    readonly green: '\u001B[32m';
+    readonly yellow: '\u001B[33m';
+    readonly blue: '\u001B[34m';
+    readonly magenta: '\u001B[35m';
+    readonly cyan: '\u001B[36m';
+    readonly white: '\u001B[37m';
+    readonly gray: '\u001B[90m';
+    readonly brightRed: '\u001B[91m';
+    readonly brightGreen: '\u001B[92m';
+    readonly brightYellow: '\u001B[93m';
+    readonly brightBlue: '\u001B[94m';
+    readonly brightMagenta: '\u001B[95m';
+    readonly brightCyan: '\u001B[96m';
+    readonly brightWhite: '\u001B[97m';
+    readonly bgBlack: '\u001B[40m';
+    readonly bgRed: '\u001B[41m';
+    readonly bgGreen: '\u001B[42m';
+    readonly bgYellow: '\u001B[43m';
+    readonly bgBlue: '\u001B[44m';
+    readonly bgMagenta: '\u001B[45m';
+    readonly bgCyan: '\u001B[46m';
+    readonly bgWhite: '\u001B[47m';
 };
 type ColorName = keyof typeof COLORS;
 export type VerbosityLevel = 'quiet' | 'normal' | 'verbose' | 'debug';