monomind 2.5.0 → 2.5.2

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

@@ -426,8 +426,53 @@ html, body { height: 100%; background: var(--bg); color: var(--text-hi); font-fa
 .oms-val { font-size: 12px; color: var(--text-hi); word-break: break-word; line-height: 1.4; }
 
 /* SVG org chart */
-.org-chart-wrap { background: var(--surface); border: 1px solid var(--border); border-radius: var(--r); overflow: hidden; margin-bottom: 12px; }
+.org-chart-wrap { position: relative; background: var(--surface); border: 1px solid var(--border); border-radius: var(--r); overflow: hidden; margin-bottom: 12px; }
 .org-chart-svg { width: 100%; display: block; }
+.v2-chart-expand {
+  position: absolute; top: 8px; right: 8px; z-index: 3;
+  width: 28px; height: 28px; padding: 0;
+  display: grid; place-items: center;
+  font-size: 14px; line-height: 1; cursor: pointer;
+  color: oklch(60% 0.01 75); background: oklch(16% 0.01 55 / 0.85);
+  border: 1px solid var(--border); border-radius: 6px;
+  transition: color 0.15s, border-color 0.15s;
+}
+.v2-chart-expand:hover { color: oklch(80% 0.12 75); border-color: oklch(72% 0.18 75 / 0.5); }
+#v2-chart-modal {
+  position: fixed; inset: 0; z-index: 1200;
+  display: flex; flex-direction: column;
+  background: oklch(9% 0.008 55 / 0.985);
+  opacity: 0; transition: opacity 0.3s cubic-bezier(0.22, 1, 0.36, 1);
+}
+#v2-chart-modal.open { opacity: 1; }
+#v2-chart-modal .v2cm-head {
+  display: flex; align-items: center; justify-content: space-between;
+  padding: 14px 20px; border-bottom: 1px solid var(--border); flex: 0 0 auto;
+}
+#v2-chart-modal .v2cm-title {
+  font-size: 14px; font-weight: 600; letter-spacing: 0.02em; color: var(--text-hi, oklch(88% 0.005 75));
+}
+#v2-chart-modal .v2cm-close {
+  width: 32px; height: 32px; padding: 0; display: grid; place-items: center;
+  font-size: 15px; cursor: pointer; color: oklch(60% 0.01 75);
+  background: oklch(16% 0.01 55); border: 1px solid var(--border); border-radius: 7px;
+  transition: color 0.15s, border-color 0.15s;
+}
+#v2-chart-modal .v2cm-close:hover { color: oklch(85% 0.01 75); border-color: oklch(50% 0.01 75); }
+#v2-chart-modal .v2cm-body {
+  flex: 1 1 auto; min-height: 0; overflow: auto; padding: 18px 24px 24px;
+  transform: scale(0.985); transition: transform 0.35s cubic-bezier(0.22, 1, 0.36, 1);
+}
+#v2-chart-modal.open .v2cm-body { transform: scale(1); }
+#v2-chart-modal .org-chart-wrap { border: none; background: transparent; }
+#v2-chart-modal .org-chart-svg { min-height: calc(100vh - 260px) !important; max-height: none; }
+.v2cm-placeholder {
+  padding: 40px 16px; text-align: center;
+  color: oklch(48% 0.005 75); font-size: 12px; letter-spacing: 0.02em;
+}
+@media (prefers-reduced-motion: reduce) {
+  #v2-chart-modal, #v2-chart-modal .v2cm-body { transition: none; transform: none; }
+}
 .v2-bubble-inner {
   background: oklch(18% 0.01 55 / 0.95);
   border: 1px solid oklch(72% 0.18 75 / 0.4);
@@ -6050,6 +6095,43 @@ function _v2OrgIsLeader(r) {
     || r.agent_type === 'coordinator' || r.agent_type === 'devbot-orchestrator';
 }
 
+// ── Full-page chart modal ──────────────────────────────────────────────
+// While open, v2RenderOrgChart() renders into the modal body (wider viewBox)
+// and the inline pane holds a placeholder. Close restores the inline chart.
+let _v2ChartExpanded = false;
+function _v2ChartEsc(e) { if (e.key === 'Escape') v2ToggleChartExpand(false); }
+function v2ToggleChartExpand(open) {
+  _v2ChartExpanded = !!open;
+  let m = document.getElementById('v2-chart-modal');
+  if (open) {
+    if (!m) {
+      m = document.createElement('div');
+      m.id = 'v2-chart-modal';
+      m.setAttribute('role', 'dialog');
+      m.setAttribute('aria-modal', 'true');
+      m.setAttribute('aria-label', 'Org chart, expanded view');
+      m.innerHTML = `
+        <div class="v2cm-head">
+          <div class="v2cm-title"></div>
+          <button class="v2cm-close" onclick="v2ToggleChartExpand(false)" aria-label="Close expanded chart">✕</button>
+        </div>
+        <div id="v2-chart-modal-body" class="v2cm-body"></div>`;
+      document.body.appendChild(m);
+    }
+    m.querySelector('.v2cm-title').textContent = _v2SelOrg || 'Org chart';
+    const inlinePane = document.getElementById('odt-chart');
+    if (inlinePane) inlinePane.innerHTML = '<div class="v2cm-placeholder">Chart is expanded to full page · press Esc or ✕ to bring it back</div>';
+    document.addEventListener('keydown', _v2ChartEsc);
+    requestAnimationFrame(() => m.classList.add('open'));
+    v2RenderOrgChart();
+    m.querySelector('.v2cm-close').focus();
+  } else {
+    document.removeEventListener('keydown', _v2ChartEsc);
+    if (m) m.remove();
+    v2RenderOrgChart();
+  }
+}
+
 function v2RenderOrgChart() {
   if (!_v2SelOrg) return;
   const d = _v2OrgData;
@@ -6060,7 +6142,17 @@ function v2RenderOrgChart() {
   const goalText = d.goal || '—';
   const topo = (d.topology || 'hierarchical').toLowerCase();
   const created = d.created_at ? new Date(d.created_at).toLocaleDateString('en', {month:'short',day:'numeric',year:'numeric'}) : '—';
-  const pane = document.getElementById('odt-chart');
+  // Expanded mode renders into the full-page modal instead of the inline pane.
+  // Exactly ONE chart instance exists at a time — the bubble/letter/particle
+  // animation code queries singleton ids (v2-org-svg, v2oc-letters, …).
+  const pane = _v2ChartExpanded
+    ? document.getElementById('v2-chart-modal-body')
+    : document.getElementById('odt-chart');
+  if (!pane) return;
+  if (_v2ChartExpanded) {
+    const _t = document.querySelector('#v2-chart-modal .v2cm-title');
+    if (_t) _t.textContent = _v2SelOrg;
+  }
 
   // ── color palette ─────────────────────────────────────
   const COLORS = [
@@ -6085,7 +6177,19 @@ function v2RenderOrgChart() {
   }
 
   // ── layout positions ──────────────────────────────────
-  const W = 720, R = 42, PAD_X = R + 20, PAD_Y = R + 24;
+  // Expanded: width scales with head-count so nodes never overlap (inline
+  // keeps the compact 720 viewBox that fits the tab column).
+  let W = _v2ChartExpanded ? Math.max(1100, roles.length * 130) : 720;
+  // Crowded orgs (8+ roles) get smaller rings + serpentine re-flow in BOTH
+  // views, so topology reads instead of a wall of overlapping circles. Top
+  // padding reserves room for activity bubbles (34px box floating 46px above
+  // the ring) so message pop-ups never clip.
+  const _crowded = roles.length > 7;
+  const R = (_v2ChartExpanded || _crowded) ? 34 : 42;
+  // Side padding must cover the 140px-wide activity bubble (70 each side of
+  // a node center) or edge-column bubbles clip against the chart border.
+  const PAD_X = (_v2ChartExpanded || _crowded) ? Math.max(R + 20, 78) : R + 20;
+  const PAD_Y = (_v2ChartExpanded || _crowded) ? R + 96 : R + 24;
   const roleIds = new Set(roles.map(r => r.id));
   // all leaders at depth 0 (supports co-lead orgs)
   const leaders = roles.filter(_v2OrgIsLeader);
@@ -6182,6 +6286,31 @@ function v2RenderOrgChart() {
     _hubAndSpoke();
   }
 
+  // ── crowded re-flow: break single-row walls into a serpentine grid ──
+  // A 12-role chain or hub laid out on one line says nothing about who talks
+  // to whom. When the layout degenerates to <=2 distinct rows with a crowded
+  // row, re-flow in reading order into rows of ~6, reversing every other row
+  // so consecutive nodes stay physically adjacent across wraps. Applies in
+  // both views for 8+ roles (the inline chart scales the viewBox down).
+  if (_crowded) {
+    const _rowsSeen = new Set(Object.values(pos).map(p => Math.round(p.y)));
+    const _widest = Math.max(..._rowsSeen.size ? [..._rowsSeen].map(y => Object.values(pos).filter(p => Math.round(p.y) === y).length) : [0]);
+    if (_rowsSeen.size <= 2 && _widest > 7) {
+      const seq = [...roles].sort((a, b) => (pos[a.id].y - pos[b.id].y) || (pos[a.id].x - pos[b.id].x));
+      const perRow = Math.min(6, Math.ceil(seq.length / Math.ceil(seq.length / 6)));
+      const COL_W = 185, ROW_H = 205;
+      seq.forEach((r, i) => {
+        const row = Math.floor(i / perRow);
+        let col = i % perRow;
+        if (row % 2 === 1) col = perRow - 1 - col; // serpentine
+        pos[r.id] = { x: PAD_X + col * COL_W, y: PAD_Y + row * ROW_H };
+      });
+      const rows = Math.ceil(seq.length / perRow);
+      W = PAD_X * 2 + (perRow - 1) * COL_W;
+      _layoutH = PAD_Y + (rows - 1) * ROW_H + R + 28;
+    }
+  }
+
   const H = _layoutH || (hasSubs ? 320 : 180);
 
   // ── build edge SVG strings with offset parallel arrows ─
@@ -6217,7 +6346,19 @@ function v2RenderOrgChart() {
     } else {
       stroke='oklch(65% 0.15 150)'; dash=''; marker='v2ah'; opacity=0.6; sw=1.5;
     }
-    edgesHTML += `<path id="${pid}" class="v2oc-edge" d="M${x1},${y1} L${x2},${y2}" stroke="${stroke}" stroke-opacity="${opacity}" stroke-width="${sw}" ${dash?`stroke-dasharray="${dash}"`:''}  fill="none" marker-end="url(#${marker})"/>`;
+    // Long spans (the boss fan-out crossing rows) bow outward as quadratic
+    // curves so crossings separate; short neighbor links stay straight.
+    const _spanLen = len - (trimS + trimE);
+    let dAttr;
+    if (_spanLen > 260) {
+      const sag = Math.min(56, _spanLen * 0.14) * edgeSide * canonDir;
+      const mx = ((+x1 + +x2) / 2 + px * sag).toFixed(1);
+      const my = ((+y1 + +y2) / 2 + py * sag).toFixed(1);
+      dAttr = `M${x1},${y1} Q${mx},${my} ${x2},${y2}`;
+    } else {
+      dAttr = `M${x1},${y1} L${x2},${y2}`;
+    }
+    edgesHTML += `<path id="${pid}" class="v2oc-edge" d="${dAttr}" stroke="${stroke}" stroke-opacity="${opacity}" stroke-width="${sw}" ${dash?`stroke-dasharray="${dash}"`:''}  fill="none" marker-end="url(#${marker})"/>`;
 
     // Animated flow particle on command edges
     if (edge.type === 'command') {
@@ -6269,13 +6410,15 @@ function v2RenderOrgChart() {
   });
 
   // ── assemble HTML ─────────────────────────────────────
+  // Expanded view: the chart owns the space — meta cards stay in the tab.
   pane.innerHTML = `
-    <div class="org-meta-strip">
+    ${_v2ChartExpanded ? '' : `<div class="org-meta-strip">
       <div class="oms-cell"><div class="oms-lbl">Goal</div><div class="oms-val" style="color:var(--text-mid);font-size:11px;line-height:1.4">${esc(goalText)}</div></div>
       <div class="oms-cell"><div class="oms-lbl">Topology</div><div class="oms-val">${esc(topo)}</div></div>
       <div class="oms-cell"><div class="oms-lbl">Created</div><div class="oms-val" style="color:var(--text-mid)">${esc(created)}</div></div>
-    </div>
+    </div>`}
     <div class="org-chart-wrap">
+      ${_v2ChartExpanded ? '' : `<button class="v2-chart-expand" onclick="v2ToggleChartExpand(true)" title="Expand chart to full page" aria-label="Expand chart to full page">⛶</button>`}
       <svg class="org-chart-svg" id="v2-org-svg" viewBox="0 0 ${W} ${H}" style="min-height:${Math.round(H * 0.5)}px">
         <defs>
           <marker id="v2ac" markerWidth="7" markerHeight="7" refX="6" refY="3.5" orient="auto"><path d="M0,0.5 L0,6.5 L6,3.5 z" fill="oklch(72% 0.18 75 / 0.8)"/></marker>
@@ -13633,8 +13776,13 @@ async function secondBrainSearch() {
       results.map(function (res) {
         var srcTag = (res.tags || []).find(function (t) { return t.indexOf('src:') === 0; });
         var label = srcTag ? srcTag.slice(4).split('/').slice(-2).join('/') : (res.key || '');
+        // Surface badge: the endpoint fuses chunks + KG triplets + rules +
+        // pattern memories (RRF); show non-chunk kinds so users see where a
+        // hit came from.
+        var kindBadge = res.triplet ? 'kg' : (res.rule ? 'rule' : (res.memory ? 'memory' : ''));
         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(label) +
+            (kindBadge ? ' <span style="color:var(--accent);border:1px solid var(--accent);border-radius:4px;padding:0 4px">' + kindBadge + '</span>' : '') +
             (res.global ? ' <span style="color:var(--accent-dim,#888);border:1px solid var(--border);border-radius:4px;padding:0 4px">global</span>' : '') +
             ' <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>' +

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

@@ -976,6 +976,7 @@ html, body {
             <div id="health-grid" class="health-grid"></div>
             <div id="health-detail"></div>
             <div id="health-history"></div>
+            <div id="health-memory"></div>
           </div>
         </div>
 
@@ -1762,6 +1763,7 @@ function renderHealth() {
   }
 
   loadRunHistory();
+  loadOrgMemory();
 }
 
 // Run history (history.jsonl, written by the daemon at each stopOrg): outcome,
@@ -1793,6 +1795,28 @@ async function loadRunHistory() {
   } catch (_) { el.innerHTML = ''; }
 }
 
+// Org memory: knowledge-graph size, learned entities, and distilled rules
+// (accumulated across runs via org_learn / heuristic extraction).
+async function loadOrgMemory() {
+  const el = document.getElementById('health-memory');
+  if (!el || !selectedOrg) return;
+  try {
+    const listOrg = allOrgs.find(o => o.name === selectedOrg) || {};
+    const r = await fetch(`/api/orgs/${encodeURIComponent(selectedOrg)}/memory?dir=${encodeURIComponent(listOrg.projectDir || '')}`);
+    if (!r.ok) { el.innerHTML = ''; return; }
+    const m = await r.json();
+    if (!m.nodes && !m.rules) { el.innerHTML = ''; return; }
+    el.innerHTML = `
+      <div style="margin-top:16px">
+        <div style="font-size:8px;letter-spacing:2px;color:var(--dim);margin-bottom:8px">ORG MEMORY — ${Number(m.nodes) || 0} ENTITIES · ${Number(m.edges) || 0} RELATIONS · ${Number(m.rules) || 0} RULES</div>
+        ${Array.isArray(m.glossary) && m.glossary.length ? `
+          <div style="font-size:9px;color:var(--muted);line-height:1.7">${m.glossary.map(g => `<span style="border:1px solid oklch(50% 0 0 / 0.25);border-radius:3px;padding:1px 5px;margin-right:4px;white-space:nowrap;display:inline-block;margin-bottom:3px">${esc(g)}</span>`).join('')}</div>` : ''}
+        ${Array.isArray(m.ruleTexts) && m.ruleTexts.length ? m.ruleTexts.map(t => `
+          <div style="font-size:9px;padding:4px 0;border-bottom:1px solid oklch(50% 0 0 / 0.1);color:var(--muted)">▸ ${esc(t)}</div>`).join('') : ''}
+      </div>`;
+  } catch (_) { el.innerHTML = ''; }
+}
+
 // ── CHAT TAB ──────────────────────────────────────────────────────
 let chatSessions = [];   // all sessions from /api/mastermind/sessions
 let chatCurrentId = null; // currently viewed session id

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

@@ -686,11 +686,72 @@ export async function startServer({ port = 4242, projectDir, openBrowser = true
   // back via an auth header or query param on non-GET requests.
   const authBytes = crypto.randomBytes(24);
   const dashboardAuthValue = authBytes.toString('hex');
-  try {
-    const authFileDir = path.join(projectDir || process.cwd(), '.monomind');
-    fs.mkdirSync(authFileDir, { recursive: true });
-    fs.writeFileSync(path.join(authFileDir, 'dashboard-token'), dashboardAuthValue, { mode: 0o600 });
-  } catch (_) {}
+  // A project has ONE primary token file (read by hooks, the CLI, and cross-
+  // project callers). Writing it eagerly here would let a SECONDARY instance
+  // (scratch port, tests, a second `serve`) clobber the live control server's
+  // token — after which every hook call to the primary 401s until it restarts,
+  // silently degrading per-prompt Second Brain injection to keyword fallback.
+  // So the write is deferred to bind time and gated: primary instances write
+  // `dashboard-token`; secondaries write `dashboard-token-<port>` instead.
+  async function writeDashboardToken(actualPort) {
+    try {
+      actualPort = Number(actualPort);
+      const authFileDir = path.join(projectDir || process.cwd(), '.monomind');
+      fs.mkdirSync(authFileDir, { recursive: true });
+      // Primary = control.json absent/invalid, or it names this port, or
+      // nothing answers on the port it names (stale record from a previous
+      // run). Liveness is an HTTP probe, not a pid check — control-start may
+      // record pid 0 for adopted servers, and dead pids get recycled; a probe
+      // is authoritative either way. Anything answering on the claimed port
+      // means "don't clobber" (conservative on ambiguity).
+      let primary = true;
+      try {
+        const ctl = JSON.parse(fs.readFileSync(path.join(authFileDir, 'control.json'), 'utf8'));
+        const ctlPort = Number(ctl.port || (String(ctl.url || '').match(/:(\d+)/) || [])[1]);
+        if (ctlPort && ctlPort !== actualPort && !(Number.isInteger(ctl.pid) && ctl.pid === process.pid)) {
+          try {
+            await fetch(`http://127.0.0.1:${ctlPort}/api/status`, { signal: AbortSignal.timeout(800) });
+            primary = false; // something answered — a live server owns the primary token
+          } catch (_) { primary = true; } // nothing answering — stale record
+        }
+      } catch (_) { /* no readable control.json — treat as primary */ }
+      fs.writeFileSync(
+        path.join(authFileDir, primary ? 'dashboard-token' : `dashboard-token-${actualPort}`),
+        dashboardAuthValue, { mode: 0o600 },
+      );
+      // Sweep stale secondary tokens (dead scratch/test instances) so they
+      // don't accumulate as orphaned credential files.
+      // monolean: age-based sweep only — no on-exit unlink plumbing.
+      try {
+        const weekMs = 7 * 24 * 3600 * 1000;
+        for (const f of fs.readdirSync(authFileDir)) {
+          if (!/^dashboard-token-\d+$/.test(f) || f === `dashboard-token-${actualPort}`) continue;
+          const fp = path.join(authFileDir, f);
+          if (Date.now() - fs.statSync(fp).mtimeMs > weekMs) fs.unlinkSync(fp);
+        }
+      } catch (_) {}
+    } catch (_) {}
+  }
+  // Propagate the fresh token to every known project whose control.json points
+  // at this server — otherwise each restart silently orphans cross-project
+  // callers (their curls/CLI reads a stale token and 401s forever).
+  // Called after bind so the match uses the ACTUAL bound port.
+  function propagateDashboardToken(actualPort) {
+    try {
+      const _kpFile = path.join(projectDir || process.cwd(), 'data', 'known-projects.json');
+      if (!fs.existsSync(_kpFile)) return;
+      for (const _kp of JSON.parse(fs.readFileSync(_kpFile, 'utf8'))) {
+        try {
+          const _kpMono = path.join(_kp, '.monomind');
+          const _kpCtl = JSON.parse(fs.readFileSync(path.join(_kpMono, 'control.json'), 'utf8'));
+          // Only pair projects that direct their traffic to this server's port.
+          if (_kpCtl && String(_kpCtl.url || '').includes(`:${actualPort}`)) {
+            fs.writeFileSync(path.join(_kpMono, 'dashboard-token'), dashboardAuthValue, { mode: 0o600 });
+          }
+        } catch (_) { /* project missing/unreadable — skip */ }
+      }
+    } catch (_) {}
+  }
 
   // Parse a .claude/agents/*.md definition into { name, description, capability{}, document }.
   // Tolerant line-based parse of the YAML frontmatter (expertise / task_types as lists).
