aimeat 1.28.0 → 1.30.0

package/dist/public/views/profile/knowledge-tab.js

@@ -13,6 +13,8 @@
  *   import KnowledgeTab from './knowledge-tab.js';
  *   html`<${KnowledgeTab} session=${session} showToast=${showToast} onStats=${onStats} />`
  * @version-history
+ *   v1.1.0 — 2026-06-22 — Drop the per-package /v1/memory/{key} hydration fallback — the memory list
+ *     already returns each package's full value inline.
  *   v1.0.0 — 2026-03-17 — Refactor: remove all inline style="" attributes, use CSS
  *     classes (pf-ref-row, pf-ref-icon, pf-external-icon, pf-ref-title, pf-badge-xs,
  *     pf-sharing-box, pf-sharing-heading, kpkg-detail-loading). Replace inline
@@ -68,16 +70,11 @@ export default function KnowledgeTab({ session, showToast, onStats }) {
   const loadPackages = useCallback(async ({ showSpinner = true } = {}) => {
     try {
       if (showSpinner) setLoading(true);
+      // The memory list (GET /v1/memory) already returns each entry's full `value`, so there's no need
+      // for a per-package /v1/memory/{key} hydration fetch (that fallback never fired in practice).
       const list = await knowledgeService.listMyPackages();
-      const hydrated = await Promise.all(list.map(async (pkg) => {
-        if (pkg.value) return pkg;
-        try {
-          const resp = await apiGet('/v1/memory/' + encodeURIComponent(pkg.key));
-          return { ...pkg, value: resp?.data?.value };
-        } catch { return pkg; }
-      }));
-      setPackages(hydrated);
-      onStats?.({ knowledge: hydrated.length });
+      setPackages(list);
+      onStats?.({ knowledge: list.length });
     } catch { if (showSpinner) setPackages([]); } // keep old list on a transient live-update refetch
     finally { setLoading(false); }
   }, [onStats]);

package/dist/public/views/profile/landing-page.js

@@ -15,6 +15,11 @@
  *   - PresencePill + PresenceDialog — header status pill that opens the availability settings dialog
  *   - LandingPage — main orchestrator (default export)
  * @version-history
+ *   v3.8.0 — 2026-06-22 — Home UsageCard: quota usage bars (memory / files / micro-memory) + resource
+ *     counts (agents, organisms, apps, connected apps, extensions, cortexes, services), backed by the
+ *     cached GET /v1/owner/usage endpoint (60s server-side TTL).
+ *   v3.7.0 — 2026-06-22 — WaitingForYou uses one getWaiting() call (server-aggregated) instead of the
+ *     per-organism listApprovals + listJoinRequests + listWorkspaces fan-out.
  *   v3.6.0 — 2026-06-21 — Change-password modal handles OAuth accounts with no password yet
  *     (e.g. Google sign-in): fetches has_password from /v1/ghii/me and, when none is set, switches
  *     to a "set a password" flow — drops the current-password field, shows an explanatory hint, and
@@ -434,36 +439,12 @@ function ChangePasswordModal({ onClose, onChanged }) {
 /* "Waiting for you" — everything that needs the user's decision, aggregated across organisms:
  * pending publish approvals (per workspace), pending join requests (orgs they manage), and
  * incoming organism invitations. Renders nothing when there is nothing to do. */
-function WaitingForYou({ owner }) {
+function WaitingForYou() {
   const [items, setItems] = useState(null);
-  const load = useCallback(async () => {
-    try {
-      const out = [];
-      const orgsResp = await orgService.listOrganisms({ member: owner }).catch(() => null);
-      const orgs = orgsResp?.data?.organisms || [];
-      await Promise.all(orgs.map(async (org) => {
-        const canManage = org.creatorGhii === owner || (org.admins || []).includes(owner);
-        const [aps, reqs] = await Promise.all([
-          orgService.listApprovals(org.id, 'pending').catch(() => []),
-          canManage ? orgService.listJoinRequests(org.id).catch(() => null) : Promise.resolve(null),
-        ]);
-        if ((aps || []).length > 0) {
-          const byWs = {};
-          for (const a of aps) { const w = a.arguments?.ws || ''; byWs[w] = (byWs[w] || 0) + 1; }
-          let names = {};
-          try { names = Object.fromEntries((await orgService.listWorkspaces(org.id)).map(w => [w.id, w.name])); } catch { /* ids will do */ }
-          for (const [wsId, n] of Object.entries(byWs)) {
-            out.push({ kind: 'review', n, orgId: org.id, orgName: org.name, wsId, wsName: names[wsId] || wsId });
-          }
-        }
-        const pend = ((reqs?.data?.join_requests) || []).filter(r => r.status === 'pending').length;
-        if (pend > 0) out.push({ kind: 'join', n: pend, orgId: org.id, orgName: org.name });
-      }));
-      const inv = await orgService.listMyInvitations().catch(() => null);
-      for (const e of (inv?.data?.invitations || [])) out.push({ kind: 'invite', orgName: e?.organism?.name || '' });
-      setItems(out);
-    } catch { setItems([]); }
-  }, [owner]);
+  // ONE aggregated request replaces the old per-org fan-out (listOrganisms → per-org listApprovals +
+  // listJoinRequests + listWorkspaces + a final listMyInvitations). The server returns the same flat
+  // {kind:'review'|'join'|'invite', …} items this widget renders.
+  const load = useCallback(async () => { setItems(await orgService.getWaiting()); }, []);
   useEffect(() => { load(); }, [load]);
   const liveRef = useRef(load); liveRef.current = load;
   // Only re-run the per-organism approvals/join-requests fan-out when ORGANISMS actually
@@ -577,6 +558,69 @@ function AgentsCard({ owner }) {
   `;
 }
 
+/* "Usage" — quota usage bars (memory / storage / micro-memory) + resource counts. Backed by the
+ * cached GET /v1/owner/usage endpoint (60s server-side TTL), so it's cheap to refetch on each
+ * live-update. Surfaces the same kind of quota bar the Memory tab shows, for the whole account. */
+function fmtBytes(n) {
+  if (n == null) return '';
+  if (n < 1024) return n + ' B';
+  if (n < 1024 * 1024) return (n / 1024).toFixed(n < 10240 ? 1 : 0) + ' KB';
+  if (n < 1024 * 1024 * 1024) return (n / (1024 * 1024)).toFixed(1) + ' MB';
+  return (n / (1024 * 1024 * 1024)).toFixed(2) + ' GB';
+}
+
+function UsageCard({ switchTab }) {
+  const [u, setU] = useState(null);
+  const load = useCallback(async () => {
+    try { const r = await apiGet('/v1/owner/usage'); setU(r?.data || null); } catch { setU(null); }
+  }, []);
+  useEffect(() => { load(); }, [load]);
+  const liveRef = useRef(load); liveRef.current = load;
+  useEffect(() => onLiveUpdate(['memory', 'files', 'agents', 'apps', 'organisms'], () => liveRef.current()), []);
+
+  if (!u) return null;
+
+  const bar = (label, q, usedText) => {
+    const pct = q.percent >= 0 ? Math.max(0, Math.min(100, q.percent)) : 0;
+    return html`
+      <div class="pf-usage-row">
+        <div class="pf-usage-head">
+          <span class="pf-usage-label">${label}</span>
+          <span class="text-meta-sm">${usedText}</span>
+        </div>
+        <div class="pf-usage-bar"><div class="pf-usage-fill ${pct >= 90 ? 'pf-usage-fill--danger' : ''}" style=${`width:${pct}%`}></div></div>
+      </div>`;
+  };
+
+  const chip = (label, value, tab) => html`
+    <button class="pf-usage-chip" onClick=${tab ? () => switchTab(tab) : undefined} disabled=${!tab}>
+      <span class="pf-usage-chip-val">${value}</span>
+      <span class="pf-usage-chip-label">${label}</span>
+    </button>`;
+
+  const c = u.counts;
+  return html`
+    <div class="pf-home-card pf-usage-card">
+      <div class="pf-home-card-title">${t('profile.landing.usageTitle') || 'Usage & quotas'}</div>
+      ${bar(t('profile.landing.usageMemory') || 'Memory', u.memory,
+        `${u.memory.used_keys}/${u.memory.max_keys} ${t('profile.memory.keysWord') || 'keys'} · ${fmtBytes(u.memory.used_bytes)} / ${fmtBytes(u.memory.max_bytes)}`)}
+      ${bar(t('profile.landing.usageStorage') || 'Files', u.storage,
+        `${u.storage.used_files} ${t('profile.landing.usageFilesWord') || 'files'} · ${fmtBytes(u.storage.used_bytes)} / ${fmtBytes(u.storage.max_bytes)}`)}
+      ${bar(t('profile.landing.usageMicro') || 'Micro-memory', u.micro_memory,
+        `${u.micro_memory.used_sets}/${u.micro_memory.max_sets} ${t('profile.landing.usageSetsWord') || 'sets'} · ${fmtBytes(u.micro_memory.used_bytes)} / ${fmtBytes(u.micro_memory.max_bytes)}`)}
+      <div class="pf-usage-chips">
+        ${chip(t('profile.landing.usageAgents') || 'Agents', c.agents, 'agents')}
+        ${chip(t('profile.landing.usageOrganisms') || 'Organisms', c.organisms, 'organisms')}
+        ${chip(t('profile.landing.usageApps') || 'Apps', `${c.apps.used}/${c.apps.max}`, 'apps')}
+        ${chip(t('profile.landing.usageEcoApps') || 'Connected apps', c.ecosystem_apps, 'ecosystem')}
+        ${chip(t('profile.landing.usageExtensions') || 'Extensions', `${c.extensions.used}/${c.extensions.max}`, 'extensions')}
+        ${chip(t('profile.landing.usageCortexes') || 'Cortexes', c.cortexes, 'extensions')}
+        ${chip(t('profile.landing.usageServices') || 'Services', `${c.services.used}/${c.services.max}`, 'offers')}
+      </div>
+    </div>
+  `;
+}
+
 /* "Presence" — the owner's own availability control. Lives as a compact status
  * pill in the ProfileCard header (<PresencePill>); clicking it opens the settings
  * <PresenceDialog>. The dot the pill shows is the same <PresenceDot> rendered next
@@ -1204,6 +1248,7 @@ export default function LandingPage({ tier, stats, session, navigate, showToast,
           <${NextSteps} switchTab=${(id) => open(id, 'main')}
             hasApps=${appsLoaded ? apps.length > 0 : undefined} />
           <div class="pf-home-grid">
+            <${UsageCard} switchTab=${(id) => open(id, 'main')} />
             <${ContinueCard} />
             <${AgentsCard} owner=${owner} />
           </div>

package/dist/public/views/profile/memory-tab.js

@@ -34,6 +34,13 @@
  *     per-row checkboxes + a bulk bar (change visibility incl. group / delete with confirm /
  *     clear). The detail-row select and edit-modal select remain as alternate paths.
  *   v2.2.1 — 2026-06-19 — JSDoc type annotations for frontend type-checking
+ *   v2.3.0 — 2026-06-22 — Scale to thousands of keys: default load is metadata-only (include=meta,
+ *     no values) with per-key lazy value fetch on expand + "Load all contents"; server-side content
+ *     search (key/value/tags) with per-group scoping; storage-usage bar; value-size column + "largest
+ *     first" sort; bulk-delete a whole group; JSON export/import (skip/overwrite/rename).
+ *   v2.3.1 — 2026-06-22 — Toolbar layout: data tools (Load all / Export / Import) grouped in their
+ *     own bordered .mem-tools-section up top; content-search + filter on one row; sort + "New memory"
+ *     moved to a bottom bar (New-memory pushed right).
  */
 import { h } from 'preact';
 import { useState, useEffect, useRef } from 'preact/hooks';
@@ -92,6 +99,19 @@ export default function MemoryTab({ session, showToast, onStats }) {
   const [browseError, setBrowseError] = useState(null);
   const [pullingKeys, setPullingKeys] = useState(new Set());
   const [sortBy, setSortBy] = useState('updated');
+  // Scalable Memory tab (v2.3): the list loads metadata-only by default (no values) so thousands of
+  // keys open fast; values are fetched per-key on expand. memQuota drives the storage-usage bar.
+  const [memQuota, setMemQuota] = useState(null);
+  const [fullLoaded, setFullLoaded] = useState(false);   // true once "Load all contents" pulls values
+  const [valueCache, setValueCache] = useState({});       // key → value (lazy-fetched in meta mode)
+  const [loadingValueKeys, setLoadingValueKeys] = useState(new Set());
+  // Server-side content search (matches key + value + tags) — separate from the instant client filter.
+  const [searchInput, setSearchInput] = useState('');
+  const [searchResults, setSearchResults] = useState(null);  // null = not searching; array = results
+  const [searchScopePrefix, setSearchScopePrefix] = useState('');  // optional namespace/group scope
+  const [searchLoading, setSearchLoading] = useState(false);
+  const [importMode, setImportMode] = useState('skip');   // skip | overwrite | rename
+  const [importing, setImporting] = useState(false);
   const [discoverEntries, setDiscoverEntries] = useState(null);
   const [discoverLoading, setDiscoverLoading] = useState(false);
   const [discoverError, setDiscoverError] = useState(null);
@@ -206,15 +226,151 @@ export default function MemoryTab({ session, showToast, onStats }) {
     } catch { /* ignore */ }
   }
 
+  // Refresh the list in whatever mode is active: metadata-only by default (fast for thousands of
+  // keys), or full values once the user pressed "Load all contents".
   async function loadMemories() {
     try {
       const agentGaii = selectedAgent || undefined;
-      const list = await memoryService.listMemories(agentGaii);
-      setMemories(Array.isArray(list) ? list : []);
-      onStats?.({ memory: Array.isArray(list) ? list.length : 0 });
+      if (fullLoaded) {
+        const list = await memoryService.listMemories(agentGaii);
+        setMemories(Array.isArray(list) ? list : []);
+        onStats?.({ memory: Array.isArray(list) ? list.length : 0 });
+      } else {
+        const { items, quota } = await memoryService.listMemoriesMeta(agentGaii);
+        setMemories(items);
+        setMemQuota(quota);
+        setValueCache({});
+        onStats?.({ memory: items.length });
+      }
     } catch { setMemories([]); }
   }
 
+  // "Load all contents" — pull every entry's value so the instant client filter can search values too.
+  async function loadFullContents() {
+    setFullLoaded(true);
+    try {
+      const list = await memoryService.listMemories(selectedAgent || undefined);
+      setMemories(Array.isArray(list) ? list : []);
+    } catch { /* keep the meta list we already have */ }
+  }
+
+  // Lazy value fetch (meta mode): on row expand, fetch the value once and cache it.
+  async function ensureValue(key) {
+    if (fullLoaded || valueCache[key] !== undefined) return;
+    setLoadingValueKeys(prev => new Set(prev).add(key));
+    try {
+      const resp = await memoryService.getMemory(key, { soft: true, agent: selectedAgent || undefined });
+      setValueCache(prev => ({ ...prev, [key]: resp?.data?.value ?? null }));
+    } catch {
+      setValueCache(prev => ({ ...prev, [key]: null }));
+    } finally {
+      setLoadingValueKeys(prev => { const n = new Set(prev); n.delete(key); return n; });
+    }
+  }
+
+  // The effective value for a row: from the full list, the lazy cache, or undefined (still loading).
+  const valueOf = (m) => (fullLoaded ? m.value : valueCache[m.key]);
+
+  // Server-side content search (key + value + tags), optionally scoped to a namespace/group prefix.
+  async function runServerSearch(query, prefix) {
+    const q = (query ?? searchInput).trim();
+    setSearchScopePrefix(prefix || '');
+    if (!q) { setSearchResults(null); return; }
+    setSearchLoading(true);
+    try {
+      const results = await memoryService.searchMemory(q, selectedAgent || undefined, prefix || undefined);
+      const list = Array.isArray(results) ? results : [];
+      setSearchResults(list);
+      // Search results carry their values — cache them so expanding a result shows the value at once.
+      setValueCache(prev => { const next = { ...prev }; for (const r of list) next[r.key] = r.value; return next; });
+    } catch (e) {
+      showToast(e.message || t('profile.error'), true);
+      setSearchResults([]);
+    } finally { setSearchLoading(false); }
+  }
+
+  function clearServerSearch() {
+    setSearchInput('');
+    setSearchResults(null);
+    setSearchScopePrefix('');
+  }
+
+  // Export all (or a prefix) of the caller's memory as a downloaded JSON backup.
+  async function handleExport(prefix) {
+    try {
+      const data = await memoryService.exportMemory(selectedAgent || undefined, prefix || undefined);
+      const blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      const stamp = new Date().toISOString().slice(0, 10);
+      a.href = url;
+      a.download = `aimeat-memory-${stamp}.json`;
+      document.body.appendChild(a);
+      a.click();
+      a.remove();
+      URL.revokeObjectURL(url);
+      showToast((t('profile.memory.exportDone') || 'Exported {n} entries').replace('{n}', String(data.count ?? (data.entries || []).length)));
+    } catch (e) { showToast(e.message || t('profile.error'), true); }
+  }
+
+  // Import a JSON backup; the user picks a conflict mode (skip/overwrite/rename) before it runs.
+  const importFileRef = useRef(null);
+  function triggerImport() { importFileRef.current?.click(); }
+  async function handleImportFile(e) {
+    const file = e.target.files?.[0];
+    e.target.value = '';   // allow re-picking the same file
+    if (!file) return;
+    let parsed;
+    try {
+      const text = await file.text();
+      parsed = JSON.parse(text);
+    } catch { showToast(t('profile.memory.importBadJson') || 'Not a valid JSON backup', true); return; }
+    const entries = Array.isArray(parsed) ? parsed : (Array.isArray(parsed?.entries) ? parsed.entries : null);
+    if (!entries || entries.length === 0) { showToast(t('profile.memory.importEmpty') || 'No entries found in file', true); return; }
+
+    const modeLabel = (m) => t('profile.memory.importMode.' + m) || m;
+    confirm(
+      (t('profile.memory.importConfirm') || 'Import {n} entries? Existing keys are handled by mode: {mode}.')
+        .replace('{n}', String(entries.length)).replace('{mode}', modeLabel(importMode)),
+      async () => {
+        setImporting(true);
+        try {
+          const resp = await memoryService.importMemory(entries, importMode, selectedAgent || undefined);
+          if (resp.ok === false) { showToast(resp.error?.message || t('profile.error'), true); return; }
+          const s = resp.data || {};
+          showToast((t('profile.memory.importDone') || 'Imported: {c} new, {u} updated, {s} skipped')
+            .replace('{c}', String(s.created || 0)).replace('{u}', String(s.updated || 0)).replace('{s}', String(s.skipped || 0))
+            + ((s.failed && s.failed.length) ? ` · ${s.failed.length} ${t('profile.error') || 'failed'}` : ''),
+            !!(s.failed && s.failed.length));
+          loadMemories();
+        } catch (e) { showToast(e.message || t('profile.error'), true); }
+        finally { setImporting(false); }
+      },
+    );
+  }
+
+  // Delete a whole namespace/group at once (server-side bulk-delete by prefix).
+  function deleteGroup(g, count) {
+    const prefix = g.kind === 'organism' ? 'organism.' + g.uuid + '.'
+      : g.kind === 'plain' ? g.id + '.'
+      : null;
+    if (!prefix) { showToast(t('profile.memory.deleteGroupUnsupported') || 'This group cannot be bulk-deleted', true); return; }
+    confirm(
+      (t('profile.memory.deleteGroupConfirm') || 'Delete all {n} entries under "{g}"? This cannot be undone.')
+        .replace('{n}', String(count)).replace('{g}', groupLabel(g)),
+      async () => {
+        try {
+          const resp = await memoryService.bulkDeleteMemory({ prefix, agentGaii: selectedAgent || undefined });
+          if (resp.ok === false) { showToast(resp.error?.message || t('profile.error'), true); return; }
+          showToast((t('profile.memory.bulkDeleted') || '{n} deleted').replace('{n}', String(resp.data?.deleted ?? 0)));
+          setExpandedMem(null);
+          loadMemories();
+        } catch (e) { showToast(e.message || t('profile.error'), true); }
+      },
+      { danger: true },
+    );
+  }
+
   async function loadFiles() {
     try {
       const list = await memoryService.listFiles();
@@ -412,6 +568,13 @@ export default function MemoryTab({ session, showToast, onStats }) {
     }
   }
 
+  function formatBytes(n) {
+    if (n == null) return '';
+    if (n < 1024) return n + ' B';
+    if (n < 1024 * 1024) return (n / 1024).toFixed(n < 10240 ? 1 : 0) + ' KB';
+    return (n / (1024 * 1024)).toFixed(1) + ' MB';
+  }
+
   function formatRelativeTime(isoStr) {
     if (!isoStr) return '';
     const d = new Date(isoStr);
@@ -436,6 +599,8 @@ export default function MemoryTab({ session, showToast, onStats }) {
         return sorted.sort((a, b) => +new Date(b.created_at || 0) - +new Date(a.created_at || 0));
       case 'alpha':
         return sorted.sort((a, b) => a.key.localeCompare(b.key));
+      case 'size':
+        return sorted.sort((a, b) => (b.bytes ?? 0) - (a.bytes ?? 0));
       default:
         return sorted;
     }
@@ -492,7 +657,9 @@ export default function MemoryTab({ session, showToast, onStats }) {
       if (!ft) return true;
       if (m.key.toLowerCase().includes(ft)) return true;
       if (m.tags && m.tags.some(tag => tag.toLowerCase().includes(ft))) return true;
-      try { return JSON.stringify(m.value).toLowerCase().includes(ft); } catch { return false; }
+      const v = valueOf(m);   // undefined in meta mode (value not loaded) → key/tag filter only
+      if (v === undefined) return false;
+      try { return JSON.stringify(v).toLowerCase().includes(ft); } catch { return false; }
     }));
 
     const toggleMemTag = (tag) => {
@@ -517,10 +684,11 @@ export default function MemoryTab({ session, showToast, onStats }) {
 
     const renderRow = (m, g) => html`
       <div key=${m.key}>
-        <div class="mem-item mem-item--grouped" onClick=${() => setExpandedMem(expandedMem === m.key ? null : m.key)}>
+        <div class="mem-item mem-item--grouped" onClick=${() => { const opening = expandedMem !== m.key; setExpandedMem(opening ? m.key : null); if (opening) ensureValue(m.key); }}>
           <input type="checkbox" class="mem-row-check" checked=${selectedKeys.has(m.key)}
             onClick=${(e) => e.stopPropagation()} onChange=${() => toggleSelected(m.key)} />
           <span class="mem-key" title=${m.key}>${escHtml(displayRemainder(m.key, g))}</span>
+          ${typeof m.bytes === 'number' && html`<span class="pf-mem-size" title=${t('profile.memory.sizeLabel') || 'Value size'}>${formatBytes(m.bytes)}</span>`}
           <span class="mem-time" title="${m.created_at ? new Date(m.created_at).toLocaleString() : ''} / ${m.updated_at ? new Date(m.updated_at).toLocaleString() : ''}">
             ${formatRelativeTime(m.updated_at || m.created_at)}
           </span>
@@ -549,8 +717,12 @@ export default function MemoryTab({ session, showToast, onStats }) {
         ${expandedMem === m.key && html`
           <div class="mem-detail">
             <div class="mem-detail-key" title=${m.key}>${escHtml(m.key)}</div>
-            ${(() => { const im = detectImage(m.value, m.key); return im ? html`<${ImageView} desc=${im} />` : null; })()}
-            <pre>${typeof m.value === 'object' ? JSON.stringify(m.value, null, 2) : String(m.value || '')}</pre>
+            ${(!fullLoaded && valueOf(m) === undefined)
+              ? html`<div class="text-meta-sm">${loadingValueKeys.has(m.key) ? (t('profile.memory.loadingValue') || 'Loading value…') : '…'}</div>`
+              : html`
+                ${(() => { const v = valueOf(m); const im = detectImage(v, m.key); return im ? html`<${ImageView} desc=${im} />` : null; })()}
+                <pre>${(() => { const v = valueOf(m); return typeof v === 'object' && v !== null ? JSON.stringify(v, null, 2) : String(v ?? ''); })()}</pre>
+              `}
             <div class="mem-detail-visrow mb-half">
               <span class="text-meta-sm">${t('profile.memory.visLabel')}</span>
               <select class="input-field mem-vis-select" value=${m.visibility || 'private'}
@@ -592,7 +764,7 @@ export default function MemoryTab({ session, showToast, onStats }) {
               </div>
             `}
             <div class="mem-actions">
-              <button class="btn-sm" onClick=${() => setEditModal({ key: m.key, value: typeof m.value === 'object' ? JSON.stringify(m.value, null, 2) : String(m.value || ''), visibility: m.visibility || 'private', version: m.version, isJson: typeof m.value === 'object' })}>${t('profile.memory.editBtn')}</button>
+              <button class="btn-sm" onClick=${() => { const v = valueOf(m); setEditModal({ key: m.key, value: typeof v === 'object' && v !== null ? JSON.stringify(v, null, 2) : String(v ?? ''), visibility: m.visibility || 'private', version: m.version, isJson: typeof v === 'object' && v !== null }); }}>${t('profile.memory.editBtn')}</button>
               ${fedConsents[m.key]
                 ? html`<button class="btn-outline btn-sm" disabled=${togglingFed === m.key}
                     onClick=${() => handleStopSharing(m.key)}>
@@ -618,22 +790,58 @@ export default function MemoryTab({ session, showToast, onStats }) {
       </div>
     `;
 
+    const quotaPct = memQuota && memQuota.max_bytes ? Math.min(100, Math.round((memQuota.used_bytes / memQuota.max_bytes) * 100)) : 0;
+
     return html`
+      ${memQuota && html`
+        <div class="pf-mem-quota">
+          <div class="pf-mem-quota-row">
+            <span class="text-meta-sm">${t('profile.memory.storageUsed') || 'Storage'}: ${memQuota.used_keys}/${memQuota.max_keys} ${t('profile.memory.keysWord') || 'keys'} · ${formatBytes(memQuota.used_bytes)} / ${formatBytes(memQuota.max_bytes)}</span>
+          </div>
+          <div class="pf-mem-quota-bar"><div class="pf-mem-quota-fill ${quotaPct >= 90 ? 'pf-mem-quota-fill--danger' : ''}" style=${`width:${quotaPct}%`}></div></div>
+        </div>
+      `}
+      <div class="mem-tools-section">
+        <span class="mem-tools-label">${t('profile.memory.toolsLabel') || 'Tools'}</span>
+        <div class="mem-tools-actions">
+          ${!fullLoaded && html`<button class="btn-outline btn-sm" onClick=${loadFullContents}>${t('profile.memory.loadContents') || 'Load all contents'}</button>`}
+          <span class="mem-import-group">
+            <button class="btn-outline btn-sm" onClick=${() => handleExport()}>${t('profile.memory.exportBtn') || 'Export'}</button>
+            <button class="btn-outline btn-sm" disabled=${importing} onClick=${triggerImport}>${importing ? '…' : (t('profile.memory.importBtn') || 'Import')}</button>
+            <select class="input-field mem-vis-select" value=${importMode} onChange=${e => setImportMode(e.target.value)} title=${t('profile.memory.importModeLabel') || 'Conflict handling'}>
+              <option value="skip">${t('profile.memory.importMode.skip') || 'Skip existing'}</option>
+              <option value="overwrite">${t('profile.memory.importMode.overwrite') || 'Overwrite'}</option>
+              <option value="rename">${t('profile.memory.importMode.rename') || 'Import as new'}</option>
+            </select>
+            <input type="file" accept="application/json,.json" ref=${importFileRef} class="pf-hidden" onChange=${handleImportFile} />
+          </span>
+        </div>
+      </div>
       <div class="action-bar">
+        <div class="search-bar">
+          <input type="text" class="input-field" placeholder=${t('profile.memory.searchContents') || 'Search content or key…'}
+            value=${searchInput} onInput=${e => setSearchInput(e.target.value)}
+            onKeyDown=${e => { if (e.key === 'Enter') runServerSearch(searchInput, searchScopePrefix); }} />
+          <button class="btn-sm" disabled=${searchLoading} onClick=${() => runServerSearch(searchInput, searchScopePrefix)}>${searchLoading ? '…' : (t('profile.memory.searchBtn') || 'Search')}</button>
+          ${searchResults !== null && html`<button class="btn-ghost btn-sm" onClick=${clearServerSearch}>✕</button>`}
+        </div>
         <div class="search-bar">
           <input type="text" class="input-field" placeholder=${t('profile.memory.filterType')}
             value=${filterText} onInput=${e => setFilterText(e.target.value)} />
           ${filterText && html`<button class="btn-ghost btn-sm" onClick=${() => setFilterText('')}>✕</button>`}
         </div>
+      </div>
+      <div class="action-bar mem-bottom-bar">
         <div class="mem-sort-bar">
           <label class="text-meta-sm">${t('profile.memory.sortLabel')}</label>
           <select class="input-field mem-sort-select" value=${sortBy} onChange=${e => setSortBy(e.target.value)}>
             <option value="updated">${t('profile.memory.sortUpdated')}</option>
             <option value="created">${t('profile.memory.sortCreated')}</option>
             <option value="alpha">${t('profile.memory.sortAlpha')}</option>
+            <option value="size">${t('profile.memory.sortSize') || 'Largest first'}</option>
           </select>
         </div>
-        <button class="btn-primary" onClick=${() => setShowMemForm(!showMemForm)}>${t('profile.memory.newBtn')}</button>
+        <button class="btn-primary mem-new-btn" onClick=${() => setShowMemForm(!showMemForm)}>${t('profile.memory.newBtn')}</button>
       </div>
       <${TagCloud} tags=${tagsByFreq} selected=${memTagFilter} onToggle=${toggleMemTag} onClear=${() => setMemTagFilter(new Set())} limit=${10} />
       ${showMemForm && html`<${MemoryForm} onSave=${handleCreateMemory} onCancel=${() => setShowMemForm(false)} groups=${groups} />`}
@@ -649,22 +857,39 @@ export default function MemoryTab({ session, showToast, onStats }) {
           <button class="btn-ghost btn-sm" onClick=${() => setSelectedKeys(new Set())}>✕ ${t('profile.memory.bulkClear') || 'Clear selection'}</button>
         </div>
       `}
-      ${filtered.length === 0
-        ? html`<div class="empty">${memories.length > 0 ? (t('tags.noMatch') || 'No items match selected tags') : t('profile.memory.empty')}</div>`
-        : groupsOrdered.map(g => {
-            const collapsed = !filtering && collapsedGroups.has(g.id);
-            return html`
-              <div class="mem-group" key=${g.id}>
-                <button class="mem-group-header" onClick=${() => toggleGroupCollapsed(g.id)}>
-                  <span class="pf-chevron ${collapsed ? '' : 'pf-chevron-open'}">▼</span>
-                  <span class="mem-group-name">${escHtml(groupLabel(g))}</span>
-                  <span class="mem-group-count">${g.items.length === 1 ? (t('profile.memory.keysOne') || '1 key') : (t('profile.memory.keysCount') || '{n} keys').replace('{n}', String(g.items.length))}</span>
-                  ${g.kind === 'organism' && orgNames[g.uuid] && html`<span class="mem-group-sub">${shortTok(g.uuid)}</span>`}
-                </button>
-                ${!collapsed && g.items.map(m => renderRow(m, g))}
-              </div>
-            `;
-          })
+      ${searchResults !== null
+        ? html`
+            <div class="mem-search-summary">
+              <span class="text-meta-sm">${(t('profile.memory.searchResultCount') || '{n} matches').replace('{n}', String(searchResults.length))}${searchScopePrefix ? ` · ${escHtml(searchScopePrefix)}` : ''}</span>
+              <button class="btn-ghost btn-sm" onClick=${clearServerSearch}>✕ ${t('profile.memory.searchClear') || 'Clear search'}</button>
+            </div>
+            ${searchResults.length === 0
+              ? html`<div class="empty">${t('profile.memory.searchEmpty') || 'No matches'}</div>`
+              : sortEntries(searchResults).map(m => renderRow(m, groupOfKey(m.key)))}
+          `
+        : filtered.length === 0
+          ? html`<div class="empty">${memories.length > 0 ? (t('tags.noMatch') || 'No items match selected tags') : t('profile.memory.empty')}</div>`
+          : groupsOrdered.map(g => {
+              const collapsed = !filtering && collapsedGroups.has(g.id);
+              const groupPrefix = g.kind === 'organism' ? 'organism.' + g.uuid + '.' : g.kind === 'plain' ? g.id + '.' : null;
+              return html`
+                <div class="mem-group" key=${g.id}>
+                  <div class="mem-group-header" role="button" tabindex="0" onClick=${() => toggleGroupCollapsed(g.id)}>
+                    <span class="pf-chevron ${collapsed ? '' : 'pf-chevron-open'}">▼</span>
+                    <span class="mem-group-name">${escHtml(groupLabel(g))}</span>
+                    <span class="mem-group-count">${g.items.length === 1 ? (t('profile.memory.keysOne') || '1 key') : (t('profile.memory.keysCount') || '{n} keys').replace('{n}', String(g.items.length))}</span>
+                    ${g.kind === 'organism' && orgNames[g.uuid] && html`<span class="mem-group-sub">${shortTok(g.uuid)}</span>`}
+                    <span class="mem-group-actions">
+                      ${groupPrefix && html`<button class="btn-ghost btn-sm" title=${t('profile.memory.searchInGroup') || 'Search in this group'}
+                        onClick=${(e) => { e.stopPropagation(); setSearchInput(''); setSearchScopePrefix(groupPrefix); showToast((t('profile.memory.searchInGroupHint') || 'Type a query to search within {g}').replace('{g}', groupLabel(g))); }}>🔍</button>`}
+                      ${groupPrefix && html`<button class="btn-ghost btn-sm" title=${t('profile.memory.deleteGroup') || 'Delete group'}
+                        onClick=${(e) => { e.stopPropagation(); deleteGroup(g, g.items.length); }}>🗑️</button>`}
+                    </span>
+                  </div>
+                  ${!collapsed && g.items.map(m => renderRow(m, g))}
+                </div>
+              `;
+            })
       }`;
   };
 
@@ -1056,7 +1281,7 @@ export default function MemoryTab({ session, showToast, onStats }) {
         <div class="agent-selector mb-half">
           <label class="text-meta pf-mr-half">${t('profile.memory.agent') || 'Agent'}:</label>
           <select class="input-field pf-select-inline"
-            value=${selectedAgent} onChange=${e => { setSelectedAgent(e.target.value); setExpandedMem(null); setMemTagFilter(new Set()); }}>
+            value=${selectedAgent} onChange=${e => { setSelectedAgent(e.target.value); setExpandedMem(null); setMemTagFilter(new Set()); setFullLoaded(false); clearServerSearch(); }}>
             <option value="">${t('profile.memory.defaultAgent') || 'Default agent'}</option>
             ${agents.map(a => html`<option key=${a.gaii} value=${a.gaii}>${escHtml(a.name || a.gaii)}${a.display_name ? ` — ${escHtml(a.display_name)}` : ''}</option>`)}
           </select>

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

@@ -8,6 +8,8 @@
  * @usage import { OrgAgentsPanel } from '/views/profile/organisms/agents.js';
  * @version-history
  *   v1.0.0 — 2026-06-19 — Extracted from organisms-tab.js during the module split.
+ *   v1.1.0 — 2026-06-22 — Agent activity context comes from one getAgentsActivity(orgId) call instead
+ *     of a per-workspace getWorkspaceActivity fan-out.
  */
 import { h } from 'preact';
 import { useState, useEffect } from 'preact/hooks';
@@ -41,22 +43,15 @@ export function OrgAgentsPanel({ org, ghii, canManage, showToast, onChanged }) {
     listAgents(ghii).then(a => setMine((a || []).filter(x => !String(x.name || '').startsWith('session-')))).catch(() => setMine([]));
   }, [ghii]);
 
-  // Best-effort activity context: which workspaces each agent has touched, and when last.
+  // Best-effort activity context: which workspaces each agent has touched, and when last. ONE
+  // aggregated request replaces the old per-workspace getWorkspaceActivity fan-out.
   useEffect(() => {
     let cancelled = false;
     (async () => {
       try {
-        const wss = (await orgService.discoverWorkspaces(orgId)).filter(w => w.access !== 'none');
+        const agents = await orgService.getAgentsActivity(orgId);
         const map = {};
-        await Promise.all(wss.map(async (w) => {
-          const a = await orgService.getWorkspaceActivity(orgId, w.id);
-          for (const e of (a.events || [])) {
-            if (!e.agent) continue;
-            const m = map[e.agent] || (map[e.agent] = { count: 0, lastAt: '', ws: new Set() });
-            m.count++; m.ws.add(w.name || w.id);
-            if (!m.lastAt || e.at > m.lastAt) m.lastAt = e.at;
-          }
-        }));
+        for (const [name, v] of Object.entries(agents)) map[name] = { count: v.count, lastAt: v.lastAt, ws: new Set(v.workspaces || []) };
         if (!cancelled) setActed(map);
       } catch { /* context is optional */ }
     })();

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

@@ -326,7 +326,7 @@ export function OrganismHome({ org, ghii, showToast, initialSettings, onOpenWs,
       <${ReadmePanel} markdown=${readme} canEdit=${canEdit} kind="organism" name=${org.name}
         aiPromptSeed=${tocSeed} onSave=${saveReadme} />
 
-      <${StructureMindmap} scope="organism" graph=${graph} onNavigate=${onMapNav} />
+      <${StructureMindmap} scope="organism" graph=${graph} onNavigate=${onMapNav} storageKey=${'org.' + org.id} />
 
       <${StructureOverview} label=${t('organisms.structureOverviewOrg') || 'Organism structure — table of contents'}
         load=${() => orgService.getOrganismOverview(org.id)} />

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

@@ -8,6 +8,8 @@
  * @usage import { OrgMemberManager } from '/views/profile/organisms/members.js';
  * @version-history
  *   v1.0.0 — 2026-06-19 — Extracted from organisms-tab.js during the module split.
+ *   v1.1.0 — 2026-06-22 — Per-member workspace access uses one getWorkspaceAccessAll(orgId) call
+ *     instead of a per-owned-workspace getWorkspaceAccess fan-out.
  */
 import { h } from 'preact';
 import { useState, useEffect, useCallback, useRef } from 'preact/hooks';
@@ -71,7 +73,12 @@ export function OrgMemberManager({ org, ghii, canManage, isCreator, showToast, c
     let cancelled = false;
     (async () => {
       try {
-        const wss = await orgService.discoverWorkspaces(orgId);
+        // discoverWorkspaces → creators of every workspace; getWorkspaceAccessAll → members of MY
+        // workspaces in ONE request (was one getWorkspaceAccess per owned workspace).
+        const [wss, accessAll] = await Promise.all([
+          orgService.discoverWorkspaces(orgId),
+          orgService.getWorkspaceAccessAll(orgId),
+        ]);
         const map = {};
         const add = (who, wsName, role) => {
           const bare = String(who || '').split('@')[0];
@@ -80,10 +87,7 @@ export function OrgMemberManager({ org, ghii, canManage, isCreator, showToast, c
           if (!list.some(x => x.ws === wsName)) list.push({ ws: wsName, role });
         };
         for (const w of wss) if (w.created_by) add(w.created_by, w.name || w.id, 'owner');
-        await Promise.all(wss.filter(w => w.access === 'owner').map(async (w) => {
-          const acc = await orgService.getWorkspaceAccess(orgId, w.id).catch(() => null);
-          for (const m of (acc?.members || [])) add(m.owner, w.name || w.id, m.role);
-        }));
+        for (const w of accessAll) for (const m of (w.members || [])) add(m.owner, w.name || w.ws, m.role);
         if (!cancelled) setWsAccess(map);
       } catch { /* the access line is optional */ }
     })();