@oar-sh/oar 0.9.9 → 0.9.11

package/server/public/app/conversation-view.js

@@ -23,7 +23,6 @@ import {
   updateWorkspaceRootHints,
   applyContextUsageBar,
   scrollBottom,
-  scrollBottomAfterSend,
   isMobileComposerViewport,
   releaseComposerFocusAfterSend,
   autoResize,
@@ -47,6 +46,7 @@ import {
   getSessionWorkerState,
   openSummaryModal,
   closeSummaryModal,
+  toggleSidebar,
 } from './store.js';
 import { getPendingQuestionCountsByConversation } from './ask-user-view.js';
 import { sendMessage as sendMessageApi, cancelConversationTurn, cancelQueuedConversationTurn, cancelSubagentRun, compactConversation as compactConversationApi, scheduleContextUsageRefresh, loadConversation as loadConversationApi, loadSharedConversation, updateConversationDraft as updateConversationDraftApi, updateMessageShareVisibility, launchSessionWorker } from './api-client.js';
@@ -55,12 +55,25 @@ import { linkifyWorkspaceMentionsInNode, parseAppFileHref, renderMarkdownPreview
 import { renderAttachmentMarkup, removeComposerAttachments, uploadAttachments, setComposerAttachments, setRepoBrowserSessionInfo, openGalleryItem } from './attachments-view.js';
 import { chatMediaGallery, chatMediaItemFromNode } from './viewer-chat-gallery.mjs';
 import { buildWorkflowRunCard } from './background-tasks-view.mjs';
+import { mergeLiveSubagentRun, subagentRowsMarkup } from './subagent-row.mjs';
+import { rememberSubagentRuns, syncSubagentRowClock } from './subagent-viewer.mjs';
 import { isMessagePinned, toggleMessagePin } from './pinned-messages-view.mjs';
+import { isMessageHiddenFromShares, setConversationHiddenMessages } from './hidden-messages-view.mjs';
 import { parsePreviewCommand, runPreviewCommand } from './preview-command.mjs';
 import { buildTranscriptPreviewCard } from './preview-cards.mjs';
 import { closeSlashAutocomplete, handleSlashAutocompleteKey, updateSlashAutocomplete } from './slash-autocomplete.mjs';
 import { closeMentionAutocomplete, handleMentionAutocompleteKey, updateMentionAutocomplete } from './mention-autocomplete.mjs';
 import { renderRemoteOriginBadgeHtml } from './remote-relay-origin-view.mjs';
+import { isRelayEventMessage, renderRelayEventRowHtml } from './relay-event-view.mjs';
+import {
+  AGENT_EXCHANGE_CLOSED_CLASS,
+  AGENT_EXCHANGE_HEAD_CLASS,
+  agentExchangeFoldOpen,
+  agentExchangeRowOf,
+  agentExchangeSummary,
+  planAgentExchangeFolds,
+  renderAgentExchangeRowHtml,
+} from './agent-exchange-fold-view.mjs';
 import { stripRemoteRelayDisplayArtifacts } from './relay-prompt-sanitizer.mjs';
 import { evaluateUnknownCommandGuard } from './slash-commands.mjs';
 import { attachCodeCopyButtons } from './code-copy.mjs';
@@ -98,9 +111,11 @@ import {
   syncSeparatorRail,
   syncTranscriptSeparators,
 } from './transcript-separators.mjs';
-import { ABSORBED_MSG_CLASS, STEER_MARKER_CLASS_BY_KIND, syncSteeredTurnMerge } from './steered-turn-merge.mjs';
+import { ABSORBED_MSG_CLASS, STEERED_MSG_CLASS, STEER_MARKER_CLASS_BY_KIND, syncSteeredTurnMerge } from './steered-turn-merge.mjs';
 import { resolveSubagentFold, subagentFoldSummary, toggledSubagentFoldChoice } from './subagent-fold.mjs';
 import { deriveComposerControlState, hasComposerDraft, hasUploadingAttachments } from './composer-control-state.mjs';
+import { resolveNoConversationState } from './no-conversation-state.mjs';
+import { getProviderReadiness, isProviderSetupRequired } from './provider-readiness.mjs';
 import { buildLiveMessageFingerprint } from './live-message-dedupe.mjs';
 import { createInfiniteLoader } from './infinite-loader.js';
 import { normalizeDraftTimestampMs, isIncomingDraftTimestampStale } from './conversation-draft-timestamp-utils.mjs';
@@ -116,6 +131,7 @@ import {
   shouldApplyIncomingDraftToComposer,
 } from './conversation-draft-sync.mjs';
 import { isChatInteractionHeld, selectionIntersectsNode } from './selection-guard.mjs';
+import { captureReadingBlock, restoreReadingBlock } from './transcript-viewport-anchor.mjs';
 import {
   applyThinkingFollow,
   getThinkingFollowMode,
@@ -126,6 +142,7 @@ import {
   toggleThinkingFollowMode,
   unobserveThinkingBubble,
 } from './thinking-follow.js';
+import { beginOwnSend, followsTranscriptEnd, nameOwnSendConversation, ownSendFollows, scrollAfterOwnSend } from './transcript-jump-bottom-view.mjs';
 import { buildInFlightSnapshotKey } from './in-flight-snapshot.mjs';
 import { computeStablePrefixLength, planListPatch } from './streaming-dom-patch.mjs';
 import { prefixToolActivityEmoji } from './tool-activity-emoji.mjs';
@@ -150,6 +167,8 @@ function syncSeparatorsNow() {
   if (!el) return;
   syncTranscriptSeparators(el);
   syncSteeredTurnMerge(el);
+  // After the merge pass: a steered row's class is one of its inputs.
+  syncAgentExchangeFolds(el);
   observeTranscriptResize(el);
 }
 
@@ -265,6 +284,7 @@ export function jumpToImageParent(messageId) {
     showTransientRelayNotice('Load earlier messages to view the source image.');
     return;
   }
+  revealAgentExchangeMessage(id);
   node.scrollIntoView({ behavior: 'smooth', block: 'center' });
   node.classList.add('message-highlight');
   window.setTimeout(() => node.classList.remove('message-highlight'), 1400);
@@ -355,6 +375,8 @@ const conversationHistoryLoader = createInfiniteLoader({
     // A steering pair split across the page boundary heals here (the absorbed
     // reply just arrived above its already-rendered steered user row).
     syncSteeredTurnMerge(el);
+    // The page's agent exchanges fold before the height delta is measured.
+    syncAgentExchangeFolds(el);
     requestAnimationFrame(() => {
       if (!el || String(currentConvId || '').trim() !== currentId) return;
       const nextScrollHeight = el.scrollHeight;
@@ -555,11 +577,28 @@ function syncSendButtonState() {
     steeringHeld: steeringHold.held,
     steeringHoldReason: steeringHold.reason,
     archived: conversations[String(currentConvId || '').trim()]?.archived === true,
+    setupRequired: !String(currentConvId || '').trim() && isProviderSetupRequired(),
   });
   btn.disabled = state.disabled;
   btn.dataset.action = state.action;
   btn.textContent = state.label;
   btn.title = state.title;
+  // The textarea follows: locked with the setup placeholder while no provider
+  // is ready, given back the moment readiness flips or a chat opens. The
+  // shared view owns its own read-only field and is left alone.
+  const input = document.getElementById('msg-input');
+  if (input && !IS_SHARED_VIEW) {
+    const lock = state.composerDisabled === true;
+    if (lock) {
+      input.disabled = true;
+      input.placeholder = state.placeholder;
+      input.dataset.setupLocked = '1';
+    } else if (input.dataset.setupLocked === '1') {
+      delete input.dataset.setupLocked;
+      input.disabled = false;
+      window.syncComposerPlaceholder?.();
+    }
+  }
 }
 
 // Button-only refresh for status, poll and question paths. It must never save
@@ -1226,6 +1265,147 @@ function splitVariantId(modelVariantId = '') {
   };
 }
 
+// The user's fold of an event row, by message id: a re-render of the
+// transcript must not open a row the user folded (or fold one they opened).
+const relayEventFoldChoices = new Map();
+
+function createRelayEventNode(msg, msgId) {
+  const div = document.createElement('div');
+  div.className = 'msg relay-event';
+  if (msgId) div.dataset.messageId = msgId;
+  const fingerprint = buildLiveMessageFingerprint({ ...msg, id: msgId || msg?.id || '' });
+  div.dataset.messageRole = fingerprint.role || '';
+  div.dataset.messageTextFingerprint = fingerprint.text || '';
+  div.dataset.messageTimestamp = String(msg?.timestamp || '').trim();
+  div.innerHTML = renderRelayEventRowHtml(msg, { escHtml, timeText: msg?.timestamp ? fmtDate(msg.timestamp) : '' });
+  const row = div.querySelector('details');
+  if (row && msgId) {
+    if (relayEventFoldChoices.has(msgId)) row.open = relayEventFoldChoices.get(msgId);
+    row.addEventListener('toggle', () => relayEventFoldChoices.set(msgId, row.open));
+  }
+  setAgentExchangeRow(div, msg, msgId);
+  return div;
+}
+
+// Agent exchanges (agent-exchange-fold-view.mjs): an agent's prompt folds
+// into one row; this session's reply to it always shows. What the fold pass
+// needs of a message is kept on its node when the row is built, so the pass
+// reads the transcript itself and not the payload it came from.
+const AGENT_EXCHANGE_ROW_KEY = '__agentExchangeRow';
+// The user's toggle of a folded prompt, by its id: true opened, false
+// closed, unset none (agentExchangeFoldOpen: open while it works, else
+// folded). Kept through any re-render.
+const agentExchangeFoldChoices = new Map();
+// Each folded prompt's status, by its id, as of the last pass.
+let agentExchangeStatusByPromptId = new Map();
+
+function setAgentExchangeRow(div, msg, msgId) {
+  div[AGENT_EXCHANGE_ROW_KEY] = agentExchangeRowOf(msg, { id: msgId || msg?.id || '' });
+}
+
+// The rows the plan reads, in order, and the node of each. The live bubble
+// is the running turn's row; cards and boards without a reply are not rows.
+function agentExchangeTranscriptRows(el) {
+  const rows = [];
+  const nodes = new Map();
+  for (const node of el.children) {
+    if (!node.classList?.contains('msg')) continue;
+    let row = null;
+    if (node.id === 'thinking-indicator') {
+      const id = String(node.dataset.messageId || '').trim();
+      if (id) row = { id, role: 'assistant', live: true };
+    } else if (node[AGENT_EXCHANGE_ROW_KEY]) {
+      row = { ...node[AGENT_EXCHANGE_ROW_KEY], steered: node.classList.contains(STEERED_MSG_CLASS) };
+    }
+    if (!row) continue;
+    rows.push(row);
+    nodes.set(row, node);
+  }
+  return { rows, nodes };
+}
+
+/**
+ * Fold the transcript's agent prompts. One idempotent pass, run after every
+ * render and update of the list like the separator and merge passes. The
+ * folded row lives in the prompt's own node, as its first child, so no
+ * insertion path has to place it; closed, a class hides the prompt's bubble.
+ * The replies and the live bubble are read for the row's status and are
+ * otherwise left alone.
+ */
+function syncAgentExchangeFolds(el = getMessagesElement()) {
+  if (!el) return;
+  const { rows, nodes } = agentExchangeTranscriptRows(el);
+  const plan = planAgentExchangeFolds(rows, {
+    runningIds: [getActiveTurnForConversation(currentConvId)?.messageId],
+  });
+  const states = new Map();
+  const statusByPromptId = new Map();
+  for (const group of plan) {
+    if (!group.fold) continue;
+    const open = agentExchangeFoldOpen(group.status, agentExchangeFoldChoices.get(group.promptId));
+    states.set(nodes.get(group.prompt), { group, open });
+    statusByPromptId.set(group.promptId, group.status);
+  }
+  agentExchangeStatusByPromptId = statusByPromptId;
+  for (const node of el.children) {
+    if (node.classList?.contains('msg')) applyAgentExchangeState(node, states.get(node) || null);
+  }
+}
+
+// For the paths that change the list outside a render: the live bubble
+// coming and going. A bulk render runs the pass once at its end.
+export function syncAgentExchangeFoldsNow() {
+  if (separatorSyncSuspended > 0) return;
+  syncAgentExchangeFolds();
+}
+
+function applyAgentExchangeState(node, state) {
+  node.classList.toggle(AGENT_EXCHANGE_HEAD_CLASS, !!state);
+  node.classList.toggle(AGENT_EXCHANGE_CLOSED_CLASS, !!state && !state.open);
+  const existing = node.querySelector(':scope > .agent-exchange-row');
+  if (!state) {
+    existing?.remove();
+    return;
+  }
+  const { group, open } = state;
+  const summary = agentExchangeSummary(group.prompt.origin, group.status, { conversations });
+  const timeText = fmtDate(node.dataset.messageTimestamp);
+  const key = JSON.stringify([summary.text, timeText]);
+  let row = existing;
+  if (!row || row.dataset.summaryKey !== key) {
+    const holder = document.createElement('div');
+    holder.innerHTML = renderAgentExchangeRowHtml(summary, { escHtml, timeText, open });
+    const fresh = holder.firstElementChild;
+    fresh.dataset.summaryKey = key;
+    fresh.dataset.promptId = group.promptId;
+    fresh.addEventListener('toggle', () => onAgentExchangeToggle(fresh));
+    if (row) row.replaceWith(fresh);
+    else node.insertBefore(fresh, node.firstChild);
+    row = fresh;
+  }
+  if (row.open !== open) row.open = open;
+}
+
+function onAgentExchangeToggle(row) {
+  const promptId = String(row.dataset.promptId || '').trim();
+  // The pass setting `open` fires this too, and a row it has since replaced
+  // (its status changed) fires it late; only the user's toggle is news.
+  if (!promptId || !row.isConnected) return;
+  const shown = agentExchangeFoldOpen(agentExchangeStatusByPromptId.get(promptId), agentExchangeFoldChoices.get(promptId));
+  if (shown === row.open) return;
+  agentExchangeFoldChoices.set(promptId, row.open);
+  syncAgentExchangeFolds();
+}
+
+// A search result, a pin or a jump to a folded prompt opens it first, so
+// the message jumped to is the one on screen.
+function revealAgentExchangeMessage(messageId) {
+  const promptId = String(messageId || '').trim();
+  if (!agentExchangeStatusByPromptId.has(promptId) || agentExchangeFoldChoices.get(promptId) === true) return;
+  agentExchangeFoldChoices.set(promptId, true);
+  syncAgentExchangeFolds();
+}
+
 function createMessageNode(msg, msgId = null, force = false) {
   const el = getMessagesElement();
   if (!el) return null;
@@ -1237,6 +1417,10 @@ function createMessageNode(msg, msgId = null, force = false) {
     seenMessageIds.add(msgId);
   }
 
+  // An event message the relay wrote into a watcher's conversation: a
+  // compact, foldable row, never a bubble of the user's.
+  if (isRelayEventMessage(msg)) return createRelayEventNode(msg, msgId);
+
   // A prompt another relay's agent sent carries `origin`: its header line is
   // hidden (the badge below says the same), and a stray remote-relay mention
   // hint never shows on any user bubble.
@@ -1258,6 +1442,7 @@ function createMessageNode(msg, msgId = null, force = false) {
   div.dataset.messageTextFingerprint = fingerprint.text || '';
   div.dataset.messageTimestamp = String(msg?.timestamp || '').trim();
   if (fingerprint.sourceMessageId) div.dataset.sourceMessageId = fingerprint.sourceMessageId;
+  setAgentExchangeRow(div, msg, msgId);
 
   const label = msg.role === 'user' ? 'You' : '';
   const { baseModelId, reasoningEffort } = splitVariantId(msg.model);
@@ -1305,10 +1490,11 @@ function createMessageNode(msg, msgId = null, force = false) {
   // (e.g. the Copilot relay answering a Cursor conversation) must be visible,
   // not silent: it ran on another plan than the header indicates.
   const executedProvider = String(msg?.executedProvider || '').trim().toLowerCase();
-  const boundProvider = String(conversations[currentConvId]?.runtimeProviderType || 'github').trim().toLowerCase();
+  const boundProvider = String(conversations[currentConvId]?.runtimeProviderType || '').trim().toLowerCase();
   // 'unknown' means the responder identity did not resolve, not that another
-  // provider ran the turn — no chip for it.
-  const crossProviderTag = (msg.role === 'assistant' && executedProvider && executedProvider !== 'unknown' && executedProvider !== boundProvider)
+  // provider ran the turn — no chip for it. Nor without a bound provider to
+  // compare with (a shared view of a conversation that has none).
+  const crossProviderTag = (msg.role === 'assistant' && executedProvider && executedProvider !== 'unknown' && boundProvider && executedProvider !== boundProvider)
     ? ` <span class="msg-provider-mismatch" title="This turn was executed by the ${escHtml(executedProvider)} provider, not the conversation's ${escHtml(boundProvider)} provider.">ran on ${escHtml(executedProvider)}</span>`
     : '';
   const usage = (msg.role === 'assistant' && msg?.usage && typeof msg.usage === 'object') ? msg.usage : null;
@@ -1361,7 +1547,14 @@ function createMessageNode(msg, msgId = null, force = false) {
   const mainThoughts = thoughts.filter((t) => !t?.subagentRunId);
   const activityHtml = mainActivities.length ? renderActivityMarkup(mainActivities, promotedBoundaryEntry) : '';
   const thoughtsHtml = mainThoughts.length ? renderThoughtsMarkup(mainThoughts) : '';
-  const subagentHtml = renderSubagentRunsMarkup(subagentRuns, activities, thoughts);
+  // One row per sub-agent the turn spawned, as in the composer's task panel;
+  // its title opens the agent's whole record. The store's copy wins: status
+  // events keep it current after the bubble was built.
+  rememberSubagentRuns(subagentRuns);
+  const subagentHtml = subagentRowsMarkup(
+    subagentRuns.map((run) => mergeLiveSubagentRun(run, getSubagentRun(run.subagentRunId))),
+    { clickable: true },
+  );
   // Finished background workflows persisted with this assistant message
   // (docs/plans/workflow-progress-tree.md, Phase 4). The template only
   // reserves a placeholder; the cards are DOM-built below so digest text
@@ -1389,7 +1582,9 @@ function createMessageNode(msg, msgId = null, force = false) {
     && cancellableSteerIdsForConversation(currentConvId).has(msgId);
   const showsCancelButton = isQueuedUserMessage || isCancellableSteer;
   const isCancelInFlight = showsCancelButton && bubbleCancelInFlight.has(msgId);
-  const hiddenFromShares = msg?.hiddenFromShares === true;
+  // The conversation's hidden list once it is known (a change on another
+  // device arrives there), else the message's own mark.
+  const hiddenFromShares = isMessageHiddenFromShares(currentConvId, msgId) ?? (msg?.hiddenFromShares === true);
   const activeTurnMessageId = String(getActiveTurnForConversation(currentConvId)?.messageId || '').trim();
   const sourceMessageId = String(msg?.sourceMessageId || '').trim();
   const belongsToActiveTurn = !!activeTurnMessageId
@@ -1402,8 +1597,8 @@ function createMessageNode(msg, msgId = null, force = false) {
   const shareVisibilityActionHtml = canToggleShareVisibility
     ? `<div class="msg-share-visibility">
         ${buildMessagePinControlsHtml(msgId, pinned)}
-        ${hiddenFromShares ? '<span class="msg-hidden-label">Hidden from shared viewers</span>' : ''}
-        <button type="button" class="msg-share-visibility-btn" data-action="toggle-share-visibility" data-message-id="${escHtml(msgId)}" data-hidden-from-shares="${hiddenFromShares ? 'true' : 'false'}" title="${hiddenFromShares ? 'Shows this message in shared conversations' : 'Hides this message from shared conversations'}">${hiddenFromShares ? 'Unhide' : 'Hide'}</button>
+        ${hiddenFromShares ? HIDDEN_LABEL_HTML : ''}
+        <button type="button" class="msg-share-visibility-btn" data-action="toggle-share-visibility" data-message-id="${escHtml(msgId)}" data-hidden-from-shares="${hiddenFromShares ? 'true' : 'false'}" title="${shareVisibilityButtonTitle(hiddenFromShares)}">${hiddenFromShares ? 'Unhide' : 'Hide'}</button>
       </div>`
     : '';
   // A terminal failure whose fix lives in the relay UI gets the fix as a button
@@ -1440,6 +1635,8 @@ function createMessageNode(msg, msgId = null, force = false) {
     <div class="msg-label">${label}${modelTag}${reasoningTag}${modeTag}${autoTag}${continuationTag}${crossProviderTag}${usageTurnTag}${usageRemainingTag}${usageStaleTag} · ${fmtDate(msg.timestamp)}</div>`;
 
   const bubble = div.querySelector('.msg-bubble');
+  // A running sub-agent's row keeps its clock going once the bubble is placed.
+  if (subagentHtml.includes('data-started-at')) setTimeout(syncSubagentRowClock, 0);
   rewriteLocalAssetUrlsInNode(bubble, { preferDrive: msg.role === 'assistant' });
   linkifyWorkspaceMentionsInNode(bubble);
   // One collapsed "Finished background task" card per persisted run, sharing
@@ -1536,21 +1733,12 @@ function prependMessageNodes(msgs) {
   return { inserted, firstMessageId };
 }
 
+// A shared view's tool lines arrive filtered by the relay's path privacy
+// setting (server/services/share-path-redaction.mjs); they are shown as sent.
 export function decorateActivityText(text) {
   const value = String(text || '').trim();
   if (!value) return '';
-  const maskSharedPathSegments = (input) => {
-    const source = String(input || '');
-    const tokenMasked = source.replace(/@(file|folder):([^\s`]+)/gi, (_m, kind, rawPath) => {
-      const normalized = String(rawPath || '').replace(/\\/g, '/').replace(/\/+$/, '');
-      const segments = normalized.split('/').filter(Boolean);
-      const basename = segments[segments.length - 1] || normalized;
-      return `@${String(kind || '').toLowerCase()}:${basename}`;
-    });
-    return tokenMasked.replace(/([A-Za-z]:)?(?:[\\/~.]?[\\/])(?:[^\\/\s]+[\\/])+([^\\/\s]+)/g, (_m, _prefix, basename) => basename);
-  };
-  const sharedSafeValue = IS_SHARED_VIEW ? maskSharedPathSegments(value) : value;
-  return prefixToolActivityEmoji(sharedSafeValue);
+  return prefixToolActivityEmoji(value);
 }
 
 export function renderThoughtsMarkup(thoughts) {
@@ -1648,83 +1836,6 @@ export function renderActivityMarkup(activities, promotedBoundaryEntry = undefin
   return `${progressHtml}${toolsHtml}`;
 }
 
-// Persisted nested subagent sections: groups a finished message's activities
-// and thoughts by subagentRunId and renders one collapsible block per run,
-// nested by parentSubagentId — mirroring the live sub-bubbles.
-export function renderSubagentRunsMarkup(subagentRuns, activities, thoughts) {
-  const activityByRun = new Map();
-  for (const item of (Array.isArray(activities) ? activities : [])) {
-    const entry = normalizeRelayActivityEntry(item);
-    if (!entry?.subagentRunId) continue;
-    const list = activityByRun.get(entry.subagentRunId) || [];
-    list.push(entry.text);
-    activityByRun.set(entry.subagentRunId, list);
-  }
-  const thoughtsByRun = new Map();
-  for (const thought of (Array.isArray(thoughts) ? thoughts : [])) {
-    const runId = thought?.subagentRunId ? String(thought.subagentRunId).trim() : '';
-    const text = String(thought?.text || '').trim();
-    if (!runId || !text) continue;
-    const list = thoughtsByRun.get(runId) || [];
-    list.push({ reasoningId: String(thought?.reasoningId || '').trim(), text });
-    thoughtsByRun.set(runId, list);
-  }
-  const runsById = new Map();
-  for (const run of (Array.isArray(subagentRuns) ? subagentRuns : [])) {
-    const runId = String(run?.subagentRunId || '').trim();
-    if (!runId) continue;
-    runsById.set(runId, {
-      subagentRunId: runId,
-      parentSubagentId: run?.parentSubagentId ? String(run.parentSubagentId).trim() : null,
-      displayName: String(run?.displayName || '').trim() || `Subagent ${runId.slice(0, 8)}`,
-      status: String(run?.status || 'completed').trim().toLowerCase(),
-    });
-  }
-  // Items may reference runs whose metadata rows are unavailable; synthesize.
-  for (const runId of new Set([...activityByRun.keys(), ...thoughtsByRun.keys()])) {
-    if (!runsById.has(runId)) {
-      runsById.set(runId, {
-        subagentRunId: runId,
-        parentSubagentId: null,
-        displayName: `Subagent ${runId.slice(0, 8)}`,
-        status: 'completed',
-      });
-    }
-  }
-  if (!runsById.size) return '';
-  const childrenByParent = new Map();
-  const roots = [];
-  for (const run of runsById.values()) {
-    const parentId = run.parentSubagentId && runsById.has(run.parentSubagentId) ? run.parentSubagentId : null;
-    if (parentId) {
-      const children = childrenByParent.get(parentId) || [];
-      children.push(run);
-      childrenByParent.set(parentId, children);
-    } else {
-      roots.push(run);
-    }
-  }
-  const renderRun = (run) => {
-    const runActivities = activityByRun.get(run.subagentRunId) || [];
-    const runThoughts = thoughtsByRun.get(run.subagentRunId) || [];
-    const children = childrenByParent.get(run.subagentRunId) || [];
-    const thoughtsBlock = runThoughts.length
-      ? `<details class="msg-thoughts msg-subagent-thoughts"><summary>💭 Thoughts (${runThoughts.length})</summary><div class="msg-thoughts-list">${runThoughts.map((thought) => `<div class="msg-thought-item"${thought.reasoningId ? ` data-reasoning-id="${escHtml(thought.reasoningId)}"` : ''}>${renderMarkdownPreview(thought.text, false)}</div>`).join('')}</div></details>`
-      : '';
-    const activitiesBlock = runActivities.length
-      ? `<div class="msg-activity-list">${runActivities.map((text) => `<div class="msg-activity-item">${escHtml(decorateActivityText(text))}</div>`).join('')}</div>`
-      : '';
-    const childrenBlock = children.map(renderRun).join('');
-    const statusLabel = run.status && run.status !== 'completed' ? ` · ${escHtml(run.status)}` : '';
-    return `
-      <details class="msg-activity msg-subagent-run" data-subagent-run-id="${escHtml(run.subagentRunId)}">
-        <summary>🤖 ${escHtml(run.displayName)}${statusLabel}${runActivities.length ? ` (${runActivities.length})` : ''}</summary>
-        ${thoughtsBlock}${activitiesBlock}${childrenBlock}
-      </details>`;
-  };
-  return roots.map(renderRun).join('');
-}
-
 // Places the live bubble directly under its owning user message, or leaves a
 // bubble already in the transcript where it is when that row is not rendered.
 // Idempotent so the reuse path can call it every tick: a bubble built before
@@ -1745,6 +1856,8 @@ function anchorThinkingBubble(div, messageId) {
     if (next) el.insertBefore(div, next);
     else el.appendChild(div);
     if (div.dataset.compactBoundary) syncSeparatorsNow();
+    // A folded agent prompt's row says the turn is working.
+    else syncAgentExchangeFoldsNow();
   } else if (div.parentNode !== el) {
     el.appendChild(div);
   }
@@ -1820,6 +1933,7 @@ export function showThinking(messageId = null, autoScroll = true) {
 export function removeThinking() {
   thinkingMessageId = null;
   lastInFlightSnapshotKey = '';
+  const hadBubble = !!document.getElementById('thinking-indicator');
   const wasCompacting = !!document.getElementById('thinking-indicator')?.dataset?.compactBoundary;
   unobserveThinkingBubble();
   document.getElementById('thinking-indicator')?.remove();
@@ -1827,6 +1941,45 @@ export function removeThinking() {
   // caller's same-tick work: a reply appended right after this call takes
   // the line over (relabelled in place) instead of it being dropped first.
   if (wasCompacting) queueMicrotask(syncSeparatorsNow);
+  // A turn that ended without a reply (cancelled) stops saying "working".
+  if (hadBubble) syncAgentExchangeFoldsNow();
+}
+
+// The turn ends under a reader who is not at the end: the live bubble is
+// taken off the page and the reply row is put in its place. The page is
+// shorter for a moment (scrollTop can be clamped), and the reply is not as
+// tall as the bubble was (its thoughts are folded). Whatever the reader looks
+// at stays where it is: the block of text at the top of the viewport is noted
+// before the swap and put back after it. Read in the bubble's stream, it is
+// found again in the reply; in a row above or below the bubble, in that row.
+export function captureLiveReplyReadingPosition() {
+  const el = getMessagesElement();
+  if (!el) return null;
+  const bubble = document.getElementById('thinking-indicator');
+  return {
+    scrollTop: el.scrollTop,
+    block: captureReadingBlock(el),
+    // Below the bubble the pixel position is the wrong fallback: everything
+    // the reader sees moves up or down with the swap, and scrollTop with it.
+    belowBubble: !!bubble && bubble.getBoundingClientRect().bottom <= el.getBoundingClientRect().top,
+  };
+}
+
+export function restoreLiveReplyReadingPosition(position) {
+  const el = getMessagesElement();
+  if (!el || !position || isChatInteractionHeld()) return;
+  if (restoreReadingBlock(el, position.block)) return;
+  if (!position.belowBubble) el.scrollTop = position.scrollTop;
+}
+
+// A rebuild of the transcript on the page that nobody asked to scroll: the
+// reader keeps the text they are at, or failing that the pixel position.
+function renderMessagesInPlace(msgs, meta) {
+  const el = getMessagesElement();
+  const reading = el ? { scrollTop: el.scrollTop, block: captureReadingBlock(el) } : null;
+  const rendered = renderMessages(msgs, false, meta);
+  if (el && reading && rendered && !restoreReadingBlock(el, reading.block)) el.scrollTop = reading.scrollTop;
+  return rendered;
 }
 
 // The live turn's compaction line: the bubble stamps the turn's compaction
@@ -2045,6 +2198,9 @@ export function restoreInFlightThinking(inFlight, autoScroll = true) {
     return;
   }
   lastInFlightSnapshotKey = snapshotKey;
+  // The snapshot may have been read before the newest live frame was stored.
+  const liveStreamSeq = relayStreamStateByMessageId.get(messageId)?.seq || 0;
+  const liveStreamText = relayStreamTextByMessageId.get(messageId);
   clearRelayStreamState();
   setConversationTurnState(currentConvId, { messageId, status: 'processing' });
   const activities = mergeRelayActivityTexts(
@@ -2086,14 +2242,19 @@ export function restoreInFlightThinking(inFlight, autoScroll = true) {
   // Seed the per-thread stream text before the bubbles are built so both the
   // reply preview and each subagent bubble repaint on reload.
   const streamTextByThread = deriveInFlightStreamTextByThread(inFlight);
-  if (streamTextByThread.main) {
+  if (streamTextByThread.main && streamTextByThread.main.seq >= liveStreamSeq) {
     relayStreamTextByMessageId.set(messageId, streamTextByThread.main.text);
+  } else if (liveStreamText !== undefined) {
+    relayStreamTextByMessageId.set(messageId, liveStreamText);
   }
   for (const [runId, entry] of streamTextByThread.bySubagentRunId) {
     upsertSubagentRun({ subagentRunId: runId, messageId, conversationId: currentConvId });
     setSubagentStreamText(runId, entry.text);
   }
   showThinking(messageId, autoScroll);
+  // relay_stream frames are volatile, so a dropped one reaches the bubble only
+  // from here; showThinking does not repaint a bubble it reuses.
+  renderThinkingStream();
   renderThinkingActivities();
   renderThinkingThoughts();
   renderRestoredSubagentBubbles(messageId);
@@ -2578,16 +2739,23 @@ export function applyRelayStreamEvent({
   if (id !== thinkingMessageId) return true;
   if (runId) renderSubagentStream(runId, text);
   else renderThinkingStream();
+  // Again once the text is in: it grew below the end the status scrolled to.
+  if (autoScroll && !getThinkingFollowMode()) scrollBottom();
   return true;
 }
 
 export function flushDeferredMessageRender() {
   if (!deferredMessageRender) return;
-  const { msgs, scroll, meta } = deferredMessageRender;
+  const { msgs, meta } = deferredMessageRender;
   deferredMessageRender = null;
   const deferredConversationId = String(meta?.conversationId || '').trim();
   if (deferredConversationId && deferredConversationId !== String(currentConvId || '').trim()) return;
-  renderMessages(msgs, scroll, meta);
+  // Whoever asked for this render has long returned, and with it whatever
+  // would have put the reader back; and where the reader was when it was
+  // held back is not where they are now. Decided as it runs: at the end it
+  // follows, anywhere else it leaves them at the text they read.
+  if (followsTranscriptEnd()) renderMessages(msgs, true, meta);
+  else renderMessagesInPlace(msgs, meta);
 }
 
 // Blacklists the id from further live relay_stream frames. Kept separate from
@@ -2905,10 +3073,13 @@ export function replaceRenderedMessage(msg, msgId) {
   seenMessageIds.delete(id);
   const fresh = createMessageNode(msg, id, true);
   placeholder.replaceWith(fresh || existing);
+  // The rebuilt row takes its merge and fold classes back.
+  if (fresh) syncSeparatorsNow();
   return Boolean(fresh);
 }
 
 async function resendStoppedSteer(conversationId, markerId) {
+  const send = beginOwnSend();
   const conversationKey = String(conversationId || '').trim();
   const id = String(markerId || '').trim();
   if (!conversationKey || !id || stoppedSteerResends.has(id)) return;
@@ -2960,7 +3131,7 @@ async function resendStoppedSteer(conversationId, markerId) {
         mode: selectedMode,
         timestamp: new Date().toISOString(),
         attachments,
-      }, true, clientMessageId, true);
+      }, ownSendFollows(send), clientMessageId, true);
       bubbleAppended = true;
     }
     const r = await sendMessageApi({
@@ -3004,7 +3175,7 @@ async function resendStoppedSteer(conversationId, markerId) {
       showTransientRelayNotice(`Resent without ${dropped} attachment${dropped === 1 ? '' : 's'} that ${dropped === 1 ? 'is' : 'are'} no longer available.`, 7000);
     }
     if (cliOnline && isCurrentConversation(conversationKey) && !getActiveTurnForConversation(conversationKey)?.messageId) {
-      showThinking(r.messageId || null);
+      showThinking(r.messageId || null, ownSendFollows(send));
     }
   } catch (error) {
     if (!hasSendEchoArrived(clientMessageId)) {
@@ -3173,6 +3344,35 @@ export function syncRenderedPinState(pinnedIds) {
   }
 }
 
+const HIDDEN_LABEL_HTML = '<span class="msg-hidden-label">Hidden from shared viewers</span>';
+
+function shareVisibilityButtonTitle(hidden) {
+  return hidden ? 'Shows this message in shared conversations' : 'Hides this message from shared conversations';
+}
+
+// The hidden list changed (this page, another device): bring the bubbles on
+// the page in line without rebuilding them. A button whose own round trip is
+// still out keeps its "Hiding…" until the answer.
+export function syncRenderedShareVisibility(hiddenIds) {
+  const el = getMessagesElement();
+  if (!el) return;
+  const ids = hiddenIds instanceof Set ? hiddenIds : new Set(hiddenIds || []);
+  for (const button of el.querySelectorAll('.msg-share-visibility-btn')) {
+    const messageId = String(button.dataset.messageId || '').trim();
+    if (shareVisibilityInFlight.has(messageId)) continue;
+    const hidden = ids.has(messageId);
+    if ((button.dataset.hiddenFromShares === 'true') === hidden) continue;
+    button.dataset.hiddenFromShares = hidden ? 'true' : 'false';
+    button.disabled = false;
+    button.textContent = hidden ? 'Unhide' : 'Hide';
+    button.title = shareVisibilityButtonTitle(hidden);
+    const sibling = button.previousElementSibling;
+    const label = sibling?.classList?.contains('msg-hidden-label') ? sibling : null;
+    if (hidden && !label) button.insertAdjacentHTML('beforebegin', HIDDEN_LABEL_HTML);
+    if (!hidden && label) label.remove();
+  }
+}
+
 async function toggleMessageShareVisibility(conversationId, messageId, hiddenFromShares) {
   const conversationKey = String(conversationId || '').trim();
   const targetMessageId = String(messageId || '').trim();
@@ -3191,13 +3391,17 @@ async function toggleMessageShareVisibility(conversationId, messageId, hiddenFro
       button.disabled = false;
       button.textContent = hiddenFromShares ? 'Unhide' : 'Hide';
     }
-    showTransientRelayNotice('Could not update shared-message visibility.');
+    showTransientRelayNotice(String(result?.error || '').trim() || 'Could not update shared-message visibility.');
     return;
   }
 
   showTransientRelayNotice(result.hiddenFromShares
     ? 'Message hidden from shared viewers.'
     : 'Message visible to shared viewers.');
+  // Stored under its own conversation: the 🙈 count, even after a switch.
+  if ('hiddenMessages' in result) {
+    setConversationHiddenMessages(conversationKey, result.hiddenMessages, result.hiddenMessagesRevision);
+  }
   // The reload below only refreshes the open view; if the user switched
   // conversations while the toggle round trip was in flight, rendering it
   // would replace the new conversation's messages with this one's.
@@ -3207,7 +3411,7 @@ async function toggleMessageShareVisibility(conversationId, messageId, hiddenFro
   });
   if (String(currentConvId || '').trim() !== conversationKey) return;
   if (response?.messages) {
-    renderMessages(response.messages, false, response);
+    renderMessagesInPlace(response.messages, response);
   }
 }
 
@@ -3376,6 +3580,14 @@ export function appendMessage(msg, scroll = true, msgId = null, force = false, i
   if (empty) empty.remove();
   const node = createMessageNode(msg, msgId, force);
   const isNewNode = !!node && !node.parentNode;
+  // A reply the socket delivers without its prompt's id in the message (a
+  // failed turn's note) is placed under that prompt, and an agent prompt's
+  // row reads its status from it.
+  const exchangeRow = isNewNode ? node[AGENT_EXCHANGE_ROW_KEY] : null;
+  const anchorId = String(insertAfterId || '').trim();
+  if (exchangeRow?.role === 'assistant' && !exchangeRow.sourceMessageId && anchorId && anchorId !== String(msgId || '').trim()) {
+    exchangeRow.sourceMessageId = anchorId;
+  }
   // Insert without scrolling: the separator pass below can add a row above
   // this message, and scrolling before it runs leaves the viewport a
   // separator-height short of the bottom (which then reads as "not at
@@ -3491,6 +3703,91 @@ export function noteTranscriptJump() {
   transcriptJumpEpoch += 1;
 }
 
+// Counts rows the socket put on the page: another client's message, a reply,
+// a row rewritten in place. A reload whose request was on its way when one
+// landed may not have it, and its rebuild would take it off the page again
+// (transcript-reload-freshness.mjs).
+let transcriptLiveRowEpoch = 0;
+
+export function getTranscriptLiveRowEpoch() {
+  return transcriptLiveRowEpoch;
+}
+
+export function noteTranscriptLiveRow() {
+  transcriptLiveRowEpoch += 1;
+}
+
+function liveConversationCount() {
+  return Object.values(conversations || {}).filter((conversation) => conversation && conversation.archived !== true).length;
+}
+
+function runEmptyStateAction(action) {
+  switch (String(action || '').trim()) {
+    case 'open-settings':
+      openSettingsModal('providers');
+      return;
+    case 'new-chat':
+      void window.newConversation?.();
+      return;
+    case 'show-conversations':
+      toggleSidebar(true);
+      return;
+    default:
+  }
+}
+
+function buildEmptyStateNode(model) {
+  const node = document.createElement('div');
+  node.className = 'empty-state';
+  node.dataset.variant = model.variant;
+  const actions = model.actions.map((action) => {
+    const classes = ['empty-state-btn'];
+    if (action.primary) classes.push('empty-state-btn-accent');
+    if (action.link) classes.push('empty-state-link');
+    return `<button type="button" id="${escHtml(action.id)}" class="${classes.join(' ')}" data-empty-action="${escHtml(action.action)}">${escHtml(action.label)}</button>`;
+  }).join('');
+  node.innerHTML = `
+    <div class="icon">${escHtml(model.icon)}</div>
+    <h3>${escHtml(model.heading)}</h3>
+    <p>${escHtml(model.text)}</p>
+    <div class="empty-state-actions">${actions}</div>`;
+  for (const button of node.querySelectorAll('[data-empty-action]')) {
+    button.addEventListener('click', (event) => {
+      event.preventDefault();
+      runEmptyStateAction(button.dataset.emptyAction);
+    });
+  }
+  return node;
+}
+
+/**
+ * Draws the "no conversation open" screen into the transcript, or redraws it
+ * when readiness or the conversation list changed. A no-op with a
+ * conversation open, in the shared view, or while the status view owns the
+ * transcript. Idempotent: the same model leaves the node alone.
+ */
+export function renderNoConversationState() {
+  if (IS_SHARED_VIEW) return false;
+  if (String(currentConvId || '').trim()) return false;
+  const el = getMessagesElement();
+  if (!el || el.querySelector('.status-view')) return false;
+  const existing = el.querySelector('.empty-state');
+  // A transcript with rows in it belongs to something else (a render in flight).
+  if (!existing && el.children.length) return false;
+  const model = resolveNoConversationState({
+    readiness: getProviderReadiness(),
+    conversationCount: liveConversationCount(),
+    mobile: isMobileComposerViewport(),
+  });
+  const key = JSON.stringify(model);
+  if (existing && existing.dataset.emptyStateKey === key) return true;
+  const node = buildEmptyStateNode(model);
+  node.dataset.emptyStateKey = key;
+  if (existing) existing.replaceWith(node);
+  else el.appendChild(node);
+  return true;
+}
+
 export function renderMessages(msgs, scroll = true, meta = {}) {
   const el = getMessagesElement();
   if (!el) return false;
@@ -3571,11 +3868,17 @@ export function renderMessages(msgs, scroll = true, meta = {}) {
     && thinkingNode.dataset.conversationId === renderConversationKey) ? thinkingNode : null;
   if (thinkingNodeInTranscript && !preservedThinkingNode) removeThinking();
   if (!ordered.length && !preservedPendingNodes.length && !preservedThinkingNode) {
-    el.innerHTML = `<div class="empty-state">
-      <div class="icon">${currentConvId ? '💬' : '🚀'}</div>
-      <h3>${currentConvId ? 'No messages yet' : 'New Conversation'}</h3>
-      <p>${currentConvId ? 'Start the conversation below' : 'Type your first message below'}</p>
-    </div>`;
+    if (!currentConvId && !IS_SHARED_VIEW) {
+      // Nothing open: the screen says what can be done here (no-conversation-state.mjs).
+      el.innerHTML = '';
+      renderNoConversationState();
+    } else {
+      el.innerHTML = `<div class="empty-state">
+        <div class="icon">${currentConvId ? '💬' : '🚀'}</div>
+        <h3>${currentConvId ? 'No messages yet' : 'New Conversation'}</h3>
+        <p>${currentConvId ? 'Start the conversation below' : 'Type your first message below'}</p>
+      </div>`;
+    }
     resetConversationHistoryState();
     renderRelayQuestions();
     renderRelayBoards();
@@ -3680,6 +3983,8 @@ export function focusConversationMessageById(messageId, { behavior = 'smooth', b
   if (!id) return false;
   const el = getMessagesElement();
   if (!el) return false;
+  // A folded agent prompt is opened before it is scrolled to.
+  revealAgentExchangeMessage(id);
   const target = el.querySelector(`.msg[data-message-id="${CSS.escape(id)}"]`);
   if (!target) return false;
   target.scrollIntoView({ behavior, block, inline: 'nearest' });
@@ -3721,6 +4026,9 @@ export function compactCurrentConversation() {
 let unknownCommandWarned = null;
 
 export async function sendMessage() {
+  // The reader's own send, as of now: what follows it scrolls to the end
+  // only while they have not scrolled since.
+  const send = beginOwnSend();
   const input = document.getElementById('msg-input');
   const originalComposerText = String(input?.value || '');
   const text = originalComposerText.trim();
@@ -3733,6 +4041,13 @@ export async function sendMessage() {
     return;
   }
   if (!hasDraft) return;
+  // No conversation open and no provider ready: a send would create a
+  // Copilot chat that cannot run. The composer is locked in this state; this
+  // guard covers a programmatic send, before any upload starts.
+  if (!String(currentConvId || '').trim() && isProviderSetupRequired()) {
+    showTransientRelayNotice('Set up a provider in Settings → Providers before starting a chat.', 6000);
+    return;
+  }
   closeSlashAutocomplete();
   closeMentionAutocomplete();
 
@@ -3754,7 +4069,7 @@ export async function sendMessage() {
     releaseComposerFocusAfterSend(input);
     void flushConversationDraft(currentConvId);
     compactCurrentConversation();
-    scrollBottomAfterSend();
+    scrollAfterOwnSend(send);
     return;
   }
 
@@ -3831,8 +4146,10 @@ export async function sendMessage() {
       input.value = '';
       autoResize(input);
       releaseComposerFocusAfterSend(input);
-      appendMessage({ role: 'user', text, model: selectedModel, mode: selectedMode, timestamp: msgTimestamp, attachments }, true, clientMessageId, true);
-      scrollBottomAfterSend();
+      // Asked before the bubble is on the page.
+      const follow = ownSendFollows(send);
+      appendMessage({ role: 'user', text, model: selectedModel, mode: selectedMode, timestamp: msgTimestamp, attachments }, follow, clientMessageId, true);
+      scrollAfterOwnSend(send);
     }
 
     const body = {
@@ -3920,7 +4237,8 @@ export async function sendMessage() {
         await window.openConversation?.(r.compactedConversationId);
         removeComposerAttachments(draftAttachments);
         if (!mobileSend) input.focus();
-        scrollBottomAfterSend();
+        // The send goes on in the conversation the compaction opened.
+        scrollAfterOwnSend({ ...send, conversationId: String(r.compactedConversationId || '').trim() });
       }
       return;
     }
@@ -3941,6 +4259,7 @@ export async function sendMessage() {
       if (adoptNewConversation) {
         setCurrentConv(r.conversationId);
         composerConversationId = r.conversationId;
+        nameOwnSendConversation(send, r.conversationId);
       }
       conversations[r.conversationId] = {
         id: r.conversationId,
@@ -3987,7 +4306,7 @@ export async function sendMessage() {
     // pinned to the newest message. Re-pin now rather than after the draft
     // save's round trip below, or the new bubble sits under the composer
     // for as long as that request takes.
-    if (viewingSendConversation()) scrollBottom();
+    if (viewingSendConversation() && ownSendFollows(send)) scrollBottom();
     const persistedConversationId = String(r.conversationId || targetConversationId || '').trim();
     if (persistedConversationId) {
       restorableDraftByConversation.delete(persistedConversationId);
@@ -4019,7 +4338,7 @@ export async function sendMessage() {
       // A turn already running here owns the live bubble; adopting the
       // just-queued id would re-anchor it under the newest user message.
       const activeTurn = getActiveTurnForConversation(composerConversationId);
-      if (!activeTurn?.messageId) showThinking(r.messageId || null);
+      if (!activeTurn?.messageId) showThinking(r.messageId || null, ownSendFollows(send));
     }
 
     // Only what this message took leaves the composer: attachments added (or
@@ -4028,7 +4347,7 @@ export async function sendMessage() {
     if (viewingSendConversation()) {
       removeComposerAttachments(draftAttachments);
       if (!mobileSend) input.focus();
-      scrollBottomAfterSend();
+      scrollAfterOwnSend(send);
     }
   } catch (e) {
     const sendLanded = hasSendEchoArrived(clientMessageId);