monomind 2.1.0 → 2.1.4

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

@@ -1,38 +1,12 @@
 // 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';
-import { readFileSync, existsSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { WebSocketServer, WebSocket } from 'ws';
-/** Daemon-owned live view: WS fanout of every bus event + tiny REST surface. */
-export async function startOrgServer(daemon, port) {
-    const here = dirname(fileURLToPath(import.meta.url));
-    const htmlPath = ['live.html', '../orgrt/live.html']
-        .map(p => join(here, p)).find(existsSync) ?? join(here, 'live.html');
+/** 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) => {
-        const url = req.url ?? '/';
-        if (req.method === 'GET' && url === '/') {
-            res.writeHead(200, { 'Content-Type': 'text/html' });
-            res.end(readFileSync(htmlPath, 'utf8'));
-        }
-        else if (req.method === 'GET' && url === '/api/orgs') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(daemon.listOrgs().map(o => ({
-                name: o.def.name, run: o.run, goal: o.def.goal,
-                agents: [...o.agents.entries()].map(([id, a]) => ({
-                    id, usage: a.policy.usage, closed: a.mailbox.isClosed,
-                    status: a.status, error: a.error,
-                })),
-            }))));
-        }
-        else if (req.method === 'GET' && url.startsWith('/api/history/')) {
-            const name = decodeURIComponent(url.slice('/api/history/'.length));
-            const org = daemon.getOrg(name);
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(org ? org.busEvents() : []));
-        }
-        else if (req.method === 'POST' && url === '/api/xdeliver') {
-            // inbound cross-process delivery — see OrgDaemon.deliverRemote() on the sending side
+        if (req.method === 'POST' && req.url === '/api/xdeliver') {
             let body = '';
             req.on('data', c => { body += c; });
             req.on('end', () => {
@@ -53,20 +27,37 @@ export async function startOrgServer(daemon, port) {
                 }
             });
         }
+        else if (req.method === 'POST' && req.url === '/api/answer-question') {
+            let body = '';
+            req.on('data', c => { body += c; });
+            req.on('end', () => {
+                (async () => {
+                    try {
+                        const payload = JSON.parse(body || '{}');
+                        if (!payload.org || !payload.role || !payload.questionId || payload.answer === undefined) {
+                            res.writeHead(400, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ ok: false, error: 'org, role, questionId, answer are required' }));
+                            return;
+                        }
+                        const result = await daemon.answerQuestion(payload.org, payload.role, payload.questionId, payload.answer);
+                        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' }));
+                    }
+                })();
+            });
+            return;
+        }
         else {
             res.writeHead(404);
             res.end('not found');
         }
     });
-    const wss = new WebSocketServer({ server, path: '/ws' });
-    const unsubscribe = daemon.subscribe(e => {
-        const line = JSON.stringify(e);
-        for (const c of wss.clients)
-            if (c.readyState === WebSocket.OPEN)
-                c.send(line);
-    });
     await new Promise(r => server.listen(port, r));
     const actual = server.address().port;
-    return { port: actual, close: () => { unsubscribe(); wss.close(); server.close(); } };
+    return { port: actual, close: () => { server.close(); } };
 }
 //# sourceMappingURL=server.js.map

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

@@ -12,12 +12,22 @@ export interface SessionOpts {
     mailbox: Mailbox;
     cwd: string;
     deliver: DeliverFn;
+    askHuman?: (role: string, question: string) => Promise<string>;
     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. */
+/**
+ * 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

@@ -12,12 +12,36 @@ export function buildRolePrompt(role, def, roster) {
         `## 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>".`,
+        `If you need a human decision, call ask_human with your question, then end your turn — you'll receive the human's answer as a new message when it arrives. Do not call ask_human for anything you can resolve yourself.`,
         `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. */
+/**
+ * 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({
@@ -28,6 +52,13 @@ export async function runAgentSession(opts) {
                 const receipt = await deliver(role.id, args.to, args.subject, args.message);
                 return { content: [{ type: 'text', text: receipt }] };
             }),
+            tool('ask_human', 'Ask a human a free-form question and pause for their answer. Use only when you genuinely need human judgment.', { question: z.string() }, async (args) => {
+                if (!opts.askHuman) {
+                    return { content: [{ type: 'text', text: 'ask_human is not available in this session' }] };
+                }
+                const receipt = await opts.askHuman(role.id, args.question);
+                return { content: [{ type: 'text', text: receipt }] };
+            }),
         ],
     });
     bus.emit({ type: 'status', from: role.id, msg: 'session starting' });

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

@@ -1,10 +1,10 @@
 // packages/@monomind/cli/src/orgrt/test-loop.ts
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import WebSocket from 'ws';
 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).
@@ -73,20 +73,20 @@ export async function runTestLoop(root, times) {
             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);
-        const wsEvents = [];
-        const ws = new WebSocket(`ws://127.0.0.1:${srv.port}/ws`);
-        ws.on('message', d => wsEvents.push(JSON.parse(d.toString())));
-        await new Promise(r => ws.on('open', r));
+        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');
-        await daemon.startOrg('partner');
+        const partner = await daemon.startOrg('partner');
         await waitFor(() => alpha.busEvents().some(e => e.type === 'message' && e.from === 'coder' && e.to === 'boss'));
         await daemon.stopAll();
-        ws.close();
         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'),
@@ -95,8 +95,8 @@ export async function runTestLoop(root, times) {
             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'),
-            wsDelivery: wsEvents.length > 0 && wsEvents.some(e => e.type === 'chat'),
             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 });
     }

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<{
@@ -832,7 +832,7 @@ export interface BusEvent {
     ts: number;
     org: string;
     run: string;
-    type: 'message' | 'xorg' | 'tool' | 'asset' | 'chat' | 'status' | 'audit' | 'usage';
+    type: 'message' | 'xorg' | 'tool' | 'asset' | 'chat' | 'status' | 'audit' | 'usage' | 'question';
     from?: string;
     to?: string;
     subject?: string;

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';

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

@@ -484,6 +484,14 @@ export class Spinner {
     start() {
         if (this.interval)
             return;
+        // `\r`-based in-place redraw only works on a real TTY. Without one
+        // (piped output, CI logs, non-interactive terminals) each animation
+        // frame prints as its own line instead of overwriting the last —
+        // so print the text once and skip the animation entirely.
+        if (!process.stdout.isTTY) {
+            process.stdout.write(`${this.text}\n`);
+            return;
+        }
         this.interval = setInterval(() => {
             this.render();
             this.frameIndex = (this.frameIndex + 1) % this.frames.length;
@@ -495,9 +503,9 @@ export class Spinner {
         if (this.interval) {
             clearInterval(this.interval);
             this.interval = null;
+            // Clear the line (only meaningful when the animation actually ran on a TTY)
+            process.stdout.write('\r' + ' '.repeat(this.text.length + 10) + '\r');
         }
-        // Clear the line
-        process.stdout.write('\r' + ' '.repeat(this.text.length + 10) + '\r');
         if (message) {
             this.formatter.writeln(message);
         }

package/packages/@monomind/cli/dist/src/pricing/model-pricing.d.ts

@@ -7,7 +7,7 @@
  *   cw  — cache-write tokens
  *   cr  — cache-read tokens
  *
- * Consumers: dist/src/ui/collector.mjs and dist/src/ui/server.mjs both
+ * Consumers: src/ui/collector.mjs and src/ui/server.mjs both
  * derive their inline pricing tables from this canonical list.
  */
 export interface ModelPrice {

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

@@ -184,7 +184,7 @@ export interface MultiSelectPromptOptions<T = string> {
 export declare class CLIError extends Error {
     code: string;
     exitCode: number;
-    details?: unknown | undefined;
-    constructor(message: string, code: string, exitCode?: number, details?: unknown | undefined);
+    details?: unknown;
+    constructor(message: string, code: string, exitCode?: number, details?: unknown);
 }
 //# sourceMappingURL=types.d.ts.map

package/packages/@monomind/cli/dist/src/ui/collector.mjs

@@ -640,15 +640,30 @@ function slugToPath(slug) {
 }
 
 // Reconstruct the real filesystem path from a Claude project slug.
-// Slugs encode the path with every '/' replaced by '-', which is lossy when
-// directory names contain literal hyphens (e.g. /Desktop/agent-f/accounting).
-// Strategy: naive replace first; if not found, greedy DFS through the filesystem
-// trying longest-possible segment (with embedded hyphens) at each level.
+// Slugs encode the path with every '/' AND '.' replaced by '-' (so a hidden
+// directory like '.claude' shows up as a bare '--claude', i.e. an empty split
+// token immediately before 'claude' — e.g. the real path
+// '/monomind/.claude/worktrees/foo' slugs to '-monomind--claude-worktrees-foo').
+// Also lossy when directory names contain literal hyphens (e.g.
+// /Desktop/agent-f/accounting). Strategy: naive replace first; if not found,
+// greedy DFS through the filesystem trying longest-possible segment (with
+// embedded hyphens) at each level.
 function resolveSlugPath(slug) {
   const naive = '/' + slug.replace(/^-/, '').replace(/-/g, '/');
   try { if (fs.existsSync(naive)) return naive; } catch {}
 
-  const tokens = slug.replace(/^-/, '').split('-').filter(Boolean);
+  // An empty token between two hyphens marks a collapsed '.' — reattach it to
+  // the following token instead of dropping it, so hidden directories survive
+  // reconstruction (dropping it silently turns '.claude' into 'claude', which
+  // never exists on disk, sending the walk down the wrong path entirely).
+  const rawTokens = slug.replace(/^-/, '').split('-');
+  const tokens = [];
+  let pendingDot = false;
+  for (const part of rawTokens) {
+    if (part === '') { pendingDot = true; continue; }
+    tokens.push(pendingDot ? '.' + part : part);
+    pendingDot = false;
+  }
 
   function walk(idx, dir) {
     if (idx === tokens.length) return dir;