@oar-sh/oar 0.9.21 → 0.9.23

package/server/public/app/activity-replay-state.mjs

@@ -1,4 +1,10 @@
-const DEFAULT_ACTIVITY_LIMIT = 24;
+// A row's place in its turn's order (migration 0038), or null: rows from
+// before it, or from an older relay, have none.
+export function normalizeTurnSeq(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const num = Number(value);
+  return Number.isInteger(num) && num > 0 ? num : null;
+}
 
 export function normalizeRelayActivityEntry(item) {
   if (item && typeof item === 'object' && !Array.isArray(item)) {
@@ -8,7 +14,8 @@ export function normalizeRelayActivityEntry(item) {
     const metadata = (item.metadata && typeof item.metadata === 'object' && !Array.isArray(item.metadata))
       ? item.metadata
       : null;
-    return { text, subagentRunId, metadata };
+    const turnSeq = normalizeTurnSeq(item.turnSeq);
+    return { text, subagentRunId, metadata, ...(turnSeq !== null ? { turnSeq } : {}) };
   }
   const text = String(item || '').trim();
   if (!text) return null;
@@ -24,25 +31,87 @@ export function isCompactBoundaryActivityEntry(item) {
   return normalizeRelayActivityEntry(item)?.metadata?.kind === 'compact_boundary';
 }
 
-// The live list of one turn keeps its newest ordinary lines only, but every
-// structured row a line of the transcript is built from: the turn's
-// compaction entries and the session-restart notes (a compaction window, a
-// billing switch) would otherwise scroll out of a busy turn and take their
-// line with them until the next reload.
-export const LIVE_ACTIVITY_CAP = 24;
+// The thread an activity row belongs to: a sub-agent run, or '' for the main
+// agent. Every cap below counts each thread apart, so a busy sub-agent never
+// pushes the main agent's lines out (or another sub-agent's).
+function activityThreadKey(item) {
+  return normalizeRelayActivityEntry(item)?.subagentRunId || '';
+}
+
+// No limit: a cap of 0 (the setting's far end), or anything not a positive
+// number.
+function isUnlimitedCap(cap) {
+  const value = Number(cap);
+  return !Number.isFinite(value) || value <= 0;
+}
+
+/**
+ * Keep the newest `cap` rows of each thread among those `isKept` does not
+ * protect, and every protected row; the order stays. A sub-agent's thread
+ * keeps `subagentCap` (the same unless given). A list already within the cap
+ * is returned as it is.
+ */
+function capNewestPerThread(list, cap, isKept, subagentCap = cap) {
+  if (isUnlimitedCap(cap) && isUnlimitedCap(subagentCap)) return list;
+  const maxFor = (key) => {
+    const limit = key ? subagentCap : cap;
+    return isUnlimitedCap(limit) ? Number.POSITIVE_INFINITY : Math.trunc(Number(limit));
+  };
+  const remaining = new Map();
+  for (const item of list) {
+    if (isKept(item)) continue;
+    const key = activityThreadKey(item);
+    remaining.set(key, (remaining.get(key) || 0) + 1);
+  }
+  if ([...remaining.entries()].every(([key, count]) => count <= maxFor(key))) return list;
+  return list.filter((item) => {
+    if (isKept(item)) return true;
+    const key = activityThreadKey(item);
+    const left = remaining.get(key) - 1;
+    remaining.set(key, left);
+    return left < maxFor(key);
+  });
+}
+
+// The live list of one turn keeps the newest ordinary lines of each thread
+// (the main agent, each sub-agent) only, as many as the "Tool lines shown
+// while an agent works" setting says (live-activity-cap.mjs; 0 keeps all),
+// but every structured row a line of the transcript is built from: the
+// turn's compaction entries and the session-restart notes (a compaction
+// window, a billing switch) would otherwise scroll out of a busy turn and
+// take their line with them until the next reload. The call sites pass the
+// setting; LIVE_ACTIVITY_CAP is its default.
+export const LIVE_ACTIVITY_CAP = 50;
 function isKeptLiveActivityEntry(item) {
   const kind = normalizeRelayActivityEntry(item)?.metadata?.kind;
   return kind === 'compact_boundary' || kind === 'compact_window_respawn' || kind === 'billing_switch_respawn';
 }
 export function capLiveActivityEntries(items, cap = LIVE_ACTIVITY_CAP) {
   const list = Array.isArray(items) ? items : [];
-  let ordinary = list.reduce((count, item) => count + (isKeptLiveActivityEntry(item) ? 0 : 1), 0);
-  if (ordinary <= cap) return list;
-  return list.filter((item) => {
-    if (isKeptLiveActivityEntry(item)) return true;
-    ordinary -= 1;
-    return ordinary < cap;
-  });
+  return capNewestPerThread(list, cap, isKeptLiveActivityEntry);
+}
+
+// What the relay sends of a turn's activity rows, per thread.
+//
+// A running turn (the in-flight snapshot the live bubble polls every 900 ms):
+// as many as the browser shows, which it says with `activityCap` (its "Tool
+// lines shown" setting); a request without it (an older page, a paired
+// relay's read) gets the default 50; the setting's "no limit" asks for the
+// most the relay sends, 500.
+export const IN_FLIGHT_ACTIVITY_LIMIT_PER_THREAD = 500;
+// A finished one (the message payload): the main agent's newest 200 (the
+// stream view lists them), each sub-agent's newest 50 (its own record is in
+// the sub-agent viewer).
+export const FINISHED_ACTIVITY_LIMIT_PER_THREAD = 200;
+export const FINISHED_SUBAGENT_ACTIVITY_LIMIT_PER_THREAD = 50;
+
+/** The in-flight cap a request asks for: `activityCap` as 1…500, 0 → 500, else 50. */
+export function inFlightActivityCap(value) {
+  const text = String(value ?? '').trim();
+  if (!/^\d+$/.test(text)) return LIVE_ACTIVITY_CAP;
+  const cap = Number(text);
+  if (cap === 0) return IN_FLIGHT_ACTIVITY_LIMIT_PER_THREAD;
+  return Math.min(IN_FLIGHT_ACTIVITY_LIMIT_PER_THREAD, cap);
 }
 
 // A compaction is published in up to two steps on the same message: a
@@ -118,56 +187,99 @@ export function visibleActivityEntries(items, promoted) {
   });
 }
 