@@ -763,7 +824,14 @@ export async function startServer({ port = 4242, projectDir, openBrowser = true
         eventProject = _norm;
       }
     }
-    const root = eventProject || projectDir || process.cwd();
+    // Forwarder events omit `project` on everything but org:start — resolve the
+    // org's home from known-projects so run-file writes land in the ORG's git
+    // dir, not the server's (the dashboard reads the org project's run files).
+    let _orgHome = null;
+    if (!eventProject && event.org) {
+      try { _orgHome = _resolveOrgProjectDir(String(event.org).trim(), projectDir || process.cwd()); } catch (_) {}
+    }
+    const root = eventProject || _orgHome || projectDir || process.cwd();
     const dataDir = path.join(root, 'data');
     try { fs.mkdirSync(dataDir, { recursive: true }); } catch (_) {}
     // Track known project dirs for aggregated session listing
@@ -1069,7 +1137,55 @@ export async function startServer({ port = 4242, projectDir, openBrowser = true
           } catch (_) { /* watcher callback must never throw */ }
         });
         activeWatchers.push(_sbWatcher);
-      } catch (_) { /* recursive watch unavailable — session-start reindex covers it */ }
+      } catch (_) { /* recursive watch unavailable — the sweep below still covers it */ }
+
+      // Polling sweep backstop: fs.watch/fsevents silently stops delivering on
+      // some volumes (exFAT/SMB — exactly where many projects live). Every 60s,
+      // a bounded mtime walk ingests anything the watcher missed. Stat-only
+      // when nothing changed; skips while a sweep is already running.
+      try {
+        const _sbDocExts2 = new Set(['.md', '.txt', '.pdf', '.docx']);
+        const _sbSkipDirs = new Set(['node_modules', '.git', 'dist', '.monomind', '.claude', '.next', '__pycache__', '.venv', 'vendor']);
+        const _sbSweepRoot = path.resolve(projectDir || process.cwd());
+        let _sbLastSweep = Date.now();
+        let _sbSweeping = false;
+        const _sbSweepTimer = setInterval(async () => {
+          if (_sbSweeping) return;
+          _sbSweeping = true;
+          const since = _sbLastSweep - 5000; // small overlap so boundary writes aren't missed
+          _sbLastSweep = Date.now();
+          try {
+            const changed = [];
+            let scanned = 0;
+            const walk = (dir, depth) => {
+              if (depth > 4 || scanned > 3000 || changed.length >= 20) return;
+              let names;
+              try { names = fs.readdirSync(dir, { withFileTypes: true }); } catch (_) { return; }
+              for (const ent of names) {
+                if (scanned++ > 3000 || changed.length >= 20) return;
+                if (ent.name.startsWith('.') || _sbSkipDirs.has(ent.name)) continue;
+                const full = path.join(dir, ent.name);
+                if (ent.isDirectory()) { walk(full, depth + 1); continue; }
+                if (!_sbDocExts2.has(path.extname(ent.name).toLowerCase())) continue;
+                try { if (fs.statSync(full).mtimeMs > since) changed.push(full); } catch (_) {}
+              }
+            };
+            walk(_sbSweepRoot, 0);
+            if (changed.length) {
+              const pipeline = await import('../knowledge/document-pipeline.js');
+              for (const f of changed) {
+                try {
+                  const r = await pipeline.ingestDocument(f, 'shared', _sbSweepRoot);
+                  if (r.chunksIndexed > 0 && !r.skipped) console.log(`[knowledge] sweep-ingested ${path.basename(f)} (${r.chunksIndexed} chunks)`);
+                } catch (_) { /* per-file failures never matter here */ }
+              }
+            }
+          } catch (_) { /* sweep is best-effort */ }
+          finally { _sbSweeping = false; }
+        }, 60_000);
+        if (_sbSweepTimer.unref) _sbSweepTimer.unref();
+        activeWatchers.push({ close: () => clearInterval(_sbSweepTimer) });
+      } catch (_) { /* non-fatal */ }
     }
   } catch (_) { /* non-fatal */ }
 
