aimeat 2.7.0 → 3.1.0

package/dist/public/views/profile/inbox-tab/helpers.js

@@ -5,6 +5,12 @@
  *   pixel defense), tracked-state labels, attachment classification, the interactive-answer summary +
  *   poll tally, and the lazy Toast UI editor loader. Extracted from inbox-tab.js to satisfy max-file-lines.
  * @version-history
+ *   v1.6.0 — 2026-08-04 — resolveThreadAttachmentUrls(): cache entries carry a mint timestamp and are
+ *     re-minted after ATTACHMENT_URL_REUSE_MS instead of reused forever — a presigned download URL
+ *     held past its 1 h token TTL failed every click with the browser's bare "Couldn't download".
+ *   v1.5.0 — 2026-08-03 — buildContactOptions() + normalizePollQuestions() moved here from inbox-tab.js
+ *     (max-file-lines); mergeThreadPage(): upsert-by-id merge of a freshly fetched newest page into a
+ *     loaded thread, for the live delta refresh that replaced full-history reloads.
  *   v1.4.0 — 2026-08-01 — parkMessage() + openTrackedRecord() moved here from inbox-tab.js: two
  *     self-contained actions that needed nothing from the tab's state beyond a toast, pulled out to
  *     keep the tab under max-file-lines while voice messages were added to it.
