aimeat 1.28.0 → 1.30.0

package/dist/public/views/profile/organisms/mindmap.js

@@ -1,16 +1,21 @@
 /**
  * @file mindmap.js
- * @description Interactive, DETERMINISTIC structure mindmap for an organism or a single workspace.
- *   Reuses the offers "Kartta" pattern: a strict-security Mermaid diagram (no Mermaid click handlers)
- *   whose node ids we generate ourselves (`ws{i}`, `ws{i}_sp{j}`, `mem{i}`, `ag{i}`, `sp{j}`) and then
- *   resolve from a click on the rendered SVG → onNavigate(target). Options (depth level, show users,
- *   show activity counts, heatmap) regenerate the source, so the map re-renders live. This is SEPARATE
- *   from the README and the OKF overview: it is generated from the /graph data, not authored, and not
- *   part of OKF. Heatmap colours are read from theme CSS variables (no hardcoded colours).
- * @structure StructureMindmap({ scope, graph, onNavigate, label }); buildOrganismMindmap; buildWorkspaceMindmap
+ * @description Interactive, DETERMINISTIC structure map for an organism or a single workspace, with
+ *   selectable chart types — **mindmap** (radial, the default; most compact / best at-a-glance),
+ *   **flowchart LR** and **flowchart TD** (familiar tree views). Reuses the offers "Kartta" pattern:
+ *   strict-security Mermaid (no Mermaid click handlers); flowchart nodes carry ids we generate
+ *   (`ws{i}`, `ws{i}_sp{j}`, `mem{i}`, `ag{i}`, `sp{j}`) and a click resolves them by id, while mindmap
+ *   nodes resolve by their label text (mindmap can't carry arbitrary ids). Options (chart type, detail
+ *   level, show users, show activity, heatmap) regenerate the source and are PERSISTED per user per
+ *   organism/workspace in localStorage. Generated from the /graph data — separate from the README and
+ *   the OKF outline, and never persisted server-side. Heatmap colours come from theme CSS variables.
+ * @structure StructureMindmap({ scope, graph, onNavigate, label, storageKey });
+ *   buildOrganismMindmap / buildWorkspaceMindmap (chart-type aware, used here + by the timeline)
  * @usage import { StructureMindmap } from '/views/profile/organisms/mindmap.js';
  * @version-history
  *   v1.0.0 — 2026-06-22 — Initial: clickable organism/workspace mindmap with level/users/activity/heatmap.
+ *   v1.1.0 — 2026-06-22 — Chart types (mindmap default + flowchart LR/TD), per-org/ws localStorage
+ *     persistence, label-text click resolution for mindmap mode.
  */
 import { h } from 'preact';
 import { useState } from 'preact/hooks';
@@ -19,12 +24,16 @@ const html = htm.bind(h);
 import { t } from '/js/i18n.js';
 import { Mermaid } from '/components/Mermaid.js';
 
