@oar-sh/oar 0.9.10 → 0.9.12

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

@@ -23,7 +23,6 @@ import {
   updateWorkspaceRootHints,
   applyContextUsageBar,
   scrollBottom,
-  scrollBottomAfterSend,
   isMobileComposerViewport,
   releaseComposerFocusAfterSend,
   autoResize,
@@ -47,10 +46,9 @@ import {
   getSessionWorkerState,
   openSummaryModal,
   closeSummaryModal,
-  parseTimestampMs,
-  relayQuestions,
-  relayBoards,
   toggleSidebar,
+  hasPendingUserMessageForConversation,
+  isMessagesNearBottom,
 } 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';
@@ -62,6 +60,7 @@ 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';
@@ -71,7 +70,6 @@ import { isRelayEventMessage, renderRelayEventRowHtml } from './relay-event-view
 import {
   AGENT_EXCHANGE_CLOSED_CLASS,
   AGENT_EXCHANGE_HEAD_CLASS,
-  AGENT_EXCHANGE_MEMBER_CLASS,
   agentExchangeFoldOpen,
   agentExchangeRowOf,
   agentExchangeSummary,
@@ -135,6 +133,8 @@ import {
   shouldApplyIncomingDraftToComposer,
 } from './conversation-draft-sync.mjs';
 import { isChatInteractionHeld, selectionIntersectsNode } from './selection-guard.mjs';
+import { captureReadingAnchor, readingAnchorContentTop, readingAnchorHoldStep, readingAnchorScrollDelta } from './transcript-reading-anchor.mjs';
+import { captureReadingBlock, restoreReadingBlock } from './transcript-viewport-anchor.mjs';
 import {
   applyThinkingFollow,
   getThinkingFollowMode,
@@ -145,9 +145,12 @@ import {
   toggleThinkingFollowMode,
   unobserveThinkingBubble,
 } from './thinking-follow.js';
+import { beginOwnSend, followsTranscriptEnd, jumpTranscriptToBottom, nameOwnSendConversation, ownSendFollows, refreshJumpButton, scrollAfterOwnSend } from './transcript-jump-bottom-view.mjs';
+import { createHeldBackLiveRows, newerPageReachesEnd } from './transcript-island.mjs';
 import { buildInFlightSnapshotKey } from './in-flight-snapshot.mjs';
 import { computeStablePrefixLength, planListPatch } from './streaming-dom-patch.mjs';
 import { prefixToolActivityEmoji } from './tool-activity-emoji.mjs';
+import { conversationPayloadCache } from './conversation-payload-cache.mjs';
 
 const CONVERSATION_HISTORY_PAGE_SIZE = 20;
 const HISTORY_LOAD_MORE_ID = 'history-load-more';
@@ -241,6 +244,20 @@ let conversationHistoryState = {
   loadingOlder: false,
   loadingNewer: false,
 };
+// Live rows for a window that ends above the conversation's end: held back
+// until the newer pages bring them (transcript-island.mjs).
+const heldBackLiveRows = createHeldBackLiveRows();
+
+// After every change of conversationHistoryState: a window that meets the
+// end, or another conversation's, holds no rows back. The button's count
+// changes without the page changing, so it is told.
+function syncHeldBackLiveRows() {
+  const released = heldBackLiveRows.follow({
+    conversationId: conversationHistoryState.conversationId,
+    atTail: !conversationHistoryState.hasMoreNewer,
+  });
+  if (released) refreshJumpButton();
+}
 
 function renderImageEditTarget() {
   const chip = document.getElementById('image-edit-target');
@@ -356,6 +373,8 @@ const conversationHistoryLoader = createInfiniteLoader({
     const previousScrollTop = el.scrollTop;
     const previousScrollHeight = el.scrollHeight;
     const inserted = prependMessageNodes(page.items || []);
+    // The kept window grows with the page: a switch back shows these rows too.
+    if (!IS_SHARED_VIEW) conversationPayloadCache.addOlder(currentId, page.items || [], { hasMoreOlder: page.hasMore });
     setConversationHistoryState({
       conversationId: currentId,
       hasMoreOlder: page.hasMore,
@@ -383,6 +402,10 @@ const conversationHistoryLoader = createInfiniteLoader({
       if (!el || String(currentConvId || '').trim() !== currentId) return;
       const nextScrollHeight = el.scrollHeight;
       el.scrollTop = previousScrollTop + (nextScrollHeight - previousScrollHeight);
+      // The page's images have no height yet: the place read is held while
+      // they come in, as after a restore.
+      const place = captureConversationReadingAnchor();
+      if (place?.conversationId === currentId) holdReadingAnchorWhileMediaLoads(el, place.anchor);
       void conversationHistoryLoader.handleBoundaryDistance(el.scrollTop);
     });
   },
@@ -429,6 +452,24 @@ const conversationFutureLoader = createInfiniteLoader({
     const currentId = String(currentConvId || '').trim();
     if (!currentId || conversationPaginationCursorIsStale(currentId)) return;
     const ordered = sortConversationMessages(page.items || []);
+    // The last page may predate a row held back meanwhile: one more is asked
+    // for, from this page's newest row. The loader reads hasMore and the
+    // cursor off this page once it is applied.
+    const heldBackIds = heldBackLiveRows.ids(currentId);
+    if (!page.hasMore && heldBackIds.length && !newerPageReachesEnd({
+      pageHasMore: page.hasMore,
+      pageMessageIds: ordered.map((m) => m?.id),
+      heldBackIds,
+      renderedIds: renderedMessageIds(),
+    })) {
+      const newest = ordered[ordered.length - 1];
+      page.hasMore = true;
+      page.nextCursor = {
+        afterMessageId: String(newest?.id || '').trim() || null,
+        afterTimestamp: String(newest?.timestamp || '').trim() || null,
+      };
+    }
+    if (!IS_SHARED_VIEW) conversationPayloadCache.addNewer(currentId, ordered, { hasMoreNewer: page.hasMore });
     let inserted = 0;
     withSuspendedSeparatorSync(() => {
       for (const m of ordered) {
@@ -450,6 +491,9 @@ const conversationFutureLoader = createInfiniteLoader({
       loadingOlder: conversationHistoryState.loadingOlder,
       loadingNewer: false,
     });
+    // The window meets the end: a turn still running gets its live bubble,
+    // which was not drawn under the window while it ended above.
+    if (!page.hasMore) showLiveBubbleOfRunningTurn();
   },
   onError: (error, { mode }) => {
     if (mode === 'load') {
@@ -462,6 +506,7 @@ const conversationFutureLoader = createInfiniteLoader({
       hasMoreNewer: state.hasMore,
       loadingNewer: state.isLoading,
     };
+    syncHeldBackLiveRows();
   },
 });
 
@@ -1179,6 +1224,7 @@ function resetConversationHistoryState() {
   conversationFutureLoader.reset({ hasMore: false, nextCursor: null });
   saveConversationLoadedMessageCount(conversationId, 0);
   syncHistoryLoadMoreControl();
+  syncHeldBackLiveRows();
 }
 
 function setConversationHistoryState(next = {}) {
@@ -1199,6 +1245,7 @@ function setConversationHistoryState(next = {}) {
     conversationHistoryState.loadedMessageCount,
   );
   syncHistoryLoadMoreControl();
+  syncHeldBackLiveRows();
 }
 
 function getConversationHistoryCursor() {
@@ -1289,38 +1336,20 @@ function createRelayEventNode(msg, msgId) {
   return div;
 }
 
-// Agent exchanges (agent-exchange-fold-view.mjs): an agent's prompt and this
-// session's reply fold into one row. 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.
+// 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 an exchange, by its prompt's id: true opened, false
+// 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();
-// Exchanges shown for the user while this page lives: a turn that had an open
-// card, or ran while a message of the user's waited, stays shown once that
-// has passed instead of folding away under them. A reload folds it again.
-const agentExchangesShownForUser = new Set();
-// Each folded row's prompt id, by message id, and each folded exchange's
-// status, by prompt id, as of the last pass.
-let agentExchangePromptIdByMessageId = 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 || '', parseTimestamp: parseTimestampMs });
-}
-
-// The turns an open question or approval card (a plan board) belongs to.
-function openCardMessageIds() {
-  const ids = new Set();
-  for (const card of [...relayQuestions.values(), ...relayBoards.values()]) {
-    if (card?.status !== 'pending') continue;
-    for (const id of [card.messageId, card.queueId]) {
-      if (id) ids.add(String(id).trim());
-    }
-  }
-  return ids;
+  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
@@ -1345,58 +1374,45 @@ function agentExchangeTranscriptRows(el) {
 }
 
 /**
- * Fold the transcript's agent exchanges. One idempotent pass, run after every
+ * 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, classes hide the prompt's bubble and
- * the exchange's other rows, which stay in the list and go on updating.
+ * 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],
-    openCardIds: openCardMessageIds(),
-    keptShownIds: agentExchangesShownForUser,
   });
   const states = new Map();
-  const promptIdByMessageId = new Map();
   const statusByPromptId = new Map();
   for (const group of plan) {
-    if (group.transient) agentExchangesShownForUser.add(group.promptId);
     if (!group.fold) continue;
     const open = agentExchangeFoldOpen(group.status, agentExchangeFoldChoices.get(group.promptId));
-    states.set(nodes.get(group.prompt), { group, head: true, open });
-    promptIdByMessageId.set(group.promptId, group.promptId);
+    states.set(nodes.get(group.prompt), { group, open });
     statusByPromptId.set(group.promptId, group.status);
-    for (const member of group.members) {
-      states.set(nodes.get(member), { group, head: false, open });
-      promptIdByMessageId.set(member.id, group.promptId);
-    }
   }
-  agentExchangePromptIdByMessageId = promptIdByMessageId;
   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, a
-// card opening. A bulk render runs the pass once at its end.
+// 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?.head);
-  node.classList.toggle(AGENT_EXCHANGE_MEMBER_CLASS, !!state && !state.head);
+  node.classList.toggle(AGENT_EXCHANGE_HEAD_CLASS, !!state);
   node.classList.toggle(AGENT_EXCHANGE_CLOSED_CLASS, !!state && !state.open);
-  // The jump-to-bottom badge counts a fold's rows as one by this id.
-  if (state) node.dataset.agentExchangePromptId = state.group.promptId;
-  else delete node.dataset.agentExchangePromptId;
   const existing = node.querySelector(':scope > .agent-exchange-row');
-  if (!state?.head) {
+  if (!state) {
     existing?.remove();
     return;
   }
@@ -1430,11 +1446,11 @@ function onAgentExchangeToggle(row) {
   syncAgentExchangeFolds();
 }
 
-// A search result, a pin or a jump inside a folded exchange opens it first:
-// a hidden row has nowhere to scroll to.
+// 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 = agentExchangePromptIdByMessageId.get(String(messageId || '').trim());
-  if (!promptId || agentExchangeFoldChoices.get(promptId) === true) return;
+  const promptId = String(messageId || '').trim();
+  if (!agentExchangeStatusByPromptId.has(promptId) || agentExchangeFoldChoices.get(promptId) === true) return;
   agentExchangeFoldChoices.set(promptId, true);
   syncAgentExchangeFolds();
 }
@@ -1523,10 +1539,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;
@@ -1585,7 +1602,7 @@ function createMessageNode(msg, msgId = null, force = false) {
   rememberSubagentRuns(subagentRuns);
   const subagentHtml = subagentRowsMarkup(
     subagentRuns.map((run) => mergeLiveSubagentRun(run, getSubagentRun(run.subagentRunId))),
-    { clickable: !IS_SHARED_VIEW },
+    { clickable: true },
   );
   // Finished background workflows persisted with this assistant message
   // (docs/plans/workflow-progress-tree.md, Phase 4). The template only
@@ -1614,7 +1631,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
@@ -1627,8 +1646,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
@@ -1763,21 +1782,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) {
@@ -1895,8 +1905,7 @@ function anchorThinkingBubble(div, messageId) {
     if (next) el.insertBefore(div, next);
     else el.appendChild(div);
     if (div.dataset.compactBoundary) syncSeparatorsNow();
-    // Under a folded agent prompt the bubble folds with it, and the row says
-    // the turn is working.
+    // A folded agent prompt's row says the turn is working.
     else syncAgentExchangeFoldsNow();
   } else if (div.parentNode !== el) {
     el.appendChild(div);
@@ -1913,6 +1922,16 @@ export function showThinking(messageId = null, autoScroll = true) {
   const nextMessageId = String(messageId || '').trim();
   if (nextMessageId) thinkingMessageId = nextMessageId;
   const existing = document.getElementById('thinking-indicator');
+  // A window that ends above the conversation's end shows no live bubble:
+  // under it, it would sit below rows that are not loaded. The turn's
+  // thoughts, tools and text are kept all the same; the bubble is drawn once
+  // the window meets the end.
+  if (!isConversationWindowAtTail()) {
+    // Through the same path as removeThinking, so the separators and the
+    // agent folds no longer show the bubble either; the turn's id stays.
+    if (existing) takeThinkingBubbleOff();
+    return;
+  }
   if (existing
     && existing.dataset.conversationId === thinkingConversationKey()
     && (!nextMessageId || String(existing.dataset.messageId || '') === nextMessageId)) {
@@ -1973,6 +1992,14 @@ export function showThinking(messageId = null, autoScroll = true) {
 export function removeThinking() {
   thinkingMessageId = null;
   lastInFlightSnapshotKey = '';
+  takeThinkingBubbleOff();
+}
+
+// The live bubble leaves the page, with what hangs on it (its compaction
+// line, the agent folds' "working"). The turn it shows is not forgotten:
+// removeThinking does that; a window that stops reaching the end only hides
+// the bubble until it meets the end again (showThinking).
+function takeThinkingBubbleOff() {
   const hadBubble = !!document.getElementById('thinking-indicator');
   const wasCompacting = !!document.getElementById('thinking-indicator')?.dataset?.compactBoundary;
   unobserveThinkingBubble();
@@ -1985,6 +2012,43 @@ export function removeThinking() {
   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
 // for the separator pass — "Compacting context…" while the last compaction
 // entry is a start without an end, the final label once the boundary is in —
@@ -2749,11 +2813,16 @@ export function applyRelayStreamEvent({
 
 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
@@ -3077,6 +3146,7 @@ export function replaceRenderedMessage(msg, msgId) {
 }
 
 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;
@@ -3118,9 +3188,12 @@ async function resendStoppedSteer(conversationId, markerId) {
       showTransientRelayNotice('Select a reasoning effort after refreshing model metadata.');
       return;
     }
+    // As a send from the composer (loadEndForOwnSend): the Resend goes to
+    // the end.
+    if (isCurrentConversation(conversationKey)) await loadEndForOwnSend();
     trackPendingUserMessage(clientMessageId, conversationKey, text, { attachments });
     pendingUserMessageIds.add(clientMessageId);
-    if (isCurrentConversation(conversationKey)) {
+    if (isCurrentConversation(conversationKey) && isConversationWindowAtTail()) {
       appendMessage({
         role: 'user',
         text,
@@ -3128,7 +3201,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({
@@ -3172,7 +3245,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)) {
@@ -3341,6 +3414,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();
@@ -3359,13 +3461,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.
@@ -3375,7 +3481,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);
   }
 }
 
@@ -3545,8 +3651,8 @@ export function appendMessage(msg, scroll = true, msgId = null, force = false, i
   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 belongs to its
-  // agent exchange too.
+  // 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()) {
@@ -3771,6 +3877,8 @@ export function renderMessages(msgs, scroll = true, meta = {}) {
     return false;
   }
   deferredMessageRender = null;
+  // Other rows: whoever renders them puts the reader in place.
+  releaseReadingAnchorHold();
   const messageById = new Map(
     ordered
       .map((item) => [String(item?.id || '').trim(), item])
@@ -3828,7 +3936,9 @@ export function renderMessages(msgs, scroll = true, meta = {}) {
   // in as an extra row, and another conversation's bubble must not leak into
   // this one (it is dropped instead, so the next restore builds afresh).
   const thinkingNodeInTranscript = !!thinkingNode && thinkingNode.parentNode === el;
+  // Nor under a window that ends above the conversation's end (showThinking).
   const preservedThinkingNode = (thinkingNodeInTranscript
+    && !hasMoreNewer
     && thinkingNode.dataset.conversationId === renderConversationKey) ? thinkingNode : null;
   if (thinkingNodeInTranscript && !preservedThinkingNode) removeThinking();
   if (!ordered.length && !preservedPendingNodes.length && !preservedThinkingNode) {
@@ -3942,12 +4052,348 @@ export function isConversationWindowAtTail() {
   return !conversationHistoryState.hasMoreNewer;
 }
 
+/**
+ * A live row for `conversationId` arrived (a message, a reply). True when it
+ * is held back instead of put on the page: the window on the page is that
+ * conversation's and ends above its end (transcript-island.mjs). The window
+ * keeps loading newer pages from its own newest row, and the jump-to-bottom
+ * button counts the row.
+ */
+export function holdBackLiveRow(conversationId, messageId) {
+  const id = String(conversationId || '').trim();
+  if (!id || isConversationWindowAtTail() || getRenderedConversationId() !== id) return false;
+  heldBackLiveRows.note(id, messageId);
+  // A reload whose request was on its way may lack this row as it would one
+  // put on the page: counted, so it is asked again (loadKeepingLiveRows)
+  // rather than rendered over the rows held.
+  noteTranscriptLiveRow();
+  refreshJumpButton();
+  return true;
+}
+
+/** How many live rows wait below the window on the page. */
+export function getHeldBackLiveRowCount() {
+  return heldBackLiveRows.count(getRenderedConversationId());
+}
+
+/** The ids of the live rows that wait below the window on the page, oldest first. */
+export function getHeldBackLiveRowIds() {
+  return heldBackLiveRows.ids(getRenderedConversationId());
+}
+
+function renderedMessageIds() {
+  const el = getMessagesElement();
+  if (!el) return [];
+  return Array.from(readingAnchorRows(el), (node) => String(node.dataset.messageId || '').trim());
+}
+
+// The running turn's live bubble, drawn from what the page kept of it (its
+// thoughts, tools and text arrived while no bubble was drawn).
+function showLiveBubbleOfRunningTurn() {
+  if (document.getElementById('thinking-indicator')) return;
+  const turn = getActiveTurnForConversation(currentConvId);
+  const messageId = String(turn?.messageId || '').trim();
+  if (!messageId || String(turn?.status || '').trim().toLowerCase() !== 'processing') return;
+  showThinking(messageId, false);
+  renderThinkingStream();
+  renderThinkingActivities();
+  renderThinkingThoughts();
+  renderRestoredSubagentBubbles(messageId);
+}
+
+/** The conversation whose rows the transcript holds; during a switch, still the one left. */
+export function getRenderedConversationId() {
+  return String(conversationHistoryState.conversationId || '').trim();
+}
+
+// The message rows, without the live bubble: it carries its prompt's id.
+function readingAnchorRows(el) {
+  return el.querySelectorAll(':scope > .msg[data-message-id]:not(#thinking-indicator)');
+}
+
+/**
+ * Where the reader is in the transcript on the page
+ * (transcript-reading-anchor.mjs), for the conversation whose rows it holds;
+ * null when no row is there.
+ */
+export function captureConversationReadingAnchor() {
+  const el = getMessagesElement();
+  const conversationId = getRenderedConversationId();
+  if (!el || !conversationId) return null;
+  const rows = readingAnchorRows(el);
+  if (!rows.length) return null;
+  const paneTop = el.getBoundingClientRect().top;
+  const rectAt = (index) => rows[index].getBoundingClientRect();
+  const anchor = captureReadingAnchor({
+    rowCount: rows.length,
+    rowAt: (index) => {
+      const rect = rectAt(index);
+      return { messageId: rows[index].dataset.messageId, top: rect.top, bottom: rect.bottom };
+    },
+    paneTop,
+    atTail: isMessagesNearBottom() && isConversationWindowAtTail(),
+  });
+  return anchor ? { conversationId, anchor } : null;
+}
+
+function readingAnchorRow(el, messageId) {
+  const id = String(messageId || '').trim();
+  return id ? el.querySelector(`:scope > .msg[data-message-id="${CSS.escape(id)}"]:not(#thinking-indicator)`) : null;
+}
+
+/**
+ * Puts the anchored message at its saved offset, or the reader at the end.
+ * False when the message is not on the page. The place is then held while
+ * the images on the page are still loading (holdReadingAnchorWhileMediaLoads).
+ */
+export function restoreConversationReadingAnchor(anchor) {
+  const el = getMessagesElement();
+  if (!el || !anchor) return false;
+  if (anchor.atTail) {
+    releaseReadingAnchorHold();
+    el.scrollTop = el.scrollHeight;
+    return true;
+  }
+  const row = readingAnchorRow(el, anchor.messageId);
+  if (!row) return false;
+  const delta = readingAnchorScrollDelta({
+    rowTop: row.getBoundingClientRect().top,
+    paneTop: el.getBoundingClientRect().top,
+    offsetPx: anchor.offsetPx,
+  });
+  if (Math.abs(delta) > 0.5) el.scrollTop += delta;
+  holdReadingAnchorWhileMediaLoads(el, anchor);
+  return true;
+}
+
+// Images reserve no height until their bytes are in (the attachment payload
+// carries no dimensions), so one above the place read that arrives after the
+// place was put back pushes it down by its height. Chrome's scroll anchoring
+// absorbs that; browsers without it (iOS Safari) do not. Long enough for a
+// slow link, short enough that a forgotten hold cannot surprise anyone.
+const READING_ANCHOR_HOLD_MAX_MS = 10_000;
+let readingAnchorHold = null;
+
+/**
+ * Lets go of the place held while images load: whoever calls this moves the
+ * reader themselves (the jump to the end, an own send).
+ */
+export function releaseReadingAnchorHold() {
+  const hold = readingAnchorHold;
+  if (!hold) return;
+  readingAnchorHold = null;
+  hold.cleanup();
+}
+
+function pendingTranscriptImages(el) {
+  return Array.from(el.querySelectorAll('img')).filter((img) => !img.complete);
+}
+
+/**
+ * Keeps the anchored message at its offset while images in the transcript
+ * are loading: each one that is laid out at its height (a ResizeObserver
+ * fires before the frame is painted; load and error events as a fallback)
+ * scrolls by what it pushed. Lets go when they are all in, after
+ * READING_ANCHOR_HOLD_MAX_MS, or as soon as the reader scrolls: a wheel, a
+ * touch or a key, or a change of scrollTop that no growth above the row
+ * explains (a drag of the scrollbar, a jump to the end, an own send). Growth
+ * below the row (a reply streaming in at the end) is not the hold's to
+ * correct (readingAnchorHoldStep). A reader at the end has nothing to hold
+ * here: the jump-to-bottom follower keeps them at the end.
+ */
+function holdReadingAnchorWhileMediaLoads(el, anchor) {
+  releaseReadingAnchorHold();
+  if (!el || !anchor || anchor.atTail || !anchor.messageId) return;
+  const pending = pendingTranscriptImages(el);
+  if (!pending.length) return;
+  const startRow = readingAnchorRow(el, anchor.messageId);
+  if (!startRow) return;
+  // Where the row sits in the content and the scroll, as of the last look:
+  // the next look corrects by what moved the row in the content only.
+  const seen = {
+    rowContentTop: readingAnchorContentTop({
+      rowTop: startRow.getBoundingClientRect().top,
+      paneTop: el.getBoundingClientRect().top,
+      scrollTop: el.scrollTop,
+    }),
+    scrollTop: el.scrollTop,
+  };
+  const check = () => {
+    if (readingAnchorHold !== hold) return;
+    const row = readingAnchorRow(el, anchor.messageId);
+    if (!row) {
+      releaseReadingAnchorHold();
+      return;
+    }
+    const step = readingAnchorHoldStep({
+      rowTop: row.getBoundingClientRect().top,
+      paneTop: el.getBoundingClientRect().top,
+      scrollTop: el.scrollTop,
+      seen,
+    });
+    if (step.action === 'release') {
+      releaseReadingAnchorHold();
+      return;
+    }
+    if (step.action === 'correct') el.scrollTop += step.delta;
+    seen.rowContentTop = step.rowContentTop;
+    // Read back: the browser can clamp the correction.
+    seen.scrollTop = el.scrollTop;
+  };
+  const onMediaSettled = () => {
+    check();
+    if (readingAnchorHold === hold && !pendingTranscriptImages(el).length) releaseReadingAnchorHold();
+  };
+  const onReaderInput = () => releaseReadingAnchorHold();
+  // A key can scroll the pane from anywhere but a field being typed in (the
+  // composer, a card's reply): typing there moves nothing.
+  const onKeyDown = (event) => {
+    const target = event?.target;
+    if (target && (target.tagName === 'TEXTAREA' || target.tagName === 'INPUT' || target.isContentEditable === true)) return;
+    releaseReadingAnchorHold();
+  };
+  const observer = typeof ResizeObserver === 'function' ? new ResizeObserver(check) : null;
+  for (const img of pending) observer?.observe(img);
+  el.addEventListener('load', onMediaSettled, true);
+  el.addEventListener('error', onMediaSettled, true);
+  // A video's box changes when its metadata is in.
+  el.addEventListener('loadedmetadata', check, true);
+  el.addEventListener('scroll', check, { passive: true });
+  el.addEventListener('wheel', onReaderInput, { passive: true });
+  el.addEventListener('touchstart', onReaderInput, { passive: true });
+  document.addEventListener('keydown', onKeyDown, true);
+  const timer = setTimeout(releaseReadingAnchorHold, READING_ANCHOR_HOLD_MAX_MS);
+  const hold = {
+    cleanup() {
+      clearTimeout(timer);
+      observer?.disconnect();
+      el.removeEventListener('load', onMediaSettled, true);
+      el.removeEventListener('error', onMediaSettled, true);
+      el.removeEventListener('loadedmetadata', check, true);
+      el.removeEventListener('scroll', check);
+      el.removeEventListener('wheel', onReaderInput);
+      el.removeEventListener('touchstart', onReaderInput);
+      document.removeEventListener('keydown', onKeyDown, true);
+    },
+  };
+  readingAnchorHold = hold;
+}
+
+/**
+ * The window on the page no longer meets the end of the conversation (more
+ * was written than one page holds): newer rows load as after a jump into
+ * the history, and the jump-to-bottom button loads the end.
+ */
+export function detachConversationWindowFromTail() {
+  const newestMessageId = String(conversationHistoryState.newestMessageId || '').trim();
+  setConversationHistoryState({ ...conversationHistoryState, hasMoreNewer: true });
+  // A live bubble on the page now sits under a window that ends above the
+  // end, below rows that are not loaded: it goes until the window meets the
+  // end again (showThinking draws none meanwhile).
+  takeThinkingBubbleOff();
+  conversationFutureLoader.reset({
+    hasMore: true,
+    nextCursor: {
+      afterMessageId: newestMessageId || null,
+      afterTimestamp: String(conversationHistoryState.newestMessageTimestamp || '').trim() || null,
+    },
+  });
+}
+
+// One message as the transcript's snapshot key sees it.
+function messageRenderKey(message) {
+  return buildMessageSnapshotKey([message], { conversationId: '', hasMoreOlder: false, hasMoreNewer: false });
+}
+
+/**
+ * Whether the transcript on the page can take a merge of `previousMessages`'
+ * window (mergeMessagesIntoTranscript) rather than a full render: not while
+ * a bubble still waits for its send, the status view is up, a selection is
+ * held, another conversation's rows are on the page, or a row of the window
+ * is missing from it (what is merged in is placed next to those rows, and a
+ * changed one is rebuilt where it stands).
+ */
+export function canMergeIntoTranscript(previousMessages, conversationId) {
+  const el = getMessagesElement();
+  const id = String(conversationId || '').trim();
+  if (!el || !id) return false;
+  if (isChatInteractionHeld()
+    || el.querySelector('.status-view')
+    || getRenderedConversationId() !== id
+    || hasPendingUserMessageForConversation(id)) {
+    return false;
+  }
+  const rendered = new Set(Array.from(readingAnchorRows(el), (node) => String(node.dataset.messageId || '').trim()));
+  for (const message of previousMessages || []) {
+    const messageId = String(message?.id || '').trim();
+    if (messageId && !rendered.has(messageId)) return false;
+  }
+  return true;
+}
+
+/**
+ * Puts a merged window (mergeTailPage) on the page without rebuilding it:
+ * the rows the newest page changed are rebuilt where they stand, its new ones
+ * are put in their place, the rows it dropped are taken off, every other row
+ * stays as it is under the reader.
+ * Falls back to a full render when the page holds rows the merge cannot
+ * place (a bubble still waiting for its send, the status view, a held
+ * selection). Returns true when the transcript changed.
+ */
+export function mergeMessagesIntoTranscript(previousMessages, msgs, meta = {}) {
+  const el = getMessagesElement();
+  if (!el) return false;
+  const conversationId = String(meta.conversationId || currentConvId || '').trim();
+  if (!canMergeIntoTranscript(previousMessages, conversationId)) return renderMessages(msgs, false, meta);
+  const ordered = sortConversationMessages(msgs || []);
+  const snapshotKey = buildMessageSnapshotKey(ordered, meta);
+  if (snapshotKey === lastRenderedMessageSnapshotKey) return false;
+  const previousById = new Map((previousMessages || []).map((m) => [String(m?.id || '').trim(), m]));
+  const messageById = new Map(ordered.map((m) => [String(m?.id || '').trim(), m]).filter(([id]) => !!id));
+  let previousId = '';
+  withSuspendedSeparatorSync(() => {
+    // A window row the merge left out was deleted while the reader was away
+    // (mergeTailPage drops it): it leaves the page too. Taken off first, so
+    // nothing merged in is placed next to it.
+    for (const id of previousById.keys()) {
+      if (!id || messageById.has(id)) continue;
+      el.querySelector(`:scope > .msg[data-message-id="${CSS.escape(id)}"]:not(#thinking-indicator)`)?.remove();
+      seenMessageIds.delete(id);
+    }
+    for (const m of ordered) {
+      const id = String(m?.id || '').trim();
+      if (!id) continue;
+      const before = previousById.get(id);
+      if (!before) {
+        const threadAnchor = getMessageThreadAnchor(m, messageById);
+        appendMessage(m, false, id, true, threadAnchor !== id ? threadAnchor : (previousId || null), false);
+      } else if (messageRenderKey(before) !== messageRenderKey(m)) {
+        replaceRenderedMessage(m, id);
+      }
+      previousId = id;
+    }
+  });
+  const newest = ordered[ordered.length - 1] || null;
+  setConversationHistoryState({
+    ...conversationHistoryState,
+    conversationId,
+    newestMessageId: String(newest?.id || conversationHistoryState.newestMessageId || '').trim(),
+    newestMessageTimestamp: String(newest?.timestamp || conversationHistoryState.newestMessageTimestamp || '').trim(),
+    loadedMessageCount: ordered.length,
+  });
+  syncSeparatorsNow();
+  renderRelayQuestions();
+  renderRelayBoards();
+  lastRenderedMessageSnapshotKey = snapshotKey;
+  return true;
+}
+
 export function focusConversationMessageById(messageId, { behavior = 'smooth', block = 'center' } = {}) {
   const id = String(messageId || '').trim();
   if (!id) return false;
   const el = getMessagesElement();
   if (!el) return false;
-  // A message in a folded agent exchange is shown before it is scrolled to.
+  // 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;
@@ -3989,7 +4435,23 @@ export function compactCurrentConversation() {
 // edit re-arms the warning.
 let unknownCommandWarned = null;
 
+// An own message goes to the end of the conversation. Sent from a window that
+// ends above it, its row put under the window would sit below rows that are
+// not loaded, and would move the newer pages' cursor past them; no live
+// bubble or reply would be drawn there either. So the end is loaded first,
+// as the jump-to-bottom button does, and the row, the bubble and the reply
+// follow at the end, whatever the scroll-on-send setting says: the end is
+// where the message is. Resolves once the end is on the page, or its load
+// failed (then the window still ends above, and no row is put under it).
+function loadEndForOwnSend() {
+  if (isConversationWindowAtTail()) return Promise.resolve();
+  return jumpTranscriptToBottom();
+}
+
 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();
@@ -4030,7 +4492,7 @@ export async function sendMessage() {
     releaseComposerFocusAfterSend(input);
     void flushConversationDraft(currentConvId);
     compactCurrentConversation();
-    scrollBottomAfterSend();
+    scrollAfterOwnSend(send);
     return;
   }
 
@@ -4087,7 +4549,10 @@ export async function sendMessage() {
   let attachments = [];
   let clientMessageId = null;
   try {
+    // Alongside the upload: the end is loaded while the files go up.
+    const endLoaded = viewingSendConversation() ? loadEndForOwnSend() : null;
     attachments = await uploadAttachments(draftAttachments);
+    await endLoaded;
 
     const isNew = !targetConversationId;
     const msgTimestamp = new Date().toISOString();
@@ -4107,8 +4572,14 @@ 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);
+      // Not under a window that still ends above the end (loadEndForOwnSend
+      // failed): the row comes with the end.
+      if (isConversationWindowAtTail()) {
+        appendMessage({ role: 'user', text, model: selectedModel, mode: selectedMode, timestamp: msgTimestamp, attachments }, follow, clientMessageId, true);
+      }
+      scrollAfterOwnSend(send);
     }
 
     const body = {
@@ -4196,7 +4667,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;
     }
@@ -4217,6 +4689,7 @@ export async function sendMessage() {
       if (adoptNewConversation) {
         setCurrentConv(r.conversationId);
         composerConversationId = r.conversationId;
+        nameOwnSendConversation(send, r.conversationId);
       }
       conversations[r.conversationId] = {
         id: r.conversationId,
@@ -4263,7 +4736,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);
@@ -4295,7 +4768,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
@@ -4304,7 +4777,7 @@ export async function sendMessage() {
     if (viewingSendConversation()) {
       removeComposerAttachments(draftAttachments);
       if (!mobileSend) input.focus();
-      scrollBottomAfterSend();
+      scrollAfterOwnSend(send);
     }
   } catch (e) {
     const sendLanded = hasSendEchoArrived(clientMessageId);