aimeat 2.2.0 → 2.3.0

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

@@ -27,6 +27,7 @@ import { PresenceDot } from '/components/PresenceDot.js';
 import * as orgService from '/js/services/organisms.js';
 import { fmtDate, orgInitials, relTime } from '/views/profile/organisms/helpers.js';
 import { InvitePanel, PendingInvites } from '/views/profile/organisms/invite-panel.js';
+import { swallowed } from '/js/swallowed.js';
 
 /** Inline per-member workspace-role editor: every manageable workspace with a
  *  none/viewer/contributor select. Changes apply immediately (grant replaces, none revokes). */
@@ -92,13 +93,13 @@ export function OrgMemberManager({ org, ghii, canManage, isCreator, showToast, c
   const [accessEditFor, setAccessEditFor] = useState(null); // bare owner name whose access panel is open
 
   const load = useCallback(async () => {
-    const tasks = [orgService.listMembers(orgId).catch(() => null)];
+    const tasks = [orgService.listMembers(orgId).catch(err => { swallowed('members: toGhii', err); return null; })];
     if (canManage) {
       tasks.push(
-        orgService.listJoinRequests(orgId).catch(() => null),
-        orgService.listMembers(orgId, 'banned').catch(() => null),
-        orgService.listInvitations(orgId).catch(() => null),
-        orgService.listEmailInvitations(orgId).catch(() => null),
+        orgService.listJoinRequests(orgId).catch(err => { swallowed('members: toGhii', err); return null; }),
+        orgService.listMembers(orgId, 'banned').catch(err => { swallowed('members: toGhii', err); return null; }),
+        orgService.listInvitations(orgId).catch(err => { swallowed('members: toGhii', err); return null; }),
+        orgService.listEmailInvitations(orgId).catch(err => { swallowed('members: toGhii', err); return null; }),
       );
     }
     const [mb, rq, bn, inv, eminv] = await Promise.all(tasks);
@@ -142,7 +143,7 @@ export function OrgMemberManager({ org, ghii, canManage, isCreator, showToast, c
           setWsAccess(map);
           setWsOptions((wss || []).map(w => ({ id: w.id, name: w.name || w.id })));
         }
-      } catch { /* the access line is optional */ }
+      } catch (err) { swallowed('members: add', err); }
     })();
     return () => { cancelled = true; };
   }, [orgId, show, accessTick]);

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

@@ -232,7 +232,7 @@ function loadOpts(storageKey) {
 }
 function saveOpts(storageKey, opts) {
   if (!storageKey) return;
-  try { localStorage.setItem(`aimeat.mm.${storageKey}`, JSON.stringify(opts)); } catch { /* quota/private mode — non-fatal */ }
+  try { localStorage.setItem(`aimeat.mm.${storageKey}`, JSON.stringify(opts)); } catch { /* quota/private mode — non-fatal */ }   // eslint-disable-line aimeat/no-silent-catch -- quota/private mode — non-fatal
 }
 
 /**

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

@@ -23,6 +23,7 @@ import * as orgService from '/js/services/organisms.js';
 import { listPosts, createPost } from '/js/services/boards.js';
 import { copyToClipboard } from '/js/utils.js';
 import { relTime } from '/views/profile/organisms/helpers.js';
+import { swallowed } from '/js/swallowed.js';
 
 /**
  * Content search inside an organism — case-insensitive substring over the records + documents of
@@ -42,7 +43,7 @@ export function OrgSearch({ orgId, onOpenWorkspace }) {
     setBusy(true);
     const tid = setTimeout(async () => {
       try { const r = await orgService.searchOrganism(orgId, query); if (!cancelled) setResults(r?.data?.results || []); }
-      catch { if (!cancelled) setResults([]); }
+      catch (err) { swallowed('panels', err); if (!cancelled) setResults([]); }
       finally { if (!cancelled) setBusy(false); }
     }, 220);
     return () => { cancelled = true; clearTimeout(tid); };
@@ -51,7 +52,7 @@ export function OrgSearch({ orgId, onOpenWorkspace }) {
   // 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 */ }
+    try { sessionStorage.setItem(`aimeat.ws.${orgId}.${r.ws}.openDoc`, JSON.stringify({ namespace: r.namespace, id: r.id })); } catch { /* noop */ }   // eslint-disable-line aimeat/no-silent-catch -- noop
     onOpenWorkspace?.(r.ws);
   };
 
