@oar-sh/oar 0.9.12 → 0.9.14

package/server/public/app/action-confirmations.js

@@ -20,6 +20,7 @@ import {
 } from './api-client.js';
 import { isSuspendHostActionVisible } from './settings-modal.js';
 import { describeRelayRestartError } from './relay-restart-error.mjs';
+import { initRelayRestartUi, openRestartRelayConfirmation } from './relay-restart-ui.js';
 import {
   applyHostSuspendState,
   describeHostSuspendBlocker,
@@ -106,21 +107,10 @@ export async function confirmKillCurrentSession() {
   }
 }
 
-export function openRestartRelayConfirmation() {
-  openSummaryModal({
-    title: 'Restart web relay',
-    subtitle: 'Queues restart via /api/relay/shutdown',
-    kind: 'restart-relay',
-    bodyHtml: `
-      <p>Queue a manual relay restart now?</p>
-      <p>The restart waits until the current turn is idle, so it does not interrupt an in-flight turn immediately.</p>
-      <div class="summary-modal-actions">
-        <button class="chat-title-action-btn" type="button" onclick="confirmRestartWebRelay()">🌄 Restart web relay</button>
-        <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Cancel</button>
-      </div>
-    `,
-  });
-}
+// ⋯ → Restart web relay first shows what the restart would wait for and
+// leave running (relay-restart-ui.js); its buttons land in
+// confirmRestartWebRelay below or in confirmRestartRelayNow.
+export { openRestartRelayConfirmation };
 
 export function openEmptyQueueConfirmation() {
   menuDeps.lockChatActionsMenuShield(350);
@@ -375,6 +365,10 @@ export async function confirmRestartWebRelay() {
       showTransientRelayNotice('Relay is already shutting down/restarting.', 7000);
       return;
     }
+    if (result.status === 'shutting_down') {
+      showTransientRelayNotice('Nothing was running: the relay is restarting now.', 7000);
+      return;
+    }
     const queue = result.queue || {};
     showTransientRelayNotice(
       `Relay restart queued (pending=${Number(queue.pendingCount || 0)}, processing=${Number(queue.processingCount || 0)}).`,
@@ -399,6 +393,9 @@ export function initActionConfirmations({
     syncQueueStatusMenuEntry: typeof syncQueueStatusMenuEntry === 'function' ? syncQueueStatusMenuEntry : menuDeps.syncQueueStatusMenuEntry,
     refreshSessionWorkerStatus: typeof refreshSessionWorkerStatus === 'function' ? refreshSessionWorkerStatus : menuDeps.refreshSessionWorkerStatus,
   };
+  // The restart confirmations' and banner's inline handlers live on window
+  // either way (bootstrap exposes this module's own).
+  initRelayRestartUi();
   if (!exposeOnWindow) return;
   window.openKillSessionConfirmation = openKillSessionConfirmation;
   window.openRestartRelayConfirmation = openRestartRelayConfirmation;

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

@@ -45,7 +45,7 @@ export function areNetworkRequestsEnabled() {
   return networkRequestsEnabled;
 }
 
-export async function apiFetch(url, opts = {}) {
+export async function apiFetch(url, { onErrorResponse, ...opts } = {}) {
   // A keepalive request is a page's last word; it goes out even when the
   // page's regular network work is already suspended.
   if (!networkRequestsEnabled && !opts.keepalive) return null;
@@ -61,6 +61,9 @@ export async function apiFetch(url, opts = {}) {
     });
     if (!response.ok) {
       console.error('API error', response.status, url);
+      // A caller that shows why a request failed reads the answer here; the
+      // result is still null.
+      if (typeof onErrorResponse === 'function') await onErrorResponse(response);
       return null;
     }
     noteFetchSuccess();
@@ -585,6 +588,18 @@ export async function updateTaskStallMinutesSetting(minutes) {
   });
 }
 
+// "After a relay restart, tell interrupted sessions to carry on" (off by default).
+export async function loadRestartResumeSetting() {
+  return apiFetch('/api/settings/restart-resume');
+}
+
+export async function updateRestartResumeSetting(enabled) {
+  return apiFetch('/api/settings/restart-resume', {
+    method: 'POST',
+    body: JSON.stringify({ enabled: enabled === true }),
+  });
+}
+
 export async function loadPwaAppNameSetting() {
   return apiFetch('/api/settings/pwa-app-name');
 }
@@ -1425,6 +1440,31 @@ export async function cancelRelayRestart(body = {}) {
   });
 }
 
