aimeat 1.23.2 → 1.23.3

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

@@ -138,6 +138,25 @@
  *   v1.25.2 — 2026-06-10 — Settings Cancel works again: it discards changes AND closes the panel
  *     (both organism + workspace settings) — the dirty-only reset variant did nothing visible on a
  *     clean form, which read as a dead button.
+ *   v1.26.0 — 2026-06-10 — Contract-agent discovery: agents tagged 'workspace-contract' (+ optional
+ *     'contract.<id>' names) surface to their OWNER — a 📜 block in the workspace People panel and a
+ *     📜 badge/marker in the organism Agents tab picker + rows. Tag convention: docs/agent-workspace-
+ *     contracts.md §7b; helpers offersWorkspaceContract/contractNamesOf in /js/services/agents.js.
+ *   v1.27.0 — 2026-06-10 — One-click contract adoption: each contract chip gets an "Adopt <id>"
+ *     button that queues the agreed adopt-contract TASK for the agent (scope[kind]=adopt-contract +
+ *     organism_id/ws/contract, status:'queued' — the create default is draft and a draft never
+ *     auto-activates; §7c) — the agent joins/provisions its own spaces and the task completion is
+ *     the ack. An agent already working in THIS workspace (per the participants data) shows a
+ *     "✓ active here" badge instead of Adopt. Convention agreed with the crewaimeat side 2026-06-10.
+ *   v1.28.0 — 2026-06-12 — Overview landing tab: the whole workspace on one vertical scroll — a
+ *     "what happened here" strip (last 8 activity events, humanized + clickable) above every
+ *     manifest space stacked in order (records: compact rows max 5 + "Show all N →"; documents:
+ *     title + first-line preview; empty space: one row with an Add button; non-memory backing:
+ *     one notice row). Overview is ALWAYS the landing view (tab persistence dropped — it hid
+ *     content). Mobile: sections collapse as accordions and documents expand INLINE (view+edit,
+ *     no popout window). Per-tab unseen badges (gray, never red) from localStorage seen marks vs
+ *     activity events — cleared when the tab opens, surviving across sessions; first visit seeds
+ *     a baseline so history is never "unseen"; own non-agent edits don't count.
  */
 import { h } from 'preact';
 import { useState, useEffect, useCallback, useRef, useMemo } from 'preact/hooks';
@@ -152,12 +171,13 @@ import { SearchBar } from '/components/SearchBar.js';
 import * as orgService from '/js/services/organisms.js';
 import * as memoryService from '/js/services/memory.js';
 import * as knowledgeService from '/js/services/knowledge.js';
-import { listAgents } from '/js/services/agents.js';
+import { listAgents, offersWorkspaceContract, contractNamesOf, adoptContractTask } from '/js/services/agents.js';
 import { getGhii } from '/js/services/auth.js';
 import { listPosts, createPost } from '/js/services/boards.js';
 import { OpenRouterSettings } from './generator-settings.js';
 import { copyToClipboard } from '/js/utils.js';
 import { dt, fmtBytes } from '/js/format.js';
+import { recordRecent } from '/js/recents.js';
 import { Markdown, slugifyHeading } from '/components/Markdown.js';
 import { Mermaid } from '/components/Mermaid.js';
 