@@ -90,7 +91,7 @@ export function IncomingInvitations({ showToast, onChanged }) {
   const [invites, setInvites] = useState([]);
   const [busy, setBusy] = useState(false);
   const load = useCallback(async () => {
-    const r = await orgService.listMyInvitations().catch(() => null);
+    const r = await orgService.listMyInvitations().catch(err => { swallowed('panels: IncomingInvitations', err); return null; });
     setInvites(r?.data?.invitations || []);
   }, []);
   useEffect(() => { load(); }, [load]);

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

@@ -31,6 +31,7 @@ import * as orgService from '/js/services/organisms.js';
 import { listAgents, offersWorkspaceContract, contractNamesOf, adoptContractTask } from '/js/services/agents.js';
 import { Mermaid } from '/components/Mermaid.js';
 import { ContactPicker } from '/components/ContactPicker.js';
+import { swallowed } from '/js/swallowed.js';
 
 /* Participants panel — who takes part in this workspace, as a node → owner → agents chart plus a
  * listing. Built from the records' identity traces (humans + their agents) + organism membership.
@@ -53,7 +54,7 @@ export function ParticipantsPanel({ orgId, wsId, showToast }) {
   const [engagements, setEngagements] = useState([]);
   const [retireBusy, setRetireBusy] = useState('');
   useEffect(() => {
-    listAgents().then(a => setContractAgents((a || []).filter(offersWorkspaceContract))).catch(() => {});
+    listAgents().then(a => setContractAgents((a || []).filter(offersWorkspaceContract))).catch(err => { swallowed('participants-panel: ParticipantsPanel', err); });
   }, []);
   // The engagement for (agent, contract) in THIS workspace, or undefined. contract '' = bare marker.
   const engFor = (a, contract) => engagements.find(e => e.agent === a.gaii && (e.contract || '') === (contract || ''));
@@ -64,7 +65,7 @@ export function ParticipantsPanel({ orgId, wsId, showToast }) {
     const key = `${a.gaii}:${contract || ''}`;
     setAdoptBusy(key);
     try {
-      await orgService.activateEngagement(orgId, wsId, a.gaii, contract).catch(() => {});
+      await orgService.activateEngagement(orgId, wsId, a.gaii, contract).catch(err => { swallowed('participants-panel: adopt', err); });
       const r = await adoptContractTask(a.name, { organismId: orgId, ws: wsId, contract });
       if (r?.ok === false) showToast?.(r?.error?.message || (t('organisms.adoptFailed') || 'Could not queue the adoption task'));
       else showToast?.((t('organisms.adoptQueued') || 'Adoption task queued for {agent} — it provisions the contract and reports back').replace('{agent}', a.display_name || a.name));
@@ -93,7 +94,7 @@ export function ParticipantsPanel({ orgId, wsId, showToast }) {
     const actions = names.length ? names : [''];
     setRetireBusy(`${a.gaii}:*`);
     try {
-      for (const c of actions) await orgService.retireEngagement(orgId, wsId, a.gaii, c).catch(() => {});
+      for (const c of actions) await orgService.retireEngagement(orgId, wsId, a.gaii, c).catch(err => { swallowed('participants-panel: retireAll', err); });
       showToast?.((t('organisms.retired') || '{agent} retired from this workspace').replace('{agent}', a.display_name || a.name));
       await refreshEngagements();
     } finally { setRetireBusy(''); }
@@ -105,30 +106,30 @@ export function ParticipantsPanel({ orgId, wsId, showToast }) {
     const actions = names.length ? names : [''];
     setAdoptBusy(`${a.gaii}:*`);
     try {
-      for (const c of actions) await orgService.activateEngagement(orgId, wsId, a.gaii, c).catch(() => {});
-      await adoptContractTask(a.name, { organismId: orgId, ws: wsId, contract: actions[0] }).catch(() => {});
+      for (const c of actions) await orgService.activateEngagement(orgId, wsId, a.gaii, c).catch(err => { swallowed('participants-panel: readoptAll', err); });
+      await adoptContractTask(a.name, { organismId: orgId, ws: wsId, contract: actions[0] }).catch(err => { swallowed('participants-panel: readoptAll', err); });
       showToast?.((t('organisms.broughtBack') || '{agent} is working here again').replace('{agent}', a.display_name || a.name));
       await refreshEngagements();
     } finally { setAdoptBusy(''); }
   };
-  const refreshEngagements = () => orgService.getWorkspaceEngagements(orgId, wsId).then(setEngagements).catch(() => {});
+  const refreshEngagements = () => orgService.getWorkspaceEngagements(orgId, wsId).then(setEngagements).catch(err => { swallowed('participants-panel: refreshEngagements', err); });
   useEffect(() => {
     let cancelled = false;
     const fetchIt = () => {
-      orgService.getWorkspaceParticipants(orgId, wsId).then(d => { if (!cancelled) setData(d); }).catch(() => {});
-      orgService.getWorkspaceEngagements(orgId, wsId).then(e => { if (!cancelled) setEngagements(e); }).catch(() => {});
+      orgService.getWorkspaceParticipants(orgId, wsId).then(d => { if (!cancelled) setData(d); }).catch(err => { swallowed('participants-panel: fetchIt', err); });
+      orgService.getWorkspaceEngagements(orgId, wsId).then(e => { if (!cancelled) setEngagements(e); }).catch(err => { swallowed('participants-panel: fetchIt', err); });
     };
     fetchIt();
     const off = onLiveUpdate(['organisms'], fetchIt);
     return () => { cancelled = true; off(); };
   }, [orgId, wsId]);
   const isManager = !!(data && (data.nodes || []).some(n => (n.owners || []).some(o => o.isSelf && o.isCreator)));
-  const loadAccess = useCallback(() => orgService.getWorkspaceAccess(orgId, wsId).then(setAccess).catch(() => {}), [orgId, wsId]);
+  const loadAccess = useCallback(() => orgService.getWorkspaceAccess(orgId, wsId).then(setAccess).catch(err => { swallowed('participants-panel: fetchIt', err); }), [orgId, wsId]);
   useEffect(() => { if (isManager) loadAccess(); }, [isManager, orgId, wsId, data, loadAccess]);  if (!data || !(data.nodes || []).length) return null;
   const owners = [];
   for (const n of data.nodes) for (const o of (n.owners || [])) owners.push({ ...o, node: n.id, isLocalNode: n.isLocal });
 
-  const after = async (p) => { setBusy(true); try { await p; await loadAccess(); } catch { /* the row stays so the user can retry */ } finally { setBusy(false); } };
+  const after = async (p) => { setBusy(true); try { await p; await loadAccess(); } catch (err) { swallowed('participants-panel: after', err); } finally { setBusy(false); } };
   const doGrant = (g, r) => { const name = (g || '').trim(); if (name) { after(orgService.grantWorkspaceRole(orgId, wsId, name, r)); setGrantee(''); } };
   const doRevoke = (g) => after(orgService.revokeWorkspaceRole(orgId, wsId, g));
   const doDecide = (requester, decision) => after(orgService.decideWorkspaceAccess(orgId, wsId, requester, decision));

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

