@oar-sh/oar 0.9.10 → 0.9.12

package/server/public/app/socket-handlers.js

@@ -20,7 +20,6 @@ import {
   updateCompactButton,
   clearPendingUserMessage,
   hasPendingUserMessageDuplicate,
-  isMessagesAtBottom,
   upsertSubagentRun,
   getSubagentRun,
   addSubagentActivity,
@@ -31,11 +30,13 @@ import {
   applySessionWorkerSteering,
   refreshSummaryModal,
   summaryModalState,
+  IS_SHARED_VIEW,
 } from './store.js';
 import { scheduleContextUsageRefresh } from './api-client.js';
 import { capLiveActivityEntries } from './activity-replay-state.mjs';
 import { publishStatusEvent, recordStatusEvent } from './status-store.mjs';
-import { clearOpenConversation, renderConvList, refreshConversations, openConversation } from './journal-view.js';
+import { clearOpenConversation, renderConvList, refreshConversations, scheduleLoadedConversationsRefresh, applyConversationGroupEvent, openConversation } from './journal-view.js';
+import { applyBackgroundTasksToConversation, applyTurnStatusToConversation } from './conversation-turn-state.mjs';
 import { applyRelayEventSubscriptions, loadRelayEventSubscriptions } from './relay-event-subscriptions-ui.js';
 import {
   upsertRelayQuestion,
@@ -43,9 +44,13 @@ import {
   updatePendingQuestionBanner,
 } from './ask-user-view.js';
 import { upsertRelayBoard, loadRelayBoards, renderRelayBoards } from './relay-board-view.js';
-import { setConversationBackgroundTasks } from './background-tasks-view.mjs';
+import { setConversationBackgroundTasks, setConversationTaskHealth } from './background-tasks-view.mjs';
+import { handleTaskConsoleReconnect, handleTaskOutputChunk } from './task-console.mjs';
 import { setConversationPins } from './pinned-messages-view.mjs';
+import { setConversationHiddenMessages } from './hidden-messages-view.mjs';
 import { setPreviews } from './preview-cards.mjs';
+import { applyShareSettings, hasActiveShare, refreshShares } from './share-state.js';
+import { handleShareOpened, handleViewerIpsForgotten } from './shared-conversations-settings.js';
 import { setRemoteRelaysSnapshot } from './remote-relays-store.mjs';
 import { REMOTE_RELAY_SOCKET_EVENT } from './remote-relay-shared.mjs';
 import { AGENT_SESSIONS_SOCKET_EVENT } from './agent-sessions-settings.mjs';
@@ -74,10 +79,14 @@ import {
   applyConversationTurnStatus,
   renderMessages,
   appendMessage,
+  captureLiveReplyReadingPosition,
+  restoreLiveReplyReadingPosition,
   replaceRenderedMessage,
   noteTranscriptLiveRow,
   applyIncomingConversationDraftUpdate,
   getRenderedConversationMessageFingerprints,
+  holdBackLiveRow,
+  isConversationWindowAtTail,
   clearBubbleCancelState,
   removeUserBubbleCancelButton,
   updateSubagentBubbleFromStatus,
@@ -85,11 +94,23 @@ import {
   syncComposerButtonState,
   syncCancellableSteerButtons,
 } from './conversation-view.js';
+import { followsTranscriptEnd, noteTranscriptNews } from './transcript-jump-bottom-view.mjs';
 import { loadRepoBrowserTree, refreshRepoBrowserIfWorkspaceOpen } from './attachments-view.js';
 import { clearMessageSearchRuntimeState } from './message-search-view.js';
 import { stripRelayPromptContext } from './relay-prompt-sanitizer.mjs';
 import { isLikelyLiveDuplicateMessage } from './live-message-dedupe.mjs';
 import { mergeRelayThoughts } from './relay-thoughts.mjs';
+import { conversationPayloadCache } from './conversation-payload-cache.mjs';
+
+// A live row of the conversation on screen joins its kept window, so a
+// switch away and back still shows it. Rows of other conversations do not:
+// their kept copy is what the reader saw, and the switch back fetches the rest.
+function keepLiveRow(conversationId, message, messageId) {
+  if (IS_SHARED_VIEW || !message || typeof message !== 'object') return;
+  const id = String(message.id || messageId || '').trim();
+  if (!id) return;
+  conversationPayloadCache.upsertMessage(conversationId, message.id ? message : { ...message, id });
+}
 import {
   handleSubagentStatusEventForViewer,
   handleSubagentTimelineEvent,
@@ -329,16 +350,26 @@ export async function connectSocket(overrideDeps) {
     // session, whose restored socket.data the server deliberately resets.
     emitDeviceVisibility(document.visibilityState === 'visible');
     clearMessageSearchRuntimeState();
+    // Events missed while the socket was down may have changed any of the
+    // conversations kept for a quick switch back.
+    conversationPayloadCache.clear();
     setRelayOnline(true);
     setCliOnline(true);
     renderConvList();
     resyncAfterConnect();
+    // Every loaded page again, not page one only: events missed while the
+    // socket was down touched rows anywhere in the list.
+    scheduleLoadedConversationsRefresh();
     refreshSessionWorkerStatus().catch(() => {});
     refreshModelCatalog().catch(() => {});
     // An open sub-agent viewer fetches whatever it missed while away.
     handleSubagentViewerReconnect();
+    // An open task console watches again and reads what it missed.
+    void handleTaskConsoleReconnect();
     // Subscriptions that changed while away.
     void loadRelayEventSubscriptions();
+    // Shares made or stopped while away.
+    void refreshShares().catch(() => {});
   });
   socket.on('connect_error', (e) => {
     setRelayOnline(false);
@@ -508,16 +539,23 @@ export async function connectSocket(overrideDeps) {
       })) {
         return;
       }
+      // A window that ends above the conversation's end takes no live row:
+      // the newer pages bring it, and the jump-to-bottom badge counts it.
+      if (holdBackLiveRow(conversationId, messageId || normalizedMessage.id)) return;
       // Another client's message (an agent's prompt included) follows the
       // end like any live row: a reader scrolled up stays where they are,
       // and the jump-to-bottom badge counts it.
-      appendMessage(normalizedMessage, isMessagesAtBottom(), messageId);
+      appendMessage(normalizedMessage, followsTranscriptEnd(), messageId);
       noteTranscriptLiveRow();
+      keepLiveRow(conversationId, normalizedMessage, messageId);
     }
   });
   socket.on('assistant_message', ({ conversationId, message, messageId, sourceMessageId }) => {
     const isCurrentConversation = conversationId === currentConvId;
-    const autoScroll = isCurrentConversation ? isMessagesAtBottom() : false;
+    const autoScroll = isCurrentConversation ? followsTranscriptEnd() : false;
+    // A reader who is not at the end keeps what they read where it is while
+    // the reply takes the live bubble's place.
+    const reading = isCurrentConversation && !autoScroll ? captureLiveReplyReadingPosition() : null;
     // A background conversation finishing its turn must not wipe the viewed
     // conversation's live bubble.
     if (isCurrentConversation) {
@@ -536,12 +574,19 @@ export async function connectSocket(overrideDeps) {
         message.thoughts = mergedThoughts;
       }
     }
-    if (messageId && seenMessageIds?.has(messageId)) return;
-    if (isCurrentConversation) {
+    if (messageId && seenMessageIds?.has(messageId)) {
+      restoreLiveReplyReadingPosition(reading);
+      return;
+    }
+    // Held back under a window that ends above the conversation's end, as
+    // in user_message.
+    if (isCurrentConversation && !holdBackLiveRow(conversationId, messageId || message?.id)) {
       appendMessage(message, autoScroll, messageId || null, false, sourceMessageId || null);
+      restoreLiveReplyReadingPosition(reading);
       noteTranscriptLiveRow();
-      scheduleContextUsageRefresh(conversationId, 120);
+      keepLiveRow(conversationId, message, messageId);
     }
+    if (isCurrentConversation) scheduleContextUsageRefresh(conversationId, 120);
     if (sourceMessageId) relayActivities.delete(sourceMessageId);
     if (sourceMessageId) relayThoughts.delete(sourceMessageId);
     if (sourceMessageId) clearRelayStreamStateForMessage(sourceMessageId);
@@ -556,11 +601,22 @@ export async function connectSocket(overrideDeps) {
   // cannot be started): same id, new text or kind. Not on the page yet (the
   // conversation was opened after it was written): appended like any other.
   socket.on('message_updated', ({ conversationId, messageId, message }) => {
-    if (!messageId || conversationId !== currentConvId || !message) return;
+    // A row rewritten in place. Another conversation's kept window would show
+    // the old one: it is dropped. The window on screen takes the new row as
+    // the page does, so a switch away and back keeps both the row and the
+    // window around it.
+    if (!messageId || conversationId !== currentConvId || !message) {
+      conversationPayloadCache.forget(conversationId);
+      return;
+    }
     if (!replaceRenderedMessage(message, messageId)) {
-      appendMessage(message, isMessagesAtBottom(), messageId, false);
+      // A row outside a window that ends above the conversation's end: the
+      // newer pages bring it as it is now.
+      if (!isConversationWindowAtTail()) return;
+      appendMessage(message, followsTranscriptEnd(), messageId, false);
     }
     noteTranscriptLiveRow();
+    keepLiveRow(conversationId, message, messageId);
   });
   socket.on('relay_question', ({ question }) => upsertRelayQuestion(question));
   socket.on('relay_question_updated', ({ question }) => upsertRelayQuestion(question));
@@ -576,19 +632,61 @@ export async function connectSocket(overrideDeps) {
   socket.on('relay_event_subscriptions', ({ subscriptions }) => {
     applyRelayEventSubscriptions(subscriptions);
   });
-  socket.on('background_tasks', ({ conversationId, tasks }) => {
-    setConversationBackgroundTasks(conversationId, tasks);
+  socket.on('background_tasks', ({ conversationId, tasks, endedTasks }) => {
+    setConversationBackgroundTasks(conversationId, tasks, { endedTasks });
+    // The sidebar's row (and its group's head) count background work as
+    // running; the set arrives under the conversation or its session id.
+    const id = String(conversationId || '').trim();
+    const record = conversations[id]
+      || Object.values(conversations).find((conversation) => String(conversation?.sdkSessionId || '') === id)
+      || null;
+    if (record && applyBackgroundTasksToConversation(record, tasks)) renderConvList();
+  });
+  // The relay's health poller: last output time and test-runner counts of
+  // shell and Monitor tasks, only when they changed.
+  socket.on('background_tasks_health', ({ conversationId, health }) => {
+    setConversationTaskHealth(conversationId, health);
+  });
+  // New bytes of the task the console shows; the relay sends them only while
+  // this page's console watches that task.
+  socket.on('task_output_chunk', (payload) => {
+    handleTaskOutputChunk(payload);
   });
   // A message was pinned or unpinned (any client): the conversation's whole
   // pin list, replacing what this page had.
   socket.on('conversation_pins_updated', ({ conversationId, pins, revision }) => {
     setConversationPins(conversationId, pins, revision);
   });
+  // A message was hidden from or shown to shared viewers (any client): the
+  // conversation's whole hidden list, replacing what this page had.
+  socket.on('conversation_hidden_messages_updated', ({ conversationId, hiddenMessages, revision }) => {
+    setConversationHiddenMessages(conversationId, hiddenMessages, revision);
+  });
   // REPLACE semantics for the whole set: the preview registry is relay-owned
   // and global, so every change ships the full list.
   socket.on('previews', ({ previews }) => {
     setPreviews(previews);
   });
+  // Public shares: the events name the conversation only; the list (Settings
+  // → Sharing, the ⋯ menu's Stop sharing) is read again.
+  for (const event of ['share_created', 'share_renewed', 'share_revoked']) {
+    socket.on(event, () => {
+      void refreshShares().catch(() => {});
+    });
+  }
+  // A deleted conversation takes its share along.
+  socket.on('conversation_deleted', ({ conversationId } = {}) => {
+    if (hasActiveShare(conversationId)) void refreshShares().catch(() => {});
+  });
+  socket.on('share_opened', ({ conversationId } = {}) => {
+    handleShareOpened(conversationId);
+  });
+  socket.on('share_settings_changed', (payload) => {
+    applyShareSettings(payload || null);
+  });
+  socket.on('share_viewer_ips_forgotten', () => {
+    handleViewerIpsForgotten();
+  });
   // REPLACE semantics too: the relay ships the whole remote-relay list (no
   // tokens) whenever a remote is added, removed, renamed or changes status.
   socket.on(REMOTE_RELAY_SOCKET_EVENT, (payload) => {
@@ -613,16 +711,17 @@ export async function connectSocket(overrideDeps) {
     const last = items[items.length - 1];
     const lastText = typeof last === 'string' ? last : String(last?.text || '');
     const lastSubagentRunId = typeof last === 'object' && last ? (last.subagentRunId || null) : null;
-    if (lastText !== entry.text || lastSubagentRunId !== entry.subagentRunId) {
-      relayActivities.set(messageId, capLiveActivityEntries(items.concat(entry)));
-    }
+    // The same line again (a repeated event) adds nothing.
+    const added = lastText !== entry.text || lastSubagentRunId !== entry.subagentRunId;
+    if (added) relayActivities.set(messageId, capLiveActivityEntries(items.concat(entry)));
     if (entry.subagentRunId) {
       upsertSubagentRun({ subagentRunId: entry.subagentRunId, messageId, conversationId });
       addSubagentActivity(entry.subagentRunId, entry.text);
     }
     if (conversationId === currentConvId) {
-      const autoScroll = isMessagesAtBottom();
+      const autoScroll = followsTranscriptEnd();
       appendThinkingActivity(entry, entry.subagentRunId, autoScroll);
+      if (added && !autoScroll) noteTranscriptNews();
     }
   });
   socket.on('relay_stream', ({ conversationId, messageId, text, done, seq, subagentRunId }) => {
@@ -631,8 +730,8 @@ export async function connectSocket(overrideDeps) {
       upsertSubagentRun({ subagentRunId: String(subagentRunId).trim(), messageId, conversationId });
     }
     if (conversationId !== currentConvId) return;
-    const autoScroll = isMessagesAtBottom();
-    applyRelayStreamEvent({
+    const autoScroll = followsTranscriptEnd();
+    const accepted = applyRelayStreamEvent({
       messageId,
       text: String(text || ''),
       done: !!done,
@@ -640,11 +739,16 @@ export async function connectSocket(overrideDeps) {
       subagentRunId: subagentRunId ? String(subagentRunId).trim() : null,
       autoScroll,
     });
+    // A frame that was dropped (out of order, a finished turn) is no news.
+    if (accepted && !autoScroll) noteTranscriptNews();
   });
   socket.on('relay_thought', ({ conversationId, messageId, reasoningId, text, done, subagentRunId }) => {
     if (!messageId) return;
     const key = String(reasoningId || 'reasoning');
     const thoughtMap = relayThoughts.get(messageId) || new Map();
+    const known = thoughtMap.get(key);
+    // The same thought again (a repeated event) adds nothing.
+    const added = !known || known.text !== String(text || '') || known.done !== !!done;
     thoughtMap.set(key, { reasoningId: key, text: String(text || ''), done: !!done, subagentRunId: subagentRunId || null });
     relayThoughts.set(messageId, thoughtMap);
     if (subagentRunId) {
@@ -652,8 +756,9 @@ export async function connectSocket(overrideDeps) {
       addSubagentThought(subagentRunId, { reasoningId: key, text: String(text || ''), done: !!done });
     }
     if (conversationId === currentConvId) {
-      const autoScroll = isMessagesAtBottom();
+      const autoScroll = followsTranscriptEnd();
       appendThinkingThought(key, String(text || ''), !!done, subagentRunId, autoScroll);
+      if (added && !autoScroll) noteTranscriptNews();
     }
   });
   socket.on('subagent_status', (payload = {}) => {
@@ -681,6 +786,8 @@ export async function connectSocket(overrideDeps) {
   });
   socket.on('conversation_compacted', async ({ sourceConversationId, targetConversationId }) => {
     if (!sourceConversationId || !targetConversationId) return;
+    conversationPayloadCache.forget(sourceConversationId);
+    conversationPayloadCache.forget(targetConversationId);
     await refreshConversations();
     if (currentConvId === sourceConversationId) {
       await openConversation(targetConversationId);
@@ -770,6 +877,9 @@ export async function connectSocket(overrideDeps) {
     applyConversationTurnStatus({ conversationId, messageId, status });
     if (conversationId && conversations[conversationId]) {
       const conversation = conversations[conversationId];
+      // The row's turn fields follow the event, open or not: the title colour, a
+      // group head's pill and its fold read them between list fetches.
+      applyTurnStatusToConversation(conversation, normalizedStatus);
       if (normalizedStatus === 'processing') {
         conversation.localTurnStatus = 'processing';
         conversation.localTurnStatusUpdatedAt = Date.now();
@@ -785,7 +895,7 @@ export async function connectSocket(overrideDeps) {
       }
     }
     if (conversationId === currentConvId && normalizedStatus === 'processing') {
-      const autoScroll = isMessagesAtBottom();
+      const autoScroll = followsTranscriptEnd();
       showThinking(messageId || null, autoScroll);
       renderThinkingActivities();
       renderThinkingThoughts();
@@ -821,11 +931,18 @@ export async function connectSocket(overrideDeps) {
     }
     renderConvList();
   });
+  // A session group changed (a member joined or left, a name, a dissolve,
+  // here or from another device): every loaded page is fetched again with
+  // its groups, so a row far down the list changes too.
+  socket.on('conversation_group_changed', (payload) => {
+    applyConversationGroupEvent(payload);
+  });
   socket.on('conversation_archived', ({ conversationId, archived }) => {
     const id = String(conversationId || '').trim();
     if (!id) return;
     const conversation = conversations[id];
     if (conversation) conversation.archived = archived !== false;
+    conversationPayloadCache.forget(id);
     renderConvList();
     if (currentConvId === id) {
       syncChatTitleControls();
@@ -834,6 +951,7 @@ export async function connectSocket(overrideDeps) {
   });
   socket.on('conversation_deleted', ({ conversationId }) => {
     delete conversations[conversationId];
+    conversationPayloadCache.forget(conversationId);
     for (const [id, question] of relayQuestions.entries()) {
       if (question?.conversationId === conversationId) relayQuestions.delete(id);
     }

package/server/public/app/store.js

@@ -1,10 +1,12 @@
 import { resolveNearBottomThresholdPx } from './transcript-viewport-anchor.mjs';
+import { normalizeReadingAnchor } from './transcript-reading-anchor.mjs';
 import { recordCliLifecycleEvent, recordRelayLifecycleEvent } from './status-store.mjs';
 import { resolveRelayDotState } from './relay-dot-state.mjs';
 import { readRepoBrowserPreferences } from './repo-browser-preferences.mjs';
 import { isChatInteractionHeld } from './selection-guard.mjs';
 import { nextSubagentStatus } from './subagent-fold.mjs';
 import { useStrictStrikethrough } from './markdown-strikethrough.mjs';
+import { parseGroupFoldChoices, pruneGroupFoldChoices } from './conversation-group-state.mjs';
 
 function resolveAppBase() {
   const configuredBase = typeof window.__COPILOT_APP_CONFIG?.basePath === 'string'
@@ -16,6 +18,8 @@ function resolveAppBase() {
   const pathname = String(window.location.pathname || '/');
   const sharedIndex = pathname.indexOf('/shared/');
   if (sharedIndex >= 0) return pathname.slice(0, sharedIndex).replace(/\/+$/, '');
+  const previewIndex = pathname.indexOf('/share-preview/');
+  if (previewIndex >= 0) return pathname.slice(0, previewIndex).replace(/\/+$/, '');
   return pathname.replace(/\/+$/, '');
 }
 
@@ -32,8 +36,24 @@ function resolveSharedConversationToken() {
   if (configured) return configured;
   return extractSharedTokenFromPathname(window.location.pathname);
 }
-export const SHARED_CONVERSATION_TOKEN = resolveSharedConversationToken();
-export const IS_SHARED_VIEW = !!SHARED_CONVERSATION_TOKEN;
+// "Preview as shared": the owner reads a conversation as a share link would
+// serve it (marked redactions), through the owner-only preview routes. It is a
+// shared view in every other respect.
+function resolveSharePreviewConversationId() {
+  const configured = String(window.__COPILOT_APP_CONFIG?.sharePreviewConversationId || '').trim();
+  if (configured) return configured;
+  const match = String(window.location.pathname || '/').match(/\/share-preview\/([^/?#]+)\/?$/i);
+  if (!match) return '';
+  try {
+    return decodeURIComponent(String(match[1] || '')).trim();
+  } catch {
+    return '';
+  }
+}
+export const SHARE_PREVIEW_CONVERSATION_ID = resolveSharePreviewConversationId();
+export const IS_SHARE_PREVIEW = !!SHARE_PREVIEW_CONVERSATION_ID;
+export const SHARED_CONVERSATION_TOKEN = IS_SHARE_PREVIEW ? '' : resolveSharedConversationToken();
+export const IS_SHARED_VIEW = !!SHARED_CONVERSATION_TOKEN || IS_SHARE_PREVIEW;
 export let TOKEN = '';
 export let socket = null;
 export let currentConvId = null;
@@ -82,6 +102,9 @@ export let updateState = null;
 export let activeRuntimeSessionCount = 0;
 export let runtimeSessionBindingCount = 0;
 export let conversations = {};
+// Session groups by id, as the list payload describes them (`groups`):
+// name, display name, head and member counts. Merged with every page.
+export const conversationGroups = {};
 export let selectedAttachments = [];
 export let imageEditTarget = null;
 export const RELAY_QUESTION_POLL_MS = 3000;
@@ -172,6 +195,8 @@ const SIDEBAR_WIDTH_PERCENT_FALLBACK = 24;
 const SIDEBAR_WIDTH_PORTRAIT_STORAGE_KEY = 'copilot_sidebar_width_pct_portrait';
 const SIDEBAR_WIDTH_LANDSCAPE_STORAGE_KEY = 'copilot_sidebar_width_pct_landscape';
 const SIDEBAR_COLLAPSED_DESKTOP_STORAGE_KEY = 'copilot_sidebar_collapsed_desktop';
+// The user's fold choices for session groups in the sidebar: { [groupId]: 'open' | 'folded' }.
+const CONVERSATION_GROUP_FOLDS_STORAGE_KEY = 'copilot_conv_group_folds';
 let sidebarWidthPercent = SIDEBAR_WIDTH_PERCENT_FALLBACK;
 const CONVERSATION_SCROLL_STORAGE_PREFIX = 'copilot_message_scroll_';
 
@@ -197,6 +222,59 @@ export function setCurrentConv(id) {
   updateCompactButton();
 }
 
+/** Merges a list payload's `groups` (by id) into the known session groups. */
+export function mergeConversationGroups(groups) {
+  if (!groups || typeof groups !== 'object') return;
+  for (const [groupId, group] of Object.entries(groups)) {
+    const id = String(groupId || '').trim();
+    if (!id || !group || typeof group !== 'object') continue;
+    conversationGroups[id] = { ...(conversationGroups[id] || {}), ...group, id };
+  }
+}
+
+/** Forgets a session group the relay no longer lists. */
+export function forgetConversationGroup(groupId) {
+  delete conversationGroups[String(groupId || '').trim()];
+}
+
+/**
+ * Keeps only the groups that a loaded row still belongs to: after a list
+ * refresh a dissolved group has no row left, and the picker must not offer
+ * it. Returns the ids dropped.
+ */
+export function pruneConversationGroups(keepGroupIds) {
+  const keep = new Set((Array.isArray(keepGroupIds) ? keepGroupIds : []).map((id) => String(id || '').trim()).filter(Boolean));
+  const dropped = [];
+  for (const id of Object.keys(conversationGroups)) {
+    if (keep.has(id)) continue;
+    delete conversationGroups[id];
+    dropped.push(id);
+  }
+  return dropped;
+}
+
+export function readConversationGroupFoldChoices() {
+  return parseGroupFoldChoices(localStorage.getItem(CONVERSATION_GROUP_FOLDS_STORAGE_KEY) || '');
+}
+
+// The stored fold choices are trimmed to the loaded groups only past this
+// size: a choice for a group on an older page or in the other view must
+// not go with every toggle.
+const CONVERSATION_GROUP_FOLDS_MAX = 300;
+
+/** Stores the user's fold choice for a group. */
+export function setConversationGroupFoldChoice(groupId, choice) {
+  const id = String(groupId || '').trim();
+  if (!id) return;
+  let next = readConversationGroupFoldChoices();
+  if (Object.keys(next).length > CONVERSATION_GROUP_FOLDS_MAX) {
+    next = pruneGroupFoldChoices(next, [...Object.keys(conversationGroups), id]);
+  }
+  if (choice === 'open' || choice === 'folded') next[id] = choice;
+  else delete next[id];
+  localStorage.setItem(CONVERSATION_GROUP_FOLDS_STORAGE_KEY, JSON.stringify(next));
+}
+
 export function setConversationWatcherCount(conversationId, count) {
   const id = String(conversationId || '').trim();
   if (!id) return;
@@ -236,6 +314,7 @@ function readConversationViewState(conversationId) {
         loadedMessageCount: Number.isFinite(Number(parsed.loadedMessageCount)) && Number(parsed.loadedMessageCount) >= 0
           ? Math.trunc(Number(parsed.loadedMessageCount))
           : null,
+        anchor: normalizeReadingAnchor(parsed.anchor),
       };
     }
   } catch {
@@ -246,6 +325,7 @@ function readConversationViewState(conversationId) {
   return {
     scrollTop: Math.trunc(legacyScrollTop),
     loadedMessageCount: null,
+    anchor: null,
   };
 }
 
@@ -260,6 +340,7 @@ function writeConversationViewState(conversationId, nextState = {}) {
     loadedMessageCount: Number.isFinite(Number(nextState.loadedMessageCount)) && Number(nextState.loadedMessageCount) >= 0
       ? Math.trunc(Number(nextState.loadedMessageCount))
       : current.loadedMessageCount ?? null,
+    anchor: 'anchor' in nextState ? normalizeReadingAnchor(nextState.anchor) : (current.anchor ?? null),
   };
   localStorage.setItem(key, JSON.stringify(next));
   return true;
@@ -296,6 +377,27 @@ export function loadConversationLoadedMessageCount(conversationId) {
   return readConversationViewState(conversationId)?.loadedMessageCount ?? null;
 }
 
+// The message read and its offset, or "at the end" (transcript-reading-anchor.mjs):
+// what a switch back and a reload restore. scrollTop is still written for
+// older pages of this app reading the same storage.
+export function saveConversationReadingAnchor(conversationId, anchor) {
+  const value = normalizeReadingAnchor(anchor);
+  if (!value) return false;
+  try {
+    return writeConversationViewState(conversationId, { anchor: value });
+  } catch {
+    return false;
+  }
+}
+
+export function loadConversationReadingAnchor(conversationId) {
+  try {
+    return readConversationViewState(conversationId)?.anchor ?? null;
+  } catch {
+    return null;
+  }
+}
+
 function normalizePendingMessageText(text) {
   return String(text || '').replace(/\s+/g, ' ').trim().toLowerCase();
 }
@@ -612,37 +714,18 @@ export function getMessagesDistanceFromBottom() {
   return Math.max(0, el.scrollHeight - el.clientHeight - el.scrollTop);
 }
 
-function resolveMessagesNearBottomThreshold(el, thresholdPx = null) {
-  if (Number.isFinite(Number(thresholdPx)) && Number(thresholdPx) >= 0) {
-    return Math.trunc(Number(thresholdPx));
-  }
-  return resolveNearBottomThresholdPx(el?.clientHeight);
-}
-
-export function isMessagesNearBottom(thresholdPx = null) {
-  const el = document.getElementById('messages');
-  if (!el) return true;
-  const distance = Math.max(0, el.scrollHeight - el.clientHeight - el.scrollTop);
-  const threshold = resolveMessagesNearBottomThreshold(el, thresholdPx);
-  return distance <= threshold;
-}
-
-export function isMessagesAtBottom(epsilonPx = 1) {
+/**
+ * "At the end" of the transcript, wherever that is decided: within the
+ * near-bottom margin (8% of the viewport, between 12 and 48 px). One margin
+ * and no parameter: a caller with a margin of its own (there was one with
+ * 80 px, one with 1 px, and a default that read as 0 px) breaks the rule that
+ * the transcript follows a reader who is at the end and nobody else.
+ */
+export function isMessagesNearBottom() {
   const el = document.getElementById('messages');
   if (!el) return true;
-  const epsilon = Math.max(0, Number.isFinite(Number(epsilonPx)) ? Number(epsilonPx) : 1);
   const distance = Math.max(0, el.scrollHeight - el.clientHeight - el.scrollTop);
-  return distance <= epsilon;
-}
-
-export function scrollBottomAfterSend() {
-  scrollBottom();
-  requestAnimationFrame(() => {
-    scrollBottom();
-  });
-  setTimeout(() => {
-    scrollBottom();
-  }, 120);
+  return distance <= resolveNearBottomThresholdPx(el.clientHeight);
 }
 
 export function isMobileComposerViewport() {
@@ -944,8 +1027,16 @@ function buildSessionWorkerStateHash(map) {
 
 let sessionWorkerStateHash = '';
 
+// Whether a status poll has answered yet: before that, a session's reported
+// background work is taken as it is; after it, only a live worker carries it.
+let sessionWorkerStatusKnown = false;
+export function hasSessionWorkerStatus() {
+  return sessionWorkerStatusKnown;
+}
+
 export function setSessionWorkerStatesFromStatusPayload(payload) {
   const workers = Array.isArray(payload?.workers) ? payload.workers : [];
+  sessionWorkerStatusKnown = true;
   const next = new Map();
   for (const worker of workers) {
     const normalized = normalizeWorkerStateEntry(worker);

package/server/public/app/subagent-row.mjs

@@ -60,9 +60,9 @@ export function isRunningSubagentStatus(status) {
 
 /**
  * The row for one run. `clickable` makes the title the button that opens the
- * viewer (`data-subagent-open`); a shared view, which cannot read the record,
- * passes false. `context` lands in a class so the bubble and the viewer can
- * size the row differently.
+ * viewer (`data-subagent-open`); a shared view opens it too, read-only,
+ * through the share's sub-agent route. `context` lands in a class so the
+ * bubble and the viewer can size the row differently.
  */
 export function subagentRowHtml(run, { context = 'bubble', clickable = true, now = Date.now() } = {}) {
   const runId = String(run?.subagentRunId || '').trim();