+// The queued restart's state, and the picture for a restart asked now: the
+// sessions it would wait for, the messages it would hold, the background
+// tasks and whether they survive (routes/relay-restart-routes.mjs).
+export async function loadRelayRestartPreview(action = 'restart') {
+  return apiFetchOrThrow(`/api/relay/shutdown?action=${encodeURIComponent(action)}`);
+}
+
+export async function keepWaitingForRelayRestart(body = {}) {
+  return apiFetchOrThrow('/api/relay/shutdown/keep-waiting', {
+    method: 'POST',
+    body: JSON.stringify({ requestedBy: 'localhost-api', ...(body || {}) }),
+  });
+}
+
+export async function loadRelayRestartMaxWaitSetting() {
+  return apiFetch('/api/settings/relay-restart-max-wait');
+}
+
+export async function updateRelayRestartMaxWaitSetting(maxWaitMinutes) {
+  return apiFetchOrThrow('/api/settings/relay-restart-max-wait', {
+    method: 'POST',
+    body: JSON.stringify({ maxWaitMinutes: Number(maxWaitMinutes) }),
+  });
+}
+
 export async function requestQueueEmpty(body = {}) {
   return apiFetchOrThrow('/api/queue/empty', {
     method: 'POST',
@@ -1436,8 +1476,22 @@ export async function requestQueueEmpty(body = {}) {
   });
 }
 
-export async function sendMessage(body) {
-  return apiFetch('/api/message', { method: 'POST', body: JSON.stringify(body) });
+// Null on any failure, like apiFetch. A send the relay refused for a reason
+// the user can act on (a 409 such as "this conversation's model is no longer
+// available") hands that reason to onRefused first, so the composer can say
+// it instead of "could not be sent". A replayed send that already landed
+// (DUPLICATE_MESSAGE_ID) is not a refusal.
+export async function sendMessage(body, { onRefused } = {}) {
+  return apiFetch('/api/message', {
+    method: 'POST',
+    body: JSON.stringify(body),
+    onErrorResponse: async (response) => {
+      if (response.status !== 409 || typeof onRefused !== 'function') return;
+      const payload = await response.json().catch(() => null);
+      const reason = readableServerError(payload?.error);
+      if (reason && payload?.code !== 'DUPLICATE_MESSAGE_ID') onRefused(reason, payload);
+    },
+  });
 }
 
 // Raw fetch instead of apiFetch: a rejected bootstrap (bad CWD, unavailable
@@ -1506,13 +1560,15 @@ export async function loadRelayQuestion(questionId) {
   return apiFetch(`/api/relay-question/${encodeURIComponent(id)}`);
 }
 
-export async function answerRelayQuestion(questionId, answer, sdkSessionId = null) {
+// `onErrorResponse` reads the relay's refusal (why, and a card's choices).
+export async function answerRelayQuestion(questionId, answer, sdkSessionId = null, { onErrorResponse } = {}) {
   const id = String(questionId || '').trim();
   if (!id) return null;
   const sessionId = String(sdkSessionId || '').trim();
   return apiFetch(`/api/relay-question/${encodeURIComponent(id)}/answer`, {
     method: 'POST',
     body: JSON.stringify({ answer, sdk_session_id: sessionId || undefined }),
+    onErrorResponse,
   });
 }
 

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

@@ -14,6 +14,7 @@ import { schemaFieldsFromQuestion } from './question-schema-view.mjs';
 import { composeMultiSelectAnswer, isMultiSelectQuestion, offersMultiSelectToggle } from './question-multi-select.mjs';
 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';
 
 let relayQuestionRenderHash = '';
@@ -265,6 +266,10 @@ export function renderRelayQuestions() {
     const modeTag = question.mode ? ` <span class="msg-mode">${escHtml(question.mode)}</span>` : '';
     const contextText = String(question?.context?.rationale || '').trim();
     const contextHtml = contextText ? `<div class="relay-question-context">${renderLinkedPlainText(contextText)}</div>` : '';
+    // The card's own title ("Agent sessions", "Remote relay", a Claude
+    // question's header), above the question.
+    const headerText = String(question?.context?.header || '').trim();
+    const headerHtml = headerText ? `<div class="relay-question-header">${escHtml(headerText)}</div>` : '';
     const fields = schemaFieldsFromQuestion(question);
     const structuredQuestion = fields.length > 0;
 
@@ -296,14 +301,21 @@ export function renderRelayQuestions() {
           choices.map((choice) => `<button class="relay-question-choice" disabled>${escHtml(choice)}</button>`).join('')
         }</div>`;
       }
-      const showReplyControls = question.status === 'pending';
+      // A card that takes no typed text (approval and permission cards) is
+      // answered by its choices alone: no reply box, and a multi-select one
+      // keeps only its "Reply with selection".
+      const freeText = questionAcceptsFreeText(question);
+      const showReplyControls = question.status === 'pending' && (freeText || multiSelect);
       const draftText = String(relayQuestionDrafts.get(question.id) || '');
       const replyPlaceholder = multiSelect
         ? 'Add another answer or a note (optional)… (Ctrl/Cmd+Enter to send)'
         : 'Type a reply… (Ctrl/Cmd+Enter to send)';
+      const replyInputHtml = freeText
+        ? `<textarea id="relay-question-input-${question.id}" placeholder="${replyPlaceholder}" onkeydown="handleRelayQuestionKey(event, '${question.id}')" oninput="onRelayQuestionDraftInput('${question.id}', this.value)">${escHtml(draftText)}</textarea>`
+        : '';
       const replyHtml = showReplyControls
         ? `<div class="relay-question-reply">
-            <textarea id="relay-question-input-${question.id}" placeholder="${replyPlaceholder}" onkeydown="handleRelayQuestionKey(event, '${question.id}')" oninput="onRelayQuestionDraftInput('${question.id}', this.value)">${escHtml(draftText)}</textarea>
+            ${replyInputHtml}
             <button class="relay-question-submit" onclick="${multiSelect ? 'submitRelayQuestionMultiSelect' : 'submitRelayQuestionAnswer'}('${question.id}')">${multiSelect ? 'Reply with selection' : 'Reply'}</button>
           </div>`
         : '';
@@ -320,6 +332,7 @@ export function renderRelayQuestions() {
     wrapper.innerHTML = `
       <div class="relay-question-card${question.status === 'timed_out' ? ' relay-question-timed-out' : ''}">
         <div class="relay-question-head">${questionCardHeadLabel(conversations[question.conversationId])}${modeTag} · ${fmtDate(question.createdAt)}</div>
+        ${headerHtml}
         <div class="relay-question-body">${renderLinkedPlainText(question.prompt || '')}</div>
         ${contextHtml}
         ${answeredHtml}
@@ -580,6 +593,15 @@ async function enqueueRelayAnswerForSync(questionId, body) {
   return queued;
 }
 
+// The relay's reason for refusing an answer (a card that takes only its
+// choices names them), or '' when it gave none.
+function relayAnswerRefusalText(refusal) {
+  const reason = String(refusal?.error || '').trim();
+  if (!reason) return '';
+  const choices = Array.isArray(refusal?.choices) ? refusal.choices.map((choice) => String(choice)).filter(Boolean) : [];
+  return choices.length ? `${reason}. Choices: ${choices.join(', ')}.` : reason;
+}
+
 export async function submitRelayQuestionAnswer(questionId, presetAnswer = null) {
   const input = document.getElementById(`relay-question-input-${questionId}`);
   // Ctrl/Cmd+Enter in a multi-select card's text field sends the ticked
@@ -600,15 +622,18 @@ export async function submitRelayQuestionAnswer(questionId, presetAnswer = null)
     const question = relayQuestions.get(questionId) || null;
     const sdkSessionId = String(question?.sdkSessionId || '').trim();
     const singleFieldStructuredAnswer = resolveSingleFieldStructuredAnswer(question, answer);
+    let refusal = null;
     const r = singleFieldStructuredAnswer
       ? await answerRelayQuestionStructured(questionId, singleFieldStructuredAnswer, sdkSessionId || null)
-      : await answerRelayQuestion(questionId, answer, sdkSessionId || null);
+      : await answerRelayQuestion(questionId, answer, sdkSessionId || null, {
+        onErrorResponse: async (response) => { refusal = await response.json().catch(() => null); },
+      });
     if (!r?.question) {
       const queued = await enqueueRelayAnswerForSync(questionId, singleFieldStructuredAnswer
         ? { structuredAnswer: singleFieldStructuredAnswer, sdk_session_id: sdkSessionId || undefined }
         : { answer, sdk_session_id: sdkSessionId || undefined });
       if (queued) return;
-      throw new Error('Failed to submit relay question answer');
+      throw new Error(relayAnswerRefusalText(refusal) || 'Failed to submit relay question answer');
     }
     relayQuestionDrafts.delete(questionId);
     relayQuestionStructuredDrafts.delete(questionId);

package/server/public/app/background-tasks-view.mjs

@@ -12,13 +12,16 @@ import { apiFetch } from './api-client.js';
 import { formatTaskModelLabel, formatTaskTokens } from './task-row-format.mjs';
 import { prefixToolActivityEmoji } from './tool-activity-emoji.mjs';
 import {
+  TASK_OUTPUT_NONE_MESSAGES,
   endedOutcome,
   normalizeStallThreshold,
+  pipeHoldNotice,
   runnerChip,
   stallHint,
   stepsLabel,
   taskHasConsole,
   taskOutputUnavailable,
+  taskPipeHold,
 } from './task-console-render.mjs';
 
 // Shared with the sub-agent rows (subagent-row.mjs); re-exported for the
@@ -52,6 +55,12 @@ const stopsInFlight = new Set();
 const workflowFoldState = new Map();
 let currentConversationId = null;
 let elapsedTimer = null;
+// Counts the `background_tasks` events per conversation. A reload's payload
+// is the set as the relay had it when the request was answered; one that was
+// asked for before the latest event can land after it and would put the
+// older set back (the panel shrinking under the reader, then growing again
+// with the next poll).
+const taskEventCounts = new Map();
 
 const TASK_TYPE_ICONS = {
   local_bash: '⌨️',
@@ -363,14 +372,35 @@ function notifyChange(conversationId) {
   }
 }
 
+/**
+ * Taken before a reload of the conversation is asked for, and handed to
+ * isBackgroundTasksSnapshotCurrent() with its answer.
+ */
+export function backgroundTasksSnapshotMark(conversationId) {
+  return taskEventCounts.get(String(conversationId || '').trim()) || 0;
+}
+
+/**
+ * Whether a reload's sets (`backgroundTasks`, `endedBackgroundTasks`) may
+ * replace the conversation's on the page: no `background_tasks` event for it
+ * arrived since `mark` was taken. Otherwise the event's set is at least as
+ * new, and the next reload brings whatever came after it. Without a mark:
+ * always.
+ */
+export function isBackgroundTasksSnapshotCurrent(conversationId, mark) {
+  return mark === undefined || mark === null || mark === backgroundTasksSnapshotMark(conversationId);
+}
+
 /**
  * The live set (REPLACE semantics). `endedTasks`, when the event or payload
  * carries it, replaces the ended set too; an older relay's event without it
- * leaves the ended rows alone.
+ * leaves the ended rows alone. `event`: it came as a `background_tasks`
+ * event (see isBackgroundTasksSnapshotCurrent).
  */
-export function setConversationBackgroundTasks(conversationId, tasks, { endedTasks } = {}) {
+export function setConversationBackgroundTasks(conversationId, tasks, { endedTasks, event = false } = {}) {
   const id = String(conversationId || '').trim();
   if (!id) return;
+  if (event) taskEventCounts.set(id, backgroundTasksSnapshotMark(id) + 1);
   const normalized = normalizeTaskList(tasks);
   // Drop fold choices for tasks that left this conversation's set so the map
   // cannot grow across long sessions.
@@ -460,6 +490,20 @@ export function findBackgroundTask(conversationId, taskId) {
   return ended ? { task: ended, ended: true } : null;
 }
 
+const panelRenderListeners = new Set();
+
+/** Called after the panel drew its rows (the task console keeps above its row). */
+export function onBackgroundTasksPanelRendered(listener) {
+  panelRenderListeners.add(listener);
+  return () => panelRenderListeners.delete(listener);
+}
+
+function notifyPanelRendered() {
+  for (const listener of panelRenderListeners) {
+    try { listener(); } catch (error) { console.warn('background task panel listener failed', error?.message || error); }
+  }
+}
+
 /** Called with the conversation id after any change of tasks or health. */
 export function subscribeBackgroundTasks(listener) {
   changeListeners.add(listener);
@@ -538,7 +582,7 @@ function taskTitleHtml(task) {
     return `<button type="button" class="subagent-open bg-task-desc" data-subagent-open="${escHtml(runId)}" title="Open this sub-agent's thoughts, tool calls and reply">${text}</button>`;
   }
   if (taskOutputUnavailable(task)) {
-    return `<span class="bg-task-desc bg-task-desc-no-output" title="output not available for this provider">${text}</span>`;
+    return `<span class="bg-task-desc bg-task-desc-no-output" title="${escHtml(TASK_OUTPUT_NONE_MESSAGES.provider)}">${text}</span>`;
   }
   if (taskHasConsole(task)) {
     return `<button type="button" class="task-console-open bg-task-desc" data-task-console="${escHtml(task.taskId)}" title="Open this task's output">${text}</button>`;
@@ -553,10 +597,13 @@ function chipHtml(health) {
 }
 
 // Always present on a live row (hidden while output is fresh) so the 1 s
-// timer can update it in place.
-function stallHtml(hint) {
+// timer can update it in place. A command piped into tail is quiet
+// until it ends: its hover title says so.
+function stallHtml(hint, task) {
   const classes = `bg-task-stall${hint?.warn ? ' bg-task-stall-warn' : ''}`;
-  return `<span class="${classes}"${hint ? '' : ' hidden'}>${hint ? escHtml(hint.text) : ''}</span>`;
+  const notice = pipeHoldNotice(taskPipeHold(task));
+  const title = notice ? ` title="${escHtml(notice.title)}"` : '';
+  return `<span class="${classes}"${title}${hint ? '' : ' hidden'}>${hint ? escHtml(hint.text) : ''}</span>`;
 }
 
 function taskSteps(task) {
@@ -613,7 +660,7 @@ export function renderTaskRow(conversationId, task) {
           ${tokens ? `<span class="bg-task-tokens">${escHtml(tokens)}</span>` : ''}
           ${steps ? `<span class="bg-task-steps">${escHtml(steps)}</span>` : ''}
           ${chipHtml(health)}
-          ${taskHasConsole(task) ? stallHtml(stall) : ''}
+          ${taskHasConsole(task) ? stallHtml(stall, task) : ''}
           <span class="bg-task-elapsed">${escHtml(elapsed)}</span>
           ${task.stoppable === false ? '' : `<button type="button" class="bg-task-stop" data-task-id="${escHtml(task.taskId)}" ${stopping ? 'disabled' : ''}>${stopping ? 'Stopping…' : 'Stop'}</button>`}
         </span>
@@ -684,6 +731,7 @@ export function renderBackgroundTasksPanel() {
     const staleList = panel.querySelector('#background-tasks-list');
     if (staleList) staleList.innerHTML = '';
     stopElapsedTimer();
+    notifyPanelRendered();
     return;
   }
   const wasOpen = panel.hasAttribute('open');
@@ -733,6 +781,7 @@ export function renderBackgroundTasksPanel() {
   if (wasOpen) panel.setAttribute('open', '');
   if (tasks.length) startElapsedTimer();
   else stopElapsedTimer();
+  notifyPanelRendered();
 }
 
 // A preview created, closed, or flipping online/offline re-renders the panel;

package/server/public/app/bootstrap.js

@@ -149,6 +149,7 @@ import {
   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';
@@ -339,6 +340,7 @@ import {
   updateBackgroundTaskTimeoutSetting,
   previewTaskStallMinutesSetting,
   updateTaskStallMinutesSetting,
+  updateRestartResumeSettingFromToggle,
   updateSubagentRecordRetentionSetting,
 } from './settings-modal.js';
 import {
@@ -3758,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 }),
@@ -3783,6 +3786,7 @@ async function pollAuthenticatedCurrentConversationLive() {
       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.
@@ -4061,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,
@@ -4085,6 +4090,7 @@ async function refreshCurrentView() {
       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;
@@ -5102,6 +5108,7 @@ 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/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-provider-indicator.mjs

@@ -33,15 +33,25 @@ export function isConversationUsingClaudeCloudProvider(conversation = null) {
 // The marker that tells a cloud chat from a local Claude one at a glance.
 const CLAUDE_CLOUD_MARKER = '☁';
 
+const PROVIDER_NAMES = Object.freeze({
+  openai: 'OpenAI',
+  claude: 'Claude',
+  'claude-cloud': 'Claude Cloud',
+  cursor: 'Cursor',
+  grok: 'Grok',
+  github: 'Copilot',
+  'github-copilot': 'Copilot',
+});
+
+// A provider type's name as the list pill and the question card say it; ''
+// when unknown. The relay's question push uses it too
+// (services/push-dispatch-service.mjs).
+export function providerDisplayName(providerType = '') {
+  return PROVIDER_NAMES[String(providerType || '').trim().toLowerCase()] || '';
+}
+
 function conversationProviderName(conversation = null) {
-  const providerType = resolveConversationProviderType(conversation);
-  if (providerType === 'openai') return 'OpenAI';
-  if (providerType === 'claude') return 'Claude';
-  if (providerType === 'claude-cloud') return 'Claude Cloud';
-  if (providerType === 'cursor') return 'Cursor';
-  if (providerType === 'grok') return 'Grok';
-  if (providerType === 'github' || providerType === 'github-copilot') return 'Copilot';
-  return '';
+  return providerDisplayName(resolveConversationProviderType(conversation));
 }
 
 // An unresolved provider stays unlabelled rather than defaulting to Copilot, so

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

@@ -67,6 +67,7 @@ import { closeSlashAutocomplete, handleSlashAutocompleteKey, updateSlashAutocomp
 import { closeMentionAutocomplete, handleMentionAutocompleteKey, updateMentionAutocomplete } from './mention-autocomplete.mjs';
 import { renderRemoteOriginBadgeHtml } from './remote-relay-origin-view.mjs';
 import { isRelayEventMessage, renderRelayEventRowHtml } from './relay-event-view.mjs';
+import { isRestartResumeNote, renderRestartResumeNoteHtml } from './relay-restart-note-view.mjs';
 import {
   AGENT_EXCHANGE_CLOSED_CLASS,
   AGENT_EXCHANGE_HEAD_CLASS,
@@ -398,14 +399,18 @@ const conversationHistoryLoader = createInfiniteLoader({
     syncSteeredTurnMerge(el);
     // The page's agent exchanges fold before the height delta is measured.
     syncAgentExchangeFolds(el);
+    // Here, not a frame later: the position taken above is the reader's only
+    // until they scroll again, and a scroll in that frame (a jump to the end
+    // and up again) was undone by it.
+    el.scrollTop = previousScrollTop + (el.scrollHeight - 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);
+    // Once the loader has taken this page's cursor: still near the top, the
+    // next page loads.
     requestAnimationFrame(() => {
-      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);
+      if (String(currentConvId || '').trim() !== currentId) return;
       void conversationHistoryLoader.handleBoundaryDistance(el.scrollTop);
     });
   },
@@ -1336,6 +1341,21 @@ function createRelayEventNode(msg, msgId) {
   return div;
 }
 
+// The relay's note to carry on after a restart cut a turn off: a folded row
+// like an event row (relay-restart-note-view.mjs).
+function createRestartResumeNoteNode(msg, msgId) {
+  const div = document.createElement('div');
+  div.className = 'msg relay-event relay-restart-resume';
+  if (msgId) div.dataset.messageId = msgId;
+  const fingerprint = buildLiveMessageFingerprint({ ...msg, id: msgId || msg?.id || '' });
+  div.dataset.messageRole = fingerprint.role || '';
+  div.dataset.messageTextFingerprint = fingerprint.text || '';
+  div.dataset.messageTimestamp = String(msg?.timestamp || '').trim();
+  div.innerHTML = renderRestartResumeNoteHtml(msg, { escHtml, timeText: msg?.timestamp ? fmtDate(msg.timestamp) : '' });
+  setAgentExchangeRow(div, msg, msgId);
+  return div;
+}
+
 // Agent exchanges (agent-exchange-fold-view.mjs): an agent's prompt folds
 // into one row; this session's reply to it always shows. What the fold pass
 // needs of a message is kept on its node when the row is built, so the pass
@@ -1469,6 +1489,7 @@ function createMessageNode(msg, msgId = null, force = false) {
   // An event message the relay wrote into a watcher's conversation: a
   // compact, foldable row, never a bubble of the user's.
   if (isRelayEventMessage(msg)) return createRelayEventNode(msg, msgId);
+  if (isRestartResumeNote(msg)) return createRestartResumeNoteNode(msg, msgId);
 
   // A prompt another relay's agent sent carries `origin`: its header line is
   // hidden (the badge below says the same), and a stray remote-relay mention
@@ -4602,7 +4623,10 @@ export async function sendMessage() {
         : undefined,
     };
 
-    const r = await sendMessageApi(body);
+    // A refusal the user can act on (the conversation's model left the
+    // catalog) is shown as the relay words it.
+    let refusal = '';
+    const r = await sendMessageApi(body, { onRefused: (reason) => { refusal = reason; } });
     if (!r) {
       // Offline: park the send in the durable outbox instead of bouncing it
       // back into the composer. The client-generated messageId makes a replay
@@ -4636,7 +4660,7 @@ export async function sendMessage() {
         sendLanded,
       });
       if (!mobileSend && viewingSendConversation()) input.focus();
-      setModelBanner('⚠️ Message could not be sent. Please try again.');
+      setModelBanner(refusal ? `⚠️ ${refusal}` : '⚠️ Message could not be sent. Please try again.');
       return;
     }