monomind 2.3.3 → 2.4.0

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

@@ -63,6 +63,12 @@ export class OrgDaemon {
         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);
+        // Single boss-selection rule for kickoff AND org_complete gating — the
+        // session layer previously keyed the tool on reports_to===null while the
+        // kickoff went to (type==='boss' || reports_to===null || roles[0]), so a
+        // fallback-selected boss could be told to call org_complete without having
+        // the tool.
+        const bossRole = def.roles.find(r => r.type === 'boss' || r.reports_to === null) ?? def.roles[0];
         for (const role of def.roles) {
             const mailbox = new Mailbox();
             const policy = new PolicyEngine(role.id, { maxTokens: perRoleBudget, ...(role.policy ?? {}) }, bus, cwd);
@@ -72,9 +78,11 @@ export class OrgDaemon {
                 maxTurns: def.run_config.max_turns_per_message,
                 deliver: (from, to, subject, body) => this.deliver(name, from, to, subject, body),
                 askHuman: (r, question) => this.askHuman(name, r, question),
-                onComplete: (r, outcome, summary) => {
-                    bus.emit({ type: 'status', from: r, reason: 'org-complete', msg: `run outcome: ${outcome}`, data: { outcome, summary } });
-                },
+                onComplete: role.id === bossRole.id
+                    ? (r, outcome, summary) => {
+                        bus.emit({ type: 'status', from: r, reason: 'org-complete', msg: `run outcome: ${outcome}`, data: { outcome, summary } });
+                    }
+                    : undefined,
                 recall: async (r, q) => {
                     const answer = await this.recallOrgMemory(name, def, q);
                     bus.emit({ type: 'status', from: r, reason: 'org-recall', msg: `recall: ${q.slice(0, 80)}`, data: { hits: answer.hits } });
@@ -98,10 +106,18 @@ export class OrgDaemon {
                         return;
                     }
                     catch (err) {
+                        // Drop the crashed session's stale waker immediately: a push()
+                        // during the backoff window must queue for the NEXT session, not
+                        // wake the dead generator to swallow it.
+                        mailbox.detach();
                         const message = err instanceof Error ? err.message : String(err);
                         const crash = () => {
                             runtime.status = 'crashed';
                             runtime.error = message;
+                            // Close the mailbox so deliver()/receiveRemote() report a real
+                            // error instead of pushing into a queue no session will read
+                            // (and returning a false "delivered" receipt to the sender).
+                            mailbox.close();
                             bus.emit({
                                 type: 'audit', from: role.id,
                                 msg: `agent "${role.id}" crashed: ${message}`,
@@ -127,7 +143,7 @@ export class OrgDaemon {
             })();
             running.agents.set(role.id, runtime);
         }
-        const boss = def.roles.find(r => r.type === 'boss' || r.reports_to === null) ?? def.roles[0];
+        const boss = bossRole;
         // Cross-run memory: brief the coordinator on the previous run so scheduled
         // orgs accumulate instead of starting cold every interval.
         const prev = readHistory(this.root, name).at(-1);
@@ -195,6 +211,10 @@ export class OrgDaemon {
             return `ERROR: unknown recipient "${toQualified}" (known: ${[...(targetOrg?.agents.keys() ?? this.orgs.keys())].join(', ')})`;
         }
         const targetAgent = targetOrg.agents.get(targetRole);
+        if (targetAgent.status === 'crashed') {
+            src?.bus.emit({ type: 'audit', from: fromRole, to: toQualified, msg: `undeliverable: ${subject}`, reason: 'recipient crashed (retry budget exhausted)' });
+            return `ERROR: recipient "${toQualified}" crashed and will not recover this run — message not delivered (${targetAgent.error ?? 'unknown error'})`;
+        }
         if (targetAgent.mailbox.isClosed) {
             // The org is mid-shutdown: mailboxes close before the org is removed
             // from `this.orgs`, so a message can arrive in that window. push() would
@@ -262,6 +282,8 @@ export class OrgDaemon {
         const agent = org.agents.get(toRole);
         if (!agent)
             return { ok: false, error: `role "${toRole}" not found in org "${toOrg}"` };
+        if (agent.status === 'crashed')
+            return { ok: false, error: `role "${toRole}" in org "${toOrg}" crashed and will not recover this run` };
         if (agent.mailbox.isClosed)
             return { ok: false, error: `role "${toRole}" in org "${toOrg}" is shutting down` };
         org.bus.emit({ type: 'xorg', from: fromQualified, to: `${toOrg}:${toRole}`, subject, msg: body });
@@ -364,6 +386,11 @@ export class OrgDaemon {
         // is already gone and no-ops instead of re-running the whole shutdown and
         // double-emitting 'org stopped' (duplicate org:complete/session:complete).
         this.orgs.delete(name);
+        // Capture THIS run's forwarder now: an autoWake-restart of the same org
+        // during the long tail below (agent wait, flush, history write) would
+        // register a NEW forwarder under the same name — settling/unsubscribing
+        // that one would sever the new run's dashboard stream.
+        const forwarder = this.forwarders.get(name);
         this.leases.get(name)?.stop();
         this.leases.delete(name);
         for (const a of org.agents.values())
@@ -402,14 +429,23 @@ export class OrgDaemon {
         // 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);
+        // leaving the run stuck showing "running" forever. Bounded: a stalled
+        // dashboard must not hang org shutdown indefinitely.
         if (forwarder) {
-            await forwarder.settle();
+            await Promise.race([
+                forwarder.settle(),
+                new Promise(r => { const t = setTimeout(r, 5_000); t.unref?.(); }),
+            ]);
             forwarder.unsubscribe();
-            this.forwarders.delete(name);
+            // Only remove from the map if it's still OURS — an autoWake-restart may
+            // have registered the new run's forwarder under this name meanwhile.
+            if (this.forwarders.get(name) === forwarder)
+                this.forwarders.delete(name);
         }
-        this.persistState(name, 'stopped', org.run);
+        // Same guard for runtime.json: if a new run started during shutdown, its
+        // 'running' record must not be overwritten with this old run's 'stopped'.
+        if (!this.orgs.has(name))
+            this.persistState(name, 'stopped', org.run);
     }
     async stopAll() {
         await Promise.all([...this.orgs.keys()].map(n => this.stopOrg(n)));

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

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

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

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

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

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

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

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

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

@@ -123,5 +123,12 @@ export function formatEvent(e) {
         default: return `${t} ▪ ${from} ${e.type}: ${trim(e.msg ?? '')}`;
     }
 }
-const trim = (s, n = 120) => !s ? '' : s.length > n ? `${s.slice(0, n - 1)}…` : s.replace(/\n/g, ' ');
+// Newlines stripped BEFORE truncation — the truncated branch previously kept
+// them, so long multi-line messages broke the one-line-per-event log format.
+const trim = (s, n = 120) => {
+    if (!s)
+        return '';
+    const oneLine = s.replace(/\s*\n\s*/g, ' ');
+    return oneLine.length > n ? `${oneLine.slice(0, n - 1)}…` : oneLine;
+};
 //# sourceMappingURL=reporting.js.map

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

@@ -39,6 +39,10 @@ export async function runAgentSession(opts) {
     // would skip that drain entirely.
     while (true) {
         await runOneSession(opts);
+        // The dead session's generator may still hold the waker — drop it so a
+        // push() before the next stream() starts only queues instead of being
+        // consumed by the abandoned generator (silent message loss).
+        mailbox.detach();
         if (mailbox.isClosed)
             return;
         opts.bus.emit({ type: 'status', from: opts.role.id, msg: 'session restarting (turn limit reached, mailbox still open)' });
@@ -48,7 +52,6 @@ export async function runAgentSession(opts) {
 async function runOneSession(opts) {
     const { org, role, bus, policy, mailbox, cwd, deliver } = opts;
     const queryFn = opts.queryFn ?? query;
-    const isCoordinator = role.reports_to == null;
     const orgServer = createSdkMcpServer({
         name: 'org',
         version: '1.0.0',
@@ -57,7 +60,10 @@ async function runOneSession(opts) {
                     const text = await opts.recall(role.id, args.query);
                     return { content: [{ type: 'text', text }] };
                 })] : []),
-            ...(isCoordinator && opts.onComplete ? [tool('org_complete', 'Record the outcome of this run. Call exactly once, when the goal is achieved or clearly cannot be. The outcome and summary are persisted to the org run history and briefed to the next run.', { outcome: z.enum(['achieved', 'partial', 'failed']), summary: z.string() }, async (args) => {
+            // Gate purely on onComplete: the daemon passes it only to the role its
+            // boss-selection rule picked, so tool availability always matches the
+            // kickoff instruction (reports_to may be non-null for a fallback boss).
+            ...(opts.onComplete ? [tool('org_complete', 'Record the outcome of this run. Call exactly once, when the goal is achieved or clearly cannot be. The outcome and summary are persisted to the org run history and briefed to the next run.', { outcome: z.enum(['achieved', 'partial', 'failed']), summary: z.string() }, async (args) => {
                     opts.onComplete(role.id, args.outcome, args.summary);
                     return { content: [{ type: 'text', text: `outcome "${args.outcome}" recorded` }] };
                 })] : []),

package/packages/@monomind/cli/dist/src/ui/dashboard.html

@@ -1914,6 +1914,12 @@ select.pb-cfg-inp { padding: 4px 7px; cursor: pointer; }
             <button class="btn chunk-build-btn" id="btn-build-docs" onclick="buildKnowledgeDocs()" title="Index .md/.mdx/.txt/.rst files">⊕ Build Docs</button>
             <span class="chunk-build-status" id="chunk-build-status"></span>
           </div>
+          <div class="filter-bar" style="margin-bottom:6px">
+            <input class="filter-input" id="sb-search-input" type="text" placeholder="Ask your Second Brain — semantic search by meaning…"
+              onkeydown="if(event.key==='Enter')secondBrainSearch()">
+            <button class="btn" onclick="secondBrainSearch()" title="Semantic search (warm local model)">⌕ Search</button>
+          </div>
+          <div id="sb-search-results" style="display:none;margin-bottom:12px"></div>
           <div class="filter-bar">
             <input class="filter-input" type="text" placeholder="Filter chunks…" oninput="filterChunks(this.value)">
             <button class="btn" onclick="_chunksLoaded=false;loadChunksTab()" title="Refresh">↺</button>
@@ -13592,6 +13598,44 @@ async function cleanSwarmData() {
 // ── chunks memory tab ──────────────────────────────────────
 let _chunks = [], _chunksLoaded = false, _editChunkId = null;
 
+// Second Brain semantic search — hits the warm /api/knowledge/search endpoint
+// (the server holds the local embedding model hot; ~60ms per query).
+async function secondBrainSearch() {
+  const input = document.getElementById('sb-search-input');
+  const box = document.getElementById('sb-search-results');
+  if (!input || !box) return;
+  const q = input.value.trim();
+  if (!q) { box.style.display = 'none'; return; }
+  box.style.display = 'block';
+  box.innerHTML = '<div class="loading-txt">Searching…</div>';
+  try {
+    const r = await fetch('/api/knowledge/search', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query: q, limit: 5 }),
+    });
+    if (!r.ok) throw new Error('HTTP ' + r.status);
+    const data = await r.json();
+    const results = data.results || [];
+    if (!results.length) {
+      box.innerHTML = '<div class="empty" style="padding:10px">No matches (' + esc(data.method || '?') + '). Ingest documents with: <code>monomind doc ingest ./path</code></div>';
+      return;
+    }
+    box.innerHTML =
+      '<div style="font-size:10px;letter-spacing:0.07em;text-transform:uppercase;color:var(--text-xs);margin-bottom:6px">' +
+        results.length + ' result(s) · ' + esc(data.method || '') + '</div>' +
+      results.map(function (res) {
+        return '<div style="border:1px solid var(--border);border-radius:8px;padding:8px 10px;margin-bottom:6px">' +
+          '<div style="font-size:10px;color:var(--text-lo);margin-bottom:3px">' + esc(res.key || '') +
+            ' <span style="color:var(--accent)">' + (typeof res.score === 'number' ? res.score.toFixed(2) : '') + '</span></div>' +
+          '<div style="font-size:12px;white-space:pre-wrap;max-height:120px;overflow:hidden">' + esc(String(res.content || '').slice(0, 600)) + '</div>' +
+        '</div>';
+      }).join('');
+  } catch (e) {
+    box.innerHTML = '<div class="empty" style="padding:10px">Search failed: ' + esc(e.message) + '</div>';
+  }
+}
+
 async function loadChunksTab() {
   if (_chunksLoaded) return;
   const grid = document.getElementById('chunks-grid');

package/packages/@monomind/cli/dist/src/ui/orgs.html

@@ -1782,12 +1782,12 @@ async function loadRunHistory() {
         ${runs.slice(0, 10).map(h => `
           <div style="font-size:9px;padding:5px 0;border-bottom:1px solid oklch(50% 0 0 / 0.1);display:flex;gap:10px;align-items:baseline">
             <span style="color:var(--dim);white-space:nowrap">${esc(h.run || '?')}</span>
-            <span style="color:var(--muted);white-space:nowrap">${h.durationMs != null ? Math.round(h.durationMs / 1000) + 's' : '—'} · ${h.totalTokens || 0} tok</span>
+            <span style="color:var(--muted);white-space:nowrap">${Number.isFinite(Number(h.durationMs)) && h.durationMs != null ? Math.round(Number(h.durationMs) / 1000) + 's' : '—'} · ${Number(h.totalTokens) || 0} tok</span>
             ${h.outcome
               ? `<span style="color:${outcomeColor(h.outcome.status)}">${esc(h.outcome.status.toUpperCase())}</span>
                  <span style="color:var(--muted);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${esc(h.outcome.summary || '')}</span>`
               : `<span style="color:var(--dim)">NO OUTCOME</span>`}
-            ${h.crashes && h.crashes.length ? `<span style="color:var(--red)">✗ ${h.crashes.length} crash</span>` : ''}
+            ${Array.isArray(h.crashes) && h.crashes.length ? `<span style="color:var(--red)">✗ ${Number(h.crashes.length)} crash</span>` : ''}
           </div>`).join('')}
       </div>`;
   } catch (_) { el.innerHTML = ''; }

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

@@ -5920,8 +5920,19 @@ new Sigma(g,document.getElementById('g'),{renderEdgeLabels:false,labelColor:{col
     // when this endpoint is cold/absent. Fully local — model + store on disk.
     if (req.method === 'POST' && url === '/api/knowledge/search') {
       let body = '';
-      req.on('data', c => { body += c; });
+      let overLimit = false;
+      req.on('data', c => {
+        if (overLimit) return;
+        body += c;
+        if (body.length > 64 * 1024) { // queries are prompts, not documents
+          overLimit = true;
+          res.writeHead(413, { 'Content-Type': 'application/json' });
+          res.end('{"error":"request body too large"}');
+          req.destroy();
+        }
+      });
       req.on('end', async () => {
+        if (overLimit) return;
         try {
           const payload = JSON.parse(body || '{}');
           const query = String(payload.query || '').slice(0, 2000);
@@ -5939,11 +5950,21 @@ new Sigma(g,document.getElementById('g'),{renderEdgeLabels:false,labelColor:{col
             res.end('{"error":"knowledge bridge unavailable"}');
             return;
           }
-          const out = await bridge.bridgeSearchEntries({ query, namespace, limit });
+          // scope: project | global | all (default all) — project results get a
+          // small tie boost; global hits are flagged so callers can show origin.
+          const scope = payload.scope === 'project' || payload.scope === 'global' ? payload.scope : 'all';
+          const [proj, glob] = await Promise.all([
+            scope !== 'global' ? bridge.bridgeSearchEntries({ query, namespace, limit }).catch(() => null) : null,
+            scope !== 'project' ? bridge.bridgeSearchEntries({ query, namespace: 'knowledge:global', limit, dbPath: '@global' }).catch(() => null) : null,
+          ]);
+          const merged = [
+            ...(proj?.results || []).map(r => ({ key: r.key, content: String(r.content || '').slice(0, 2000), score: r.score + 0.05, global: false, tags: r.tags })),
+            ...(glob?.results || []).map(r => ({ key: r.key, content: String(r.content || '').slice(0, 2000), score: r.score, global: true, tags: r.tags })),
+          ].sort((a, b) => b.score - a.score).slice(0, limit);
           res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
           res.end(JSON.stringify({
-            method: out?.searchMethod || 'none',
-            results: (out?.results || []).map(r => ({ key: r.key, content: String(r.content || '').slice(0, 2000), score: r.score })),
+            method: proj?.searchMethod || glob?.searchMethod || 'none',
+            results: merged,
           }));
         } catch (err) {
           res.writeHead(500, { 'Content-Type': 'application/json' });

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "2.3.3",
+  "version": "2.4.0",
   "type": "module",
   "description": "CLI engine for Monomind — an open-source MCP server that extends Claude Code with a codebase knowledge graph (tree-sitter + SQLite), persistent memory, multi-agent task coordination, and session hooks. MIT licensed, fully local.",
   "main": "dist/src/index.js",
@@ -105,7 +105,7 @@
   },
   "optionalDependencies": {
     "@huggingface/transformers": "^3.8.1",
-    "@monoes/memory": "^1.0.7",
+    "@monoes/memory": "^1.0.8",
     "@monomind/hooks": "*",
     "@monomind/mcp": "*",
     "@monomind/routing": "*",