@@ -66,21 +72,68 @@ export function sendFailure(err) {
  * recipient's duplicated local copy; outbound resolves the original. `resolveUrl` = messages.attachmentUrl.
  * Returns { convId, map } to store as the new cache.
  */
+/** Recipient suggestions for a new message: your own agents (GAIIs) + everyone you've a thread with. */
+export function buildContactOptions(myAgents, conversations) {
+  const map = new Map();
+  for (const a of myAgents) {
+    if (a?.gaii) map.set(a.gaii, `${a.name || a.gaii} ${t('inbox.contactAgentSuffix')}`);
+  }
+  for (const c of conversations) {
+    if (c?.peerGhii && !map.has(c.peerGhii)) map.set(c.peerGhii, peerName(c.peerGhii));
+  }
+  return [...map.entries()].map(([id, label]) => ({ id, label }));
+}
+
+/** Broadcast poll: keep only answerable questions (a prompt + ≥1 labelled option), normalized for send. */
+export function normalizePollQuestions(bcQuestions) {
+  return bcQuestions
+    .map(q => ({ ...q, options: (q.options || []).filter(o => o.label.trim()) }))
+    .filter(q => q.prompt.trim() && q.options.length >= 1)
+    .map(q => ({
+      id: q.id, header: (q.header || q.prompt).slice(0, 80), prompt: q.prompt.trim(),
+      options: q.options.map(o => ({ id: o.id, label: o.label.trim() })),
+      multiSelect: !!q.multiSelect, allowOther: q.allowOther !== false, required: !!q.required,
+    }));
+}
+
+/** Merge a freshly fetched NEWEST page (chronological) into an already-loaded thread: upsert by id —
+ *  a new message appends, a changed one (read tick) replaces — ordered by createdAt. Messages older
+ *  than the fetched page stay as loaded, so a live refresh never re-walks the whole history. */
+export function mergeThreadPage(prev, newest) {
+  const newestIds = new Set(newest.map(m => m.id));
+  return [...prev.filter(m => !newestIds.has(m.id)), ...newest]
+    .sort((a, b) => String(a.createdAt || '').localeCompare(String(b.createdAt || '')));
+}
+
+/** Resolved attachment URLs are PRESIGNED — the token inside them expires after 1 h (server
+ *  OWN_HANDLE_TTL_SECONDS). Reusing a cached URL forever meant a download click in a long-open tab
+ *  hit a dead token (410 → the browser's bare "Couldn't download"). Entries older than this are
+ *  re-minted instead of reused; paired with ATTACHMENT_URL_REFRESH_MS in inbox-tab.js (15 min ticks)
+ *  the worst-case age of a link in the DOM stays ~55 min, always inside the token's lifetime. */
+export const ATTACHMENT_URL_REUSE_MS = 40 * 60 * 1000;
+
 export async function resolveThreadAttachmentUrls(msgs, conversationId, prevCache, resolveUrl) {
-  const prev = prevCache?.convId === conversationId ? (prevCache.map || {}) : {};
+  const sameConv = prevCache?.convId === conversationId;
+  const prev = sameConv ? (prevCache.map || {}) : {};
+  // mintedAt per entry — a pre-timestamp cache ({} fallback) reads as age-infinite and re-mints.
+  const prevTs = sameConv ? (prevCache.ts || {}) : {};
+  const now = Date.now();
   const map = {};
+  const ts = {};
   await Promise.all(msgs.flatMap(m => (m.attachments || [])
     .filter(a => !a.inline)
     .map(async a => {
       const uk = `${m.id}::${a.id}`;
-      if (prev[uk]) { map[uk] = prev[uk]; return; }
+      if (prev[uk] && now - (prevTs[uk] || 0) < ATTACHMENT_URL_REUSE_MS) {
+        map[uk] = prev[uk]; ts[uk] = prevTs[uk]; return;
+      }
       const key = (a.mode === 'duplicate' && a.localKey) ? a.localKey
         : (m.direction === 'outbound' && a.storageKey) ? a.storageKey : null;
       if (!key) return;
       const u = await resolveUrl(key).catch(err => { swallowed('helpers: key', err); return null; });
-      if (u) map[uk] = u;
+      if (u) { map[uk] = u; ts[uk] = now; }
     })));
-  return { convId: conversationId, map };
+  return { convId: conversationId, map, ts };
 }
 
 /* Lazy-load the vendored Toast UI Editor (MIT, /lib/toastui/) — the same editor the workspace

package/dist/public/views/profile/inbox-tab/panels.js

@@ -6,6 +6,8 @@
  *   (broadcast/poll results). Each is a presentational component driven entirely by props from InboxTab;
  *   the stateful container keeps all hooks. Extracted from inbox-tab.js to satisfy max-file-lines.
  * @version-history
+ *   v1.7.0 — 2026-08-03 — ThreadPanel: "Show full history (N messages)" pill at the top of a thread
+ *     showing only its newest page (threads now open on the newest 50 — inbox-tab v1.28.0).
  *   v1.6.0 — 2026-08-01 — Voice messages threaded through: ThreadPanel passes onTranscribe /
  *     canTranscribe to each bubble and voiceMaxSeconds to the Composer. An agent-owned ("via
  *     <agent>") thread is read-only for the owner, so it gets no transcribe action.
@@ -169,6 +171,11 @@ export function ThreadPanel({
       </div>
       <div class="inbox-msgs" ref=${msgsRef}>
         ${thread.length === 0 ? html`<div class="inbox-empty-sm">${t('inbox.noThread')}</div>` : null}
+        ${(!threadAll && (activeConv.messageCount || 0) > thread.length) ? html`
+          <div class="inbox-thread-older">
+            <button class="btn-ghost btn-sm" onClick=${toggleThreadAll}>
+              ↩ ${t('inbox.thread.showOlder', { count: activeConv.messageCount })}</button>
+          </div>` : null}
         ${thread.map(m => {
           const dk = dayKey(m.createdAt);
           const showDay = dk !== lastDay; lastDay = dk;

package/dist/public/views/profile/inbox-tab/use-thread-ux.js

@@ -2,11 +2,16 @@
  * @file public/views/profile/inbox-tab/use-thread-ux.js
  * @description Thread-pane UX hooks for the profile Inbox tab: useThreadAutoScroll (jump to the
  *   latest message on open / near-bottom follow / a single one-time jump when a NEW message arrives —
- *   never a sticky pin) and useMobileComposerKeyboard (≤760px: publishes the on-screen keyboard's
- *   height as --inbox-kb from visualViewport and scrolls the composer into view on focus).
+ *   never a sticky pin), useMobileComposerKeyboard (≤760px: publishes the on-screen keyboard's
+ *   height as --inbox-kb from visualViewport and scrolls the composer into view on focus) and
+ *   useAttachmentUrlRefresh (re-mints expiring presigned attachment URLs while a thread is open).
  *   Extracted from inbox-tab.js to satisfy max-file-lines.
  * @usage import { useThreadAutoScroll, useMobileComposerKeyboard } from './inbox-tab/use-thread-ux.js';
  * @version-history
+ *   v1.5.0 — 2026-08-04 — Add useAttachmentUrlRefresh: while a thread is open, a 15 min tick re-mints
+ *     presigned attachment URLs approaching their 1 h token expiry — a download click in a long-open
+ *     tab hit a dead token (410 → the browser's bare "Couldn't download"). useRecentBroadcasts moved
+ *     here from inbox-tab.js (max-file-lines).
  *   v1.4.0 — 2026-07-21 — useThreadAutoScroll: on OPEN, keep re-pinning to the bottom for ~2.5s while late
  *     content (images, link previews, long histories) grows the thread, instead of a single jump that left
  *     a big thread stuck partway up. Re-pins only on real height growth; aborts the moment the reader
@@ -24,8 +29,49 @@
  *     the messenger on Android Chrome; drop the composer scrollIntoView(center) that left a dead gap.
  */
 import { useEffect, useRef, useState } from 'preact/hooks';
+import { resolveThreadAttachmentUrls } from './helpers.js';
+import { attachmentUrl } from '/js/services/messages.js';
 
 const LINK_PREVIEWS_KEY = 'aimeat.inbox.linkPreviews';
+const BC_STORE = 'aimeat.inbox.broadcasts';
+
+/** Recent broadcasts/polls the user sent — tracked in localStorage so results stay re-accessible.
+ *  Moved here from inbox-tab.js (max-file-lines). */
+export function useRecentBroadcasts() {
+  const [recentBroadcasts, setRecentBroadcasts] = useState([]);
+  useEffect(() => { try { setRecentBroadcasts(JSON.parse(localStorage.getItem(BC_STORE) || '[]')); } catch { /* none */ } }, []);   // eslint-disable-line aimeat/no-silent-catch -- none
+  const trackBroadcast = (entry) => setRecentBroadcasts(prev => {
+    const next = [entry, ...prev.filter(b => b.id !== entry.id)].slice(0, 30);
+    try { localStorage.setItem(BC_STORE, JSON.stringify(next)); } catch { /* quota */ }   // eslint-disable-line aimeat/no-silent-catch -- quota
+    return next;
+  });
+  return { recentBroadcasts, trackBroadcast };
+}
+
+/** Presigned attachment URLs carry a 1 h token. While a thread stays open (no reload, no SSE
+ *  traffic), the links in the DOM would outlive their tokens and every download click would fail.
+ *  A 15 min tick re-runs the resolver: entries younger than the reuse window (helpers.
+ *  ATTACHMENT_URL_REUSE_MS) come back from cache (no network), entries approaching expiry get a
+ *  fresh token before it dies. */
+export function useAttachmentUrlRefresh(activeConv, activeConvRef, threadRef, urlCacheRef, setUrlMap) {
+  useEffect(() => {
+    if (!activeConv) return undefined;
+    const iv = setInterval(async () => {
+      const conv = activeConvRef.current;
+      if (!conv) return;
+      const prevMap = urlCacheRef.current.map || {};
+      const cache = await resolveThreadAttachmentUrls(threadRef.current, conv.conversationId, urlCacheRef.current, attachmentUrl);
+      if (activeConvRef.current?.conversationId !== conv.conversationId) return;   // user switched threads mid-fetch
+      urlCacheRef.current = cache;
+      // Only re-render when a URL actually changed — an all-fresh tick must not touch <img>/<audio> src.
+      const keys = Object.keys(cache.map);
+      if (keys.length !== Object.keys(prevMap).length || keys.some(k => cache.map[k] !== prevMap[k])) setUrlMap(cache.map);
+    }, 15 * 60 * 1000);
+    return () => clearInterval(iv);
+    // The refs are stable — the open conversation is the real trigger.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [activeConv]);
+}
 
 /** Persisted global toggle for the link-preview cards (default ON). Returns the flag + a toggler that
  *  writes the choice to localStorage. Per-card dismissal is owned separately by /components/LinkPreview.js. */

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

@@ -14,6 +14,15 @@
  *   (./inbox-tab/use-thread-ux.js)
  * @usage Lazy-loaded profile tab; registered in profile.js TABS as id `messages`.
  * @version-history
+ *   v1.28.1 -- 2026-08-04 -- Fix "attachment download fails in a long-open tab": presigned attachment
+ *     URLs expire after 1 h but were cached forever, so a click hit a dead token (410 → the browser's
+ *     bare "Couldn't download"). useAttachmentUrlRefresh (use-thread-ux.js) re-mints entries older
+ *     than the reuse window (helpers.ATTACHMENT_URL_REUSE_MS) while a thread is open.
+ *   v1.28.0 -- 2026-08-03 -- Messages-view speedup: peer names seed from the overview's peerNames map
+ *     (kills the ~48-request per-peer GET fan-out on mount); threads open on the newest 50 again
+ *     (reverses the v1.25.0 full-history default — ~3s / ~190 requests on a 400-message thread; the
+ *     thread-top pill / header toggle load the rest); a live 'messages' update fetches only the newest
+ *     page and merges by id (refreshThreadDelta + helpers.mergeThreadPage).
  *   v1.27.0 -- 2026-08-01 -- Voice messages: 🎤 in the composer records a clip that travels the normal
  *     attachment path, an audio bubble plays in place, and a voice attachment can be turned into text
  *     with the owner's own key (useVoiceMessages → POST /v1/messages/:id/attachments/:attId/transcribe).
@@ -139,11 +148,11 @@ import { apiGet } from '/js/api.js';
 import { getSession } from '/js/services/auth.js';
 import { TrackResponseModal } from './track-response-modal.js';
 import { peerLabel } from '/js/services/messages-ai-prompts.js';
-import { peerName, ownerKeyOf, isAgentPeer, buildAnswerSummary, resolveThreadAttachmentUrls, sendFailure, parkMessage, openTrackedRecord } from './inbox-tab/helpers.js';
+import { peerName, ownerKeyOf, isAgentPeer, buildAnswerSummary, resolveThreadAttachmentUrls, sendFailure, parkMessage, openTrackedRecord, buildContactOptions, normalizePollQuestions, mergeThreadPage } from './inbox-tab/helpers.js';
 import { Composer, PollBuilder, MarkdownViewer, ReplyWithAiPopover, ConversationToNotebookPopover } from './inbox-tab/components.js';
 import { buildConversationReplyProps, buildMessageReplyProps, buildConversationNotebookProps } from './inbox-tab/ai-actions.js';
 import { ListPanel, ThreadPanel, TrackedPanel, ResultsPanel } from './inbox-tab/panels.js';
-import { useThreadAutoScroll, useMobileComposerKeyboard, useLinkPreviewToggle } from './inbox-tab/use-thread-ux.js';
+import { useThreadAutoScroll, useMobileComposerKeyboard, useLinkPreviewToggle, useAttachmentUrlRefresh, useRecentBroadcasts } from './inbox-tab/use-thread-ux.js';
 import { useVoiceMessages } from './inbox-tab/use-voice.js';
 import { ContactPicker } from '/components/ContactPicker.js';
 import { swallowed } from '/js/swallowed.js';
@@ -177,7 +186,7 @@ export default function InboxTab({ showToast }) {
   const [myGroups, setMyGroups] = useState([]);           // the owner's Share Groups (audiences)
   const [resultsId, setResultsId] = useState(null);       // broadcast id whose results are shown
   const [results, setResults] = useState(null);           // fetched broadcast results
-  const [recentBroadcasts, setRecentBroadcasts] = useState([]); // localStorage-tracked sent broadcasts
+  const { recentBroadcasts, trackBroadcast } = useRecentBroadcasts(); // localStorage-tracked sent broadcasts
   const [sending, setSending] = useState(false);
   const [important, setImportant] = useState(new Set());  // message ids flagged important (Tier 1)
   const [trackedList, setTrackedList] = useState([]);     // active Tracked Responses (Tier 2)
@@ -225,6 +234,13 @@ export default function InboxTab({ showToast }) {
       apiGet('/v1/groups').then(gr => setMyGroups(gr?.data?.groups || [])).catch(err => { swallowed('inbox-tab: isOperator', err); });
       return;
     }
+    // Seed the peer display-name cache from the composite BEFORE the lists render — the resolvePeerNames
+    // effect then finds every id present and fetches nothing (was ~48 profile GETs per mount). '' entries
+    // are kept: "looked up, not resolvable here" (federated peer) → handle fallback, no re-fetch.
+    if (d.peerNames && typeof d.peerNames === 'object') {
+      peerNamesRef.current = { ...d.peerNames, ...peerNamesRef.current };
+      setPeerNames({ ...peerNamesRef.current });
+    }
     setRequests(d.requests || []);
     setConversations(d.conversations || []);
     setImportant(new Set(d.important || []));
@@ -323,14 +339,12 @@ export default function InboxTab({ showToast }) {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [awaitingIds]);
 
-  // markRead=true ONLY when the user opens the conversation. Marking read POSTs a receipt which itself
-  // emits a 'messages' change → SSE → live refresh; doing it on every live refresh creates a
-  // self-sustaining request loop. So live refreshes reload the thread WITHOUT marking read.
-  // Per-conversation "show all vs newest 50" mode. Defaults to ALL (show the full history on open so
-  // nothing looks lost); the header toggle collapses to the newest 50. A ref (read at call time) keeps
-  // loadThread []-memoized; the state drives the button. Re-defaults to ALL whenever a thread opens.
-  const [threadAll, setThreadAll] = useState(true);
-  const threadAllRef = useRef(true); threadAllRef.current = threadAll;
+  // markRead=true ONLY on explicit open — the read receipt itself emits a 'messages' change → SSE →
+  // refresh, so marking read on every live refresh would self-sustain a request loop.
+  // "Show all vs newest 50": defaults to the NEWEST 50 (one page request) — a 400-message full-history
+  // open cost ~3s / ~190 requests. Full history = thread-top pill or header toggle; re-defaults on open.
+  const [threadAll, setThreadAll] = useState(false);
+  const threadAllRef = useRef(false); threadAllRef.current = threadAll;
   const loadThread = useCallback(async (conv, markRead = false) => {
     if (!conv) return;
     // threadAllRef: false = newest 50 (fast default); true = the FULL history (header "All messages" toggle).
@@ -344,7 +358,31 @@ export default function InboxTab({ showToast }) {
     // Agent-owned ("via <agent>") threads are read-only for the owner — don't post a read receipt as them.
     if (markRead && !conv.viaAgent) await messages.markConversationRead(conv.conversationId).catch(err => { swallowed('inbox-tab: msgs', err); });
   }, []);
-  const toggleThreadAll = () => setThreadAll(v => { const nv = !v; threadAllRef.current = nv; if (activeConv) loadThread(activeConv); return nv; });
+  // Side effects OUTSIDE the state updater — Preact may re-invoke an updater (loadThread inside it double-fetched).
+  const toggleThreadAll = () => {
+    const nv = !threadAllRef.current;
+    threadAllRef.current = nv; setThreadAll(nv);
+    if (activeConv) loadThread(activeConv);
+  };
+
+  // Live (SSE) refresh of the OPEN thread: fetch only the NEWEST page and merge (helpers.mergeThreadPage)
+  // instead of re-walking the whole history; the attachment-URL cache means only new attachments fetch.
+  const threadRef = useRef([]); threadRef.current = thread;
+  const refreshThreadDelta = useCallback(async (conv) => {
+    if (!conv) return;
+    const newest = (await messages.getConversation(conv.conversationId, conv.viaAgent, false).catch(err => { swallowed('inbox-tab: delta', err); return []; })).slice().reverse();
+    if (!newest.length) return;
+    if (activeConvRef.current?.conversationId !== conv.conversationId) return;   // user switched threads mid-fetch
+    const merged = mergeThreadPage(threadRef.current, newest);
+    setThread(merged);
+    const cache = await resolveThreadAttachmentUrls(merged, conv.conversationId, urlCacheRef.current, messages.attachmentUrl);
+    urlCacheRef.current = cache;
+    setUrlMap(cache.map);
+  }, []);
+
+  // While a thread is open, re-mint presigned attachment URLs before their 1 h token expires —
+  // otherwise a download click in a long-open tab hits a dead token ("Couldn't download").
+  useAttachmentUrlRefresh(activeConv, activeConvRef, threadRef, urlCacheRef, setUrlMap);
 
   // Voice messages: can this owner transcribe, how long may a recording run, and the call that does it.
   const { canTranscribe, voiceMaxSeconds, transcribeVoice } = useVoiceMessages(loadThread, activeConvRef);
@@ -369,14 +407,6 @@ export default function InboxTab({ showToast }) {
     return () => { cancelled = true; };
   }, [activePeer]);
 
-  // Recent broadcasts/polls the user sent — tracked in localStorage so results stay re-accessible.
-  const BC_STORE = 'aimeat.inbox.broadcasts';
-  useEffect(() => { try { setRecentBroadcasts(JSON.parse(localStorage.getItem(BC_STORE) || '[]')); } catch { /* none */ } }, []);   // eslint-disable-line aimeat/no-silent-catch -- none
-  const trackBroadcast = (entry) => setRecentBroadcasts(prev => {
-    const next = [entry, ...prev.filter(b => b.id !== entry.id)].slice(0, 30);
-    try { localStorage.setItem(BC_STORE, JSON.stringify(next)); } catch { /* quota */ }   // eslint-disable-line aimeat/no-silent-catch -- quota
-    return next;
-  });
   const openResults = async (id) => {
     setMode('results'); setResultsId(id); setResults(null); setActiveConv(null);
     setResults(await messages.getBroadcastResults(id).catch(err => { swallowed('inbox-tab', err); return null; }));
@@ -398,35 +428,18 @@ export default function InboxTab({ showToast }) {
     try { window.history.replaceState({}, '', '/v1/profile?tab=messages'); } catch (err) { swallowed('inbox-tab: toParam', err); }
   }, []);
 
-  // Recipient suggestions for a new message: your own agents (GAIIs) + everyone you've a thread with.
-  const contactOptions = (() => {
-    const map = new Map();
-    for (const a of myAgents) {
-      if (a?.gaii) map.set(a.gaii, `${a.name || a.gaii} ${t('inbox.contactAgentSuffix')}`);
-    }
-    for (const c of conversations) {
-      if (c?.peerGhii && !map.has(c.peerGhii)) map.set(c.peerGhii, peerName(c.peerGhii));
-    }
-    return [...map.entries()].map(([id, label]) => ({ id, label }));
-  })();
-
-  // A 'messages' live-update ALWAYS reloads the open thread so incoming messages render immediately —
-  // even while you're typing a reply (previously the whole reload was skipped when an editable was
-  // focused, so new messages stayed invisible until send/reopen: the "badge shows N new but the thread
-  // never updates" bug). The "don't yank scroll while I write" concern is handled where it belongs —
-  // useThreadAutoScroll suppresses the new-message jump while the composer is focused (near-bottom
-  // follow still applies), so the message list re-renders without stealing the caret or the scroll.
+  const contactOptions = buildContactOptions(myAgents, conversations);
+
+  // A 'messages' live-update ALWAYS refreshes the open thread (delta merge) so incoming messages render
+  // immediately, even mid-typing — skipping it while an editable was focused left new messages invisible
+  // until send/reopen. Scroll/caret protection lives in useThreadAutoScroll, not here.
   const liveRef = useRef(null);
-  liveRef.current = () => { loadLists(); if (activeConv) loadThread(activeConv); };
-  // Selective live refresh. `e.detail.domains` is a Set<string> (or null = "everything changed",
-  // e.g. a reconnect catch-up). IMPORTANT: it is a Set, not an Array — an earlier `Array.isArray`
-  // check silently never matched, so the inbox re-fetched on EVERY change (memory/organism/task
-  // churn from dozens of agents → a request storm). We branch by domain:
-  //   • 'messages'        (a direct message changed)  → full refresh (conversations + flags +
-  //                                                      open thread + requests)
-  //   • 'agent-messages'  (agent activity)            → ONLY the tracked-responses list (1 request)
-  // Everything else (memory, organisms, agent-tasks, …) is ignored. A burst is coalesced into one
-  // refresh; if any 'messages' event lands in the window we do the full refresh.
+  liveRef.current = () => { loadLists(); if (activeConv) refreshThreadDelta(activeConv); };
+  // Selective live refresh. `e.detail.domains` is a Set<string> (or null = "everything changed", e.g. a
+  // reconnect catch-up) — a Set, NOT an Array (an earlier Array.isArray check never matched → refresh on
+  // every change → request storm). 'messages' → full refresh (lists + open-thread delta);
+  // 'agent-messages' → only the tracked-responses list. Everything else ignored; bursts coalesce, and
+  // any 'messages' event in the window wins the full refresh.
   const liveTimerRef = useRef(null);
   const pendingFullRef = useRef(false);
   useEffect(() => {
@@ -454,7 +467,7 @@ export default function InboxTab({ showToast }) {
 
   const openConversation = async (conv) => {
     setActiveConv(conv); setMode('thread');
-    setThreadAll(true); threadAllRef.current = true;   // each thread opens showing its FULL history
+    setThreadAll(false); threadAllRef.current = false;   // each thread opens on its newest 50 (full history = one click)
     setDraftPrefill(''); setReplyingTrId(null); setReplyQuote(null);   // don't leak a suggested reply / quote across threads
     await loadThread(conv, true);                 // mark read only on explicit open (avoids a refresh loop)
     loadLists();
@@ -513,14 +526,7 @@ export default function InboxTab({ showToast }) {
 
     let interactive;
     if (bcType === 'poll') {
-      const questions = bcQuestions
-        .map(q => ({ ...q, options: (q.options || []).filter(o => o.label.trim()) }))
-        .filter(q => q.prompt.trim() && q.options.length >= 1)
-        .map(q => ({
-          id: q.id, header: (q.header || q.prompt).slice(0, 80), prompt: q.prompt.trim(),
-          options: q.options.map(o => ({ id: o.id, label: o.label.trim() })),
-          multiSelect: !!q.multiSelect, allowOther: q.allowOther !== false, required: !!q.required,
-        }));
+      const questions = normalizePollQuestions(bcQuestions);
       if (!questions.length) { showToast?.(t('inbox.pollNeedQuestion'), true); return; }
       interactive = { role: 'questions', v: 1, questions };
     } else if (!body && files.length === 0) { return; }

package/dist/public/views/profile/instruction-block.js

@@ -14,6 +14,9 @@
  * @usage import { InstructionBlock } from '/views/profile/instruction-block.js';
  * @version-history
  *   v1.0.0 — 2026-07-31 — Initial.
+ *   v1.1.0 — 2026-08-08 — Copy labels now resolve from the shared common.copy / common.copied / common.copyPrompt /
+ *       common.copyLink / common.copyUrl keys; the per-view copy label keys this file used were
+ *       removed from both locales. Same words on screen.
  */
 import { h } from 'preact';
 import { useState, useEffect } from 'preact/hooks';
@@ -78,7 +81,7 @@ export function InstructionBlock({ orgId }) {
       <div class="ib-actions">
         <${CopyButton} text=${text} className="btn-primary"
           label=${tr('instrBlock.copy', 'Copy the block')}
-          copiedLabel=${tr('instrBlock.copied', 'Copied')} />
+          copiedLabel=${tr('common.copied', 'Copied')} />
         <span class="ib-meta">${tr('instrBlock.from', 'Generated from')} ${data.organism_name || data.organism_id}${
           Array.isArray(data.workspaces) && data.workspaces.length
             ? `, ${data.workspaces.length} ${tr('instrBlock.workspaces', 'workspaces')}` : ''}</span>

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

@@ -12,6 +12,7 @@
  *   v1.0.0 — 2026-07-13 — Extracted from views/profile/landing-page.js (max-file-lines)
  */
 import { h } from "preact";
+import { OpenItemsList } from '/components/OpenItemsList.js';
 import { useState, useEffect, useCallback, useRef } from "preact/hooks";
 import htm from "htm";
 const html = htm.bind(h);
@@ -113,7 +114,13 @@ export function AgentsCard({ owner, initialAgents }) {
   // The Home /v1/owner/home composite already resolves the owner's agent list (initialAgents) — seed from
   // it and skip the mount /v1/agents fetch (dropping that duplicate). The next-scheduled-job row still
   // needs the schedules call (not in the composite); live-update refreshes both.
-  const seedAgents = (list) => (Array.isArray(list) ? list : []).filter(a => !String(a.name || '').startsWith('session-'))
+  // Excluded from the HOME card (both still live in the Agents tab):
+  //   session-*  — per-session scratch identities, never user-facing.
+  //   app        — the built-in agent registration creates for in-app calls. Counting it made a
+  //                brand-new account read "1 agent active today" when the person had connected
+  //                nothing, which is a claim about work that never happened (UX-remake v3, P5).
+  const seedAgents = (list) => (Array.isArray(list) ? list : [])
+    .filter(a => !String(a.name || '').startsWith('session-') && String(a.name || '') !== 'app')
     .slice().sort((a, b) => String(b.last_seen || '').localeCompare(String(a.last_seen || '')));
   const [agents, setAgents] = useState(initialAgents ? seedAgents(initialAgents) : null);
   const [nextJob, setNextJob] = useState(null);
@@ -545,6 +552,7 @@ export function NextSteps({ switchTab, hasApps }) {
           </button>
         `)}
       </div>
+      <${OpenItemsList} />
     </div>
   `;
 }
@@ -628,6 +636,10 @@ export const SIDEBAR_GROUPS = [
     { id: 'email', labelKey: 'profile.tabs.email' },
     { id: 'chatsessions', labelKey: 'profile.tabs.chatSessions' },
   ] },
+  { titleKey: 'profile.landing.menuBusiness', items: [     // the company and its money
+    { id: 'companies', labelKey: 'profile.tabs.companies' },
+    { id: 'pnl', labelKey: 'profile.tabs.pnl' },
+  ] },
   { titleKey: 'profile.landing.menuBuildShare', items: [
     { id: 'apps', labelKey: 'profile.tabs.apps' },
     { id: 'appdev', labelKey: 'profile.tabs.appDev' },
@@ -663,7 +675,25 @@ export const SIDEBAR_GROUPS = [
   ] },
 ];
 
+/**
+ * The BASIC menu: what a person needs before they have built anything on the node. 38 items in
+ * one flat list was a measured wall for a non-technical newcomer (UX-remake v3, K5), and the
+ * chat-first model says the profile's deeper surfaces are for technical users. Everything else
+ * is one "Show all tools" toggle away, and the toggle state is remembered — nothing is removed.
+ * Operator-only groups are never in the basic set (they are role-gated anyway).
+ */
+export const BASIC_TAB_IDS = new Set([
+  'companies',                                  // your company: address, legal identity, sender
+  'organisms', 'memory', 'notebook',            // where the work and knowledge live
+  'agents', 'mcp',                              // the chat/agent connection
+  'notifications', 'contacts',                  // what happened, who with
+  'apps', 'portfolio',                          // what you made
+  'wallet', 'access',                           // account
+]);
+
 // Flat item lookup (pinned section renders items by id).
 export const SIDEBAR_ITEM_BY_ID = Object.fromEntries(SIDEBAR_GROUPS.flatMap(g => g.items.map(it => [it.id, it])));
 export const INFRA_TAB_IDS = new Set(['federation', 'nodes', 'nodeStats', 'security']);
-export const DEFAULT_PINS = ['organisms', 'agents', 'memory', 'scheduler'];
+// Defaults stay inside BASIC_TAB_IDS: a default pin to a tool the basic menu hides (scheduler,
+// until 2026-08-07) contradicted the two-level menu the moment it shipped.
+export const DEFAULT_PINS = ['organisms', 'agents', 'memory', 'mcp'];

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

@@ -97,7 +97,7 @@ import { h } from "preact";
 import { useState, useEffect, useCallback, useRef } from "preact/hooks";
 import htm from "htm";
 const html = htm.bind(h);
-import { t } from "/js/i18n.js";
+import { t, tOr } from "/js/i18n.js";
 import { listApps } from "/js/services/apps.js";
 import { onLiveUpdate } from "/lib/live-updates.js";
 import { getMemory, createMemory } from "/js/services/memory.js";
@@ -105,10 +105,11 @@ import { minidenticon } from "/lib/minidenticons.min.js";
 import { syncTabHistory } from "./landing-page.helpers.js";
 import { EditProfileModal, ChangePasswordModal } from "./landing-page.modals.js";
 import { swallowed } from '/js/swallowed.js';
+import { HomeUiSwitch } from '/components/HomeUiSwitch.js';
 import {
   ProfileCard, WaitingForYou, NextSteps, UsageCard, AiSpendCard, AgentLedgerCard,
   CommerceCard, ContinueCard, AgentsCard, CortexSection, InboxNavButton,
-  SIDEBAR_GROUPS, SIDEBAR_ITEM_BY_ID, INFRA_TAB_IDS, DEFAULT_PINS,
+  SIDEBAR_GROUPS, SIDEBAR_ITEM_BY_ID, INFRA_TAB_IDS, DEFAULT_PINS, BASIC_TAB_IDS,
 } from "./landing-page.cards.js";
 
 /* ───── Tier heuristic ───── */
@@ -172,12 +173,35 @@ export default function LandingPage({ tier, stats, homeUsage, homeAgents, sessio
   const fromPopRef = useRef(false);
   openViewRef.current = openView;
   const [drawerOpen, setDrawerOpen] = useState(false);
+  // Sidebar depth (K5): basic set by default, everything behind one remembered toggle. A user who
+  // has already opened a non-basic tab is clearly past the basics — start them expanded.
+  const [showAllTools, setShowAllTools] = useState(() => {
+    try {
+      const saved = localStorage.getItem('aimeat.sidebar.allTools');
+      if (saved === '1') return true;
+      if (saved === '0') return false;
+    // eslint-disable-next-line aimeat/no-silent-catch -- blocked storage just means "no remembered choice"
+    } catch { /* fall through to the heuristic */ }
+    try {
+      const saved = JSON.parse(sessionStorage.getItem('aimeat-profile-tab') || 'null');
+      return !!(saved && saved.tabId && !BASIC_TAB_IDS.has(saved.tabId));
+    // eslint-disable-next-line aimeat/no-silent-catch -- no remembered tab means start basic
+    } catch { return false; }
+  });
   // Extensions promo: onboarding-only (apps < 3) and dismissable for good.
   const [showPromo, setShowPromo] = useState(() => { try { return localStorage.getItem('aimeat.cortexPromoDismissed') !== '1'; } catch { return true; } });
   const dismissPromo = () => { setShowPromo(false); try { localStorage.setItem('aimeat.cortexPromoDismissed', '1'); } catch { /* noop */ } };   // eslint-disable-line aimeat/no-silent-catch -- noop
 
   const owner = session.owner;
 
+  // Has this account produced ANYTHING yet? Gates the inventory cards (quotas, spend, commerce)
+  // off a brand-new account's first screen (UX-remake v3, P5). Only KNOWN-positive counts flip it,
+  // so the cards never flash in before the stats land and then disappear.
+  const hasOwnContent = (apps.length > 0)
+    || (typeof stats?.agents === 'number' && stats.agents > 0)
+    || (typeof stats?.organisms === 'number' && stats.organisms > 0)
+    || (typeof stats?.memories === 'number' && stats.memories > 0);
+
   /* Fetch app list for app strip */
   const loadApps = useCallback(async () => {
     try {
@@ -361,15 +385,28 @@ export default function LandingPage({ tier, stats, homeUsage, homeAgents, sessio
             `}
             ${SIDEBAR_GROUPS.filter(g => !g.adminOnly || isOperator).map(g => {
               const collapsed = collapsedGroups.has(g.titleKey);
+              // Basic view: only the everyday items. The rest are one toggle away, never gone.
+              const items = showAllTools ? g.items : g.items.filter(it => BASIC_TAB_IDS.has(it.id));
+              if (items.length === 0) return null;
               return html`
                 <div class="pf-side-group" key=${g.titleKey}>
                   <button class="pf-side-group-title pf-side-group-toggle" onClick=${() => toggleGroup(g.titleKey)}>
                     <span class="pf-chevron ${collapsed ? '' : 'pf-chevron-open'}">▼</span> ${t(g.titleKey)}
                   </button>
-                  ${!collapsed && g.items.map(it => renderItem(it, false))}
+                  ${!collapsed && items.map(it => renderItem(it, false))}
                 </div>
               `;
             })}
+            <button class="pf-side-item pf-side-more" onClick=${() => setShowAllTools(v => {
+              const next = !v;
+              // eslint-disable-next-line aimeat/no-silent-catch -- a blocked store only costs the remembered choice
+              try { localStorage.setItem('aimeat.sidebar.allTools', next ? '1' : '0'); } catch { /* not persisted */ }
+              return next;
+            })}>
+              <span class="pf-side-label">${showAllTools
+                ? tOr('profile.landing.showBasicTools', 'Show fewer tools')
+                : tOr('profile.landing.showAllTools', 'Show all tools')}</span>
+            </button>
           `;
         })()}
       </aside>
@@ -388,15 +425,23 @@ export default function LandingPage({ tier, stats, homeUsage, homeAgents, sessio
           <${NextSteps} switchTab=${(id) => open(id, 'main')}
             hasApps=${appsLoaded ? apps.length > 0 : undefined} />
           <div class="pf-home-grid">
-            <${UsageCard} switchTab=${(id) => open(id, 'main')} initialUsage=${homeUsage} />
-            <${AiSpendCard} />
-            <${AgentLedgerCard} />
-            <${CommerceCard} />
             <${ContinueCard} />
             <${AgentsCard} owner=${owner} initialAgents=${homeAgents} />
+            ${/* Inventory (quotas, spend, commerce) stays OFF the first screen until the account
+                  has produced something. A brand-new account measurably read the zero-rows as a
+                  half-finished tool (UX-remake v3, P5); an established one still gets them. */
+              hasOwnContent ? html`
+              <${UsageCard} switchTab=${(id) => open(id, 'main')} initialUsage=${homeUsage} />
+              <${AiSpendCard} />
+              <${AgentLedgerCard} />
+              <${CommerceCard} />` : null}
           </div>
           ${(showPromo && apps.length < 3) ? html`
             <${CortexSection} switchTab=${() => open('extensions', 'main')} onDismiss=${dismissPromo} />` : null}
+          ${/* The way to the new home. It has to be HERE: somebody on this side could not reach it
+                from anywhere, which made the choice invisible rather than optional. Same shared
+                control the new home mounts in its settings. */''}
+          <${HomeUiSwitch} className="pf-ui-switch" />
         `}
       </main>
     </div>

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

@@ -9,7 +9,7 @@ import { useState, useEffect, useCallback, useRef } from "preact/hooks";
 import htm from "htm";
 const html = htm.bind(h);
 import { t } from "/js/i18n.js";
-import { getProfile, updateProfile, changePassword } from "/js/services/auth.js";
+import { getProfile, updateProfile, changePassword, updateSessionMeta } from "/js/services/auth.js";
 import { getMyPresence, setMyPresence } from "/js/services/presence.js";
 import { onLiveUpdate } from "/lib/live-updates.js";
 import { Spinner } from "./shared.js";
@@ -58,11 +58,7 @@ export function EditProfileModal({ session, onClose, onSaved, onChangePassword }
       if (resp && resp.data) {
         if (session && typeof fields.display_name === 'string') {
           // Persist + re-render the golden login pill live (so it shows the new name now).
-          if (window.AIMEAT?.auth?.updateSessionMeta) {
-            window.AIMEAT.auth.updateSessionMeta({ displayName: fields.display_name });
-          } else {
-            session.displayName = fields.display_name;
-          }
+          updateSessionMeta({ displayName: fields.display_name });
         }
         onSaved?.();
       } else {