@oar-sh/oar 0.9.11 → 0.9.13

package/server/public/app/bootstrap.js

@@ -43,6 +43,8 @@ import {
   loadConversationScrollTop,
   loadConversationLoadedMessageCount,
   saveConversationScrollTop,
+  loadConversationReadingAnchor,
+  saveConversationReadingAnchor,
   getSessionWorkerState,
   resolveConversationUiState,
   summaryModalState,
@@ -61,6 +63,8 @@ import {
 } from './transcript-viewport-anchor.mjs';
 import { initTranscriptJumpToBottom, onTranscriptEndLeft } from './transcript-jump-bottom-view.mjs';
 import { syncScrollOnSendToggle, updateScrollOnSendSetting } from './transcript-jump-bottom.mjs';
+import { previewWindowRetention, syncWindowRetentionSlider, updateWindowRetention } from './conversation-window-retention.mjs';
+import { conversationPayloadCache, mergeReloadIntoWindow } from './conversation-payload-cache.mjs';
 import {
   verifyExistingSession,
   verifyToken,
@@ -101,6 +105,7 @@ import {
   openOriginConversation,
   openConversationGroupPicker,
   toggleConversationGroupFold,
+  isConversationWorking,
 } from './journal-view.js';
 import {
   loadRelayQuestions,
@@ -139,8 +144,13 @@ import {
   isConversationWindowAtTail,
   getTranscriptJumpEpoch,
   getTranscriptLiveRowEpoch,
+  getHeldBackLiveRowIds,
+  captureConversationReadingAnchor,
+  canMergeIntoTranscript,
 } from './conversation-view.js';
 import { loadKeepingLiveRows } from './transcript-reload-freshness.mjs';
+import { backgroundTasksSnapshotMark } from './background-tasks-view.mjs';
+import { newerPageReachesEnd } from './transcript-island.mjs';
 import { initPinnedMessagesView, setPinsConversation } from './pinned-messages-view.mjs';
 import { initHiddenMessagesView, setHiddenMessagesConversation } from './hidden-messages-view.mjs';
 import { bindChatSelectionGuard, chatSelectionGuard, isChatInteractionHeld } from './selection-guard.mjs';
@@ -189,6 +199,7 @@ import {
   closeMessageSearchModal,
 } from './message-search-view.js';
 import { initSubagentViewer } from './subagent-viewer.mjs';
+import { initTaskConsole } from './task-console.mjs';
 import { watchPreviewMarks } from './share-preview-marks.mjs';
 import {
   initGitChangesView,
@@ -327,6 +338,9 @@ import {
   updateTurnCeilingSetting,
   previewBackgroundTaskTimeoutSetting,
   updateBackgroundTaskTimeoutSetting,
+  previewTaskStallMinutesSetting,
+  updateTaskStallMinutesSetting,
+  updateRestartResumeSettingFromToggle,
   updateSubagentRecordRetentionSetting,
 } from './settings-modal.js';
 import {
@@ -3703,6 +3717,23 @@ function transcriptIsInHistory(conversationId) {
   return !isConversationWindowAtTail() && !hasPendingUserMessageForConversation(conversationId);
 }
 
+// A reload of the end of the conversation on screen, when the page holds
+// more rows than the answer can (the relay caps a page at 100): the answer
+// is merged into the window (mergeReloadIntoWindow) rather than rendered,
+// which would cut the page and its kept window down to the answer. Null
+// means the plain render, as before: nothing to merge, or a transcript that
+// cannot take a merge (a bubble waiting for its send, the status view, a
+// held selection, a row missing from the page). Both callers merge only an
+// answer no live row overtook (loadKeepingLiveRows not stale), so the window
+// predates it: a newer row the answer lacks was deleted (a cancelled
+// follow-up) and leaves the page.
+function reloadMergeFor(conversationId, response) {
+  if (IS_SHARED_VIEW) return null;
+  const merge = mergeReloadIntoWindow(conversationPayloadCache.peekWindow(conversationId), response, { windowPredatesPage: true });
+  if (!merge || !canMergeIntoTranscript(merge.mergeFrom, conversationId)) return null;
+  return merge;
+}
+
 async function pollAuthenticatedCurrentConversationLive() {
   if (liveConversationPollInFlight) return;
   if (isSharedReaderMode()) return;
@@ -3729,6 +3760,7 @@ async function pollAuthenticatedCurrentConversationLive() {
     const savedScrollTop = messagesEl?.scrollTop || 0;
     const savedLoadedCount = loadConversationLoadedMessageCount(currentId);
     const requestLimit = Math.max(20, getConversationLoadedMessageCount() || 0, savedLoadedCount || 0);
+    const tasksMark = backgroundTasksSnapshotMark(currentId);
     const jumpEpoch = getTranscriptJumpEpoch();
     const { response, stale } = await loadKeepingLiveRows(
       () => loadConversation(currentId, { limit: requestLimit }),
@@ -3748,11 +3780,17 @@ async function pollAuthenticatedCurrentConversationLive() {
     // The rows are rebuilt: a reader who is not at the end keeps the text
     // they read where it is, whatever the rows above it measure now.
     const reading = preserveBottom ? null : captureReadingBlock(messagesEl);
-    applyLoadedConversationState(currentId, response, {
+    const merge = reloadMergeFor(currentId, response);
+    applyLoadedConversationState(currentId, merge?.payload || response, {
       restoreScroll: !preserveBottom,
       savedScrollTop: preserveBottom ? null : stableSavedScrollTop,
       followLiveUpdates: preserveBottom,
+      mergeFrom: merge?.mergeFrom || null,
+      backgroundTasksAsOf: tasksMark,
     });
+    // A merge does not scroll as the full render does: a reader at the end
+    // is taken to the new end here.
+    if (merge && preserveBottom && messagesEl) messagesEl.scrollTop = messagesEl.scrollHeight;
     if (reading) restoreReadingBlock(messagesEl, reading);
   } finally {
     liveConversationPollInFlight = false;
@@ -3888,6 +3926,21 @@ function initComposerAttachmentInput() {
   window.addEventListener('dragend', clearHighlight);
 }
 
+// The place read is noted once per frame: it measures rows, a scroll event
+// can come many times a frame. It is noted for the conversation whose rows
+// are on the page, and only while that is the one open: during a switch the
+// page still shows the conversation left.
+let readingAnchorSaveFrame = 0;
+function scheduleReadingAnchorSave() {
+  if (readingAnchorSaveFrame || IS_SHARED_VIEW) return;
+  readingAnchorSaveFrame = requestAnimationFrame(() => {
+    readingAnchorSaveFrame = 0;
+    const captured = captureConversationReadingAnchor();
+    if (!captured || captured.conversationId !== String(currentConvId || '').trim()) return;
+    saveConversationReadingAnchor(captured.conversationId, captured.anchor);
+  });
+}
+
 function initMessageScrollPersistence() {
   const el = document.getElementById('messages');
   if (!el || el.dataset.scrollPersistenceBound === '1') return;
@@ -3897,19 +3950,43 @@ function initMessageScrollPersistence() {
     const convId = String(currentConvId || '').trim();
     if (!convId) return;
     saveConversationScrollTop(convId, el.scrollTop);
+    scheduleReadingAnchorSave();
   }, { passive: true });
 }
 
-// The jump-to-bottom button on a window in the middle of the history: the
-// end of the conversation replaces it, scrolled to the bottom.
+// The end's answer can predate a row held back below the window while it
+// was on its way (stored after the request read the conversation), and its
+// render lets the held rows go. The newest row held is the one to look for:
+// older ones can lie before a page of the end and are not missing.
+function endAnswerLacksHeldBackRow(response) {
+  const newestHeld = getHeldBackLiveRowIds().slice(-1);
+  if (!newestHeld.length) return false;
+  return !newerPageReachesEnd({
+    pageHasMore: false,
+    pageMessageIds: (Array.isArray(response?.messages) ? response.messages : []).map((message) => message?.id),
+    heldBackIds: newestHeld,
+  });
+}
+
+// The jump-to-bottom button on a window in the middle of the history (and an
+// own send from one): the end of the conversation replaces it, scrolled to
+// the bottom.
 async function loadCurrentConversationEnd() {
   const currentId = String(currentConvId || '').trim();
   if (!currentId) return;
   const jumpEpoch = getTranscriptJumpEpoch();
-  const response = await loadConversation(currentId, { limit: 20 });
+  const load = () => loadConversation(currentId, { limit: 20 });
+  let response = await load();
   if (!response || String(currentConvId || '').trim() !== currentId) return;
   // A jump into the history while it was on its way wins.
   if (getTranscriptJumpEpoch() !== jumpEpoch) return;
+  // Asked once more, not until it has them: a held row deleted since would
+  // never come.
+  if (endAnswerLacksHeldBackRow(response)) {
+    const again = await load();
+    if (String(currentConvId || '').trim() !== currentId || getTranscriptJumpEpoch() !== jumpEpoch) return;
+    if (again) response = again;
+  }
   applyLoadedConversationState(currentId, response, { restoreScroll: false });
 }
 
@@ -3988,6 +4065,7 @@ async function refreshCurrentView() {
 
   const savedLoadedCount = loadConversationLoadedMessageCount(currentId);
   const requestLimit = Math.max(20, getConversationLoadedMessageCount() || 0, savedLoadedCount || 0);
+  const tasksMark = backgroundTasksSnapshotMark(currentId);
   const { response: r, stale } = await loadKeepingLiveRows(
     () => loadConversation(currentId, { limit: requestLimit }),
     getTranscriptLiveRowEpoch,
@@ -4005,12 +4083,17 @@ async function refreshCurrentView() {
   const reading = preserveBottom || keepTranscript ? null : captureReadingBlock(messagesEl);
   let restoredAt = null;
   if (r) {
-    applyLoadedConversationState(currentId, r, {
+    const merge = keepTranscript ? null : reloadMergeFor(currentId, r);
+    applyLoadedConversationState(currentId, merge?.payload || r, {
       restoreScroll: !preserveBottom,
       savedScrollTop: preserveBottom ? null : stableSavedScrollTop,
       followLiveUpdates: preserveBottom && !keepTranscript,
       keepTranscript,
+      mergeFrom: merge?.mergeFrom || null,
+      backgroundTasksAsOf: tasksMark,
     });
+    // As in the live poll: a merge leaves the scrolling to the caller.
+    if (merge && preserveBottom && messagesEl) messagesEl.scrollTop = messagesEl.scrollHeight;
     // At once, and again below once the cards are back on the page.
     restoreReadingBlock(messagesEl, reading);
     restoredAt = { scrollTop: messagesEl?.scrollTop };
@@ -4254,6 +4337,7 @@ function syncChatTitleControls() {
   if (title) {
     if (!convId || !conversation) {
       delete title.dataset.uiState;
+      delete title.dataset.working;
     } else {
       const pendingByConversation = getPendingQuestionCountsByConversation();
       const pendingCount = Number(pendingByConversation[convId] || 0);
@@ -4264,6 +4348,8 @@ function syncChatTitleControls() {
         hasPendingQuestion: pendingCount > 0,
       });
       title.dataset.uiState = uiState;
+      // Bright green while it works, the darker green while idle, as its row.
+      title.toggleAttribute('data-working', isConversationWorking(conversation));
     }
   }
   if (chatTitleEditingConversationId && chatTitleEditingConversationId !== convId) {
@@ -4519,6 +4605,7 @@ async function initApp() {
   if (!sharedMode) {
     syncSuspendHostVisibility();
     syncScrollOnSendToggle();
+    syncWindowRetentionSlider();
     initHostSuspendUi();
     initUsageLimitUi();
   }
@@ -4848,6 +4935,7 @@ async function initApp() {
   initComposerAttachmentInput();
   initMessageSearchView({ openConversation });
   initSubagentViewer();
+  initTaskConsole();
   initPinnedMessagesView({
     openConversation,
     focusMessage: focusConversationMessageById,
@@ -5007,11 +5095,20 @@ window.resetGrokAllowanceAccounting = resetGrokAllowanceAccounting;
 window.toggleCursorProvider = toggleCursorProvider;
 window.updateShowSuspendHostSetting = updateShowSuspendHostSetting;
 window.updateScrollOnSendSetting = (enabled) => updateScrollOnSendSetting(enabled);
+window.previewConversationWindowRetention = (position) => previewWindowRetention(position);
+// A lower cap cuts the kept windows down now; the open conversation's is cut
+// when it is left.
+window.updateConversationWindowRetention = (position) => updateWindowRetention(position, {
+  onChange: (cap) => conversationPayloadCache.trimAll(cap, loadConversationReadingAnchor, { except: currentConvId }),
+});
 window.updateWindowsAutostartMode = updateWindowsAutostartMode;
 window.previewTurnCeilingSetting = previewTurnCeilingSetting;
 window.updateTurnCeilingSetting = updateTurnCeilingSetting;
 window.previewBackgroundTaskTimeoutSetting = previewBackgroundTaskTimeoutSetting;
 window.updateBackgroundTaskTimeoutSetting = updateBackgroundTaskTimeoutSetting;
+window.previewTaskStallMinutesSetting = previewTaskStallMinutesSetting;
+window.updateTaskStallMinutesSetting = updateTaskStallMinutesSetting;
+window.updateRestartResumeSettingFromToggle = updateRestartResumeSettingFromToggle;
 window.updateSubagentRecordRetentionSetting = updateSubagentRecordRetentionSetting;
 window.togglePushOnThisDevice = togglePushOnThisDevice;
 window.updatePushPreferencesFromControls = updatePushPreferencesFromControls;

package/server/public/app/claude-background-command-limit-options.mjs

@@ -0,0 +1,21 @@
+// Mirrors shared/claude-background-command-limit.mjs, which the browser cannot
+// import (only server/public is served).
+// shared/claude-background-command-limit.test.mjs asserts the two stay
+// identical.
+//
+// The Claude settings slider shows the default until the relay's own value
+// loads; the authoritative bounds come from GET /api/settings/claude.
+
+export const DEFAULT_CLAUDE_BACKGROUND_COMMAND_LIMIT_MINUTES = 120;
+export const CLAUDE_BACKGROUND_COMMAND_LIMIT_MIN_MINUTES = 30;
+export const CLAUDE_BACKGROUND_COMMAND_LIMIT_MAX_MINUTES = 480;
+export const CLAUDE_BACKGROUND_COMMAND_LIMIT_STEP_MINUTES = 30;
+
+export function formatClaudeBackgroundCommandLimitLabel(minutes) {
+  const numeric = Math.round(Number(minutes));
+  const value = Number.isFinite(numeric) && numeric > 0 ? numeric : DEFAULT_CLAUDE_BACKGROUND_COMMAND_LIMIT_MINUTES;
+  if (value < 60) return `${value} min`;
+  const hours = Math.floor(value / 60);
+  const remainder = value % 60;
+  return remainder ? `${hours} h ${remainder} min` : `${hours} h`;
+}

package/server/public/app/conversation-payload-cache.mjs

@@ -0,0 +1,357 @@
+// The window of messages the page showed for each recently viewed
+// conversation, with the payload it came in, in memory for this page load
+// only. Switching back to one of them draws it at once from here, where the
+// reader left it, older pages included; the fresh answer the switch asks for
+// is merged into it when it arrives. The window follows the page: pages of
+// older or newer history and the socket's live rows are added to it, and it
+// is cut down to the retention cap when the reader leaves the conversation
+// (conversation-window-retention.mjs).
+// The live parts of a payload (a turn in flight, its state, tasks, draft,
+// usage pause) are left out of the copy a read hands out: they are out of
+// date the moment the payload is stored, and the fresh answer and the socket
+// set them.
+
+import { mergeTailPage, trimMessageWindow } from './transcript-reading-anchor.mjs';
+
+/** Conversations kept; the least recently used goes first. */
+export const CONVERSATION_PAYLOAD_CACHE_LIMIT = 8;
+
+// Fields of a conversation payload that describe the moment it was read, not
+// the transcript. A cached copy without them cannot end a turn, start the
+// thinking bubble, or bring back a draft or a task list that has changed.
+const LIVE_PAYLOAD_FIELDS = [
+  'inFlight',
+  'activeTurn',
+  'sessionState',
+  'backgroundTasks',
+  'endedBackgroundTasks',
+  'usageLimitPause',
+  'draftText',
+  'draftAttachments',
+  'draftUpdatedAt',
+  'draftUpdatedByClientId',
+  'previews',
+];
+
+// What the payload said about its own page; a read describes the kept
+// window instead.
+const PAGE_FIELDS = ['pageInfo', 'hasMoreHistory', 'historyCursor', 'historyNewestMessageId'];
+
+function normalizeId(conversationId) {
+  return String(conversationId || '').trim();
+}
+
+function messageIdOf(message) {
+  return String(message?.id || '').trim();
+}
+
+function clonePayload(value) {
+  try {
+    return structuredClone(value);
+  } catch {
+    // A payload is plain JSON; this is only reached by an odd value in it.
+    return JSON.parse(JSON.stringify(value));
+  }
+}
+
+/** True when the payload is a window with newer messages left unloaded. */
+export function payloadHasMoreNewer(response) {
+  if (!response || typeof response !== 'object') return false;
+  if (typeof response.hasMoreNewer === 'boolean') return response.hasMoreNewer;
+  const pageInfo = response.pageInfo && typeof response.pageInfo === 'object' ? response.pageInfo : null;
+  return !!pageInfo?.hasMoreNewer;
+}
+
+/** True when the payload has older messages left unloaded; read as renderMessages reads it. */
+export function payloadHasMoreOlder(response) {
+  if (!response || typeof response !== 'object') return false;
+  if (typeof response.hasMoreOlder === 'boolean') return response.hasMoreOlder;
+  if (typeof response.hasMoreHistory === 'boolean') return response.hasMoreHistory;
+  const pageInfo = response.pageInfo && typeof response.pageInfo === 'object' ? response.pageInfo : null;
+  return !!pageInfo?.hasMoreOlder || !!pageInfo?.hasMore;
+}
+
+function isCacheable(response) {
+  return !!response && typeof response === 'object' && Array.isArray(response.messages);
+}
+
+function cursorOf(message, direction) {
+  if (!message) return null;
+  const id = messageIdOf(message);
+  const timestamp = String(message.timestamp || '').trim() || null;
+  return direction === 'older'
+    ? { beforeMessageId: id, beforeTimestamp: timestamp }
+    : { afterMessageId: id, afterTimestamp: timestamp };
+}
+
+/** The pageInfo of a kept window, in the relay's shape, so the loaders page on from its edges. */
+export function windowPageInfo(messages, { hasMoreOlder = false, hasMoreNewer = false } = {}) {
+  const list = Array.isArray(messages) ? messages : [];
+  const first = list[0] || null;
+  const last = list[list.length - 1] || null;
+  return {
+    hasMore: !!hasMoreOlder,
+    hasMoreOlder: !!hasMoreOlder,
+    hasMoreNewer: !!hasMoreNewer,
+    nextCursor: cursorOf(first, 'older'),
+    olderCursor: cursorOf(first, 'older'),
+    newerCursor: cursorOf(last, 'newer'),
+  };
+}
+
+function windowPayload(entry) {
+  const transcriptOnly = { ...entry.payload };
+  for (const field of LIVE_PAYLOAD_FIELDS) delete transcriptOnly[field];
+  for (const field of PAGE_FIELDS) delete transcriptOnly[field];
+  const flags = { hasMoreOlder: entry.hasMoreOlder, hasMoreNewer: entry.hasMoreNewer };
+  return {
+    ...transcriptOnly,
+    messages: entry.messages,
+    ...flags,
+    pageInfo: windowPageInfo(entry.messages, flags),
+  };
+}
+
+/**
+ * The copy of a payload the cache hands out, without its live fields, or
+ * null when it must not be kept. The live fields are left out before the
+ * clone: a turn in flight can carry thousands of thought rows nobody reads.
+ */
+export function cacheablePayload(response) {
+  if (!isCacheable(response)) return null;
+  return clonePayload(windowPayload(entryFor(response)));
+}
+
+function entryFor(response) {
+  return {
+    payload: response,
+    messages: response.messages,
+    hasMoreOlder: payloadHasMoreOlder(response),
+    hasMoreNewer: payloadHasMoreNewer(response),
+  };
+}
+
+// The messages of `incoming` whose ids the window lacks, in their order.
+function unseen(entry, incoming) {
+  const known = new Set(entry.messages.map(messageIdOf).filter(Boolean));
+  return (Array.isArray(incoming) ? incoming : []).filter((message) => {
+    const id = messageIdOf(message);
+    if (!message || !id || known.has(id)) return false;
+    known.add(id);
+    return true;
+  });
+}
+
+/**
+ * A reload of the end of the conversation on screen (the live poll, a view
+ * refresh) merged into the window the page holds, or null when the plain
+ * render of the answer is right. The relay caps a page at 100 messages: with
+ * more loaded, a render of the answer would cut the page and the kept window
+ * down to it. Merged only when both the window and the answer reach the end,
+ * the window holds more than the answer, and the two meet (mergeTailPage).
+ * `mergeFrom` is the window as it is on the page, `payload` the answer with
+ * the merged window as its messages and the window's edges.
+ * `windowPredatesPage`: no live row reached the window while the answer was
+ * on its way (see mergeTailPage), so a newer window row the answer lacks was
+ * deleted, not brought by the socket after the read.
+ */
+export function mergeReloadIntoWindow(kept, response, { windowPredatesPage = false } = {}) {
+  if (!kept || !Array.isArray(kept.messages) || !isCacheable(response)) return null;
+  if (kept.hasMoreNewer || payloadHasMoreNewer(response)) return null;
+  if (kept.messages.length <= response.messages.length) return null;
+  const merged = mergeTailPage(kept.messages, response.messages, {
+    pageHasMoreOlder: payloadHasMoreOlder(response),
+    windowPredatesPage,
+  });
+  if (!merged) return null;
+  const flags = { hasMoreOlder: !!kept.hasMoreOlder, hasMoreNewer: false };
+  return {
+    mergeFrom: kept.messages,
+    payload: {
+      ...response,
+      messages: merged.messages,
+      ...flags,
+      pageInfo: windowPageInfo(merged.messages, flags),
+    },
+  };
+}
+
+export function createConversationPayloadCache({ limit = CONVERSATION_PAYLOAD_CACHE_LIMIT } = {}) {
+  const maxEntries = Math.max(1, Math.trunc(Number(limit) || CONVERSATION_PAYLOAD_CACHE_LIMIT));
+  // A Map keeps insertion order: the first key is the least recently used.
+  const entries = new Map();
+
+  function forget(conversationId) {
+    const id = normalizeId(conversationId);
+    if (!id) return false;
+    return entries.delete(id);
+  }
+
+  /**
+   * Keeps the payload just applied for the conversation: its messages are the
+   * window the page shows. A payload that may not be kept drops the older one
+   * too: the page no longer shows it.
+   * Only a reference is kept: this runs on every apply, the live poll during
+   * a turn included, and a fresh payload from the relay is not changed once
+   * it is on the page. The copy is made on read, when a switch needs it; the
+   * window's own changes below make new arrays and never touch the payload.
+   */
+  function remember(conversationId, response) {
+    const id = normalizeId(conversationId);
+    if (!id) return false;
+    entries.delete(id);
+    if (!isCacheable(response)) return false;
+    entries.set(id, entryFor(response));
+    while (entries.size > maxEntries) {
+      entries.delete(entries.keys().next().value);
+    }
+    return true;
+  }
+
+  // Changes to a window do not count as use: a conversation still open is
+  // the most recently used anyway, and one read last keeps its place.
+  function entryOf(conversationId) {
+    return entries.get(normalizeId(conversationId)) || null;
+  }
+
+  /** An older page was put above the window. */
+  function addOlder(conversationId, messages, { hasMoreOlder = false } = {}) {
+    const entry = entryOf(conversationId);
+    if (!entry) return false;
+    entry.messages = [...unseen(entry, messages), ...entry.messages];
+    entry.hasMoreOlder = !!hasMoreOlder;
+    return true;
+  }
+
+  /** A newer page was put below the window. */
+  function addNewer(conversationId, messages, { hasMoreNewer = false } = {}) {
+    const entry = entryOf(conversationId);
+    if (!entry) return false;
+    entry.messages = [...entry.messages, ...unseen(entry, messages)];
+    entry.hasMoreNewer = !!hasMoreNewer;
+    return true;
+  }
+
+  /**
+   * A live row from the socket: it replaces the message with its id, or joins
+   * the end of a window that is the end of the conversation. A window in the
+   * middle of the history leaves it to the newer pages.
+   */
+  function upsertMessage(conversationId, message) {
+    const entry = entryOf(conversationId);
+    const messageId = messageIdOf(message);
+    if (!entry || !messageId) return false;
+    const index = entry.messages.findIndex((item) => messageIdOf(item) === messageId);
+    if (index >= 0) {
+      entry.messages = entry.messages.map((item, at) => (at === index ? message : item));
+      return true;
+    }
+    if (entry.hasMoreNewer) return false;
+    entry.messages = [...entry.messages, message];
+    return true;
+  }
+
+  /** The window no longer meets the end of the conversation (more was written than one page holds). */
+  function detachFromTail(conversationId) {
+    const entry = entryOf(conversationId);
+    if (!entry) return false;
+    entry.hasMoreNewer = true;
+    return true;
+  }
+
+  /**
+   * Cuts the window down to `cap` messages around the reader's place
+   * (trimMessageWindow). True when rows were dropped.
+   */
+  function trim(conversationId, { cap = Infinity, anchorMessageId = '', atTail = false } = {}) {
+    const entry = entryOf(conversationId);
+    if (!entry) return false;
+    const next = trimMessageWindow(entry.messages, {
+      cap,
+      anchorMessageId,
+      atTail,
+      hasMoreOlder: entry.hasMoreOlder,
+      hasMoreNewer: entry.hasMoreNewer,
+    });
+    if (!next.trimmed) return false;
+    entry.messages = next.messages;
+    entry.hasMoreOlder = next.hasMoreOlder;
+    entry.hasMoreNewer = next.hasMoreNewer;
+    return true;
+  }
+
+  /** `anchorOf(id)` gives the reader's place in each kept conversation. */
+  function trimAll(cap, anchorOf = () => null, { except = '' } = {}) {
+    const skip = normalizeId(except);
+    let trimmed = 0;
+    for (const id of [...entries.keys()]) {
+      if (id === skip) continue;
+      const anchor = anchorOf(id) || null;
+      if (trim(id, { cap, anchorMessageId: anchor?.messageId || '', atTail: anchor?.atTail === true })) trimmed += 1;
+    }
+    return trimmed;
+  }
+
+  /**
+   * A copy of the kept window without its live fields (the caller may change
+   * it), or null. Its messages are the window, its pageInfo and flags
+   * describe the window's edges.
+   */
+  function read(conversationId) {
+    const id = normalizeId(conversationId);
+    if (!id || !entries.has(id)) return null;
+    const entry = entries.get(id);
+    entries.delete(id);
+    entries.set(id, entry);
+    return clonePayload(windowPayload(entry));
+  }
+
+  function has(conversationId) {
+    return entries.has(normalizeId(conversationId));
+  }
+
+  /**
+   * The window as it is, uncopied, without counting as use: for a reload of
+   * the conversation on screen, which reads it on every poll. The caller must
+   * not change it (the window's own changes make new arrays, so a held
+   * reference stays as it was read).
+   */
+  function peekWindow(conversationId) {
+    const entry = entryOf(conversationId);
+    if (!entry) return null;
+    return { messages: entry.messages, hasMoreOlder: entry.hasMoreOlder, hasMoreNewer: entry.hasMoreNewer };
+  }
+
+  /** How many messages the window holds (0 when none is kept). */
+  function windowSize(conversationId) {
+    return entryOf(conversationId)?.messages.length || 0;
+  }
+
+  function clear() {
+    entries.clear();
+  }
+
+  return {
+    remember,
+    addOlder,
+    addNewer,
+    upsertMessage,
+    detachFromTail,
+    trim,
+    trimAll,
+    read,
+    peekWindow,
+    forget,
+    has,
+    windowSize,
+    clear,
+    keys: () => [...entries.keys()],
+    get size() {
+      return entries.size;
+    },
+  };
+}
+
+// The page's one cache: the conversation views write and read it, the socket
+// handlers drop entries the relay has changed.
+export const conversationPayloadCache = createConversationPayloadCache();

package/server/public/app/conversation-preferences.mjs

@@ -89,11 +89,14 @@ function normalizeEffortList(efforts = []) {
  *   3. else the lowest supported rung ABOVE it, ignoring 'none'
  *      (a remembered 'minimal' on a model whose floor is 'low' → low);
  *   4. else the next candidate.
- * With no candidate usable: the lowest non-'none' rung the model offers, or
- * 'none' when that is all there is. Effort names off the ladder (image
- * quality values, unknown providers) only ever match exactly.
+ * With no candidate usable: the lowest non-'none' rung the model offers (by
+ * rung, whatever the list order), or 'none' when that is all there is; a
+ * list with names off the ladder keeps its own order there. A caller with a
+ * default of its own passes `fallback`, returned instead in that case.
+ * Effort names off the ladder (image quality values, unknown providers) only
+ * ever match exactly.
  */
-export function nearestSupportedReasoningEffort(candidates = [], supportedEfforts = []) {
+export function nearestSupportedReasoningEffort(candidates = [], supportedEfforts = [], { fallback } = {}) {
   const options = normalizeEffortList(supportedEfforts);
   if (!options.length) return '';
   const rungOf = (effort) => REASONING_EFFORT_LADDER.indexOf(effort);
@@ -109,6 +112,9 @@ export function nearestSupportedReasoningEffort(candidates = [], supportedEffort
     const above = ranked.find((option) => rungOf(option) > rung && option !== 'ultracode');
     if (above) return above;
   }
+  if (fallback !== undefined) return fallback;
+  const lowest = ranked.find((option) => option !== 'ultracode');
+  if (lowest && options.every((option) => rungOf(option) >= 0)) return lowest;
   return options.find((option) => option !== 'none') || options[0];
 }
 

package/server/public/app/conversation-turn-state.mjs

@@ -2,7 +2,7 @@
 // `backgroundTaskCount`) kept in step with the live events, for every row
 // and not only the open one. The list fetch sets them; between fetches the
 // `message_status` and `background_tasks` events are the only word on what
-// a session is doing, and the sidebar's dots, a group head's pill and its
+// a session is doing, and the sidebar's title colour, a group head's pill and its
 // fold read these fields. DOM-free.
 
 const TERMINAL_STATUSES = new Set(['done', 'failed', 'dropped', 'cancelled']);