-/** Sanitize a label for a Mermaid quoted string (strip quotes/newlines/structural chars, clip). */
+/** Sanitize a label for a Mermaid quoted flowchart string. */
 function mmdLabel(s) {
   return String(s ?? '').replace(/["\n\r]/g, ' ').replace(/[<>|{}[\]]/g, '').trim().slice(0, 48) || '—';
 }
+/** Stricter sanitize for MINDMAP labels — also strips parentheses (mindmap treats `(...)` as a node
+ *  shape, so a label like "Ledger (410)" would mis-parse). Counts are shown with " · N" instead. */
+function mmLabel(s) {
+  return String(s ?? '').replace(/["\n\r]/g, ' ').replace(/[<>|{}[\]()]/g, '').trim().slice(0, 48) || '—';
+}
 
-/** Bucket an item count into a heat class index (0 = none → no class). */
 function heatBucket(n) {
   if (!n) return 0;
   if (n <= 3) return 1;
@@ -32,7 +41,7 @@ function heatBucket(n) {
   return 3;
 }
 
-/** Read heat colours from theme CSS variables (source of truth stays in theme.css). */
+/** Heat colours from theme CSS variables (source of truth = theme.css). */
 function heatColors() {
   const cs = typeof window !== 'undefined' ? getComputedStyle(document.documentElement) : null;
   const v = (n, fb) => ((cs && cs.getPropertyValue(n).trim()) || fb);
@@ -43,8 +52,8 @@ function heatColors() {
   };
 }
 
-/** Build the classDef + class lines for the heatmap (only for nodes with content). */
-function heatLines(assignments) {
+/** classDef + class lines for the flowchart heatmap (mindmap uses :::class + CSS instead). */
+function flowchartHeatLines(assignments) {
   if (!assignments.length) return [];
   const c = heatColors();
   const lines = [
@@ -56,20 +65,21 @@ function heatLines(assignments) {
   return lines;
 }
 
-/** Short activity label suffix for a node (counts + last update), when showActivity is on. */
 function activitySuffix(opts, { records, documents, lastActivity }) {
   if (!opts.showActivity) return '';
   const bits = [];
-  if (documents != null && documents) bits.push(`${documents}d`);
-  if (records != null && records) bits.push(`${records}r`);
+  if (documents) bits.push(`${documents}d`);
+  if (records) bits.push(`${records}r`);
   let s = bits.length ? ` · ${bits.join('+')}` : '';
   if (lastActivity) s += ` · ${String(lastActivity).slice(0, 10)}`;
   return s;
 }
 
-/** Build deterministic Mermaid source for an ORGANISM graph + render options. */
-export function buildOrganismMindmap(graph, opts) {
-  const lines = ['flowchart LR', `  org["${mmdLabel(graph.name)}"]`];
+/* ── Flowchart builders (LR / TD) — node ids encode the target for click resolution ── */
+
+function buildOrgFlowchart(graph, opts) {
+  const dir = opts.chartType === 'flowchart-td' ? 'TD' : 'LR';
+  const lines = [`flowchart ${dir}`, `  org["${mmdLabel(graph.name)}"]`];
   const heat = [];
   (graph.workspaces || []).forEach((w, i) => {
     const wsTotal = (w.totalRecords || 0) + (w.totalDocuments || 0);
@@ -78,8 +88,8 @@ export function buildOrganismMindmap(graph, opts) {
     if (opts.heatmap) { const b = heatBucket(wsTotal); if (b) heat.push({ id: `ws${i}`, bucket: b }); }
     if (opts.level === 'spaces' || opts.level === 'counts') {
       (w.spaces || []).forEach((sp, j) => {
-        const countSuffix = opts.level === 'counts' ? ` (${sp.count || 0})` : '';
-        lines.push(`  ws${i} --> ws${i}_sp${j}["${mmdLabel(sp.name)}${countSuffix}"]`);
+        const c = opts.level === 'counts' ? ` (${sp.count || 0})` : '';
+        lines.push(`  ws${i} --> ws${i}_sp${j}["${mmdLabel(sp.name)}${c}"]`);
         if (opts.heatmap) { const b = heatBucket(sp.count || 0); if (b) heat.push({ id: `ws${i}_sp${j}`, bucket: b }); }
       });
     }
@@ -88,81 +98,163 @@ export function buildOrganismMindmap(graph, opts) {
     (graph.members || []).forEach((m, i) => lines.push(`  org --> mem${i}["👤 ${mmdLabel(m.name)}"]`));
     (graph.agents || []).forEach((a, i) => lines.push(`  org --> ag${i}["🤖 ${mmdLabel(a.name || a.gaii)}"]`));
   }
-  return lines.concat(heatLines(heat)).join('\n');
+  return lines.concat(flowchartHeatLines(heat)).join('\n');
 }
 
-/** Build deterministic Mermaid source for a single WORKSPACE graph node + render options. */
-export function buildWorkspaceMindmap(node, opts) {
+function buildWsFlowchart(node, opts) {
+  const dir = opts.chartType === 'flowchart-td' ? 'TD' : 'LR';
   const wsLabel = mmdLabel(node.name) + activitySuffix(opts, { records: node.totalRecords, documents: node.totalDocuments, lastActivity: node.lastActivity });
-  const lines = ['flowchart LR', `  wsroot["${wsLabel}"]`];
+  const lines = [`flowchart ${dir}`, `  wsroot["${wsLabel}"]`];
   const heat = [];
   if (opts.level !== 'ws') {
     (node.spaces || []).forEach((sp, j) => {
-      const countSuffix = opts.level === 'counts' ? ` (${sp.count || 0})` : '';
-      lines.push(`  wsroot --> sp${j}["${mmdLabel(sp.name)}${countSuffix}"]`);
+      const c = opts.level === 'counts' ? ` (${sp.count || 0})` : '';
+      lines.push(`  wsroot --> sp${j}["${mmdLabel(sp.name)}${c}"]`);
       if (opts.heatmap) { const b = heatBucket(sp.count || 0); if (b) heat.push({ id: `sp${j}`, bucket: b }); }
     });
   }
-  return lines.concat(heatLines(heat)).join('\n');
+  return lines.concat(flowchartHeatLines(heat)).join('\n');
+}
+
+/* ── Mindmap builders (radial) — labels resolve clicks by text. Mermaid's mindmap does NOT support
+ *    the `:::class` node-class syntax (it renders it as literal text), so the heatmap is shown with a
+ *    trailing marker emoji instead of a coloured shape. ── */
+
+const HEAT_MARK = { 1: '🟢', 2: '🔶', 3: '🔥' };
+function heatMark(opts, n) { if (!opts.heatmap) return ''; const b = heatBucket(n); return b ? ` ${HEAT_MARK[b]}` : ''; }
+
+function buildOrgMindmap(graph, opts) {
+  const lines = ['mindmap', `  root((${mmLabel(graph.name)}))`];
+  (graph.workspaces || []).forEach((w) => {
+    const wsTotal = (w.totalRecords || 0) + (w.totalDocuments || 0);
+    const wsLabel = mmLabel(w.name) + activitySuffix(opts, { records: w.totalRecords, documents: w.totalDocuments, lastActivity: w.lastActivity });
+    lines.push(`    ${wsLabel}${heatMark(opts, wsTotal)}`);
+    if (opts.level === 'spaces' || opts.level === 'counts') {
+      (w.spaces || []).forEach((sp) => {
+        const c = opts.level === 'counts' ? ` · ${sp.count || 0}` : '';
+        lines.push(`      ${mmLabel(sp.name)}${c}${heatMark(opts, sp.count || 0)}`);
+      });
+    }
+  });
+  if (opts.showUsers) {
+    (graph.members || []).forEach((m) => lines.push(`    👤 ${mmLabel(m.name)}`));
+    (graph.agents || []).forEach((a) => lines.push(`    🤖 ${mmLabel(a.name || a.gaii)}`));
+  }
+  return lines.join('\n');
+}
+
+function buildWsMindmap(node, opts) {
+  const wsLabel = mmLabel(node.name) + activitySuffix(opts, { records: node.totalRecords, documents: node.totalDocuments, lastActivity: node.lastActivity });
+  const lines = ['mindmap', `  root((${wsLabel}))`];
+  if (opts.level !== 'ws') {
+    (node.spaces || []).forEach((sp) => {
+      const c = opts.level === 'counts' ? ` · ${sp.count || 0}` : '';
+      lines.push(`    ${mmLabel(sp.name)}${c}${heatMark(opts, sp.count || 0)}`);
+    });
+  }
+  return lines.join('\n');
 }
 
-/** Resolve a click on a rendered Mermaid node to a navigation target, by parsing the node's DOM id
- *  (which embeds the id we generated). Returns null for the root / unknown nodes. */
-function resolveClick(scope, graph, domId) {
+/** Build deterministic Mermaid source for an ORGANISM graph honouring opts.chartType. */
+export function buildOrganismMindmap(graph, opts) {
+  return opts.chartType === 'mindmap' ? buildOrgMindmap(graph, opts) : buildOrgFlowchart(graph, opts);
+}
+/** Build deterministic Mermaid source for a single WORKSPACE graph node honouring opts.chartType. */
+export function buildWorkspaceMindmap(node, opts) {
+  return opts.chartType === 'mindmap' ? buildWsMindmap(node, opts) : buildWsFlowchart(node, opts);
+}
+
+/* ── Click resolution ── */
+
+/** Flowchart: parse the clicked node's DOM id (it embeds the generated id). */
+function resolveFlowchartClick(scope, graph, domId) {
   if (scope === 'organism') {
     let m = /ws(\d+)_sp(\d+)/.exec(domId);
-    if (m) {
-      const w = graph.workspaces?.[+m[1]]; const sp = w?.spaces?.[+m[2]];
-      if (w && sp) return { type: 'space', wsId: w.id, space: sp.name };
-      return null;
-    }
+    if (m) { const w = graph.workspaces?.[+m[1]]; const sp = w?.spaces?.[+m[2]]; return (w && sp) ? { type: 'space', wsId: w.id, space: sp.name } : null; }
     m = /ws(\d+)(?![_\d])/.exec(domId);
     if (m) { const w = graph.workspaces?.[+m[1]]; return w ? { type: 'workspace', wsId: w.id } : null; }
     if (/mem\d+/.test(domId) || /ag\d+/.test(domId)) return { type: 'members' };
     return null;
   }
-  // workspace scope
   const m = /sp(\d+)/.exec(domId);
   if (m) { const sp = graph.spaces?.[+m[1]]; return sp ? { type: 'space', space: sp.name } : null; }
   return null;
 }
 
+/** Mindmap: resolve by the clicked node's label text (mindmap nodes have no stable id). Strips the
+ *  activity/count suffix and the user emoji, then matches the core name to a workspace / space /
+ *  member. Workspace + member matches are exact; a space name is matched to the first workspace that
+ *  has it (mindmap can't disambiguate a repeated space name across workspaces — opens that workspace). */
+function resolveMindmapClick(scope, graph, text) {
+  const core = String(text || '').trim().split(' · ')[0].replace(/^👤\s*|^🤖\s*/, '').trim();
+  if (!core) return null;
+  if (scope === 'organism') {
+    for (const w of (graph.workspaces || [])) if (w.name === core) return { type: 'workspace', wsId: w.id };
+    for (const w of (graph.workspaces || [])) for (const sp of (w.spaces || [])) if (sp.name === core) return { type: 'workspace', wsId: w.id };
+    if ((graph.members || []).some(m => m.name === core) || (graph.agents || []).some(a => (a.name || a.gaii) === core)) return { type: 'members' };
+    return null;
+  }
+  for (const sp of (graph.spaces || [])) if (sp.name === core) return { type: 'space', space: sp.name };
+  return null;
+}
+
+const CHART_TYPES = [
+  { key: 'mindmap', label: 'mindmap.chartMindmap', fallback: 'Mindmap' },
+  { key: 'flowchart-lr', label: 'mindmap.chartLr', fallback: 'Flowchart →' },
+  { key: 'flowchart-td', label: 'mindmap.chartTd', fallback: 'Flowchart ↓' },
+];
 const LEVELS = [
   { key: 'ws', label: 'mindmap.levelWs', fallback: 'Workspaces' },
   { key: 'spaces', label: 'mindmap.levelSpaces', fallback: '+ Spaces' },
   { key: 'counts', label: 'mindmap.levelCounts', fallback: '+ Counts' },
 ];
 
+const DEFAULTS = { chartType: 'mindmap', level: 'spaces', showUsers: false, showActivity: true, heatmap: true };
+
+/** Load persisted options for this org/ws (per-user via localStorage), merged over defaults. */
+function loadOpts(storageKey) {
+  if (!storageKey) return { ...DEFAULTS };
+  try {
+    const raw = localStorage.getItem(`aimeat.mm.${storageKey}`);
+    return raw ? { ...DEFAULTS, ...JSON.parse(raw) } : { ...DEFAULTS };
+  } catch { return { ...DEFAULTS }; }
+}
+function saveOpts(storageKey, opts) {
+  if (!storageKey) return;
+  try { localStorage.setItem(`aimeat.mm.${storageKey}`, JSON.stringify(opts)); } catch { /* quota/private mode — non-fatal */ }
+}
+
 /**
- * StructureMindmap — collapsible interactive map. Default collapsed so the 3MB Mermaid bundle only
- * loads when asked for. scope 'organism' (root = organism, with workspaces → spaces + members/agents)
- * or 'workspace' (root = the workspace, with its spaces). onNavigate(target) receives:
- *   { type:'workspace', wsId } | { type:'space', wsId?, space } | { type:'members' }
- * @param {{ scope: 'organism'|'workspace', graph: object, onNavigate: (t:object)=>void, label?: string }} props
+ * StructureMindmap — collapsible interactive map. Default collapsed so the Mermaid bundle only loads
+ * when asked for. scope 'organism' (root → workspaces → spaces + members/agents) or 'workspace'.
+ * onNavigate(target): { type:'workspace', wsId } | { type:'space', wsId?, space } | { type:'members' }.
+ * @param {{ scope:'organism'|'workspace', graph:object, onNavigate:(t:object)=>void, label?:string, storageKey?:string }} props
  */
-export function StructureMindmap({ scope, graph, onNavigate, label }) {
+export function StructureMindmap({ scope, graph, onNavigate, label, storageKey }) {
   const [open, setOpen] = useState(false);
-  const [level, setLevel] = useState(scope === 'workspace' ? 'spaces' : 'spaces');
-  const [showUsers, setShowUsers] = useState(false);
-  const [showActivity, setShowActivity] = useState(true);
-  const [heatmap, setHeatmap] = useState(true);
+  const [opts, setOpts] = useState(() => loadOpts(storageKey));
 
   if (!graph) return null;
-  const opts = { level, showUsers, showActivity, heatmap };
+  const set = (patch) => setOpts(prev => { const next = { ...prev, ...patch }; saveOpts(storageKey, next); return next; });
+
   const src = open
     ? (scope === 'organism' ? buildOrganismMindmap(graph, opts) : buildWorkspaceMindmap(graph, opts))
     : '';
 
   const onMapClick = (e) => {
-    const node = e.target?.closest?.('.node');
-    if (!node) return;
-    const target = resolveClick(scope, graph, node.id || '');
-    if (target) onNavigate?.(target);
+    if (opts.chartType === 'mindmap') {
+      const g = e.target?.closest?.('.mindmap-node, [class*="mindmap"], g');
+      const target = resolveMindmapClick(scope, graph, (g?.textContent) || e.target?.textContent || '');
+      if (target) onNavigate?.(target);
+    } else {
+      const node = e.target?.closest?.('.node');
+      if (!node) return;
+      const target = resolveFlowchartClick(scope, graph, node.id || '');
+      if (target) onNavigate?.(target);
+    }
   };
 
-  const lbl = label || (scope === 'organism'
-    ? (t('mindmap.titleOrg') || 'Organism map')
-    : (t('mindmap.titleWs') || 'Workspace map'));
+  const lbl = label || (scope === 'organism' ? (t('mindmap.titleOrg') || 'Organism map') : (t('mindmap.titleWs') || 'Workspace map'));
 
   return html`
     <div class="pj-mindmap">
@@ -173,17 +265,23 @@ export function StructureMindmap({ scope, graph, onNavigate, label }) {
       ${open ? html`
         <div class="pj-mindmap-body card-detail">
           <div class="pj-mindmap-opts">
+            <label class="pj-mm-opt">
+              <span>${t('mindmap.chart') || 'Chart'}</span>
+              <select class="input-field input-sm" value=${opts.chartType} onChange=${e => set({ chartType: e.target.value })}>
+                ${CHART_TYPES.map(c => html`<option value=${c.key}>${t(c.label) || c.fallback}</option>`)}
+              </select>
+            </label>
             <label class="pj-mm-opt">
               <span>${t('mindmap.level') || 'Level'}</span>
-              <select class="input-field input-sm" value=${level} onChange=${e => setLevel(e.target.value)}>
+              <select class="input-field input-sm" value=${opts.level} onChange=${e => set({ level: e.target.value })}>
                 ${LEVELS.map(l => html`<option value=${l.key}>${t(l.label) || l.fallback}</option>`)}
               </select>
             </label>
             ${scope === 'organism' ? html`
-              <label class="pj-mm-check"><input type="checkbox" checked=${showUsers} onChange=${e => setShowUsers(e.target.checked)} /> ${t('mindmap.showUsers') || 'Users'}</label>
+              <label class="pj-mm-check"><input type="checkbox" checked=${opts.showUsers} onChange=${e => set({ showUsers: e.target.checked })} /> ${t('mindmap.showUsers') || 'Users'}</label>
             ` : null}
-            <label class="pj-mm-check"><input type="checkbox" checked=${showActivity} onChange=${e => setShowActivity(e.target.checked)} /> ${t('mindmap.showActivity') || 'Activity'}</label>
-            <label class="pj-mm-check"><input type="checkbox" checked=${heatmap} onChange=${e => setHeatmap(e.target.checked)} /> ${t('mindmap.heatmap') || 'Heatmap'}</label>
+            <label class="pj-mm-check"><input type="checkbox" checked=${opts.showActivity} onChange=${e => set({ showActivity: e.target.checked })} /> ${t('mindmap.showActivity') || 'Activity'}</label>
+            <label class="pj-mm-check"><input type="checkbox" checked=${opts.heatmap} onChange=${e => set({ heatmap: e.target.checked })} /> ${t('mindmap.heatmap') || 'Heatmap'}</label>
           </div>
           <div class="pj-mindmap-canvas of-mapwrap--clickable" onClick=${onMapClick}>
             <${Mermaid} chart=${src} />

package/dist/public/views/profile/organisms/panels.js

@@ -8,6 +8,8 @@
  * @usage import { OrgSearch, IncomingInvitations, BoardPreview } from '/views/profile/organisms/panels.js';
  * @version-history
  *   v1.0.0 — 2026-06-19 — Extracted from organisms-tab.js during the module split.
+ *   v1.1.0 — 2026-06-22 — OrgSearch: instant (debounced) indexed search, results grouped by workspace,
+ *     and clicking a hit deep-links to the exact record/document (via the workspace openDoc handoff).
  */
 import { h } from 'preact';
 import { useState, useEffect, useCallback, useRef } from 'preact/hooks';
@@ -32,34 +34,49 @@ export function OrgSearch({ orgId, onOpenWorkspace }) {
   const [results, setResults] = useState(null);
   const [busy, setBusy] = useState(false);
 
-  const doSearch = async () => {
+  // Instant (debounced) search across the organism — indexed FTS backend (GET /:id/search).
+  useEffect(() => {
     const query = q.trim();
-    if (query.length < 2) return;
+    if (query.length < 2) { setResults(null); setBusy(false); return undefined; }
+    let cancelled = false;
     setBusy(true);
-    try {
-      const r = await orgService.searchOrganism(orgId, query);
-      setResults(r?.data?.results || []);
-    } catch { setResults([]); }
-    finally { setBusy(false); }
+    const tid = setTimeout(async () => {
+      try { const r = await orgService.searchOrganism(orgId, query); if (!cancelled) setResults(r?.data?.results || []); }
+      catch { if (!cancelled) setResults([]); }
+      finally { if (!cancelled) setBusy(false); }
+    }, 220);
+    return () => { cancelled = true; clearTimeout(tid); };
+  }, [q, orgId]);
+
+  // Open a hit at the exact record/document: stash the deep-link the workspace reads on mount, then
+  // navigate to that workspace (its openDoc effect resolves namespace → space tab + opens the item).
+  const openHit = (r) => {
+    try { sessionStorage.setItem(`aimeat.ws.${orgId}.${r.ws}.openDoc`, JSON.stringify({ namespace: r.namespace, id: r.id })); } catch { /* noop */ }
+    onOpenWorkspace?.(r.ws);
   };
 
+  // Group hits by workspace so a big organism's results stay legible.
+  const byWs = {};
+  for (const r of (results || [])) (byWs[r.ws] = byWs[r.ws] || { name: r.wsName || r.ws, hits: [] }).hits.push(r);
+
   return html`
     <div class="pj-orgsearch">
       <div class="flex-row-wrap">
         <input class="input-field input-sm pj-orgsearch-input" placeholder=${t('organisms.searchPlaceholder') || 'Find records & documents…'} value=${q}
-          onInput=${(e) => setQ(e.target.value)} onKeyDown=${(e) => { if (e.key === 'Enter') doSearch(); }} />
-        <button class="btn-outline btn-sm" disabled=${busy || q.trim().length < 2} onClick=${doSearch}>${t('organisms.search') || 'Search'}</button>
+          onInput=${(e) => setQ(e.target.value)} />
+        ${busy ? html`<${Spinner} />` : null}
+        ${results !== null ? html`<button class="btn-ghost btn-sm" onClick=${() => setQ('')}>${t('search.clear') || 'Clear'}</button>` : null}
       </div>
-      ${results !== null && results.length === 0 ? html`<div class="section-desc">${t('organisms.searchNoResults') || 'No matches.'}</div>` : null}
-      ${(results || []).map(r => html`
-        <div class="pj-access-row card-clickable" key=${r.ws + '/' + r.space + '/' + r.id} role="button" onClick=${() => onOpenWorkspace?.(r.ws)}>
-          <span>
-            <b>${(r.title)}</b>
-            <span class="pj-mini"> — ${(r.wsName || r.ws)} · ${(r.space)}</span>
-            <div class="pj-mini">${(r.snippet)}</div>
-          </span>
-        </div>
-      `)}
+      ${results !== null && results.length === 0 && !busy ? html`<div class="section-desc">${t('search.noMatches') || 'No matches.'}</div>` : null}
+      ${Object.entries(byWs).map(([ws, grp]) => html`
+        <div class="pj-search-group" key=${ws}>
+          <div class="pj-search-group-head">${(grp.name)}<span class="pj-org-tab-count">${grp.hits.length}</span></div>
+          ${grp.hits.map(r => html`
+            <button class="pj-search-hit" key=${r.space + '/' + r.id} onClick=${() => openHit(r)}>
+              <span class="pj-search-hit-title">${(r.title)} <span class="pj-mini">· ${(r.space)}</span></span>
+              <span class="pj-search-hit-snippet">${(r.snippet)}</span>
+            </button>`)}
+        </div>`)}
     </div>
   `;
 }

package/dist/public/views/profile/organisms/timeline-panel.js

@@ -9,6 +9,8 @@
  * @usage import { TimelinePanel } from '/views/profile/organisms/timeline-panel.js';
  * @version-history
  *   v1.0.0 — 2026-06-22 — Initial: structure timeline view over trackable-memory history (Osa D3).
+ *   v1.1.0 — 2026-06-22 — Add a Mermaid `timeline` diagram of the changes; the selected-snapshot map
+ *     honours the chart type the user picked for this organism's mindmap (localStorage).
  */
 import { h } from 'preact';
 import { useState } from 'preact/hooks';
@@ -41,6 +43,30 @@ function totals(fp) {
   return { workspaces: ws.length, documents: docs, records: recs, members: fp.memberCount || 0 };
 }
 
+/** The chart type the user picked for THIS organism's mindmap (shared with the snapshot map below). */
+function readChartType(orgId) {
+  try {
+    const raw = localStorage.getItem(`aimeat.mm.org.${orgId}`);
+    return (raw && JSON.parse(raw).chartType) || 'mindmap';
+  } catch { return 'mindmap'; }
+}
+
+/** A Mermaid `timeline` diagram of the structural changes (chronological). `:` is the timeline
+ *  separator, so it is stripped from event text; multiple events on one day share a row. */
+function buildTimelineDiagram(rows) {
+  const chron = rows.slice().reverse();   // rows are newest-first → oldest-first for the time axis
+  const byDate = new Map();
+  for (const r of chron) {
+    const d = String(r.at).slice(0, 10) || '—';
+    const ev = String(r.event || '').replace(/[:\n\r]/g, ' ').replace(/[<>|{}]/g, '').trim().slice(0, 60) || 'muutos';
+    if (!byDate.has(d)) byDate.set(d, []);
+    byDate.get(d).push(ev);
+  }
+  const lines = ['timeline'];
+  for (const [d, evs] of byDate) lines.push(`  ${d} : ${evs.join(' : ')}`);
+  return lines.join('\n');
+}
+
 export function TimelinePanel({ orgId }) {
   const [open, setOpen] = useState(false);
   const [loaded, setLoaded] = useState(false);
@@ -79,6 +105,9 @@ export function TimelinePanel({ orgId }) {
             : (!rows.length
               ? html`<div class="section-desc">${t('timeline.empty') || 'No structural history yet.'}</div>`
               : html`
+                <div class="pj-timeline-diagram">
+                  <${Mermaid} chart=${buildTimelineDiagram(rows)} />
+                </div>
                 <div class="pj-timeline-grid">
                   <ul class="pj-timeline-list">
                     ${rows.map(r => {
@@ -95,7 +124,7 @@ export function TimelinePanel({ orgId }) {
                   </ul>
                   <div class="pj-timeline-map">
                     ${selected
-                      ? html`<${Mermaid} chart=${buildOrganismMindmap({ name: t('timeline.snapshot') || 'Snapshot', workspaces: selected.workspaces || [], members: [], agents: [] }, { level: 'counts', showUsers: false, showActivity: true, heatmap: true })} />`
+                      ? html`<${Mermaid} chart=${buildOrganismMindmap({ name: t('timeline.snapshot') || 'Snapshot', workspaces: selected.workspaces || [], members: [], agents: [] }, { chartType: readChartType(orgId), level: 'counts', showUsers: false, showActivity: true, heatmap: true })} />`
                       : html`<div class="section-desc">${t('timeline.pick') || 'Pick a point to see the structure then.'}</div>`}
                   </div>
                 </div>`)}

package/dist/public/views/profile/organisms/workspace-comments.js

@@ -7,6 +7,9 @@
  * @usage import { WorkspaceComments } from '/views/profile/organisms/workspace-comments.js';
  * @version-history
  *   v1.0.0 — 2026-06-19 — Extracted from organisms-tab.js during the module split.
+ *   v1.1.0 — 2026-06-22 — Optional BATCHED mode (batched/initialComments/onReload): the parent fetches
+ *     all visible threads in one /comments/batch request instead of each thread self-fetching +
+ *     self-subscribing to 'organisms' events (which was the per-document comments request storm).
  */
 import { h } from 'preact';
 import { useState, useEffect, useCallback, useRef } from 'preact/hooks';
@@ -23,8 +26,12 @@ import * as orgService from '/js/services/organisms.js';
  * (comment on a specific passage) and threaded replies (parentId). Backend: /v1/organisms/:id/comments.
  * Agents use the same endpoints via aimeat_workspace_comment(s).
  */
-export function WorkspaceComments({ orgId, ws, space, instanceId, showToast }) {
-  const [comments, setComments] = useState(null);
+export function WorkspaceComments({ orgId, ws, space, instanceId, showToast, batched, initialComments, onReload }) {
+  // BATCHED mode (parent owns the fetch): the container fetches every visible thread in one
+  // /comments/batch request and passes this thread's slice via `initialComments`; we don't self-fetch
+  // or self-subscribe (that per-thread fan-out was the comments request storm). STANDALONE mode
+  // (no `batched`): unchanged — self-fetch on mount + refresh on 'organisms' events.
+  const [comments, setComments] = useState(batched ? (initialComments ?? null) : null);
   const [body, setBody] = useState('');
   const [anchorQuote, setAnchorQuote] = useState('');
   const [replyTo, setReplyTo] = useState(null);   // { id, body } of the comment being replied to
@@ -33,13 +40,16 @@ export function WorkspaceComments({ orgId, ws, space, instanceId, showToast }) {
   const mine = (author) => author && (author === me.gaii || author === me.ghii);
 
   const load = useCallback(async () => {
+    if (batched) { await onReload?.(); return; }   // parent re-runs the batch → flows back via initialComments
     if (!ws || !space || !instanceId) return;
     const r = await orgService.listComments(orgId, ws, space, instanceId).catch(() => null);
     setComments(r?.data?.comments || []);
-  }, [orgId, ws, space, instanceId]);
-  useEffect(() => { load(); }, [load]);
+  }, [orgId, ws, space, instanceId, batched, onReload]);
+  // Batched: keep local view in sync with the prop (undefined = still loading → null). Standalone: self-fetch.
+  useEffect(() => { if (batched) setComments(initialComments ?? null); }, [batched, initialComments]);
+  useEffect(() => { if (!batched) load(); }, [load, batched]);
   const liveRef = useRef(load); liveRef.current = load;
-  useEffect(() => onLiveUpdate(['organisms'], () => liveRef.current()), []);
+  useEffect(() => { if (batched) return undefined; return onLiveUpdate(['organisms'], () => liveRef.current()); }, [batched]);
 
   const submit = async () => {
     const text = body.trim();

package/dist/public/views/profile/organisms/workspace-list.js

@@ -10,6 +10,9 @@
  * @version-history
  *   v1.0.0 — 2026-06-19 — Extracted from organisms-tab.js during the module split; the hidden file
  *     input uses the .pj-hidden-input class instead of an inline style (Rule 8).
+ *   v1.1.0 — 2026-06-22 — Kill the per-workspace fetch storm: one discoverWorkspaces({include:'enrichment'})
+ *     replaces the 1 + 3N (getWorkspace+activity+participants) fan-out; pending-review counts come inline;
+ *     the 'organisms' live refresh is debounced (1.5s) so an agent-driven event burst is one reload.
  */
 import { h } from 'preact';
 import { useState, useEffect, useCallback, useRef } from 'preact/hooks';
@@ -48,32 +51,33 @@ export function WorkspaceList({ org, showToast, onOpen, onCount }) {
   // Discovery: every workspace in the org (membership-gated) with this user's access status. A member
   // sees workspaces they can't yet read (access:'none') so they can request access. Row enrichment
   // (record/doc counts, last event, review counter) loads per workspace afterwards, best effort.
+  // ONE enriched request replaces the old discover + per-row getWorkspace+activity+participants
+  // fan-out (1 + 3N requests, each re-scanning the same workspace memory). The server computes the
+  // same recs/docs/lastEvent/participants + pending-review counts and returns them inline.
   const load = useCallback(async () => {
-    const l = await orgService.discoverWorkspaces(orgId);
+    const l = await orgService.discoverWorkspaces(orgId, { include: 'enrichment' });
     setList(l);
     onCount?.(Array.isArray(l) ? l.length : 0);
-    orgService.listApprovals(orgId, 'pending').then(aps => {
-      const by = {};
-      for (const a of (aps || [])) { const w = a.arguments?.ws; if (w) by[w] = (by[w] || 0) + 1; }
-      setApprByWs(by);
-    }).catch(() => {});
-    for (const w of (l || []).filter(x => x.access !== 'none')) {
-      Promise.all([
-        orgService.getWorkspace(orgId, w.id).catch(() => null),
-        orgService.getWorkspaceActivity(orgId, w.id),
-        orgService.getWorkspaceParticipants(orgId, w.id).catch(() => null),
-      ]).then(([wsData, act, parts]) => {
-        let recs = 0, docs = 0;
-        for (const ot of (wsData?.manifest?.objectTypes || []).filter(orgService.isMemorySpace)) {
-          const n = new Set([...(wsData.drafts?.[ot.name] || []), ...(wsData.objects?.[ot.name] || [])].map(d => d.id)).size;
-          if (orgService.isDocSpace(ot)) docs += n; else recs += n;
-        }
-        const lastEv = (act?.events || []).reduce((b, e) => (!b || (e.at || '') > (b.at || '') ? e : b), null);
-        const owners = [];
-        for (const n of (parts?.nodes || [])) for (const o of (n.owners || [])) owners.push({ ...o, node: n.id, isLocalNode: n.isLocal });
-        setWsStats(s => ({ ...s, [w.id]: { recs, docs, lastEv, hasManifest: !!wsData?.manifest, owners } }));
-      }).catch(() => {});
+    const stats = {};
+    const reviews = {};
+    for (const w of (l || [])) {
+      const e = w.enrichment;
+      if (w.access === 'none' || !e) continue;
+      if (e.pendingReviews) reviews[w.id] = e.pendingReviews;
+      stats[w.id] = {
+        recs: e.recs || 0,
+        docs: e.docs || 0,
+        lastEv: e.lastEvent || null,
+        hasManifest: !!e.hasManifest,
+        // UI only reads owners[].length and per-owner {owner,isCreator,isSelf,isLocalNode,agents.length}.
+        owners: (e.participants || []).map(p => ({
+          owner: p.owner, node: p.node, isLocalNode: p.isLocalNode,
+          isCreator: p.isCreator, isSelf: p.isSelf, agents: new Array(p.agentsCount || 0),
+        })),
+      };
     }
+    setWsStats(stats);
+    setApprByWs(reviews);
   }, [orgId, onCount]);
   useEffect(() => { load(); }, [load]);
 
@@ -103,7 +107,15 @@ export function WorkspaceList({ org, showToast, onOpen, onCount }) {
     orgService.buildOrganismOverviewMermaid(orgId).then(c => { if (!cancelled) setOverview(c); }).catch(() => {});
     return () => { cancelled = true; };
   }, [orgId, list, showOverview]);
-  useEffect(() => onLiveUpdate(['organisms'], () => load()), [load]);
+  // Re-load on organism changes, but DEBOUNCE: on a busy node dozens of agents emit 'organisms'
+  // events ~1/sec; a trailing debounce collapses a burst into one reload (the load is now a single
+  // cheap request). `onLiveUpdate` reads the Set-typed domains correctly — never via e.detail directly.
+  const liveRef = useRef(load); liveRef.current = load;
+  useEffect(() => {
+    let timer = null;
+    const off = onLiveUpdate(['organisms'], () => { clearTimeout(timer); timer = setTimeout(() => liveRef.current(), 1500); });
+    return () => { clearTimeout(timer); off(); };
+  }, []);
 
   const create = async () => {
     const name = newName.trim();