aimeat 1.28.0 → 1.29.0

package/dist/public/views/command-palette.js

@@ -0,0 +1,145 @@
+/**
+ * @file command-palette.js
+ * @description Global command palette / quick-switcher (Cmd/Ctrl-K) — Layer 2 of the search feature.
+ *   Mounted once at the app shell so it works on any authenticated page. Empty query shows recents;
+ *   typing runs the indexed cross-owner librarian search (GET /v1/librarian/search, own scope) plus a
+ *   name match over the caller's organisms. Results are grouped (Organisms / content hits), keyboard-
+ *   navigable (↑↓/Enter/Esc), and selecting one jumps to that organism/workspace — pre-filling the
+ *   in-workspace search (Layer 1) with the same query so you land on the filtered list. Navigation
+ *   hands off via sessionStorage (read by OrganismsTab on mount) + an `aimeat-open-organism` event
+ *   (picked up if the tab is already mounted) + a route change to the organisms tab.
+ * @structure CommandPalette({ navigate })
+ * @usage import { CommandPalette } from '/views/command-palette.js';  html`<${CommandPalette} navigate=${navigate} />`
+ * @version-history
+ *   v1.0.0 — 2026-06-22 — Initial: Cmd-K quick-switcher over librarian search + organism names + recents.
+ */
+import { h } from 'preact';
+import { useState, useEffect, useRef, useCallback } from 'preact/hooks';
+import htm from 'htm';
+const html = htm.bind(h);
+import { t } from '/js/i18n.js';
+import { Modal } from '/components/Modal.js';
+import { SearchBar } from '/components/SearchBar.js';
+import { Spinner } from '/components/Spinner.js';
+import { EmptyState } from '/components/EmptyState.js';
+import { librarianSearch } from '/js/services/memory.js';
+import { listOrganisms } from '/js/services/organisms.js';
+import { getOwner } from '/js/services/auth.js';
+import { listRecents } from '/js/recents.js';
+
+/** Hand off to the organisms tab using the app's existing nav contract: prime the sessionStorage the
+ *  OrganismsTab reads on mount (open id + workspace + an optional ws-search pre-fill), then switch to
+ *  the Organisms tab via `aimeat-open-tab` (the LandingPage listener). Also fire `aimeat-open-organism`
+ *  for an ALREADY-mounted OrganismsTab (it won't remount, so it can't re-read sessionStorage), and a
+ *  route fallback for when we're not on /v1/profile at all. */
+function openTarget(navigate, { orgId, wsId, query }) {
+  try {
+    if (orgId) sessionStorage.setItem('aimeat.ws.openId', orgId);
+    if (wsId) sessionStorage.setItem('aimeat.ws.openWs', wsId); else sessionStorage.removeItem('aimeat.ws.openWs');
+    if (orgId && wsId && query) sessionStorage.setItem(`aimeat.ws.${orgId}.${wsId}.search`, query);
+  } catch { /* private mode — the route fallback still works */ }
+  try {
+    window.dispatchEvent(new CustomEvent('aimeat-open-tab', { detail: { tabId: 'organisms' } }));
+    window.dispatchEvent(new CustomEvent('aimeat-open-organism', { detail: { orgId, wsId: wsId || null } }));
+  } catch { /* noop */ }
+  if (!location.pathname.startsWith('/v1/profile')) navigate('/v1/profile?tab=organisms');
+}
+
+export function CommandPalette({ navigate }) {
+  const [open, setOpen] = useState(false);
+  const [q, setQ] = useState('');
+  const [hits, setHits] = useState(null);     // librarian content hits
+  const [orgs, setOrgs] = useState([]);       // caller's organisms (for name match)
+  const [busy, setBusy] = useState(false);
+  const [sel, setSel] = useState(0);
+  const inputRef = useRef(null);
+
+  // Global Cmd/Ctrl-K to open (ignore when typing in a field, except to toggle); Esc handled by Modal.
+  useEffect(() => {
+    const onKey = (e) => {
+      if ((e.ctrlKey || e.metaKey) && (e.key === 'k' || e.key === 'K')) {
+        e.preventDefault();
+        setOpen(o => !o);
+      }
+    };
+    document.addEventListener('keydown', onKey);
+    return () => document.removeEventListener('keydown', onKey);
+  }, []);
+
+  // On open: load recents + the caller's organisms (for name matching), focus the input.
+  useEffect(() => {
+    if (!open) { setQ(''); setHits(null); setSel(0); return; }
+    const me = getOwner();
+    if (me) listOrganisms({ member: me }).then(r => setOrgs((r?.data?.organisms) || [])).catch(() => {});
+    setTimeout(() => inputRef.current?.querySelector('input')?.focus(), 30);
+  }, [open]);
+
+  // Debounced content search.
+  useEffect(() => {
+    if (!open) return undefined;
+    const query = q.trim();
+    if (query.length < 2) { setHits(null); setBusy(false); return undefined; }
+    let cancelled = false;
+    setBusy(true);
+    const tid = setTimeout(async () => {
+      const r = await librarianSearch(query, 30, 'own').catch(() => []);
+      if (!cancelled) { setHits(r || []); setBusy(false); setSel(0); }
+    }, 200);
+    return () => { cancelled = true; clearTimeout(tid); };
+  }, [q, open]);
+
+  const orgName = useCallback((id) => orgs.find(o => o.id === id)?.name || id, [orgs]);
+
+  // Build a flat, selectable item list (with group headers derived for rendering).
+  const query = q.trim();
+  const orgMatches = query.length >= 2
+    ? orgs.filter(o => (o.name || '').toLowerCase().includes(query.toLowerCase())).slice(0, 6)
+        .map(o => ({ kind: 'org', orgId: o.id, label: o.name, sub: t(`organisms.types.${o.type}`) || o.type }))
+    : [];
+  const contentItems = (hits || []).map(hh => ({
+    kind: 'hit', orgId: hh.organismId, wsId: hh.workspaceId, label: hh.title || hh.key,
+    sub: [orgName(hh.organismId), hh.workspaceId, hh.space].filter(Boolean).join(' · '), snippet: hh.snippet,
+  })).filter(it => it.orgId);
+  const recents = (!query) ? listRecents(8).filter(r => r.type === 'workspace' && r.data?.orgId)
+    .map(r => ({ kind: 'recent', orgId: r.data.orgId, wsId: r.data.wsId, label: r.label, sub: r.sub })) : [];
+  const items = [...orgMatches, ...contentItems, ...recents];
+
+  const choose = (it) => {
+    if (!it) return;
+    openTarget(navigate, { orgId: it.orgId, wsId: it.wsId, query: it.kind === 'hit' ? query : '' });
+    setOpen(false);
+  };
+  const onInputKey = (e) => {
+    if (e.key === 'ArrowDown') { e.preventDefault(); setSel(s => Math.min(s + 1, items.length - 1)); }
+    else if (e.key === 'ArrowUp') { e.preventDefault(); setSel(s => Math.max(s - 1, 0)); }
+    else if (e.key === 'Enter') { e.preventDefault(); choose(items[sel]); }
+  };
+
+  if (!open) return null;
+  let idx = -1;
+  const row = (it) => { idx++; const i = idx; return html`
+    <button class=${'cmdk-item' + (i === sel ? ' is-sel' : '')} key=${it.kind + (it.orgId || '') + (it.wsId || '') + it.label}
+      onMouseEnter=${() => setSel(i)} onClick=${() => choose(it)}>
+      <span class="cmdk-item-label">${it.kind === 'org' ? '🏢 ' : it.kind === 'recent' ? '🕘 ' : '📄 '}${it.label}</span>
+      ${it.sub ? html`<span class="cmdk-item-sub">${it.sub}</span>` : null}
+      ${it.snippet ? html`<span class="cmdk-item-snippet">${it.snippet}</span>` : null}
+    </button>`; };
+
+  return html`
+    <${Modal} open=${open} onClose=${() => setOpen(false)} title=${t('search.paletteTitle') || 'Search everything'} className="cmdk-modal">
+      <div class="cmdk" ref=${inputRef} onKeyDown=${onInputKey}>
+        <${SearchBar} value=${q} onInput=${e => setQ(e.target.value)} placeholder=${t('search.palettePlaceholder') || 'Search organisms, workspaces, records…'} />
+        <div class="cmdk-hint section-desc">${t('search.openHint') || '↵ open · Esc close'}</div>
+        <div class="cmdk-list">
+          ${busy && !items.length ? html`<${Spinner} text=${t('search.searching') || 'Searching…'} />` : null}
+          ${!busy && query.length >= 2 && !items.length ? html`<${EmptyState} text=${t('search.noMatches') || 'No matches'} />` : null}
+          ${orgMatches.length ? html`<div class="cmdk-group">${t('organisms.title') || 'Organisms'}</div>` : null}
+          ${orgMatches.map(row)}
+          ${contentItems.length ? html`<div class="cmdk-group">${t('search.results') || 'Results'}</div>` : null}
+          ${contentItems.map(row)}
+          ${recents.length ? html`<div class="cmdk-group">${t('search.recents') || 'Recent'}</div>` : null}
+          ${recents.map(row)}
+        </div>
+      </div>
+    </${Modal}>`;
+}

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,8 @@
  *   - PresencePill + PresenceDialog — header status pill that opens the availability settings dialog
  *   - LandingPage — main orchestrator (default export)
  * @version-history
+ *   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 +436,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

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>