@@ -52,6 +52,7 @@ export function ReadmePanel({ markdown, canEdit, onSave, aiPromptSeed, kind, nam
   const copyPrompt = async () => {
     const prompt = buildAiPrompt(kind, name, aiPromptSeed);
     try { await navigator.clipboard.writeText(prompt); setCopied(true); setTimeout(() => setCopied(false), 2500); }
+    // eslint-disable-next-line aimeat/no-silent-catch -- clipboard may be blocked; the user can still type the README
     catch { /* clipboard may be blocked; the user can still type the README */ }
   };
 

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

@@ -21,6 +21,7 @@ import * as knowledgeService from '/js/services/knowledge.js';
 import { EmptyState } from '/components/EmptyState.js';
 import { SearchBar } from '/components/SearchBar.js';
 import { fmtBytes } from '/js/format.js';
+import { swallowed } from '/js/swallowed.js';
 
 const SRC_ICON = { memory: '🧠', storage: '📎', knowledge: '📚' };
 
@@ -70,7 +71,7 @@ export function SourcesPanel({ orgId, wsId, showToast }) {
         const r = await knowledgeService.discoverPackages({ limit: 50, sort: 'recent' });
         setResults((r?.data?.packages || []).filter(p => !ql || String(p.name || '').toLowerCase().includes(ql)));
       }
-    } catch { setResults([]); }
+    } catch (err) { swallowed('sources-panel', err); setResults([]); }
     finally { setLoading(false); }
   };
   const searchRef = useRef(doSearch); searchRef.current = doSearch;

package/dist/public/views/profile/organisms/workspace/doc-space.js

@@ -20,6 +20,7 @@ import { DocumentView, DocumentEditor } from '/views/profile/organisms/document.
 import { WorkspaceComments } from '/views/profile/organisms/workspace-comments.js';
 import { ColorPicker } from './color-picker.js';
 import { groupDocs } from './helpers.js';
+import { swallowed } from '/js/swallowed.js';
 
 // A document-space: left index (section tree + documents, with an Unsorted group) + a main
 // area showing the active document (view/edit). Sections nest via parentId; documents are