-// Head-cap that never drops structured rows. Activity lists are capped from
-// the front (the start of a turn is the interesting part), but a
+// The relay's cap of a turn's activity rows, which never drops structured
+// rows. Each thread (the main agent, each sub-agent) keeps its newest `limit`
+// prose rows: a busy sub-agent no longer pushes the main agent's lines out,
+// and the latest lines are the ones a reader of a long turn is after. A
 // metadata-bearing row carries transcript structure rather than prose, and a
 // long agentic turn can push its compaction boundary past the cap — losing
 // the break row entirely, with no prose fallback since the bubble filters
-// compact entries out. Keep every structured row, spend the rest of the
-// budget on the leading prose rows, preserve the original order.
-export function capRelayActivityEntries(items, limit = DEFAULT_ACTIVITY_LIMIT) {
+// compact entries out. Keep every structured row, preserve the original
+// order. Returns a new array. `subagentLimit` is a sub-agent thread's own
+// limit (the finished payload keeps fewer of those).
+//
+// `omittedMarker`: when the main agent's rows were cut, a structured row
+// saying how many (kind ACTIVITY_OMITTED_KIND) goes right before its first
+// kept row, so a reader of the finished turn sees that its list starts late.
+export function capRelayActivityEntries(items, limit, { subagentLimit = limit, omittedMarker = false } = {}) {
   const list = Array.isArray(items) ? items : [];
-  const max = Math.max(1, Math.trunc(Number(limit)) || DEFAULT_ACTIVITY_LIMIT);
-  if (list.length <= max) return list.slice();
-  const structuredIndexes = [];
-  for (let index = 0; index < list.length; index += 1) {
-    if (normalizeRelayActivityEntry(list[index])?.metadata) structuredIndexes.push(index);
-  }
-  if (!structuredIndexes.length) return list.slice(0, max);
+  const max = Math.max(1, Math.trunc(Number(limit)) || LIVE_ACTIVITY_CAP);
+  const subagentMax = Math.max(1, Math.trunc(Number(subagentLimit)) || max);
+  const isStructured = (item) => !!normalizeRelayActivityEntry(item)?.metadata;
+  const structured = list.filter(isStructured);
   // Safety valve for a pathological turn with more structured rows than the
   // cap allows: the most recent ones win.
-  const keep = new Set(structuredIndexes.slice(-max));
-  let budget = max - keep.size;
-  const kept = [];
-  for (let index = 0; index < list.length; index += 1) {
-    if (keep.has(index)) {
-      kept.push(list[index]);
-      continue;
-    }
-    if (budget <= 0) continue;
-    budget -= 1;
-    kept.push(list[index]);
+  let source = list;
+  if (structured.length > max) {
+    const keep = new Set(structured.slice(-max));
+    source = list.filter((item) => !isStructured(item) || keep.has(item));
   }
-  return kept;
+  const capped = capNewestPerThread(source, max, isStructured, subagentMax);
+  if (capped === list) return list.slice();
+  if (!omittedMarker) return capped;
+  const isMainProse = (item) => !isStructured(item) && !activityThreadKey(item);
+  const kept = new Set(capped);
+  const dropped = source.filter((item) => isMainProse(item) && !kept.has(item));
+  if (!dropped.length) return capped;
+  const at = capped.findIndex(isMainProse);
+  // Where the first line left out was in the turn's order, when it had one.
+  const fromTurnSeq = normalizeRelayActivityEntry(dropped[0])?.turnSeq ?? null;
+  const marker = omittedActivityMarker(dropped.length, fromTurnSeq);
+  return at === -1 ? [...capped, marker] : [...capped.slice(0, at), marker, ...capped.slice(at)];
+}
+
+// The row that stands for the main agent's tool lines a finished turn's cap
+// left out. It has no turn order of its own; `fromTurnSeq` is the place of
+// the first line it stands for, where the stream view puts it.
+export const ACTIVITY_OMITTED_KIND = 'activity_omitted';
+
+export function omittedActivityMarker(count, fromTurnSeq = null) {
+  const n = Math.max(1, Math.trunc(Number(count)) || 1);
+  const from = normalizeTurnSeq(fromTurnSeq);
+  return {
+    text: `… ${n} earlier tool ${n === 1 ? 'line' : 'lines'} omitted`,
+    subagentRunId: null,
+    metadata: { kind: ACTIVITY_OMITTED_KIND, count: n, ...(from !== null ? { fromTurnSeq: from } : {}) },
+  };
+}
+
+export function isOmittedActivityMarker(item) {
+  return normalizeRelayActivityEntry(item)?.metadata?.kind === ACTIVITY_OMITTED_KIND;
+}
+
+// The finished turn's cap, as the relay sends it and the bubble reads it; a
+// cut in the main agent's lines is marked.
+export function capFinishedActivityEntries(items) {
+  return capRelayActivityEntries(items, FINISHED_ACTIVITY_LIMIT_PER_THREAD, {
+    subagentLimit: FINISHED_SUBAGENT_ACTIVITY_LIMIT_PER_THREAD,
+    omittedMarker: true,
+  });
 }
 
 export function relayActivityEntryText(item) {
   return normalizeRelayActivityEntry(item)?.text || '';
 }
 
-function normalizeActivityItems(items, limit = DEFAULT_ACTIVITY_LIMIT) {
+// The live list's rule: the newest `cap` ordinary lines of each thread, the
+// structured rows kept (capLiveActivityEntries); Infinity or 0 keeps all.
+function normalizeActivityItems(items, cap = LIVE_ACTIVITY_CAP) {
   const normalized = Array.isArray(items)
     ? items.map((item) => normalizeRelayActivityEntry(item)).filter(Boolean)
     : [];
-  return normalized.slice(-Math.max(1, Number(limit) || DEFAULT_ACTIVITY_LIMIT));
+  return capLiveActivityEntries(normalized, cap);
 }
 
+// A numbered row is the row with that number (the same tool line twice is two
+// rows; a replayed event is one); an unnumbered one is known by its text.
 function activityEntryKey(item) {
   const entry = normalizeRelayActivityEntry(item);
   if (!entry) return '';
+  if (entry.turnSeq !== undefined) return `#${entry.turnSeq}`;
   return `${entry.subagentRunId || ''}::${entry.text}`;
 }
 
+const isNumbered = (item) => normalizeRelayActivityEntry(item)?.turnSeq !== undefined;
+
 function isSubsequence(subset, sequence) {
   if (!subset.length) return true;
   let cursor = 0;
@@ -178,11 +290,17 @@ function isSubsequence(subset, sequence) {
   return false;
 }
 
-export function mergeRelayActivityTexts(existingItems, incomingItems, limit = DEFAULT_ACTIVITY_LIMIT) {
+export function mergeRelayActivityTexts(existingItems, incomingItems, limit = LIVE_ACTIVITY_CAP) {
   const existing = normalizeActivityItems(existingItems, Number.POSITIVE_INFINITY);
   const incoming = normalizeActivityItems(incomingItems, Number.POSITIVE_INFINITY);
   if (!existing.length) return normalizeActivityItems(incoming, limit);
   if (!incoming.length) return normalizeActivityItems(existing, limit);
+  // Both sides numbered (migration 0038): the union by number, in order.
+  if (existing.every(isNumbered) && incoming.every(isNumbered)) {
+    const byTurnSeq = new Map();
+    for (const item of [...existing, ...incoming]) byTurnSeq.set(item.turnSeq, item);
+    return normalizeActivityItems([...byTurnSeq.values()].sort((a, b) => a.turnSeq - b.turnSeq), limit);
+  }
   if (isSubsequence(existing, incoming)) return normalizeActivityItems(incoming, limit);
   if (isSubsequence(incoming, existing)) return normalizeActivityItems(existing, limit);
 

package/server/public/app/api-client.js

@@ -1,4 +1,5 @@
 import { BASE, TOKEN, CLIENT_ID, IS_SHARE_PREVIEW, SHARE_PREVIEW_CONVERSATION_ID, SHARED_CONVERSATION_TOKEN, authHeaders, updateWorkspaceRootHints, applyContextUsageBar, readContextUsageRatio, currentConvId, conversations, setCliOnline, setCloudflaredTunnelState, setActiveRuntimeSessionCount, setRuntimeSessionBindingCount, setContextIndicatorMode, setServerPlatform, setUpdateState } from './store.js';
+import { liveActivityCap } from './live-activity-cap.mjs';
 
 // fetch() has no default timeout. Without one, a request issued while the app is
 // being backgrounded can hang indefinitely on a half-open mobile connection and
@@ -981,6 +982,12 @@ export async function loadConversation(id, options = {}) {
   if (afterTimestamp) params.set('afterTimestamp', afterTimestamp);
   const aroundMessageId = String(options.aroundMessageId || '').trim();
   if (aroundMessageId) params.set('aroundMessageId', aroundMessageId);
+  // The running turn's tool lines per agent this page shows ("Tool lines
+  // shown"; 0 = no limit): the relay sends no more of them.
+  params.set('activityCap', String(liveActivityCap()));
+  // The live poll's finished replies it already holds (held-details.mjs).
+  const heldDetails = String(options.heldDetails || '');
+  if (heldDetails) params.set('heldDetails', heldDetails);
   const query = params.toString();
   // `onErrorResponse` tells a conversation the relay does not know (404) from a failed load.
   const onErrorResponse = typeof options.onErrorResponse === 'function' ? options.onErrorResponse : undefined;

package/server/public/app/ask-user-view.js

@@ -16,7 +16,7 @@ import { isChatInteractionHeld } from './selection-guard.mjs';
 import { questionCardHeadLabel } from './conversation-provider-indicator.mjs';
 import { questionAcceptsFreeText } from './question-answer-rule.mjs';
 import { beginOwnSend, followsTranscriptEnd, refreshJumpButton, scrollAfterOwnSend } from './transcript-jump-bottom-view.mjs';
-import { renderSessionAskCards } from './inbox-ui.js';
+import { renderQuestionStubs } from './questions-panel-ui.js';
 import { isConversationAutoOpenHeld } from './session-history-ui.js';
 
 let relayQuestionRenderHash = '';
@@ -230,8 +230,9 @@ function scrollQuestionCardIntoMessages(el, target) {
 export function renderRelayQuestions() {
   const el = document.getElementById('messages');
   if (!el) return;
-  // The questions that don't block go first: the cards a turn waits on stay last.
-  renderSessionAskCards();
+  // The questions that don't block: their 📓 stubs, in their turns' bubbles
+  // or standing alone before the cards a turn waits on.
+  renderQuestionStubs();
   const previousScrollTop = el.scrollTop;
   // A card is shown to a reader who is at the end. Anyone further up stays
   // where they are; the jump-to-bottom button says that a question waits.

package/server/public/app/bootstrap.js

@@ -63,6 +63,9 @@ import {
 } from './transcript-viewport-anchor.mjs';
 import { initTranscriptJumpToBottom, onTranscriptEndLeft } from './transcript-jump-bottom-view.mjs';
 import { syncScrollOnSendToggle, updateScrollOnSendSetting } from './transcript-jump-bottom.mjs';
+import { isThoughtsExpanded, syncThoughtsExpandedToggle, updateThoughtsExpandedSetting } from './thoughts-preference.mjs';
+import { previewLiveActivityCap, syncLiveActivityCapSlider, updateLiveActivityCap } from './live-activity-cap.mjs';
+import { STREAM_VIEW_CHANGE_EVENT, isStreamViewEnabled, syncStreamViewToggle, updateStreamViewSetting } from './stream-view-preference.mjs';
 import { previewWindowRetention, syncWindowRetentionSlider, updateWindowRetention } from './conversation-window-retention.mjs';
 import { conversationPayloadCache, mergeReloadIntoWindow } from './conversation-payload-cache.mjs';
 import {
@@ -93,7 +96,7 @@ import {
   reportSharedViewerPresence,
   setNetworkRequestsEnabled,
 } from './api-client.js';
-import { loadConversations, refreshConversations, openConversation, renderConvList, applyLoadedConversationState, initConversationListLazyLoading, initConversationFilter } from './journal-view.js';
+import { loadConversations, refreshConversations, openConversation, renderConvList, applyLoadedConversationState, heldDetailsStore, initConversationListLazyLoading, initConversationFilter } from './journal-view.js';
 import {
   newConversation,
   confirmNewConversationModel,
@@ -150,6 +153,7 @@ import {
   getHeldBackLiveRowIds,
   captureConversationReadingAnchor,
   canMergeIntoTranscript,
+  refreshStreamViewLayout,
 } from './conversation-view.js';
 import { loadKeepingLiveRows } from './transcript-reload-freshness.mjs';
 import { backgroundTasksSnapshotMark } from './background-tasks-view.mjs';
@@ -250,6 +254,8 @@ import { closeAnnotateEditor } from './annotate-editor.js';
 import { closeEmojiPicker } from './emoji-view.js';
 import { closeChangeCwdMenu } from './cwd-picker.js';
 import { closeRelayWatchPanel } from './relay-event-subscriptions-ui.js';
+import { closeQuestionsPanel, initQuestionsPanel, openQuestionsPanel, setQuestionsConversation } from './questions-panel-ui.js';
+import { questionsTwinLabel } from './questions-view.mjs';
 import { closeRelaySchedulePanel } from './relay-schedules-ui.js';
 import { isInboxViewActive } from './inbox-ui.js';
 import { initScrollbarHover } from './scrollbar-hover.mjs';
@@ -261,6 +267,8 @@ import {
   renderAutoCompactNotesHtml,
   renderContextUsageHtml,
   renderThinkingControlHtml,
+  renderThoughtsPreferenceHtml,
+  renderStreamViewPreferenceHtml,
   thinkingEnabledFromKey,
   thinkingEnabledToKey,
 } from './context-usage-view.mjs';
@@ -3702,6 +3710,18 @@ function initThinkingControl() {
   if (!body || body.dataset.thinkingBound === '1') return;
   body.dataset.thinkingBound = '1';
   body.addEventListener('click', (event) => {
+    // 🧵 Stream view and 💭 Thoughts: settings of this browser, nothing goes
+    // to the relay. (The stream view's buttons share the thoughts' look.)
+    const streamViewBtn = event.target?.closest?.('.ctx-stream-view-btn');
+    if (streamViewBtn && body.contains(streamViewBtn)) {
+      updateStreamViewSetting(streamViewBtn.dataset.streamView === 'on');
+      return;
+    }
+    const thoughtsBtn = event.target?.closest?.('.ctx-thoughts-btn[data-thoughts-expanded]');
+    if (thoughtsBtn && body.contains(thoughtsBtn)) {
+      updateThoughtsExpandedSetting(thoughtsBtn.dataset.thoughtsExpanded !== 'off');
+      return;
+    }
     const btn = event.target?.closest?.('.ctx-thinking-btn');
     if (!btn || !body.contains(btn)) return;
     void applyThinkingSelection(btn.dataset.thinkingAxis, btn.dataset.thinkingValue);
@@ -3861,6 +3881,10 @@ async function loadContextSummaryAndRender(convId) {
       thinkingDisplay: payload.thinkingDisplay ?? null,
     })
     : '';
+  // Every provider streams thoughts somewhere; the row mirrors the Settings
+  // toggle and is this browser's own.
+  const thoughtsHtml = renderThoughtsPreferenceHtml({ expanded: isThoughtsExpanded() })
+    + renderStreamViewPreferenceHtml({ on: isStreamViewEnabled() });
   // What this folder's commits say, with the folder override: Claude (on
   // either billing), and a Claude Cloud chat that was started from a folder
   // (no path, no row).
@@ -3885,10 +3909,10 @@ async function loadContextSummaryAndRender(convId) {
   // The structured breakdown is the answer; the runtime's own text dump stays
   // available underneath for the details it carries that categories don't.
   const bodyHtml = usageHtml
-    ? `${usageHtml}${autoCompactHtml}${thinkingHtml}${attributionHtml}${agentSessionsHtml}${detailText
+    ? `${usageHtml}${autoCompactHtml}${thinkingHtml}${thoughtsHtml}${attributionHtml}${agentSessionsHtml}${detailText
       ? `<details class="ctx-usage-raw"><summary>Raw details</summary><pre>${escHtml(detailText)}</pre></details>`
       : ''}`
-    : `${autoCompactHtml}${thinkingHtml}${attributionHtml}${agentSessionsHtml}<pre>${escHtml(detailText || 'No context data available.')}</pre>`;
+    : `${autoCompactHtml}${thinkingHtml}${thoughtsHtml}${attributionHtml}${agentSessionsHtml}<pre>${escHtml(detailText || 'No context data available.')}</pre>`;
 
   renderSummaryModalContent({
     title: 'Context usage',
@@ -4130,12 +4154,17 @@ async function pollAuthenticatedCurrentConversationLive() {
     const requestLimit = Math.max(20, getConversationLoadedMessageCount() || 0, savedLoadedCount || 0);
     const tasksMark = backgroundTasksSnapshotMark(currentId);
     const jumpEpoch = getTranscriptJumpEpoch();
+    // The finished replies this page already holds go out without their
+    // tool lines and thoughts (held-details.mjs); the answer gets them back
+    // from the store, or is dropped if it names one the store lacks.
+    const heldDetails = heldDetailsStore.param(currentId);
     const { response, stale } = await loadKeepingLiveRows(
-      () => loadConversation(currentId, { limit: requestLimit }),
+      () => loadConversation(currentId, { limit: requestLimit, heldDetails }),
       getTranscriptLiveRowEpoch,
     );
     if (!response) return;
     if (String(currentConvId || '').trim() !== currentId) return;
+    if (!heldDetailsStore.restore(currentId, response)) return;
     // The user jumped into the history while this request was on its way: the
     // answer is the end of the conversation as it was asked for before that,
     // and would overwrite the window they jumped to. The next round asks again.
@@ -4155,6 +4184,7 @@ async function pollAuthenticatedCurrentConversationLive() {
       followLiveUpdates: preserveBottom,
       mergeFrom: merge?.mergeFrom || null,
       backgroundTasksAsOf: tasksMark,
+      fromPoll: true,
     });
     // A merge does not scroll as the full render does: a reader at the end
     // is taken to the new end here.
@@ -4600,6 +4630,7 @@ function headerPriorityActionAvailability() {
   const fullscreen = document.getElementById('fullscreen-btn');
   return resolveHeaderActionAvailability({
     sharedMode: isSharedReaderMode(),
+    questionCount: Number(document.getElementById('questions-btn')?.dataset.count || 0),
     pinCount: Number(pins?.dataset.count || 0),
     hiddenCount: Number(hiddenBtn?.dataset.count || 0),
     fullscreenAvailable: fullscreen?.dataset.headerAvailable === '1',
@@ -4676,6 +4707,8 @@ function headerFitSignature(header, availability) {
     banner?.className, banner?.hidden, banner?.textContent,
     document.getElementById('sidebar-toggle')?.hidden,
     document.getElementById('chat-actions-menu-btn')?.hidden,
+    document.getElementById('questions-btn')?.dataset.count,
+    document.getElementById('questions-btn')?.dataset.urgent,
     document.getElementById('pinned-messages-btn')?.dataset.count,
     document.getElementById('hidden-messages-btn')?.dataset.count,
     document.getElementById('fullscreen-btn')?.textContent,
@@ -4782,6 +4815,14 @@ function syncHeaderPriorityTwinLabels() {
     const count = Number(document.getElementById(buttonId)?.dataset.count || 0);
     twin.textContent = count ? `${icon} ${text} (${count})` : `${icon} ${text}`;
   };
+  const questions = document.getElementById('questions-btn');
+  const questionsTwin = document.getElementById('chat-menu-questions');
+  if (questionsTwin) {
+    questionsTwin.textContent = questionsTwinLabel({
+      pending: Number(questions?.dataset.count || 0),
+      urgent: Number(questions?.dataset.urgent || 0),
+    });
+  }
   label('pinned-messages-btn', 'chat-menu-pins', 'Pinned messages', '📍');
   label('hidden-messages-btn', 'chat-menu-hidden', 'Hidden from shared viewers', '🙈');
 }
@@ -4812,6 +4853,11 @@ function scheduleHeaderPrioritySync({ force = false } = {}) {
 // syncChatTitleControls.
 function initHeaderPriorityActions({ sharedMode = false } = {}) {
   if (!sharedMode) {
+    // 📓's own button toggles the list under it (questions-panel-ui.js); the
+    // twin opens it under ︙.
+    bindHeaderPriorityAction('questions', () => {
+      openQuestionsPanel({ anchor: document.getElementById('chat-actions-menu-btn') });
+    }, { inline: false });
     bindHeaderPriorityAction('pins', () => openPinnedMessagesModal(), { inline: false });
     bindHeaderPriorityAction('hidden', () => openHiddenMessagesModal(), { inline: false });
     bindHeaderPriorityAction('search', () => openMessageSearchModal(), { inline: false });
@@ -5052,6 +5098,7 @@ function syncChatTitleControls() {
   if (!convId) {
     setPinsConversation(null);
     setHiddenMessagesConversation(null);
+    setQuestionsConversation(null);
   }
   const conversation = convId ? (conversations[convId] || null) : null;
   const sdkSessionId = String(conversation?.sdkSessionId || '').trim();
@@ -5333,6 +5380,9 @@ async function initApp() {
   if (!sharedMode) {
     syncSuspendHostVisibility();
     syncScrollOnSendToggle();
+    syncThoughtsExpandedToggle();
+    syncLiveActivityCapSlider();
+    syncStreamViewToggle();
     syncWindowRetentionSlider();
     initHostSuspendUi();
     initUsageLimitUi();
@@ -5734,6 +5784,7 @@ async function initApp() {
   void loadRelaySchedules();
   // The Inbox's count, and the cards of questions that don't block.
   startInbox();
+  initQuestionsPanel();
   if (pushConversationId) {
     await openConversation(pushConversationId, { history: 'replace' }).catch(() => {});
   }
@@ -5812,6 +5863,7 @@ async function bootstrap() {
     closeTmuxInspector: closeTmuxInspectorView,
     closeAnnotateEditor,
     closeRelayWatchPanel,
+    closeQuestionsPanel,
     closeRelaySchedulePanel,
     closeEmojiPicker,
   });
@@ -5900,6 +5952,12 @@ window.resetGrokAllowanceAccounting = resetGrokAllowanceAccounting;
 window.toggleCursorProvider = toggleCursorProvider;
 window.updateShowSuspendHostSetting = updateShowSuspendHostSetting;
 window.updateScrollOnSendSetting = (enabled) => updateScrollOnSendSetting(enabled);
+window.updateThoughtsExpandedSetting = (expanded) => updateThoughtsExpandedSetting(expanded);
+window.updateStreamViewSetting = (on) => updateStreamViewSetting(on);
+// The transcript and the live bubble take the other layout at once.
+window.addEventListener(STREAM_VIEW_CHANGE_EVENT, () => refreshStreamViewLayout());
+window.previewLiveActivityCap = (position) => previewLiveActivityCap(position);
+window.updateLiveActivityCap = (position) => updateLiveActivityCap(position);
 window.previewConversationWindowRetention = (position) => previewWindowRetention(position);
 // A lower cap cuts the kept windows down now; the open conversation's is cut
 // when it is left.

package/server/public/app/chat-actions-menu-state.mjs

@@ -47,6 +47,7 @@ export const CHAT_ACTIONS_MENU_ENTRY_IDS = Object.freeze([
   'chat-menu-schedules',
   'chat-menu-origin',
   'chat-menu-edit-title',
+  'chat-menu-questions',
   'chat-menu-pins',
   'chat-menu-hidden',
   'chat-menu-search',
@@ -82,6 +83,7 @@ const ALWAYS_HIDDEN_IDS = new Set(['chat-menu-compact', 'chat-menu-refresh-histo
  * with HEADER_PRIORITY_MENU_IDS by the tests.
  */
 export const CHAT_ACTIONS_MENU_TWIN_IDS = Object.freeze([
+  'chat-menu-questions',
   'chat-menu-pins',
   'chat-menu-hidden',
   'chat-menu-search',

package/server/public/app/context-usage-view.mjs

@@ -350,6 +350,74 @@ ${renderThinkingButtons('display', THINKING_DISPLAY_CHOICES, displayKey)}
   `;
 }
 
+const THOUGHTS_EXPANDED_CHOICES = Object.freeze([
+  { key: 'on', label: 'Expanded' },
+  { key: 'off', label: 'Collapsed' },
+]);
+
+/**
+ * The mirror of Settings › General "Expand thoughts while an agent works", for
+ * every provider. A setting of this browser, so nothing goes to the relay:
+ * the buttons write thoughts-preference.mjs and both places follow it.
+ *
+ * @returns {string} HTML
+ */
+export function renderThoughtsPreferenceHtml({ expanded = true } = {}) {
+  const activeKey = expanded === false ? 'off' : 'on';
+  const buttons = THOUGHTS_EXPANDED_CHOICES.map(({ key, label }) => `
+          <button
+            type="button"
+            class="ctx-thoughts-btn${key === activeKey ? ' is-active' : ''}"
+            data-thoughts-expanded="${key}"
+            aria-pressed="${key === activeKey ? 'true' : 'false'}"
+          >${escapeHtml(label)}</button>`).join('');
+  return `
+    <div class="ctx-thinking ctx-thoughts">
+      <div class="ctx-thinking-row">
+        <span class="ctx-thinking-label">💭 Thoughts</span>
+        <div class="ctx-thinking-group" role="group" aria-label="Thoughts while an agent works">
+${buttons}
+        </div>
+      </div>
+      <div class="ctx-thinking-note">Whether thoughts open while an agent works, in sub-agent bubbles and in the sub-agent viewer. A thought you fold or open by hand stays that way. Saved in this browser.</div>
+    </div>
+  `;
+}
+
+const STREAM_VIEW_CHOICES = Object.freeze([
+  { key: 'on', label: 'On' },
+  { key: 'off', label: 'Off' },
+]);
+
+/**
+ * The mirror of Settings › General "Stream view", for every provider. A
+ * setting of this browser (stream-view-preference.mjs); nothing goes to the
+ * relay.
+ *
+ * @returns {string} HTML
+ */
+export function renderStreamViewPreferenceHtml({ on = false } = {}) {
+  const activeKey = on === true ? 'on' : 'off';
+  const buttons = STREAM_VIEW_CHOICES.map(({ key, label }) => `
+          <button
+            type="button"
+            class="ctx-thoughts-btn ctx-stream-view-btn${key === activeKey ? ' is-active' : ''}"
+            data-stream-view="${key}"
+            aria-pressed="${key === activeKey ? 'true' : 'false'}"
+          >${escapeHtml(label)}</button>`).join('');
+  return `
+    <div class="ctx-thinking ctx-stream-view">
+      <div class="ctx-thinking-row">
+        <span class="ctx-thinking-label">🧵 Stream view</span>
+        <div class="ctx-thinking-group" role="group" aria-label="Stream view">
+${buttons}
+        </div>
+      </div>
+      <div class="ctx-thinking-note">Thoughts, tool calls and the reply of a turn as one list in the order they happened. Turns recorded before this version keep the grouped layout. Saved in this browser.</div>
+    </div>
+  `;
+}
+
 /**
  * The owner's switch for a session an agent started: may its agents start
  * sessions themselves (the relay_tool's one-level rule lifted for it)?