monomind 2.3.3 → 2.3.4

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

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "2.3.3",
+  "version": "2.3.4",
   "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": "*",