npm - monomind - Versions diffs - 2.0.2 → 2.1.0 - Mend

monomind 2.0.2 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (90) hide show

package/packages/@monomind/cli/dist/src/orgrt/live.html ADDED Viewed

@@ -0,0 +1,56 @@
+<!-- packages/@monomind/cli/src/orgrt/live.html -->
+<!doctype html>
+<html><head><meta charset="utf-8"><title>org live</title>
+<style>
+  :root { color-scheme: dark; }
+  body { margin:0; font:13px/1.5 ui-monospace,monospace; background:#0d1117; color:#e6edf3;
+         display:grid; grid-template-columns:220px 1fr 1fr; grid-template-rows:auto 1fr 1fr; gap:1px; height:100vh; }
+  header { grid-column:1/4; padding:8px 14px; background:#161b22; font-weight:700; }
+  section { background:#161b22; overflow:auto; padding:10px; }
+  h2 { font-size:11px; text-transform:uppercase; letter-spacing:.1em; color:#7d8590; margin:0 0 8px; }
+  #agents { grid-row:2/4; }
+  .agent { padding:6px 8px; border-left:3px solid #2f81f7; margin-bottom:6px; background:#0d1117; }
+  .agent small { color:#7d8590; display:block; }
+  .row { padding:4px 6px; border-bottom:1px solid #21262d; word-break:break-word; }
+  .from { color:#2f81f7; font-weight:700; } .to { color:#a371f7; }
+  .deny { color:#f85149; } .allow { color:#3fb950; } .xorg { color:#d29922; font-weight:700; }
+  .ts { color:#484f58; font-size:11px; margin-right:6px; }
+</style></head>
+<body>
+<header>org live — <span id="conn">connecting…</span></header>
+<section id="agents"><h2>Agents</h2><div id="agents-list"></div></section>
+<section id="chat"><h2>Chats &amp; Messages</h2><div id="chat-list"></div></section>
+<section id="tools"><h2>Tool Activity &amp; Assets</h2><div id="tools-list"></div></section>
+<script>
+const $ = id => document.getElementById(id);
+const fmt = ts => new Date(ts).toLocaleTimeString();
+const add = (listId, html, cap = 500) => {
+  const el = document.createElement('div'); el.className = 'row'; el.innerHTML = html;
+  const list = $(listId); list.prepend(el);
+  while (list.children.length > cap) list.lastChild.remove();
+};
+const esc = s => String(s ?? '').replace(/[&<>]/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;'}[c]));
+const decisionClass = d => (d === 'allow' || d === 'deny') ? d : 'unknown';
+function render(e) {
+  const t = `<span class="ts">${fmt(e.ts)}</span>`;
+  if (e.type === 'chat') add('chat-list', `${t}<span class="from">${esc(e.org)}/${esc(e.from)}</span>: ${esc(e.msg)}`);
+  else if (e.type === 'message') add('chat-list', `${t}<span class="from">${esc(e.from)}</span> → <span class="to">${esc(e.to)}</span> [${esc(e.subject||'')}] ${esc(e.msg)}`);
+  else if (e.type === 'xorg') add('chat-list', `${t}<span class="xorg">⇄ ${esc(e.from)} → ${esc(e.to)}</span> [${esc(e.subject||'')}] ${esc(e.msg)}`);
+  else if (e.type === 'tool') add('tools-list', `${t}<span class="from">${esc(e.from)}</span> ${esc(e.tool)} <span class="${decisionClass(e.decision)}">${esc(e.decision)}</span>${e.reason ? ' — ' + esc(e.reason) : ''}`);
+  else if (e.type === 'asset') add('tools-list', `${t}<span class="from">${esc(e.from)}</span> 📄 <b>${esc(e.path)}</b>`);
+  else if (e.type === 'status' || e.type === 'usage') add('tools-list', `${t}<i>${esc(e.org)}/${esc(e.from ?? 'org')}: ${esc(e.msg ?? JSON.stringify(e.data))}</i>`);
+}
+async function refreshAgents() {
+  const orgs = await fetch('/api/orgs').then(r => r.json()).catch(() => []);
+  $('agents-list').innerHTML = orgs.map(o =>
+    `<div class="agent"><b>${esc(o.name)}</b><small>${esc(o.run)}</small>` +
+    o.agents.map(a => `<div>${a.closed ? '⚫' : '🟢'} ${esc(a.id)} <small>${esc(a.usage)} tok</small></div>`).join('') +
+    `</div>`).join('') || '<i>no running orgs</i>';
+}
+const ws = new WebSocket(`ws://${location.host}/ws`);
+ws.onopen = () => { $('conn').textContent = 'live'; refreshAgents(); };
+ws.onclose = () => { $('conn').textContent = 'disconnected'; };
+ws.onmessage = ev => { render(JSON.parse(ev.data)); };
+setInterval(refreshAgents, 5000);
+</script>
+</body></html>

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

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -0,0 +1,8 @@
+import type { OrgDaemon } from './daemon.js';
+export interface OrgServer {
+    port: number;
+    close: () => void;
+}
+/** Daemon-owned live view: WS fanout of every bus event + tiny REST surface. */
+export declare function startOrgServer(daemon: OrgDaemon, port: number): Promise<OrgServer>;
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1,72 @@
+// packages/@monomind/cli/src/orgrt/server.ts
+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');
+    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
+            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');
+        }
+    });
+    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(); } };
+}
+//# sourceMappingURL=server.js.map

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

@@ -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 ADDED Viewed

@@ -0,0 +1,108 @@
+// 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 { 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 });
+        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));
+        const alpha = await daemon.startOrg('alpha');
+        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 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'),
+            wsDelivery: wsEvents.length > 0 && wsEvents.some(e => e.type === 'chat'),
+            persisted: persistedCount === evs.length,
+        };
+        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/output.js CHANGED Viewed

@@ -77,9 +77,12 @@ export class OutputFormatter {
         // Check for NO_COLOR environment variable
         if (process.env.NO_COLOR !== undefined)
             return false;
-        // Check for FORCE_COLOR environment variable
-        if (process.env.FORCE_COLOR !== undefined)
-            return true;
+        // Check for FORCE_COLOR environment variable.
+        // Per the supports-color convention, FORCE_COLOR=0 (or "false") forces
+        // color OFF; any other defined, non-empty value forces color ON.
+        if (process.env.FORCE_COLOR !== undefined) {
+            return process.env.FORCE_COLOR !== '0' && process.env.FORCE_COLOR !== 'false';
+        }
         // Check if stdout is a TTY
         return process.stdout.isTTY ?? false;
     }
@@ -149,14 +152,18 @@ export class OutputFormatter {
         if (this.verbosity === 'quiet')
             return;
         const icon = this.color('[WARN]', 'yellow', 'bold');
-        this.writeln(`${icon} ${message}`);
+        // Write to stderr (not stdout) so it never interleaves with structured
+        // stdout output (e.g. --format json | jq .)
+        this.writeErrorln(`${icon} ${message}`);
     }
     printInfo(message) {
         // Info suppressed in quiet mode
         if (this.verbosity === 'quiet')
             return;
         const icon = this.color('[INFO]', 'blue', 'bold');
-        this.writeln(`${icon} ${message}`);
+        // Write to stderr (not stdout) so it never interleaves with structured
+        // stdout output (e.g. --format json | jq .)
+        this.writeErrorln(`${icon} ${message}`);
     }
     printDebug(message) {
         // Debug only shows in verbose/debug mode

package/packages/@monomind/cli/dist/src/parser.d.ts CHANGED Viewed

@@ -35,7 +35,35 @@ export declare class CommandParser {
      */
     private static readonly RESERVED_FLAG_KEYS;
     private setFlagSafe;
+    /**
+     * Merge a single parsed flag (or set of `_` positionals) into the
+     * accumulated result flags, collecting repeats into an array instead of
+     * overwriting. Declared `type: 'array'` options always end up as an array
+     * (even a single occurrence); any other repeated flag also becomes an
+     * array on its second occurrence rather than silently dropping the first
+     * value.
+     */
+    private mergeParsedFlags;
     parse(args: string[]): ParseResult;
+    /**
+     * Convert a camelCase key to kebab-case (inverse of normalizeKey).
+     */
+    private camelToKebab;
+    /**
+     * Ensure every flag is reachable under both its camelCase and
+     * kebab-case spelling. Runs once, after all flags (including
+     * defaults) have been merged into the result.
+     */
+    private mirrorFlagKeys;
+    /**
+     * True when `value` looks like a space-separated negative number
+     * (`-0.5`, `-42`) rather than a new flag. Scoped narrowly to "leading `-`
+     * immediately followed by a digit" — a legitimate flag name never starts
+     * with a digit, so this can't misfire on a genuine following flag while
+     * still letting `--threshold -0.5` consume `-0.5` as the value instead of
+     * being misparsed as a new (bogus) flag.
+     */
+    private looksLikeNegativeNumber;
     private parseFlag;
     private parseValue;
     private normalizeKey;
@@ -50,6 +78,10 @@ export declare class CommandParser {
      * Get boolean flags scoped to a specific command/subcommand.
      */
     private getScopedBooleanFlags;
+    /**
+     * Get flags declared `type: 'array'`, scoped to a specific command/subcommand.
+     */
+    private getScopedArrayFlags;
     private getBooleanFlags;
     private applyDefaults;
     validateFlags(flags: ParsedFlags, command?: Command): string[];

package/packages/@monomind/cli/dist/src/parser.js CHANGED Viewed

@@ -72,6 +72,12 @@ export class CommandParser {
                 description: 'Enable interactive mode',
                 type: 'boolean',
                 default: true
+            },
+            {
+                name: 'update',
+                description: 'Check for updates on startup (use --no-update to disable)',
+                type: 'boolean',
+                default: true
             }
         ];
     }
@@ -111,6 +117,48 @@ export class CommandParser {
             return;
         flags[key] = value;
     }
+    /**
+     * Merge a single parsed flag (or set of `_` positionals) into the
+     * accumulated result flags, collecting repeats into an array instead of
+     * overwriting. Declared `type: 'array'` options always end up as an array
+     * (even a single occurrence); any other repeated flag also becomes an
+     * array on its second occurrence rather than silently dropping the first
+     * value.
+     */
+    mergeParsedFlags(into, from, arrayFlags, booleanFlags) {
+        for (const key of Object.keys(from)) {
+            if (key === '_') {
+                into._.push(...from._);
+                continue;
+            }
+            if (CommandParser.RESERVED_FLAG_KEYS.has(key))
+                continue;
+            const incoming = from[key];
+            if (Array.isArray(into[key])) {
+                into[key].push(...[].concat(incoming).map(String));
+            }
+            else if (into[key] !== undefined && booleanFlags?.has(key)) {
+                // Declared boolean flag repeated (e.g. `--dry-run --dry-run`) — last
+                // value wins instead of promoting to an array. Callers throughout the
+                // codebase check booleans with `flags['x'] === true`; an array value
+                // would silently fail that check (e.g. guidance.ts's --dry-run,
+                // which guards a destructive write).
+                into[key] = incoming;
+            }
+            else if (into[key] !== undefined) {
+                // Repeated flag not previously an array — promote to array so the
+                // earlier value isn't lost.
+                into[key] = [String(into[key]), String(incoming)];
+            }
+            else if (arrayFlags.has(key)) {
+                // First occurrence of a declared array flag — still wrap in an array.
+                into[key] = [String(incoming)];
+            }
+            else {
+                into[key] = incoming;
+            }
+        }
+    }
     parse(args) {
         const result = {
             command: [],
@@ -135,6 +183,7 @@ export class CommandParser {
         // Subcommand-specific aliases take priority over global ones
         const aliases = this.buildScopedAliases(resolvedSub || resolvedCmd);
         const booleanFlags = this.getScopedBooleanFlags(resolvedSub || resolvedCmd);
+        const arrayFlags = this.getScopedArrayFlags(resolvedSub || resolvedCmd);
         let i = 0;
         let parsingFlags = true;
         while (i < args.length) {
@@ -148,8 +197,13 @@ export class CommandParser {
             // Handle flags
             if (parsingFlags && arg.startsWith('-')) {
                 const parseResult = this.parseFlag(args, i, aliases, booleanFlags);
-                // Apply to result flags
-                Object.assign(result.flags, parseResult.flags);
+                // Merge into result flags. A plain Object.assign here would silently
+                // drop earlier values whenever the same flag is passed more than once
+                // (`-p a=1 -p b=2` kept only `b=2`) — options declared `type: 'array'`
+                // (e.g. browse-action.ts's --params/-p, swarm.ts) are meant to
+                // collect every occurrence, and even a flag NOT declared array
+                // shouldn't silently lose data on repetition.
+                this.mergeParsedFlags(result.flags, parseResult.flags, arrayFlags, booleanFlags);
                 i = parseResult.nextIndex;
                 continue;
             }
@@ -201,8 +255,55 @@ export class CommandParser {
         // shadow same-name global options (e.g. `browse screenshot --format` is an
         // image format, not the global text|json|table output format).
         this.applyDefaults(result.flags, resolvedCmd);
+        // Dual-write flag keys: every flag ends up stored under BOTH its
+        // camelCase form (`keepConfig`) and its original kebab-case form
+        // (`keep-config`). Historically only the camelCase key was ever set,
+        // but dozens of command action functions across the codebase read
+        // `ctx.flags['kebab-case']` directly — which was always `undefined`,
+        // silently disabling those flags (see AUDIT-BACKLOG P0-10). Running
+        // this as a single pass over the fully-merged flags object (long
+        // flags, `--no-x` negation, short-flag aliases, and defaults are all
+        // merged into `result.flags` by this point) covers every entry point
+        // in one place instead of touching each call site individually.
+        this.mirrorFlagKeys(result.flags);
         return result;
     }
+    /**
+     * Convert a camelCase key to kebab-case (inverse of normalizeKey).
+     */
+    camelToKebab(key) {
+        return key.replace(/[A-Z]/g, (letter) => '-' + letter.toLowerCase());
+    }
+    /**
+     * Ensure every flag is reachable under both its camelCase and
+     * kebab-case spelling. Runs once, after all flags (including
+     * defaults) have been merged into the result.
+     */
+    mirrorFlagKeys(flags) {
+        for (const key of Object.keys(flags)) {
+            if (key === '_' || CommandParser.RESERVED_FLAG_KEYS.has(key))
+                continue;
+            const camelKey = this.normalizeKey(key);
+            if (camelKey !== key && flags[camelKey] === undefined && !CommandParser.RESERVED_FLAG_KEYS.has(camelKey)) {
+                flags[camelKey] = flags[key];
+            }
+            const kebabKey = this.camelToKebab(key);
+            if (kebabKey !== key && flags[kebabKey] === undefined && !CommandParser.RESERVED_FLAG_KEYS.has(kebabKey)) {
+                flags[kebabKey] = flags[key];
+            }
+        }
+    }
+    /**
+     * True when `value` looks like a space-separated negative number
+     * (`-0.5`, `-42`) rather than a new flag. Scoped narrowly to "leading `-`
+     * immediately followed by a digit" — a legitimate flag name never starts
+     * with a digit, so this can't misfire on a genuine following flag while
+     * still letting `--threshold -0.5` consume `-0.5` as the value instead of
+     * being misparsed as a new (bogus) flag.
+     */
+    looksLikeNegativeNumber(value) {
+        return /^-\d/.test(value);
+    }
     parseFlag(args, index, aliases, booleanFlags) {
         const flags = { _: [] };
         const arg = args[index];
@@ -239,7 +340,8 @@ export class CommandParser {
                 if (booleanFlags.has(normalizedKey)) {
                     this.setFlagSafe(flags, normalizedKey, true);
                 }
-                else if (nextIndex < args.length && !args[nextIndex].startsWith('-')) {
+                else if (nextIndex < args.length &&
+                    (!args[nextIndex].startsWith('-') || this.looksLikeNegativeNumber(args[nextIndex]))) {
                     this.setFlagSafe(flags, normalizedKey, this.parseValue(args[nextIndex]));
                     nextIndex++;
                 }
@@ -258,7 +360,8 @@ export class CommandParser {
                 if (booleanFlags.has(normalizedKey)) {
                     this.setFlagSafe(flags, normalizedKey, true);
                 }
-                else if (nextIndex < args.length && !args[nextIndex].startsWith('-')) {
+                else if (nextIndex < args.length &&
+                    (!args[nextIndex].startsWith('-') || this.looksLikeNegativeNumber(args[nextIndex]))) {
                     this.setFlagSafe(flags, normalizedKey, this.parseValue(args[nextIndex]));
                     nextIndex++;
                 }
@@ -368,6 +471,20 @@ export class CommandParser {
         }
         return flags;
     }
+    /**
+     * Get flags declared `type: 'array'`, scoped to a specific command/subcommand.
+     */
+    getScopedArrayFlags(resolvedCmd) {
+        const flags = new Set();
+        if (resolvedCmd?.options) {
+            for (const opt of resolvedCmd.options) {
+                if (opt.type === 'array') {
+                    flags.add(this.normalizeKey(opt.name));
+                }
+            }
+        }
+        return flags;
+    }
     getBooleanFlags() {
         const flags = new Set();
         for (const opt of this.globalOptions) {
@@ -471,7 +588,15 @@ export class CommandParser {
         }
         // Check for unknown flags if not allowed
         if (!this.options.allowUnknownFlags) {
-            const knownFlags = new Set(allOptions.map(opt => this.normalizeKey(opt.name)));
+            // Include both the camelCase and original (kebab-case) spelling of
+            // each option name — parse() now mirrors flags under both forms, so
+            // validation must recognize both or the mirrored key would be
+            // flagged as an unknown option.
+            const knownFlags = new Set();
+            for (const opt of allOptions) {
+                knownFlags.add(this.normalizeKey(opt.name));
+                knownFlags.add(opt.name);
+            }
             knownFlags.add('_'); // Positional args
             for (const key of Object.keys(flags)) {
                 if (!knownFlags.has(key) && key !== '_') {

package/packages/@monomind/cli/dist/src/routing/embed-worker.js CHANGED Viewed

@@ -50,7 +50,19 @@ async function main() {
     const result = await layer.route(task);
     // Emit on its own line, prefixed, so the parent can unambiguously locate the
     // result even if the model loader wrote stray bytes to stdout earlier.
-    process.stdout.write(`\n__ROUTE_RESULT__${JSON.stringify(result)}\n`);
+    //
+    // Fix (P1-3): onnxruntime's native thread pool keeps the event loop alive
+    // even after this function returns, so the process never exits on its own
+    // and the parent's `close` listener waits until it force-kills us at the
+    // timeout — discarding the result we already wrote. Force-exit once the
+    // write is flushed (same onnx-teardown class as memory.ts's #1428 fix).
+    const wroteSynchronously = process.stdout.write(`\n__ROUTE_RESULT__${JSON.stringify(result)}\n`);
+    if (wroteSynchronously) {
+        process.exit(0);
+    }
+    else {
+        process.stdout.once('drain', () => process.exit(0));
+    }
 }
 main().catch((err) => {
     process.stderr.write(`embed-worker: ${err instanceof Error ? err.message : String(err)}\n`);