monomind 2.0.2 → 2.1.0

package/packages/@monomind/cli/dist/src/memory/intelligence.js

@@ -10,9 +10,9 @@
  *
  * @module v1/cli/intelligence
  */
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync, unlinkSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { cosineSimilarity as sharedCosineSimilarity } from '../utils/cosine-similarity.js';
 import { readJsonFileSync, writeJsonFileAtomic } from '../utils/json-file.js';
 // ============================================================================
@@ -49,6 +49,75 @@ function ensureDataDir() {
 function getPatternsPath() {
     return join(getDataDir(), 'patterns.json');
 }
+// ── multi-process-safe patterns.json flush (P1-14) ─────────────────────────
+// patterns.json can be flushed by more than one process at once — e.g. the
+// long-lived MCP server process and a short-lived CJS hook subprocess each
+// load their own in-memory copy, then flush independently. Without a lock +
+// re-read-before-write, whichever flush lands last silently erases whatever
+// the other process added since its own load. flushToDisk() below re-reads
+// the current on-disk file immediately before writing and merges this
+// process's in-memory patterns in by `id` (keeping whichever record has the
+// newer `lastUsedAt`), guarded by a short advisory lock.
+function getPatternsLockPath() {
+    return `${getPatternsPath()}.lock`;
+}
+const PATTERNS_LOCK_STALE_MS = 10_000; // single JSON write — 10s is generous
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e?.code === 'EPERM';
+    }
+}
+/**
+ * Mirrors the stale-lock-breaking pattern in
+ * .claude/helpers/control-start.cjs (claimSpawnLock/releaseSpawnLock):
+ * wx-flag write to claim, break the lock if its holder is dead or the lock
+ * is older than the stale threshold, retry once, then give up and proceed
+ * unlocked (best-effort — a missed lock still merges via the re-read, it
+ * just narrows a tiny TOCTOU window further).
+ */
+function claimPatternsLock() {
+    const lockPath = getPatternsLockPath();
+    try {
+        mkdirSync(dirname(lockPath), { recursive: true });
+    }
+    catch {
+        /* ignore */
+    }
+    try {
+        writeFileSync(lockPath, String(process.pid), { flag: 'wx' });
+        return true;
+    }
+    catch {
+        try {
+            const stat = statSync(lockPath);
+            const holder = Number(readFileSync(lockPath, 'utf-8'));
+            if (Date.now() - stat.mtimeMs < PATTERNS_LOCK_STALE_MS && isPidAlive(holder))
+                return false;
+            unlinkSync(lockPath);
+            writeFileSync(lockPath, String(process.pid), { flag: 'wx' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function releasePatternsLock() {
+    const lockPath = getPatternsLockPath();
+    try {
+        if (Number(readFileSync(lockPath, 'utf-8')) === process.pid)
+            unlinkSync(lockPath);
+    }
+    catch {
+        /* ignore */
+    }
+}
 /**
  * Get the stats file path
  */
@@ -412,7 +481,34 @@ class LocalReasoningBank {
             return;
         try {
             ensureDataDir();
-            writeJsonFileAtomic(getPatternsPath(), this.patternList);
+            let acquired = claimPatternsLock();
+            if (!acquired)
+                acquired = claimPatternsLock(); // one retry — lock is short-lived
+            try {
+                // Re-read the current on-disk patterns and merge this process's
+                // in-memory changes in by id (newer lastUsedAt wins) instead of
+                // blindly overwriting the whole file with this.patternList — see
+                // the P1-14 comment above claimPatternsLock() for why.
+                const diskPatterns = readJsonFileSync(getPatternsPath(), []);
+                const merged = new Map();
+                if (Array.isArray(diskPatterns)) {
+                    for (const p of diskPatterns) {
+                        if (p && typeof p.id === 'string')
+                            merged.set(p.id, p);
+                    }
+                }
+                for (const p of this.patternList) {
+                    const existing = merged.get(p.id);
+                    if (!existing || (p.lastUsedAt ?? 0) >= (existing.lastUsedAt ?? 0)) {
+                        merged.set(p.id, p);
+                    }
+                }
+                writeJsonFileAtomic(getPatternsPath(), Array.from(merged.values()));
+            }
+            finally {
+                if (acquired)
+                    releasePatternsLock();
+            }
             this.dirty = false;
         }
         catch {

package/packages/@monomind/cli/dist/src/memory/memory-bridge.d.ts

@@ -7,6 +7,8 @@
  * @module v1/cli/memory-bridge
  */
 export declare function safeParseEmbedding(raw: string | null | undefined): number[] | null;
+/** Resolve the real on-disk LanceDB path for a given custom path (or the default). */
+export declare function bridgeGetDbPath(customPath?: string): string;
 export declare function bridgeStoreEntry(options: {
     key: string;
     value: string;
@@ -113,6 +115,11 @@ export declare function bridgeLoadEmbeddingModel(dbPath?: string): Promise<{
     modelName: string;
     loadTime?: number;
 } | null>;
+export declare function bridgeGetBackendStats(dbPath?: string): Promise<{
+    totalEntries: number;
+    entriesByNamespace: Record<string, number>;
+    memoryUsage: number;
+} | null>;
 export declare function bridgeGetHNSWStatus(dbPath?: string): Promise<{
     built: boolean;
     size: number;

package/packages/@monomind/cli/dist/src/memory/memory-bridge.js

@@ -88,6 +88,10 @@ function getDbPath(customPath) {
         return resolved;
     return defaultDir;
 }
+/** Resolve the real on-disk LanceDB path for a given custom path (or the default). */
+export function bridgeGetDbPath(customPath) {
+    return getDbPath(customPath);
+}
 function getAutomemConfig() {
     const defaults = { dedupThreshold: 0.85, staleDays: 7 };
     try {
@@ -439,6 +443,22 @@ export async function bridgeLoadEmbeddingModel(dbPath) {
         return null;
     }
 }
+export async function bridgeGetBackendStats(dbPath) {
+    const backend = await getBackend(dbPath);
+    if (!backend)
+        return null;
+    try {
+        const stats = await backend.getStats();
+        return {
+            totalEntries: stats?.totalEntries ?? 0,
+            entriesByNamespace: stats?.entriesByNamespace ?? {},
+            memoryUsage: stats?.memoryUsage ?? 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
 // ===== HNSW (replaced by LanceDB ANN — stubs kept for API compat) =====
 export async function bridgeGetHNSWStatus(dbPath) {
     const backend = await getBackend(dbPath);

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

@@ -0,0 +1,24 @@
+export interface BrokerEntry {
+    url: string;
+    pid: number;
+    updatedAt: number;
+}
+export declare function defaultRegistryDir(): string;
+/** Publish that this process hosts org `name`, reachable via `url`. Call again periodically (heartbeat) — see BrokerLease. */
+export declare function registerOrg(name: string, url: string, dir?: string): void;
+/** Remove this process's registration for `name` (best effort). */
+export declare function unregisterOrg(name: string, dir?: string): void;
+/** Find which process (if any) currently hosts org `name`. Null if never registered or the registration is stale (owner crashed without cleanup). */
+export declare function lookupOrg(name: string, dir?: string, staleMs?: number): BrokerEntry | null;
+/** Keeps a broker registration alive with periodic heartbeats until stop() is called. */
+export declare class BrokerLease {
+    private name;
+    private url;
+    private dir;
+    private intervalMs;
+    private timer;
+    constructor(name: string, url: string, dir?: string, intervalMs?: number);
+    start(): void;
+    stop(): void;
+}
+//# sourceMappingURL=broker.d.ts.map

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

@@ -0,0 +1,68 @@
+// packages/@monomind/cli/src/orgrt/broker.ts
+// monolean: file-based local broker for cross-process org discovery (different
+// `monomind org` processes / project directories, same machine). Upgrade path:
+// a real network registry when cross-machine discovery is needed.
+import { mkdirSync, writeFileSync, readFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const SAFE_NAME = /^[a-z0-9][a-z0-9_-]*$/i;
+const DEFAULT_STALE_MS = 90_000;
+export function defaultRegistryDir() {
+    return process.env.MONOMIND_ORGRT_BROKER_DIR || join(homedir(), '.monomind', 'orgrt-broker');
+}
+function entryPath(name, dir) {
+    if (!SAFE_NAME.test(name))
+        throw new Error(`invalid org name for broker registry: ${name}`);
+    return join(dir, `${name}.json`);
+}
+/** Publish that this process hosts org `name`, reachable via `url`. Call again periodically (heartbeat) — see BrokerLease. */
+export function registerOrg(name, url, dir = defaultRegistryDir()) {
+    mkdirSync(dir, { recursive: true });
+    const entry = { url, pid: process.pid, updatedAt: Date.now() };
+    writeFileSync(entryPath(name, dir), JSON.stringify(entry));
+}
+/** Remove this process's registration for `name` (best effort). */
+export function unregisterOrg(name, dir = defaultRegistryDir()) {
+    try {
+        unlinkSync(entryPath(name, dir));
+    }
+    catch { /* already gone */ }
+}
+/** Find which process (if any) currently hosts org `name`. Null if never registered or the registration is stale (owner crashed without cleanup). */
+export function lookupOrg(name, dir = defaultRegistryDir(), staleMs = DEFAULT_STALE_MS) {
+    try {
+        const entry = JSON.parse(readFileSync(entryPath(name, dir), 'utf8'));
+        if (Date.now() - entry.updatedAt >= staleMs)
+            return null;
+        return entry;
+    }
+    catch {
+        return null;
+    }
+}
+/** Keeps a broker registration alive with periodic heartbeats until stop() is called. */
+export class BrokerLease {
+    name;
+    url;
+    dir;
+    intervalMs;
+    timer = null;
+    constructor(name, url, dir = defaultRegistryDir(), intervalMs = 20_000) {
+        this.name = name;
+        this.url = url;
+        this.dir = dir;
+        this.intervalMs = intervalMs;
+    }
+    start() {
+        registerOrg(this.name, this.url, this.dir);
+        this.timer = setInterval(() => registerOrg(this.name, this.url, this.dir), this.intervalMs);
+        this.timer.unref?.();
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        unregisterOrg(this.name, this.dir);
+    }
+}
+//# sourceMappingURL=broker.js.map

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

@@ -7,6 +7,9 @@ interface AgentRuntime {
     mailbox: Mailbox;
     policy: PolicyEngine;
     done: Promise<void>;
+    /** 'running' until the session promise settles; 'crashed' if it rejected (see error). */
+    status: 'running' | 'ended' | 'crashed';
+    error?: string;
 }
 export interface RunningOrg {
     def: OrgDef;
@@ -19,13 +22,28 @@ export interface DaemonOpts {
     queryFn?: typeof query;
     forward?: boolean;
     controlJson?: string;
+    /** Enables cross-process inter-org routing: on a local delivery miss, ask the
+     *  machine-local broker whether another `monomind org` process (e.g. a
+     *  different project directory) hosts the target org, and deliver over HTTP
+     *  if so. Off by default — tests and single-process runs don't need it. */
+    crossProcess?: boolean;
+    /** Base URL at which OTHER processes can reach this daemon's inbox (see
+     *  server.ts POST /api/xdeliver). Set this to make orgs hosted here
+     *  discoverable; omit for outbound-only cross-process delivery. */
+    inboxUrl?: string;
+    /** Override the broker's file registry directory (tests only). */
+    brokerDir?: string;
 }
 export declare class OrgDaemon {
     private root;
     private opts;
     private orgs;
     private globalSubscribers;
+    private leases;
+    private forwarders;
     constructor(root: string, opts?: DaemonOpts);
+    /** Publish this daemon's inbox so orgs started AFTER this call register with the broker. */
+    setInboxUrl(url: string): void;
     /** subscribe to events from ALL running orgs (dashboard server uses this) */
     subscribe(fn: (e: BusEvent) => void): () => void;
     listOrgs(): RunningOrg[];
@@ -33,6 +51,18 @@ export declare class OrgDaemon {
     startOrg(name: string, taskOverride?: string): Promise<RunningOrg>;
     /** Route a message. to = "role" (same org) or "org:role" (cross-org). Returns a receipt string. */
     deliver(fromOrg: string, fromRole: string, to: string, subject: string, body: string): Promise<string>;
+    /** Cross-process leg of deliver(): ask the machine-local broker who hosts targetOrgName, then POST over HTTP. */
+    private deliverRemote;
+    /** Inbound handler for cross-process delivery — called by the server's POST /api/xdeliver route
+     *  when ANOTHER process's deliverRemote() reaches this daemon. Pushes straight into the target
+     *  agent's mailbox; the agent picks it up on its own next turn (see Mailbox — never interrupts). */
+    receiveRemote(toOrg: string, toRole: string, fromQualified: string, subject: string, body: string): {
+        ok: true;
+        receipt: string;
+    } | {
+        ok: false;
+        error: string;
+    };
     stopOrg(name: string): Promise<void>;
     stopAll(): Promise<void>;
     private persistState;

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

@@ -7,16 +7,21 @@ import { PolicyEngine } from './policy.js';
 import { Mailbox } from './mailbox.js';
 import { runAgentSession } from './session.js';
 import { attachForwarder } from './forwarder.js';
+import { BrokerLease, lookupOrg } from './broker.js';
 import { OrgDefSchema, ORG_DIR } from './types.js';
 export class OrgDaemon {
     root;
     opts;
     orgs = new Map();
     globalSubscribers = new Set();
+    leases = new Map();
+    forwarders = new Map();
     constructor(root, opts = {}) {
         this.root = root;
         this.opts = opts;
     }
+    /** Publish this daemon's inbox so orgs started AFTER this call register with the broker. */
+    setInboxUrl(url) { this.opts.inboxUrl = url; }
     /** subscribe to events from ALL running orgs (dashboard server uses this) */
     subscribe(fn) {
         this.globalSubscribers.add(fn);
@@ -29,7 +34,9 @@ export class OrgDaemon {
             throw new Error(`org ${name} already running`);
         const defPath = join(this.root, ORG_DIR, `${name}.json`);
         const def = OrgDefSchema.parse(JSON.parse(readFileSync(defPath, 'utf8')));
-        const run = `run-${new Date().toISOString().replace(/[-:T]/g, '').slice(0, 15)}`;
+        // random suffix: second-precision stamps collide across processes (two CLI
+        // invocations in the same second would share a run dir and its bus.jsonl)
+        const run = `run-${new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14)}-${Math.random().toString(36).slice(2, 6)}`;
         const dir = join(this.root, ORG_DIR, name, run);
         mkdirSync(dir, { recursive: true });
         const cwd = join(this.root, ORG_DIR, name, 'workspace');
@@ -39,35 +46,63 @@ export class OrgDaemon {
         bus.subscribe(e => { collected.push(e); for (const fn of this.globalSubscribers)
             fn(e); });
         if (this.opts.forward !== false)
-            attachForwarder(bus, this.opts.controlJson ?? join(this.root, '.monomind/control.json'));
+            this.forwarders.set(name, attachForwarder(bus, this.opts.controlJson ?? join(this.root, '.monomind/control.json')));
         const running = { def, run, bus, agents: new Map(), busEvents: () => [...collected] };
         this.orgs.set(name, running);
         const perRoleBudget = Math.floor((def.run_config.budget_tokens ?? 1_000_000) / def.roles.length);
         for (const role of def.roles) {
             const mailbox = new Mailbox();
             const policy = new PolicyEngine(role.id, { maxTokens: perRoleBudget, ...(role.policy ?? {}) }, bus, cwd);
-            const done = runAgentSession({
+            const runtime = { mailbox, policy, status: 'running', done: Promise.resolve() };
+            runtime.done = runAgentSession({
                 org: name, role, bus, policy, mailbox, cwd, def,
                 maxTurns: def.run_config.max_turns_per_message,
                 deliver: (from, to, subject, body) => this.deliver(name, from, to, subject, body),
                 queryFn: this.opts.queryFn,
-            }).catch(() => { });
-            running.agents.set(role.id, { mailbox, policy, done });
+            }).then(() => { runtime.status = 'ended'; })
+                .catch((err) => {
+                const message = err instanceof Error ? err.message : String(err);
+                runtime.status = 'crashed';
+                runtime.error = message;
+                // runAgentSession already emits a 'status' event for the raw error; emit an
+                // 'audit' event too so dashboards/alerts that filter on actionable failures
+                // (not routine status chatter) can surface a dead agent instead of a run that
+                // silently never progresses.
+                bus.emit({
+                    type: 'audit', from: role.id,
+                    msg: `agent "${role.id}" crashed: ${message}`,
+                    reason: 'agent-session-crash',
+                    data: { agentId: role.id, error: message },
+                });
+            });
+            running.agents.set(role.id, runtime);
         }
         const boss = def.roles.find(r => r.type === 'boss' || r.reports_to === null) ?? def.roles[0];
         running.agents.get(boss.id).mailbox.push(`Org "${name}" started (run ${run}).\nGoal: ${taskOverride ?? def.goal}\n` +
             `Coordinate your team via org_send. Report completion by ending your turn.`);
         bus.emit({ type: 'status', msg: `org started (${def.roles.length} agents)`, data: { goal: taskOverride ?? def.goal } });
         this.persistState(name, 'running', run);
+        if (this.opts.crossProcess && this.opts.inboxUrl) {
+            const lease = new BrokerLease(name, this.opts.inboxUrl, this.opts.brokerDir);
+            lease.start();
+            this.leases.set(name, lease);
+        }
         return running;
     }
     /** Route a message. to = "role" (same org) or "org:role" (cross-org). Returns a receipt string. */
     async deliver(fromOrg, fromRole, to, subject, body) {
-        const cross = to.includes(':');
-        const [targetOrgName, targetRole] = cross ? to.split(':', 2) : [fromOrg, to];
+        let cross = to.includes(':');
+        let [targetOrgName, targetRole] = cross ? to.split(':', 2) : [fromOrg, to];
+        // "own-org:role" is intra-org — agents often self-prefix; don't tag it xorg
+        if (cross && targetOrgName === fromOrg) {
+            cross = false;
+            to = targetRole;
+        }
         const targetOrg = this.orgs.get(targetOrgName);
         const src = this.orgs.get(fromOrg);
         if (!targetOrg || !targetOrg.agents.has(targetRole)) {
+            if (cross && this.opts.crossProcess)
+                return this.deliverRemote(fromOrg, fromRole, targetOrgName, targetRole, to, subject, body, src);
             src?.bus.emit({ type: 'audit', from: fromRole, to, msg: `undeliverable: ${subject}`, reason: 'unknown recipient' });
             return `ERROR: unknown recipient "${to}" (known: ${[...(targetOrg?.agents.keys() ?? this.orgs.keys())].join(', ')})`;
         }
@@ -78,15 +113,69 @@ export class OrgDaemon {
         targetOrg.agents.get(targetRole).mailbox.push(`[message from ${evt.from}] subject: ${subject}\n\n${body}`);
         return `delivered to ${to}`;
     }
+    /** Cross-process leg of deliver(): ask the machine-local broker who hosts targetOrgName, then POST over HTTP. */
+    async deliverRemote(fromOrg, fromRole, targetOrgName, targetRole, to, subject, body, src) {
+        const remote = lookupOrg(targetOrgName, this.opts.brokerDir);
+        if (!remote) {
+            src?.bus.emit({ type: 'audit', from: fromRole, to, msg: `undeliverable: ${subject}`, reason: 'unknown recipient' });
+            return `ERROR: unknown recipient "${to}" (no local org, and no process on this machine has org "${targetOrgName}" registered)`;
+        }
+        try {
+            const res = await fetch(`${remote.url}/api/xdeliver`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ fromOrg, fromRole, toOrg: targetOrgName, toRole: targetRole, subject, body }),
+                signal: AbortSignal.timeout(10_000),
+            });
+            const data = await res.json().catch(() => ({}));
+            if (res.ok && data.ok) {
+                src?.bus.emit({ type: 'xorg', from: `${fromOrg}:${fromRole}`, to, subject, msg: body });
+                return data.receipt ?? `delivered to ${to} (remote)`;
+            }
+            src?.bus.emit({ type: 'audit', from: fromRole, to, msg: `remote delivery rejected: ${data.error ?? res.status}`, reason: 'remote-delivery-rejected' });
+            return `ERROR: remote org "${to}" rejected delivery: ${data.error ?? res.status}`;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            src?.bus.emit({ type: 'audit', from: fromRole, to, msg: `remote delivery failed: ${message}`, reason: 'remote-delivery-failed' });
+            return `ERROR: remote org "${targetOrgName}" unreachable: ${message}`;
+        }
+    }
+    /** Inbound handler for cross-process delivery — called by the server's POST /api/xdeliver route
+     *  when ANOTHER process's deliverRemote() reaches this daemon. Pushes straight into the target
+     *  agent's mailbox; the agent picks it up on its own next turn (see Mailbox — never interrupts). */
+    receiveRemote(toOrg, toRole, fromQualified, subject, body) {
+        const org = this.orgs.get(toOrg);
+        if (!org)
+            return { ok: false, error: `org "${toOrg}" not hosted here` };
+        const agent = org.agents.get(toRole);
+        if (!agent)
+            return { ok: false, error: `role "${toRole}" not found in org "${toOrg}"` };
+        org.bus.emit({ type: 'xorg', from: fromQualified, to: `${toOrg}:${toRole}`, subject, msg: body });
+        agent.mailbox.push(`[message from ${fromQualified}] subject: ${subject}\n\n${body}`);
+        return { ok: true, receipt: `delivered to ${toOrg}:${toRole} (remote)` };
+    }
     async stopOrg(name) {
         const org = this.orgs.get(name);
         if (!org)
             return;
+        this.leases.get(name)?.stop();
+        this.leases.delete(name);
         for (const a of org.agents.values())
             a.mailbox.close();
         await Promise.allSettled([...org.agents.values()].map(a => a.done));
         org.bus.emit({ type: 'status', msg: 'org stopped' });
         await org.bus.flush();
+        // the "org stopped" event above triggers the forwarder's final org:complete /
+        // session:complete POST — without waiting for it here, the CLI process can exit
+        // (and kill the in-flight fetch) before that last event reaches the dashboard,
+        // leaving the run stuck showing "running" forever.
+        const forwarder = this.forwarders.get(name);
+        if (forwarder) {
+            await forwarder.settle();
+            forwarder.unsubscribe();
+            this.forwarders.delete(name);
+        }
         this.persistState(name, 'stopped', org.run);
         this.orgs.delete(name);
     }

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

@@ -1,11 +1,16 @@
 import type { OrgBus } from './bus.js';
-/**
- * Forwards every bus event to the running mastermind control server
- * (dist/src/ui/server.mjs, POST /api/mastermind/event) so the existing
- * dashboard SSE stream shows org activity. Best-effort: failures are dropped.
- */
+import type { BusEvent } from './types.js';
 export declare function attachForwarder(bus: OrgBus, controlJsonPath?: string): {
     settle: () => Promise<void>;
     unsubscribe: () => void;
 };
+/**
+ * Companion dashboard events a single bus event needs beyond its primary
+ * translate() mapping. Currently: org-started -> session:start (registers
+ * the run in the client's session list) and org-stopped -> session:complete.
+ * Exported for tests.
+ */
+export declare function companionEvents(e: BusEvent): Record<string, unknown>[];
+/** BusEvent → dashboard-native mastermind event. Exported for tests. */
+export declare function translate(e: BusEvent): Record<string, unknown>;
 //# sourceMappingURL=forwarder.d.ts.map

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

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