@@ -422,7 +442,7 @@ function OrgAgentsPanel({ org, ghii, canManage, showToast, onChanged }) {
             <div class="flex-row-wrap">
               <select class="input-field input-sm" value=${pick} onChange=${e => setPick(e.target.value)}>
                 <option value="">${t('organisms.pickAgent') || 'Choose one of your agents…'}</option>
-                ${pickable.map(a => html`<option value=${a.gaii} key=${a.gaii}>${a.display_name || a.name}</option>`)}
+                ${pickable.map(a => html`<option value=${a.gaii} key=${a.gaii}>${(a.display_name || a.name) + (offersWorkspaceContract(a) ? ` · 📜 ${t('organisms.contractTag') || 'contract'}` : '')}</option>`)}
               </select>
               <button class="btn-outline btn-sm" disabled=${busy || !pick} onClick=${() => attach(pick)}>${t('organisms.attach') || 'Attach'}</button>
             </div>` : html`
@@ -448,6 +468,7 @@ function OrgAgentsPanel({ org, ghii, canManage, showToast, onChanged }) {
               <div class="pj-org-titlerow">
                 <span class="pj-org-name">${(own?.display_name || p.name)}</span>
                 ${p.node ? html`<span class="badge badge-info">${(p.node)}</span>` : null}
+                ${own && offersWorkspaceContract(own) ? html`<span class="badge badge-success" title=${(t('organisms.contractAgentHint') || 'Advertises a workspace contract') + (contractNamesOf(own).length ? `: ${contractNamesOf(own).join(', ')}` : '')}>${'📜 '}${t('organisms.contractTag') || 'contract'}</span>` : null}
               </div>
               <div class="pj-org-desc" title=${g}>
                 <span class="mono">${(p.owner ? `${p.name}#${p.owner}` : g)}</span>
@@ -1167,6 +1188,11 @@ function OrganismHome({ org, ghii, showToast, initialSettings, onOpenWs, onBack,
     return () => { cancelled = true; window.removeEventListener('aimeat-live-update', fetchIt); };
   }, [org.id, canEdit]);
 
+  // Feed the home page's "Continue" list (only once the real name is known, not the {id} stub).
+  useEffect(() => {
+    if (org.name) recordRecent({ type: 'organism', id: org.id, label: org.name, data: { orgId: org.id } });
+  }, [org.id, org.name]);
+
   /* ── Settings: labelled + grouped form (Identity / Access) with live dirty-check, a one-line
    * read-only metadata row, per-choice access hints, and a clearly separated danger zone whose
    * delete needs the organism's name typed and states exactly what gets removed. ── */
@@ -1788,13 +1814,33 @@ function ActivityPanel({ orgId, wsId }) {
 /* 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.
  * The viewer's own agents are named; everyone else's appear as anonymous ghost boxes. */
-function ParticipantsPanel({ orgId, wsId }) {
+function ParticipantsPanel({ orgId, wsId, showToast }) {
   const [data, setData] = useState(null);
   const [show, setShow] = useState(true);
   const [access, setAccess] = useState(null);     // { requests, members } — only for the workspace creator
   const [grantee, setGrantee] = useState('');
   const [role, setRole] = useState('contributor');
   const [busy, setBusy] = useState(false);
+  // The viewer's own agents advertising a workspace contract (tag 'workspace-contract' +
+  // optional 'contract.<name>' tags) — surfaced here so a user looking at a workspace sees
+  // straight away which of their agents can serve it.
+  const [contractAgents, setContractAgents] = useState([]);
+  const [adoptBusy, setAdoptBusy] = useState('');   // `${gaii}:${contract}` of the in-flight adopt
+  useEffect(() => {
+    listAgents().then(a => setContractAgents((a || []).filter(offersWorkspaceContract))).catch(() => {});
+  }, []);
+  // One-click adoption: queue the agreed adopt-contract task (docs/agent-workspace-contracts.md
+  // §7c) — the agent provisions its contract's spaces itself and the task completion is the ack.
+  const adopt = async (a, contract) => {
+    const key = `${a.gaii}:${contract || ''}`;
+    setAdoptBusy(key);
+    try {
+      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));
+    } catch (e) { showToast?.((e && e.message) || (t('organisms.adoptFailed') || 'Could not queue the adoption task')); }
+    finally { setAdoptBusy(''); }
+  };
   useEffect(() => {
     let cancelled = false;
     const fetchIt = () => orgService.getWorkspaceParticipants(orgId, wsId).then(d => { if (!cancelled) setData(d); }).catch(() => {});
@@ -1824,6 +1870,35 @@ function ParticipantsPanel({ orgId, wsId }) {
       </div>
       ${show ? html`
         <div class="pj-parts">
+          ${contractAgents.length ? html`
+            <div class="pj-contract-agents">
+              <div class="pj-access-title">${'📜 '}${t('organisms.contractAgents') || 'Your contract agents'}</div>
+              <div class="section-desc">${t('organisms.contractAgentsDesc') || 'These agents of yours advertise a workspace contract — they can process a workspace like this one. Grant access (below) or attach them in the organism Agents tab.'}</div>
+              <div class="pj-part-agents">
+                ${contractAgents.map(a => {
+                  const names = contractNamesOf(a);
+                  // An agent already working in THIS workspace (it appears among the viewer's own
+                  // agents in the participants data) gets a ✓ instead of Adopt buttons — offering
+                  // adoption for an agent that is already here is noise, and the task would be a
+                  // no-op re-provision anyway.
+                  const here = owners.some(o => o.isSelf && (o.agents || []).some(ag => ag.isOwn && ag.name === a.name));
+                  // One adopt action per advertised contract (a single unnamed one falls back to
+                  // the bare marker). The agent does the rest — join, provision, complete the task.
+                  const actions = names.length ? names : [''];
+                  return html`
+                    <span class="pj-part-agent own" key=${a.gaii} title=${a.gaii}>
+                      ${'📜 '}${a.display_name || a.name}
+                      ${here ? html`<span class="badge badge-success pj-mini" title=${t('organisms.contractActiveHint') || 'This agent already works in this workspace'}>${'✓ '}${t('organisms.contractActive') || 'active here'}</span>`
+                        : actions.map(c => html`
+                        <button class="btn-outline btn-sm pj-adopt-btn" key=${c} disabled=${adoptBusy === `${a.gaii}:${c}`}
+                          title=${t('organisms.adoptHint') || 'Queue a task for this agent to adopt its contract into THIS workspace (it provisions the spaces itself)'}
+                          onClick=${() => adopt(a, c)}>
+                          ${adoptBusy === `${a.gaii}:${c}` ? '…' : `${t('organisms.adoptContract') || 'Adopt'}${c ? ` ${c}` : ''}`}
+                        </button>`)}
+                    </span>`;
+                })}
+              </div>
+            </div>` : null}
           <${Mermaid} chart=${orgService.buildParticipantsMermaid(data)} />
           <div class="pj-parts-list">
             ${owners.map((o, i) => html`<div class="pj-part-owner" key=${i}>
@@ -1967,9 +2042,15 @@ function Workspace({ org, wsId, showToast, onBack, onBackToList }) {
   const [wsName, setWsName] = useState('');
   useEffect(() => {
     let cancelled = false;
-    orgService.listWorkspaces(orgId).then(list => { if (!cancelled) setWsName((list.find(w => w.id === wsId)?.name) || ''); }).catch(() => {});
+    orgService.listWorkspaces(orgId).then(list => {
+      if (cancelled) return;
+      const name = (list.find(w => w.id === wsId)?.name) || '';
+      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(() => {});
     return () => { cancelled = true; };
-  }, [orgId, wsId]);
+  }, [orgId, wsId]);   // eslint-disable-line react-hooks/exhaustive-deps
   // Pop a document out into its own window (served by doc-solo.js) so several can sit side by side,
   // each independent. The window name is unique per document, so re-clicking focuses the open one.
   const popOut = (typeName, docId) => {
@@ -2005,11 +2086,10 @@ function Workspace({ org, wsId, showToast, onBack, onBackToList }) {
     } catch (e) { /* noop */ }
     return null;
   });
-  // Active tab — one tab per manifest space + fixed Review/Activity/People. Persisted per workspace
-  // so an F5 (or back-and-forth) returns to the same tab. '' = not chosen yet → first space.
-  const tabStoreKey = 'aimeat.ws.' + orgId + '.' + wsId + '.tab';
-  const [tab, setTabState] = useState(() => { try { return sessionStorage.getItem(tabStoreKey) || ''; } catch (e) { return ''; } });
-  const setTab = (id) => { setTabState(id); try { sessionStorage.setItem(tabStoreKey, id); } catch (e) { /* noop */ } };
+  // Active tab — Overview first (ALWAYS the landing view: the whole workspace on one scroll),
+  // then one tab per manifest space + fixed Sources/Share/Review/Activity/People. Deliberately
+  // NOT persisted: opening a workspace must show the overview, not whatever tab was last open.
+  const [tab, setTab] = useState('overview');
   const [sectionsByType, setSectionsByType] = useState({});  // { typeName: [{id,name,parentId,documents:[docId]}] }
   const [editingSec, setEditingSec] = useState(null);        // section id currently being renamed inline
   const draggedDoc = useRef(null);                            // { type, id } of the doc being dragged
@@ -2023,16 +2103,50 @@ function Workspace({ org, wsId, showToast, onBack, onBackToList }) {
   const [showFlow, setShowFlow] = useState(true);             // the manifest-defined edit-flow chart (first item)
   const [share, setShare] = useState(null);                   // { public, spaces, docs } — lazy-loaded when Settings opens
   const [shareBusy, setShareBusy] = useState(false);
+  const [wsEvents, setWsEvents] = useState([]);               // activity events — Overview strip + per-tab unseen badges
+  const [ovOpen, setOvOpen] = useState({});                   // Overview accordion: { spaceName: bool } (mobile starts collapsed)
+  const [ovDoc, setOvDoc] = useState(null);                   // Overview inline document (mobile): { type, id, mode }
+
+  // ── Unseen-change tracking: per-tab "seen" marks in localStorage (they survive sessions).
+  // A tab's badge counts items changed since the tab was last opened; opening it (or changes
+  // landing while it is open) marks it seen. First-ever visit seeds a baseline at "now", so
+  // 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 (e) { return null; }
+  });
+  const markSeen = useCallback((tabId) => setSeen(prev => {
+    const next = { ...(prev || {}), [tabId]: new Date().toISOString() };
+    try { localStorage.setItem(seenKey, JSON.stringify(next)); } catch (e) { /* noop */ }
+    return next;
+  }), [seenKey]);
+  // Items (not raw events) changed since the tab's seen mark. The user's own non-agent edits
+  // are not news to them, so they never count. Event actors come as the BARE owner name from
+  // the version history, so compare against both the bare name and the full GHII.
+  const unseenOf = useCallback((tabId) => {
+    if (!seen) return 0;
+    const base = seen[tabId] || seen.__base;
+    if (!base) return 0;
+    const me = getGhii();
+    const meBare = String(me || '').split('@')[0];
+    const isOwn = (e) => !e.agent && me && (e.actor === me || e.actor === meBare);
+    const match = tabId.startsWith('space:') ? (e) => e.type === tabId.slice(6)
+      : (tabId === 'activity' ? () => true : () => false);
+    const evs = wsEvents.filter(e => (e.at || '') > base && match(e) && !isOwn(e));
+    return new Set(evs.map(e => (e.type || '') + ':' + (e.instance || ''))).size;
+  }, [seen, wsEvents]);
 
   const load = useCallback(async () => {
     const w = await orgService.getWorkspace(orgId, wsId).catch(() => null);
     if (w && w.manifest) {
-      const [ap, cfg, secs] = await Promise.all([
+      const [ap, cfg, secs, act] = await Promise.all([
         orgService.listApprovals(orgId, 'pending').catch(() => []),
         orgService.getConfig(orgId).catch(() => ({})),
         orgService.getAllSections(orgId, wsId).catch(() => ({})),
+        orgService.getWorkspaceActivity(orgId, wsId).catch(() => ({ events: [] })),
       ]);
       setApprovals(ap); setGateOn(!!(cfg?.gates?.publish?.enabled)); setSectionsByType(secs);
+      setWsEvents(act?.events || []);
     }
     setWs(w && w.manifest ? w : null);
   }, [orgId, wsId]);
@@ -2054,6 +2168,22 @@ function Workspace({ org, wsId, showToast, onBack, onBackToList }) {
     return () => window.removeEventListener('aimeat-live-update', handler);
   }, []);
 
+  // First-ever visit: seed the seen baseline once the workspace has loaded — no badges for history.
+  useEffect(() => {
+    if (seen !== null || ws === undefined) return;
+    const next = { __base: new Date().toISOString() };
+    try { localStorage.setItem(seenKey, JSON.stringify(next)); } catch (e) { /* noop */ }
+    setSeen(next);
+  }, [seen, ws]);   // eslint-disable-line react-hooks/exhaustive-deps
+
+  // Changes landing on the tab the user is LOOKING at are seen immediately — otherwise a draft
+  // saved while you're on its space tab would raise that tab's own badge.
+  useEffect(() => {
+    if (!seen || showSettings) return;
+    const cur = tab || 'overview';
+    if (unseenOf(cur) > 0) markSeen(cur);
+  }, [wsEvents, tab, showSettings, seen, unseenOf, markSeen]);
+
   const setup = useCallback(async () => {
     setBusy(true);
     try {
@@ -2466,6 +2596,23 @@ function Workspace({ org, wsId, showToast, onBack, onBackToList }) {
   const isDocSpace = orgService.isDocSpace;
   const draftsFor = (name) => (ws.drafts && ws.drafts[name]) || [];
   const objectsFor = (name) => (ws.objects && ws.objects[name]) || [];
+  // One entry per id, draft (working copy) taking precedence over its published version —
+  // the index must show the draft badge even when a published `.latest` also exists.
+  const mergedDocs = (ot) => {
+    const byId = new Map();
+    for (const d of objectsFor(ot.name)) byId.set(d.id, { ...d, _draft: false, _published: true });
+    for (const d of draftsFor(ot.name)) {
+      const pub = byId.get(d.id);   // kept on `_pub` for the view's Draft/Published toggle
+      byId.set(d.id, { ...d, _draft: true, _published: !!pub, _pub: pub || null });
+    }
+    return [...byId.values()];
+  };
+  const mergedRecords = (ot) => {
+    const byId = new Map();
+    for (const o of objectsFor(ot.name)) byId.set(o.id, { ...o, _draft: false });
+    for (const d of draftsFor(ot.name)) byId.set(d.id, { ...d, _draft: true });
+    return [...byId.values()];
+  };
 
   // ── Public sharing (meta.share) — what published document-space pages anyone can read via the
   // no-login viewer. Independent of the access roles. Lazy-loaded the first time the panel opens. ──
@@ -2500,17 +2647,7 @@ function Workspace({ org, wsId, showToast, onBack, onBackToList }) {
   // tied to a section's documents[] (or unsorted). Edits to the tree persist immediately.
   const renderDocSpace = (ot) => {
     const secs = sectionsByType[ot.name] || [];
-    // One entry per document id. A draft (working copy) takes precedence over its published
-    // version, so the index shows the draft badge even when a published `.latest` also exists.
-    // (Without this, keying docById by id let the published entry overwrite the draft and the
-    // "draft" badge silently disappeared whenever a doc had both versions.)
-    const byId = new Map();
-    for (const d of objectsFor(ot.name)) byId.set(d.id, { ...d, _draft: false, _published: true });
-    for (const d of draftsFor(ot.name)) {
-      const pub = byId.get(d.id);   // the published version, if one exists — kept on `_pub` for the view's Draft/Published toggle
-      byId.set(d.id, { ...d, _draft: true, _published: !!pub, _pub: pub || null });
-    }
-    const docs = [...byId.values()];
+    const docs = mergedDocs(ot);
     const docById = {}; docs.forEach(d => { docById[d.id] = d; });
     const used = new Set(); secs.forEach(s => (s.documents || []).forEach(id => used.add(id)));
     const unsorted = docs.filter(d => !used.has(d.id));
@@ -2665,12 +2802,13 @@ function Workspace({ org, wsId, showToast, onBack, onBackToList }) {
     { id: 'activity', label: t('organisms.activity') || 'Activity', count: null },
     { id: 'people', label: t('organisms.tabPeople') || 'People', count: null },
   ];
-  const wsTabs = [...spaceTabs, ...fixedTabs];
+  const wsTabs = [{ id: 'overview', label: t('organisms.tabOverview') || 'Overview', count: null }, ...spaceTabs, ...fixedTabs];
   // Settings REPLACES the tab content: while it is open no tab is active (the previous state — a
   // highlighted tab above settings content — lied about what the user was looking at).
-  const activeTab = showSettings ? '' : (wsTabs.some(tb => tb.id === tab) ? tab : (spaceTabs[0]?.id || 'review'));
+  const activeTab = showSettings ? '' : (wsTabs.some(tb => tb.id === tab) ? tab : 'overview');
   const activeSpace = activeTab.startsWith('space:') ? allTypes.find(ot => ot.name === activeTab.slice(6)) : null;
-  const pickTab = (id) => guardWsDirty(() => { setShowSettings(false); setTab(id); });
+  // Opening a tab clears its unseen badge (the seen mark persists across sessions).
+  const pickTab = (id) => guardWsDirty(() => { setShowSettings(false); setTab(id); markSeen(id); });
 
   // Menu items are VERBS (a click copies to the clipboard; the toast confirms). The contract-agent
   // builder is a different category from the two copy actions, so a divider separates it.
@@ -2681,6 +2819,123 @@ function Workspace({ org, wsId, showToast, onBack, onBackToList }) {
     { label: t('organisms.contractPrompt') || 'Create contract agent', icon: '⚙️', onClick: copyContractPrompt },
   ];
 
+  // ── Overview (landing tab): the whole workspace on one vertical scroll — a "what happened
+  // here" strip from the activity feed, then every manifest space as its own stacked section.
+  // Tabs stay for focused work; this answers "where is everything and what changed".
+  const isMobileView = () => window.matchMedia('(max-width: 640px)').matches;
+  const shortActor = (a) => String(a || '').split('@')[0];
+  // First non-empty markdown line as a gray preview (heading/list markers stripped).
+  const firstLine = (md) => {
+    const line = String(md || '').split('\n').map(s => s.trim()).find(s => s && !s.startsWith('```'));
+    return line ? line.replace(/^#{1,6}\s+/, '').replace(/^[-*>]\s+/, '').slice(0, 120) : '';
+  };
+  // Strip event → jump straight to the changed item in its space tab.
+  const gotoEvent = (e) => {
+    const target = allTypes.find(o => o.name === e.type);
+    if (!target || !orgService.isMemorySpace(target)) { pickTab('activity'); return; }
+    if (isDocSpace(target)) setActiveDoc({ type: target.name, mode: 'view', page: { id: e.instance } });
+    else setExpandedRec(s => ({ ...s, [target.name + ':' + e.instance]: true }));
+    pickTab('space:' + target.name);
+  };
+  const openOvRec = (ot, r) => { setExpandedRec(s => ({ ...s, [ot.name + ':' + r.id]: true })); pickTab('space:' + ot.name); };
+  // A document opens in its space tab on desktop; on mobile it expands INLINE right here —
+  // view and edit both — so no window juggling is ever needed on a phone.
+  const openOvDoc = (ot, d) => {
+    if (isMobileView()) setOvDoc(v => (v && v.type === ot.name && v.id === d.id) ? null : { type: ot.name, id: d.id, mode: 'view' });
+    else { setActiveDoc({ type: ot.name, mode: 'view', page: { id: d.id } }); pickTab('space:' + ot.name); }
+  };
+  const ovAddNew = (ot, docMode) => {
+    if (docMode) setActiveDoc({ type: ot.name, mode: 'edit', page: { id: '', title: '', markdown: '' } });
+    else startAdd(ot);
+    pickTab('space:' + ot.name);
+  };
+
+  const renderOvDocInline = (ot, d) => ovDoc.mode === 'edit'
+    ? html`<div class="pj-ov-doc-inline"><${DocumentEditor} key=${'oved-' + d.id} orgId=${orgId} page=${d} busy=${busy}
+        onSave=${(p) => { savePage(ot, p); setOvDoc({ type: ot.name, id: d.id, mode: 'view' }); }}
+        onCancel=${() => setOvDoc({ type: ot.name, id: d.id, mode: 'view' })} /></div>`
+    : html`<div class="pj-ov-doc-inline"><${DocumentView} key=${'ovv-' + d.id} page=${d} busy=${busy}
+        onEdit=${() => setOvDoc({ type: ot.name, id: d.id, mode: 'edit' })}
+        onPublish=${() => publish(ot, d.id)}
+        onWikiLink=${(content) => {
+          const title = String(content).split('#')[0].trim();
+          const targetDoc = title && mergedDocs(ot).find(x => (x.title || '').toLowerCase() === title.toLowerCase());
+          if (targetDoc) setOvDoc({ type: ot.name, id: targetDoc.id, mode: 'view' });
+        }} /></div>`;
+
+  const renderOvSection = (ot) => {
+    const memory = orgService.isMemorySpace(ot);
+    const docMode = memory && isDocSpace(ot);
+    const items = memory ? (docMode ? mergedDocs(ot) : mergedRecords(ot)) : [];
+    const label = cap(wsT('type.' + ot.name) || ot.name);
+    // A space the manifest declares but memory doesn't back → one notice row, never hidden.
+    if (!memory) return html`
+      <div class="pj-ov-row" key=${ot.name}>
+        <button class="pj-ov-name pj-ov-name-link" onClick=${() => pickTab('space:' + ot.name)}>${label}</button>
+        <span class="badge badge-warn">${String(ot.backing)}</span>
+      </div>`;
+    // Empty space → a single compact row (name + none + add), not an empty box.
+    if (items.length === 0) return html`
+      <div class="pj-ov-row" key=${ot.name}>
+        <span class="pj-ov-name">${label}</span>
+        <span class="pj-muted">${t('organisms.noneYet') || 'none yet'}</span>
+        <button class="btn-ghost btn-sm" onClick=${() => ovAddNew(ot, docMode)}>${'+ '}${docMode ? (t('organisms.newPage') || 'New document') : (t('organisms.addDraft') || 'Add draft')}</button>
+      </div>`;
+    const open = ovOpen[ot.name] ?? !isMobileView();
+    const shown = items.slice(0, 5);
+    return html`
+      <div class="pj-ov-sec" key=${ot.name}>
+        <div class="pj-ov-sec-head" onClick=${() => setOvOpen(s => ({ ...s, [ot.name]: !open }))}>
+          <span class="pj-ov-chevron">${open ? '▾' : '▸'}</span>
+          <span class="pj-ov-name">${label}</span>
+          <span class="pj-org-tab-count">${items.length}</span>
+          ${docMode ? html`<span class="pj-doc-tag">${t('organisms.docs') || 'docs'}</span>` : null}
+          <span class="pj-ov-spacer"></span>
+          <button class="btn-ghost btn-sm" onClick=${(ev) => { ev.stopPropagation(); ovAddNew(ot, docMode); }}>${'+ '}${docMode ? (t('organisms.newPage') || 'New document') : (t('organisms.addDraft') || 'Add draft')}</button>
+        </div>
+        ${open ? html`
+          <div class="pj-ov-items">
+            ${shown.map(d => docMode ? html`
+              <div class="pj-ov-doc" key=${d.id}>
+                <button class="pj-ov-item" onClick=${() => openOvDoc(ot, d)}>
+                  ${d._draft ? html`<span class="badge badge-warn pj-mini">${t('organisms.draft') || 'draft'}</span>` : null}
+                  <span class="pj-ov-item-title">${d.title || d.id}</span>
+                  <span class="pj-ov-preview">${firstLine(d.markdown)}</span>
+                </button>
+                ${ovDoc && ovDoc.type === ot.name && ovDoc.id === d.id ? renderOvDocInline(ot, d) : null}
+              </div>` : html`
+              <button class="pj-ov-item" key=${d.id} onClick=${() => openOvRec(ot, d)}>
+                ${d._draft ? html`<span class="badge badge-warn pj-mini">${t('organisms.draft') || 'draft'}</span>` : null}
+                <span class="pj-ov-item-title">${String(d[PRIMARY_FIELD[ot.name] || 'title'] || d.summary || d.id || '')}</span>
+                ${d.status ? html`<span class="badge badge-info">${String(d.status)}</span>` : null}
+              </button>`)}
+            ${items.length > 5 ? html`
+              <button class="pj-ov-more" onClick=${() => pickTab('space:' + ot.name)}>${(t('organisms.ovShowAll') || 'Show all {n} →').replace('{n}', String(items.length))}</button>` : null}
+          </div>` : null}
+      </div>`;
+  };
+
+  const renderOverview = () => {
+    const recent = wsEvents.slice(0, 8);
+    return html`
+      <div class="pj-ov">
+        ${recent.length > 0 ? html`
+          <div class="pj-ov-strip">
+            <div class="pj-ov-strip-title">${t('organisms.ovRecent') || 'What happened here'}</div>
+            ${recent.map((e, i) => html`
+              <button class="pj-ov-event" key=${i} onClick=${() => gotoEvent(e)}>
+                <span class="pj-act-dot ${e.action}"></span>
+                <span class="pj-ov-event-who">${shortActor(e.actor)}${e.agent ? html` <span class="pj-act-agent" title=${t('organisms.viaAgent') || 'via this agent'}>🤖 ${e.agent}</span>` : null}</span>
+                <span class="pj-ov-event-act">${e.action === 'publish' ? (t('organisms.publishedVerb') || 'published') : (t('organisms.editedVerb') || 'edited')}</span>
+                <span class="pj-ov-event-what">${e.mode === 'document' ? '📄' : '🗂'} ${(wsT('type.' + e.type) || e.type)}${' / '}${e.instance}</span>
+                <span class="pj-ov-event-time">${relTime(e.at)}</span>
+              </button>`)}
+          </div>` : null}
+        ${allTypes.map(renderOvSection)}
+        ${allTypes.length === 0 ? html`<${EmptyState} text=${t('organisms.noneYet') || 'none yet'} />` : null}
+      </div>`;
+  };
+
   return html`
     <div class="pj-ws">
       <${ConfirmUI} />
@@ -2706,11 +2961,15 @@ function Workspace({ org, wsId, showToast, onBack, onBackToList }) {
         </div>` : null}
 
       <div class="pj-org-tabs" role="tablist">
-        ${wsTabs.map(tb => html`
+        ${wsTabs.map(tb => {
+          const u = activeTab === tb.id ? 0 : unseenOf(tb.id);
+          return html`
           <button class="pj-org-tab ${activeTab === tb.id ? 'active' : ''}" role="tab" aria-selected=${activeTab === tb.id} key=${tb.id}
             onClick=${() => pickTab(tb.id)}>
             ${(tb.label)}${tb.count !== null && tb.count !== undefined ? html`<span class="pj-org-tab-count">${tb.count}</span>` : null}
-          </button>`)}
+            ${u > 0 ? html`<span class="pj-org-tab-unseen" title=${t('organisms.unseenHint') || 'Changed since your last visit'}>${u}</span>` : null}
+          </button>`;
+        })}
         <button class="pj-org-tab pj-ws-tab-add" title=${t('organisms.addDocSpaceTitle') || 'Add a document space'} onClick=${() => guardWsDirty(() => { setShowSettings(false); setShowSpaces(s => !s); })}>+</button>
       </div>
 
@@ -2793,6 +3052,8 @@ function Workspace({ org, wsId, showToast, onBack, onBackToList }) {
         </div>
       `}
 
+      ${activeTab === 'overview' ? renderOverview() : null}
+
       ${activeSpace
         ? (!orgService.isMemorySpace(activeSpace)
           ? renderSpaceNotice(activeSpace)
@@ -2870,7 +3131,7 @@ function Workspace({ org, wsId, showToast, onBack, onBackToList }) {
             `)}
           </div>` : null}` : null}
 
-      ${activeTab === 'people' ? html`<${ParticipantsPanel} orgId=${orgId} wsId=${wsId} />` : null}
+      ${activeTab === 'people' ? html`<${ParticipantsPanel} orgId=${orgId} wsId=${wsId} showToast=${showToast} />` : null}
     </div>
   `;
 }