@@ -5948,6 +6064,34 @@ new Sigma(g,document.getElementById('g'),{renderEdgeLabels:false,labelColor:{col
       return;
     }
 
+    // GET /api/orgs/:name/memory — org knowledge-graph stats + glossary + rules
+    if (req.method === 'GET' && /^\/api\/orgs\/[^/]+\/memory$/.test(url)) {
+      try {
+        const orgName = decodeURIComponent(url.split('/')[3]);
+        const _memQs = new URL(req.url, 'http://localhost').searchParams;
+        const root = path.resolve(_memQs.get('dir') || projectDir || process.cwd());
+        if (!orgName || orgName.length > 64 || !/^[a-z0-9][a-z0-9_-]*$/i.test(orgName)) {
+          res.writeHead(400); res.end('{"error":"invalid org name"}'); return;
+        }
+        const monoDir = _getGitMonomindDir(root) || path.join(root, '.monomind');
+        const dbPath = path.join(monoDir, 'org-memory');
+        if (!fs.existsSync(dbPath)) {
+          res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
+          res.end(JSON.stringify({ nodes: 0, edges: 0, rules: 0, glossary: [], ruleTexts: [] }));
+          return;
+        }
+        const kg = await import('../memory/memory-kg.js');
+        const [stats, glossary, ruleList] = await Promise.all([
+          kg.kgStats({ dbPath }), kg.kgGlossary({ dbPath, limit: 12 }), kg.kgListRules({ dbPath, limit: 10 }),
+        ]);
+        res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
+        res.end(JSON.stringify({ ...stats, glossary, ruleTexts: ruleList.map(r => r.rule.slice(0, 200)) }));
+      } catch(err) {
+        res.writeHead(500); res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
     // POST /api/knowledge/search — warm semantic knowledge search for hooks.
     // The dashboard server is the one long-lived process on the machine, so it
     // holds the local embedding model warm; per-prompt hook subprocesses (which
@@ -5988,17 +6132,69 @@ new Sigma(g,document.getElementById('g'),{renderEdgeLabels:false,labelColor:{col
           // 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([
+          // Rule-based router (no LLM): chunks always run (this endpoint's
+          // bread and butter); the auxiliary surfaces — distilled rules,
+          // knowledge-graph triplets, pattern memories — only spend a query
+          // when the router votes for them or routing is unconfident.
+          let wantRules = true, wantKg = true, wantMemory = true;
+          let rrfFuse = null;
+          try {
+            const routerMod = await import('../memory/query-router.js');
+            const route = routerMod.routeQuery(query);
+            rrfFuse = routerMod.rrfFuse;
+            wantRules = !route.confident || route.surfaces.includes('rules');
+            wantKg = !route.confident || route.surfaces.includes('kg');
+            wantMemory = !route.confident || route.surfaces.includes('memory');
+          } catch { /* router unavailable — keep all surfaces on */ }
+          let kgSearch = null;
+          if (wantKg && scope !== 'global') {
+            try { kgSearch = (await import('../memory/memory-kg.js')).kgSearch; } catch { /* kg unavailable */ }
+          }
+          const [proj, glob, rules, graph, mems] = 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,
+            // Distilled rules ("when X do Y") learned from sessions/runs —
+            // small namespace, high injection value, threshold keeps it quiet.
+            scope !== 'global' && wantRules ? bridge.bridgeSearchEntries({ query, namespace: 'rules', limit: 2, threshold: 0.45 }).catch(() => null) : null,
+            // Knowledge-graph triplets: relationship-shaped queries surface
+            // facts no chunk contains. Triplet scores derive from seeded
+            // cosine matches (≥0.35), so they clear callers' relevance floors.
+            scope !== 'global' && kgSearch ? kgSearch({ query, limit: 4 }).catch(() => null) : null,
+            // Past patterns/decisions for "last time / previously" queries.
+            scope !== 'global' && wantMemory ? bridge.bridgeSearchEntries({ query, namespace: 'patterns', limit: 2, threshold: 0.4 }).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);
+          const lists = [
+            (proj?.results || []).map(r => ({ id: r.id, key: r.key, content: String(r.content || '').slice(0, 2000), score: r.score + 0.05, global: false, tags: r.tags, importance: 0.6 })),
+            (glob?.results || []).map(r => ({ id: r.id, key: r.key, content: String(r.content || '').slice(0, 2000), score: r.score, global: true, tags: r.tags })),
+            (rules?.results || []).map(r => ({ id: r.id, key: r.key, content: String(r.content || '').slice(0, 2000), score: r.score + 0.05, global: false, rule: true, tags: r.tags, importance: 0.7 })),
+            (graph?.triplets || []).map((t, i) => ({
+              id: 'kg:' + i + ':' + t.source + '|' + t.relation + '|' + t.target,
+              key: 'kg:' + t.source,
+              content: String(t.source + ' —' + t.relation + '→ ' + t.target + (t.fact && t.fact !== (t.source + ' ' + t.relation + ' ' + t.target) ? ' (' + String(t.fact).slice(0, 300) + ')' : '')).slice(0, 2000),
+              score: t.score, global: false, triplet: true,
+            })),
+            (mems?.results || []).map(r => ({ id: r.id, key: r.key, content: String(r.content || '').slice(0, 2000), score: r.score, global: false, memory: true, tags: r.tags })),
+          ];
+          // Rank-fuse across surfaces (raw scores aren't comparable between
+          // cosine chunks and blended triplets); each item keeps its native
+          // score so downstream relevance floors still apply. Fallback: flat
+          // score sort when the router module failed to load.
+          const merged = (rrfFuse
+            ? rrfFuse(lists, limit)
+            : lists.flat().sort((a, b) => b.score - a.score).slice(0, limit)
+          ).map(({ importance, rrf, ...r }) => r);
+          // Served excerpts are (very likely) injected into the caller's prompt —
+          // that IS usage. Reinforce frequency_weight, per-store, fire-and-forget.
+          try {
+            const projIds = merged.filter(m => !m.global && !m.triplet && m.id).map(m => m.id);
+            const globIds = merged.filter(m => m.global && m.id).map(m => m.id);
+            if (projIds.length) bridge.bridgeRecordUsage?.({ entryIds: projIds }).catch(() => {});
+            if (globIds.length) bridge.bridgeRecordUsage?.({ entryIds: globIds, dbPath: '@global' }).catch(() => {});
+          } catch { /* best effort */ }
           res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
           res.end(JSON.stringify({
-            method: proj?.searchMethod || glob?.searchMethod || 'none',
+            method: proj?.searchMethod || glob?.searchMethod || rules?.searchMethod || mems?.searchMethod
+              || (merged.length ? 'mixed' : 'none'),
             results: merged,
           }));
         } catch (err) {
@@ -6390,6 +6586,8 @@ new Sigma(g,document.getElementById('g'),{renderEdgeLabels:false,labelColor:{col
       fs.writeFileSync(process.env.MONOMIND_BOUND_REPORT, JSON.stringify({ pid: process.pid, port: boundPort, ts: Date.now() }));
     } catch (_) { /* non-fatal — spawner falls back to pid-matched HTTP probe */ }
   }
+  await writeDashboardToken(boundPort);
+  propagateDashboardToken(boundPort);
 
   // ── One-time migration: mastermind-sessions.json → per-session JSONL ─────
   // Runs once on startup. Existing sessions in the old monolithic format are

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

@@ -1,8 +1,8 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "2.5.0",
+  "version": "2.5.2",
   "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.",
+  "description": "CLI engine for Monomind \u2014 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",
   "types": "dist/src/index.d.ts",
   "sideEffects": false,
@@ -72,6 +72,7 @@
     ".claude",
     "!.claude/**/.monomind/**",
     "!.claude/**/*.lock",
+    "!.claude/**/._*",
     "!dist/**/.monomind/**",
     "!dist/**/._*",
     "!.claude/agents/generated/**",
@@ -84,7 +85,7 @@
     "build:loose": "tsc --noEmitOnError false || true && mkdir -p dist/src/browser/dashboard && cp src/browser/dashboard/ui.html dist/src/browser/dashboard/ui.html && mkdir -p dist/src/ui && cp src/ui/dashboard.html src/ui/server.mjs src/ui/collector.mjs src/ui/orgs.html src/ui/orgs-files.js src/ui/sse-manager.mjs src/ui/mastermind-diagram-fallback.html dist/src/ui/ && rm -rf dist/src/ui/data && cp -r src/ui/data dist/src/ui/data",
     "test": "vitest run",
     "test:pattern-store": "npx tsx src/transfer/store/tests/standalone-test.ts",
-    "prepublishOnly": "cp ../../../README.md ./README.md",
+    "prepublishOnly": "node ../../@monoes/monodesign/scripts/sync-skill.mjs && cp ../../../README.md ./README.md",
     "release": "npm version prerelease --preid=alpha && npm run publish:all",
     "publish:all": "./scripts/publish.sh"
   },
@@ -95,6 +96,7 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.207",
     "@monoes/monobrowse": "^1.0.3",
+    "@monoes/monodesign": "^1.0.1",
     "@monoes/monograph": "^1.4.0",
     "@noble/ed25519": "^2.1.0",
     "mammoth": "^1.12.0",
@@ -105,7 +107,7 @@
   },
   "optionalDependencies": {
     "@huggingface/transformers": "^3.8.1",
-    "@monoes/memory": "^1.0.8",
+    "@monoes/memory": "^1.0.10",
     "@monomind/hooks": "*",
     "@monomind/mcp": "*",
     "@monomind/routing": "*",