@@ -43,7 +44,7 @@ export function renderDocSpace(ctx, ot) {
   const docItem = (d) => html`
     <div class="pj-doc-item ${isActive(d) ? 'active' : ''} ${itemColor(ot.name, d.id) ? 'pj-colored pj-tag-' + itemColor(ot.name, d.id) : ''}" key=${'di' + d.id}
       draggable=${true}
-      onDragStart=${(e) => { draggedDoc.current = { type: ot.name, id: d.id }; if (e.dataTransfer) { e.dataTransfer.effectAllowed = 'move'; try { e.dataTransfer.setData('text/plain', d.id); } catch { /* noop */ } } }}
+      onDragStart=${(e) => { draggedDoc.current = { type: ot.name, id: d.id }; if (e.dataTransfer) { e.dataTransfer.effectAllowed = 'move'; try { e.dataTransfer.setData('text/plain', d.id); } catch (err) { swallowed('doc-space: docItem', err); } } }}
       onDragEnd=${() => { draggedDoc.current = null; }}>
       <span class="pj-grip" title=${t('organisms.dragHint') || 'Drag into a section'}>⠿</span>
       <${ColorPicker} value=${itemColor(ot.name, d.id)} onPick=${(c) => setItemColor(ot.name, d.id, c)} />

package/dist/public/views/profile/organisms/workspace/model.js

@@ -92,6 +92,7 @@ export function buildWorkspaceModel(ctx) {
     || Object.values(share.spaces || {}).some(Boolean) || Object.values(share.docs || {}).some(Boolean));
   const copyShareLink = async (url) => {
     try { await navigator.clipboard.writeText(window.location.origin + url); showToast(t('organisms.linkCopied') || 'Link copied'); }
+    // eslint-disable-next-line aimeat/no-silent-catch -- a browser API refusing here IS the answer
     catch { showToast(t('organisms.copyFailed') || 'Copy failed'); }
   };
 

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

@@ -19,6 +19,7 @@ import { t } from '/js/i18n.js';
 import { openAppSandboxed } from '/js/app-sandbox.js';
 import { listApps } from '/js/services/apps.js';
 import { saveWorkspaceApps } from '/js/services/organisms.js';
+import { swallowed } from '/js/swallowed.js';
 
 /** The launch URL for a pinned app, carrying the workspace context in the fragment. */
 function launchHref(orgId, wsId, b) {
@@ -38,7 +39,7 @@ export function WorkspaceApps({ orgId, wsId, apps, canEdit, showToast, onChanged
   useEffect(() => {
     if (bound.length === 0 && !showPicker) return undefined;
     let cancelled = false;
-    listApps().then(a => { if (!cancelled) setCatalog(a); }).catch(() => { if (!cancelled) setCatalog([]); });
+    listApps().then(a => { if (!cancelled) setCatalog(a); }).catch((err) => { swallowed('workspace-apps', err); if (!cancelled) setCatalog([]); });
     return () => { cancelled = true; };
   }, [bound.length, showPicker]);
 
@@ -58,7 +59,8 @@ export function WorkspaceApps({ orgId, wsId, apps, canEdit, showToast, onChanged
       await saveWorkspaceApps(orgId, wsId, next.map(b => ({ owner: b.owner, filename: b.filename, ...(b.label ? { label: b.label } : {}) })));
       showToast?.(t('organisms.apps.saved') || 'Workspace apps updated', 'success');
       onChanged?.();
-    } catch {
+    } catch (err) {
+      swallowed('workspace-apps: save', err);
       showToast?.(t('organisms.apps.saveError') || 'Could not update apps', 'error');
     } finally { setBusy(false); }
   };

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

@@ -19,6 +19,7 @@ const html = htm.bind(h);
 import { t } from '/js/i18n.js';
 import { dt } from '/js/format.js';
 import * as orgService from '/js/services/organisms.js';
+import { swallowed } from '/js/swallowed.js';
 
 /**
  * Comment thread on one workspace object (record or document). Targeted by orgId+ws+space+instanceId.
@@ -36,13 +37,13 @@ export function WorkspaceComments({ orgId, ws, space, instanceId, showToast, bat
   const [anchorQuote, setAnchorQuote] = useState('');
   const [replyTo, setReplyTo] = useState(null);   // { id, body } of the comment being replied to
   const [busy, setBusy] = useState(false);
-  const me = (() => { try { return window.AIMEAT?.auth?.getSession?.() || {}; } catch { return {}; } })();
+  const me = (() => { try { return window.AIMEAT?.auth?.getSession?.() || {}; } catch (err) { swallowed('workspace-comments', err); return { }; } })();
   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);
+    const r = await orgService.listComments(orgId, ws, space, instanceId).catch(err => { swallowed('workspace-comments: mine', err); return null; });
     setComments(r?.data?.comments || []);
   }, [orgId, ws, space, instanceId, batched, onReload]);
   // Batched: keep local view in sync with the prop (undefined = still loading → null). Standalone: self-fetch.

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

@@ -34,6 +34,7 @@ import * as orgService from '/js/services/organisms.js';
 import * as memoryService from '/js/services/memory.js';
 import { fmtDate, relTime } from '/views/profile/organisms/helpers.js';
 import { OrgSearch } from '/views/profile/organisms/panels.js';
+import { swallowed } from '/js/swallowed.js';
 
 /* Workspace list — an organism contains many workspaces (each an independent manifest + data set,
  * namespaced under organism.{id}.w.{wsId}.*). Lists the registry (organism.{id}.meta.workspaces),
@@ -77,12 +78,12 @@ export function WorkspaceList({ org, showToast, onOpen, onCount }) {
           if (Array.isArray(v.order)) setCustomOrder(v.order.filter(x => typeof x === 'string'));
           if (['custom', 'name', 'newest'].includes(v.sort)) setSortMode(v.sort);
         }
-      } catch { /* no saved prefs yet */ }
+      } catch (err) { swallowed('workspace-list: WorkspaceList', err); }
     })();
     return () => { alive = false; };
   }, [UI_PREFS_KEY]);
   const savePrefs = useCallback((order, sort) => {
-    memoryService.createMemory(UI_PREFS_KEY, { order, sort }, 'private').catch(() => {});
+    memoryService.createMemory(UI_PREFS_KEY, { order, sort }, 'private').catch(err => { swallowed('workspace-list: WorkspaceList', err); });
   }, [UI_PREFS_KEY]);
 
   // Active workspaces sorted for display; archived ones stay in server order in their own section.
@@ -171,7 +172,7 @@ export function WorkspaceList({ org, showToast, onOpen, onCount }) {
   useEffect(() => {
     if (!showOverview) return;
     let cancelled = false;
-    orgService.buildOrganismOverviewMermaid(orgId).then(c => { if (!cancelled) setOverview(c); }).catch(() => {});
+    orgService.buildOrganismOverviewMermaid(orgId).then(c => { if (!cancelled) setOverview(c); }).catch(err => { swallowed('workspace-list: decide', err); });
     return () => { cancelled = true; };
   }, [orgId, list, showOverview]);
   // Re-load on organism changes, but DEBOUNCE: on a busy node dozens of agents emit 'organisms'
@@ -223,7 +224,7 @@ export function WorkspaceList({ org, showToast, onOpen, onCount }) {
   };
 
   // ── Export (download ZIP backup) + Import (upload a ZIP as a new workspace) ──
-  const jwt = () => { try { return window.AIMEAT?.auth?.getSession?.()?.jwt || ''; } catch { return ''; } };
+  const jwt = () => { try { return window.AIMEAT?.auth?.getSession?.()?.jwt || ''; } catch (err) { swallowed('workspace-list', err); return ''; } };
   const fileRef = useRef(null);
   const doExport = async (w) => {
     try {

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

@@ -70,6 +70,7 @@ import { renderRecordSpace } from './workspace/record-space.js';
 import { renderOverview, renderObjectives, renderWsSearchResults, renderOvSection } from './workspace/overview.js';
 import { renderTabsNav, renderSpacesAdd, renderSettingsPanel, renderShareTab, renderReviewTab, renderActivityTab } from './workspace/panels.js';
 import { buildBreadcrumb, buildWorkspaceModel } from './workspace/model.js';
+import { swallowed } from '/js/swallowed.js';
 
 /* ───────────────── Organism workspace (manifest-driven) ─────────────────
  * Any organism can have a governed workspace. If it has no manifest yet, offer
@@ -89,7 +90,7 @@ export function Workspace({ org, wsId, showToast, onBack, onBackToList, initialS
       setWsName(name);
       // Feed the home page's "Continue" list with a real display name.
       recordRecent({ type: 'workspace', id: `${orgId}/${wsId}`, label: name || wsId, sub: org.name || '', data: { orgId, wsId } });
-    }).catch(() => {});
+    }).catch(err => { swallowed('workspace: name', err); });
     return () => { cancelled = true; };
     // eslint-disable-next-line react-hooks/exhaustive-deps -- org.name only feeds recordRecent's display sub; the workspace-name fetch is intentionally keyed to orgId/wsId.
   }, [orgId, wsId]);  // Pop a document out into its own window (served by doc-solo.js) so several can sit side by side,
@@ -121,6 +122,7 @@ export function Workspace({ org, wsId, showToast, onBack, onBackToList, initialS
     try {
       const raw = sessionStorage.getItem(docKey);
       if (raw) { const v = JSON.parse(raw); if (v && v.type && v.id) return { type: v.type, mode: v.mode === 'edit' ? 'edit' : 'view', page: { id: v.id } }; }
+    // eslint-disable-next-line aimeat/no-silent-catch -- noop
     } catch { /* noop */ }
     return null;
   });
@@ -157,11 +159,11 @@ export function Workspace({ org, wsId, showToast, onBack, onBackToList, initialS
   // history never shows as unseen. Neutral gray badges only — red is reserved for errors.
   const seenKey = 'aimeat.ws.' + orgId + '.' + wsId + '.seen';
   const [seen, setSeen] = useState(() => {
-    try { const raw = localStorage.getItem(seenKey); return raw ? JSON.parse(raw) : null; } catch { return null; }
+    try { const raw = localStorage.getItem(seenKey); return raw ? JSON.parse(raw) : null; } catch { return null; }   // eslint-disable-line aimeat/no-silent-catch -- a browser API refusing here IS the answer
   });
   const markSeen = useCallback((tabId) => setSeen(prev => {
     const next = { ...(prev || {}), [tabId]: new Date().toISOString() };
-    try { localStorage.setItem(seenKey, JSON.stringify(next)); } catch { /* noop */ }
+    try { localStorage.setItem(seenKey, JSON.stringify(next)); } catch { /* noop */ }   // eslint-disable-line aimeat/no-silent-catch -- noop
     return next;
   }), [seenKey]);
   // Items (not raw events) changed since the tab's seen mark. The user's own non-agent edits
@@ -182,14 +184,14 @@ export function Workspace({ org, wsId, showToast, onBack, onBackToList, initialS
 
   const load = useCallback(async () => {
     // In the archived view, request ONLY archived content (read-only); otherwise the normal active set.
-    const w = await orgService.getWorkspace(orgId, wsId, showArchived ? { archived: 'only' } : undefined).catch(() => null);
+    const w = await orgService.getWorkspace(orgId, wsId, showArchived ? { archived: 'only' } : undefined).catch(err => { swallowed('workspace', err); return null; });
     if (w && w.manifest) {
       const [ap, cfg, secs, act, cols] = await Promise.all([
-        orgService.listApprovals(orgId, 'pending').catch(() => []),
-        orgService.getConfig(orgId).catch(() => ({})),
-        orgService.getAllSections(orgId, wsId).catch(() => ({})),
+        orgService.listApprovals(orgId, 'pending').catch(err => { swallowed('workspace', err); return []; }),
+        orgService.getConfig(orgId).catch(err => { swallowed('workspace', err); return ({}); }),
+        orgService.getAllSections(orgId, wsId).catch(err => { swallowed('workspace', err); return ({}); }),
         orgService.getWorkspaceActivity(orgId, wsId).catch(() => ({ events: [] })),
-        orgService.getAllColors(orgId, wsId).catch(() => ({})),
+        orgService.getAllColors(orgId, wsId).catch(err => { swallowed('workspace', err); return ({}); }),
       ]);
       setApprovals(ap); setGateOn(!!(cfg?.gates?.publish?.enabled)); setSectionsByType(secs);
       setWsEvents(act?.events || []); setColorsByType(cols);
@@ -208,7 +210,7 @@ export function Workspace({ org, wsId, showToast, onBack, onBackToList, initialS
     let cancelled = false;
     const loadGraph = async () => {
       const [g, ov] = await Promise.all([
-        orgService.getWorkspaceGraph(orgId, wsId).catch(() => null),
+        orgService.getWorkspaceGraph(orgId, wsId).catch(err => { swallowed('workspace: loadGraph', err); return null; }),
         orgService.getWorkspaceOverviewFull(orgId, wsId).catch(() => ({ markdown: '', objectives: [] })),
       ]);
       if (cancelled) return;
@@ -241,7 +243,7 @@ export function Workspace({ org, wsId, showToast, onBack, onBackToList, initialS
     let cancelled = false;
     setWsSearching(true);
     const tid = setTimeout(async () => {
-      const r = await orgService.searchOrganism(orgId, q, wsId).catch(() => null);
+      const r = await orgService.searchOrganism(orgId, q, wsId).catch(err => { swallowed('workspace: onWsMapNav', err); return null; });
       if (!cancelled) { setWsHits((r?.data?.results) || []); setWsSearching(false); }
     }, 220);   // debounce — instant feel without a request per keystroke
     return () => { cancelled = true; clearTimeout(tid); };
@@ -251,7 +253,7 @@ export function Workspace({ org, wsId, showToast, onBack, onBackToList, initialS
   // filtered result list for the query you jumped from.
   useEffect(() => {
     const k = `aimeat.ws.${orgId}.${wsId}.search`;
-    try { const v = sessionStorage.getItem(k); if (v) { setWsQuery(v); sessionStorage.removeItem(k); } } catch { /* noop */ }
+    try { const v = sessionStorage.getItem(k); if (v) { setWsQuery(v); sessionStorage.removeItem(k); } } catch { /* noop */ }   // eslint-disable-line aimeat/no-silent-catch -- noop
   }, [orgId, wsId]);
 
   // Deep-link from the librarian "Open" button: aimeat.ws.{org}.{ws}.openDoc = { namespace, id }.
@@ -261,11 +263,11 @@ export function Workspace({ org, wsId, showToast, onBack, onBackToList, initialS
   useEffect(() => {
     if (!ws?.manifest) return;
     let req = null;
-    try { req = JSON.parse(sessionStorage.getItem(openDocKey) || 'null'); } catch { req = null; }
+    try { req = JSON.parse(sessionStorage.getItem(openDocKey) || 'null'); } catch { req = null; }   // eslint-disable-line aimeat/no-silent-catch -- a browser API refusing here IS the answer
     if (!req || !req.namespace || !req.id) return;
     const ot = (ws.manifest.objectTypes || []).find(o => o.namespace === req.namespace);
     if (ot) { setTab('space:' + ot.name); setActiveDoc({ type: ot.name, mode: 'view', page: { id: req.id } }); }
-    try { sessionStorage.removeItem(openDocKey); } catch { /* noop */ }
+    try { sessionStorage.removeItem(openDocKey); } catch { /* noop */ }   // eslint-disable-line aimeat/no-silent-catch -- noop
   }, [ws, openDocKey]);
 
   // Persist the open document (id only) so an F5 returns to it. Skip unsaved new docs (no id yet).
@@ -273,6 +275,7 @@ export function Workspace({ org, wsId, showToast, onBack, onBackToList, initialS
     try {
       if (activeDoc?.type && activeDoc.page?.id) sessionStorage.setItem(docKey, JSON.stringify({ type: activeDoc.type, id: activeDoc.page.id, mode: activeDoc.mode }));
       else sessionStorage.removeItem(docKey);
+    // eslint-disable-next-line aimeat/no-silent-catch -- noop
     } catch { /* noop */ }
   }, [activeDoc, docKey]);
 
@@ -334,7 +337,7 @@ export function Workspace({ org, wsId, showToast, onBack, onBackToList, initialS
   useEffect(() => {
     if (seen !== null || ws === undefined) return;
     const next = { __base: new Date().toISOString() };
-    try { localStorage.setItem(seenKey, JSON.stringify(next)); } catch { /* noop */ }
+    try { localStorage.setItem(seenKey, JSON.stringify(next)); } catch { /* noop */ }   // eslint-disable-line aimeat/no-silent-catch -- noop
     setSeen(next);
   }, [seen, ws, seenKey]);
   // Changes landing on the tab the user is LOOKING at are seen immediately — otherwise a draft
@@ -405,7 +408,7 @@ export function Workspace({ org, wsId, showToast, onBack, onBackToList, initialS
         if (sectionId) {
           const secs = (sectionsByType[ot.name] || []).map(s => s.id === sectionId
             ? { ...s, documents: [...(s.documents || []).filter(d => d !== id), id] } : s);
-          await orgService.saveSections(orgId, wsId, ot.name, secs).catch(() => {});
+          await orgService.saveSections(orgId, wsId, ot.name, secs).catch(err => { swallowed('workspace: secs', err); });
         }
         // Reload, then open the just-saved document (view mode). renderDocSpace re-resolves the id
         // to the fresh merged entry, so the new draft shows with its badge instead of the empty state.
@@ -441,7 +444,7 @@ export function Workspace({ org, wsId, showToast, onBack, onBackToList, initialS
   const sectionsRef = useRef(sectionsByType); sectionsRef.current = sectionsByType;
   const setSecName = (typeName, secId, name) =>
     setSectionsByType(s => ({ ...s, [typeName]: (s[typeName] || []).map(x => x.id === secId ? { ...x, name } : x) }));
-  const commitSecName = (typeName) => { setEditingSec(null); orgService.saveSections(orgId, wsId, typeName, sectionsRef.current[typeName] || []).catch(() => {}); };
+  const commitSecName = (typeName) => { setEditingSec(null); orgService.saveSections(orgId, wsId, typeName, sectionsRef.current[typeName] || []).catch(err => { swallowed('workspace: commitSecName', err); }); };
 
   // ── Optional color tags. Section colors live on the section object (persisted via updateSections);
   // per-document/record colors live in a parallel meta.colors map (persisted via saveColors). ──

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

@@ -51,6 +51,7 @@ import { fmtDate, orgInitials, exportOrganismZip } from '/views/profile/organism
 import { IncomingInvitations } from '/views/profile/organisms/panels.js';
 import { OrganismHome } from '/views/profile/organisms/home.js';
 import { Workspace } from '/views/profile/organisms/workspace.js';
+import { swallowed } from '/js/swallowed.js';
 
 export default function OrganismsTab({ session, showToast, onStats }) {
   const { confirm, ConfirmUI } = useConfirm();
@@ -60,7 +61,9 @@ export default function OrganismsTab({ session, showToast, onStats }) {
   const [archivedOpen, setArchivedOpen] = useState(false);   // collapsible "Archived" section (closed by default)
   // organism whose workspaces are open, then the specific workspace within it — both restored from
   // sessionStorage so an F5 returns to where you were. openId set + openWs null = the workspace LIST.
+  // eslint-disable-next-line aimeat/no-silent-catch -- a browser API refusing here IS the answer
   const [openId, setOpenId] = useState(() => { try { return sessionStorage.getItem('aimeat.ws.openId') || null; } catch { return null; } });
+  // eslint-disable-next-line aimeat/no-silent-catch -- a browser API refusing here IS the answer
   const [openWs, setOpenWs] = useState(() => { try { return sessionStorage.getItem('aimeat.ws.openWs') || null; } catch { return null; } });
   // Transient deep-link target from the organism mindmap: open this space's tab on first render of the
   // workspace. In-memory only (not persisted) — an F5 lands on the workspace overview, not a stale tab.
@@ -123,8 +126,9 @@ export default function OrganismsTab({ session, showToast, onStats }) {
       setPublicOrganisms((pubResp?.data?.organisms || []).filter(o => !mineIds.has(o.id)));
       onStats?.({ organisms: mine.length });
       setWsCounts(Object.fromEntries(mine.map(o => [o.id, o.workspace_count ?? 0])));
-      try { const r = await memoryService.getMemory('organisms.ui', { soft: true }); applyPrefs(r?.data?.value); } catch { /* no saved prefs */ }
-    } catch {
+      try { const r = await memoryService.getMemory('organisms.ui', { soft: true }); applyPrefs(r?.data?.value); } catch (err) { swallowed('organisms-tab: applyPrefs', err); }
+    } catch (err) {
+      swallowed('organisms-tab: applyPrefs', err);
       setMyOrganisms([]);
       setPublicOrganisms([]);
     }
@@ -138,7 +142,7 @@ export default function OrganismsTab({ session, showToast, onStats }) {
   // Read as part of loadData's mount composite (above); this key backs savePrefs.
   const UI_PREFS_KEY = 'organisms.ui';
   const savePrefs = useCallback((order, sort) => {
-    memoryService.createMemory(UI_PREFS_KEY, { order, sort }, 'private').catch(() => {});
+    memoryService.createMemory(UI_PREFS_KEY, { order, sort }, 'private').catch(err => { swallowed('organisms-tab: applyPrefs', err); });
   }, []);
 
   // Stable sort keeps server order for ids missing from the saved manual order (appended at the end).
@@ -189,10 +193,10 @@ export default function OrganismsTab({ session, showToast, onStats }) {
 
   // Persist the open organism + workspace (F5 restore), and drop a restored id the user can no longer open.
   useEffect(() => {
-    try { if (openId) sessionStorage.setItem('aimeat.ws.openId', openId); else sessionStorage.removeItem('aimeat.ws.openId'); } catch { /* noop */ }
+    try { if (openId) sessionStorage.setItem('aimeat.ws.openId', openId); else sessionStorage.removeItem('aimeat.ws.openId'); } catch { /* noop */ }   // eslint-disable-line aimeat/no-silent-catch -- noop
   }, [openId]);
   useEffect(() => {
-    try { if (openWs) sessionStorage.setItem('aimeat.ws.openWs', openWs); else sessionStorage.removeItem('aimeat.ws.openWs'); } catch { /* noop */ }
+    try { if (openWs) sessionStorage.setItem('aimeat.ws.openWs', openWs); else sessionStorage.removeItem('aimeat.ws.openWs'); } catch { /* noop */ }   // eslint-disable-line aimeat/no-silent-catch -- noop
   }, [openWs]);
   useEffect(() => {
     if (openId && myOrganisms && !myOrganisms.some(o => o.id === openId)) { setOpenId(null); setOpenWs(null); }
@@ -217,7 +221,7 @@ export default function OrganismsTab({ session, showToast, onStats }) {
       const params = new URLSearchParams(window.location.search);
       const org = params.get('org');
       if (org) { setOpenId(org); setOpenWs(params.get('ws') || null); setOpenSpace(null); setOpenSettings(false); }
-    } catch { /* noop */ }
+    } catch (err) { swallowed('organisms-tab: onOpen', err); }
   }, []);
 
   // Cross-organism content search (debounced) — librarian FTS across all my own content.
@@ -227,7 +231,7 @@ export default function OrganismsTab({ session, showToast, onStats }) {
     let cancelled = false;
     setGBusy(true);
     const tid = setTimeout(async () => {
-      const hits = await memoryService.librarianSearch(query, 60, 'own').catch(() => []);
+      const hits = await memoryService.librarianSearch(query, 60, 'own').catch(err => { swallowed('organisms-tab: onOpen', err); return []; });
       if (!cancelled) { setGHits(hits || []); setGBusy(false); }
     }, 220);
     return () => { cancelled = true; clearTimeout(tid); };
@@ -262,7 +266,8 @@ export default function OrganismsTab({ session, showToast, onStats }) {
       } else {
         showToast(result?.error?.message || (t('organisms.createError') || 'Failed to create'));
       }
-    } catch {
+    } catch (err) {
+      swallowed('organisms-tab: onOpen', err);
       showToast(t('organisms.createError') || 'Failed to create');
     } finally { setCreating(false); }
   }, [formName, formDesc, formType, formPolicy, formVisibility, formInterests, showToast, loadData]);
@@ -278,7 +283,8 @@ export default function OrganismsTab({ session, showToast, onStats }) {
         showToast(result?.error?.message || 'Could not join');
       }
       loadData();
-    } catch {
+    } catch (err) {
+      swallowed('organisms-tab: onOpen', err);
       showToast(t('organisms.joinError') || 'Failed to join');
     }
   }, [showToast, loadData]);
@@ -290,7 +296,8 @@ export default function OrganismsTab({ session, showToast, onStats }) {
         showToast(t('organisms.left') || 'Left organism');
         setOpenId(null); setOpenWs(null);
         loadData();
-      } catch {
+      } catch (err) {
+        swallowed('organisms-tab: onOpen', err);
         showToast(t('organisms.leaveError') || 'Failed to leave');
       }
     }, { danger: true });
@@ -304,7 +311,8 @@ export default function OrganismsTab({ session, showToast, onStats }) {
         setExpanded(null);
         setOpenId(null); setOpenWs(null);
         loadData();
-      } catch {
+      } catch (err) {
+        swallowed('organisms-tab: onOpen', err);
         showToast(t('organisms.deleteError') || 'Failed to delete');
       }
     }, { danger: true });
@@ -455,7 +463,7 @@ export default function OrganismsTab({ session, showToast, onStats }) {
   // Open a cross-organism search hit: jump to its organism + workspace, pre-filling the in-workspace
   // search with the query so you land on the filtered result list (reuses Kerros 1).
   const openGHit = (hit) => {
-    try { if (hit.workspaceId) sessionStorage.setItem(`aimeat.ws.${hit.organismId}.${hit.workspaceId}.search`, gQuery.trim()); } catch { /* noop */ }
+    try { if (hit.workspaceId) sessionStorage.setItem(`aimeat.ws.${hit.organismId}.${hit.workspaceId}.search`, gQuery.trim()); } catch { /* noop */ }   // eslint-disable-line aimeat/no-silent-catch -- noop
     setOpenId(hit.organismId);
     setOpenWs(hit.workspaceId || null);
     setOpenSpace(null);

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

@@ -34,6 +34,7 @@ import { Spinner } from './shared.js';
 import { useConfirm } from '/components/Modal.js';
 import * as pkgService from '/js/services/packages.js';
 import { apiGet } from '/js/api.js';
+import { swallowed } from '/js/swallowed.js';
 
 // ─── InstanceCard ───────────────────────────────────────────────────────────
 // Expanded card for one installed package instance: shows every component's
@@ -169,7 +170,7 @@ export default function PackagesTab({ session, showToast, navigate }) {
       // Mount: ONE composite (GET /v1/packages/tab) seeds the three LOCAL sections (installed instances +
       // owner's packages + newest templates). Falls back to the three individual reads on failure. The
       // cross-node federation-templates call below stays separate (best-effort outbound).
-      const ov = await apiGet('/v1/packages/tab').then(r => r?.data).catch(() => null);
+      const ov = await apiGet('/v1/packages/tab').then(r => r?.data).catch(err => { swallowed('packages-tab: PackagesTab', err); return null; });
       if (ov) {
         setInstances(ov.instances?.instances ?? []);
         setPackages(ov.packages?.packages ?? []);
@@ -188,8 +189,8 @@ export default function PackagesTab({ session, showToast, navigate }) {
       try {
         const fedRes = await pkgService.listFederationTemplates({ limit: 50 });
         if (fedRes.ok) setRemoteTemplates(fedRes.data?.templates ?? []);
-      } catch { /* federation may not be available */ }
-    } catch { /* ignore */ }
+      } catch (err) { swallowed('packages-tab: PackagesTab', err); }
+    } catch (err) { swallowed('packages-tab: PackagesTab', err); }
     setLoading(false);
   }, [session?.owner]);
 
@@ -350,7 +351,8 @@ export default function PackagesTab({ session, showToast, navigate }) {
       } else {
         showToast('Failed to load prompt', true);
       }
-    } catch {
+    } catch (err) {
+      swallowed('packages-tab: copyPackagePrompt', err);
       showToast('Failed to load prompt', true);
     }
   };

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

@@ -42,7 +42,7 @@ export default function PortfolioTab({ session, navigate, showToast }) {
   // prop function of uncertain stability, and adding it could re-fire the forward before unmount.
   useEffect(() => {
     if (cfg !== undefined && !cfg?.enabled) {
-      try { sessionStorage.removeItem('aimeat-profile-tab'); } catch { /* noop */ }
+      try { sessionStorage.removeItem('aimeat-profile-tab'); } catch { /* noop */ }   // eslint-disable-line aimeat/no-silent-catch -- noop
       navigate('/v1/portfolio');
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps

package/dist/public/views/profile/scheduler-calendar.js

@@ -23,6 +23,7 @@ import htm from 'htm';
 import { useState, useMemo, useEffect, useCallback } from 'preact/hooks';
 import { t } from '/js/i18n.js';
 import { listScheduleOccurrences } from '/js/services/schedules.js';
+import { swallowed } from '/js/swallowed.js';
 
 const html = htm.bind(h);
 
@@ -112,7 +113,7 @@ export default function SchedulerCalendar({ schedules = [], reloadKey = 0, onJum
         setFreq(res?.data?.frequent || []);
         setTruncated(!!res?.data?.truncated);
       })
-      .catch(() => { if (alive) { setOcc([]); setFreq([]); setTruncated(false); } })
+      .catch((err) => { swallowed('scheduler-calendar', err); if (alive) { setOcc([]); setFreq([]); setTruncated(false); } })
       .finally(() => { if (alive) setLoading(false); });
     return () => { alive = false; };
   }, [startMs, endMs, reloadKey]);