@oar-sh/oar 0.9.12 → 0.9.13

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-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;
     }
 

package/server/public/app/host-suspend-ui.js

@@ -6,8 +6,19 @@
 // host action" setting on purpose: a device with the action hidden must still
 // be able to see and cancel a queued suspend.
 
-import { escHtml, showTransientRelayNotice } from './store.js';
-import { cancelHostSuspend, cancelRelayRestart } from './api-client.js';
+import { showTransientRelayNotice } from './store.js';
+import { cancelHostSuspend } from './api-client.js';
+import {
+  cancelQueuedRelayRestart,
+  isRelayRestartRequestInFlight,
+  keepWaitingForQueuedRelayRestart,
+  noteRelayRestartStateForDialogs,
+  openRestartNowConfirmation,
+  refreshRelayRestartWaitedLabels,
+  relayRestartHeadline,
+  renderRelayRestartRow,
+  setRelayRestartStateSink,
+} from './relay-restart-ui.js';
 
 const BANNER_ID = 'pending-action-banner';
 const SUSPEND_MENU_ID = 'chat-menu-suspend-host';
@@ -20,6 +31,7 @@ const RESTART_MENU_PENDING_LABEL = '🌄 Restart pending…';
 let hostSuspendState = null;
 let relayShutdownState = null;
 let countdownTimer = null;
+let waitedTimer = null;
 let cancelInFlight = false;
 
 export function getHostSuspendState() {
@@ -96,20 +108,10 @@ export function hostSuspendBannerText(state, nowMs = Date.now()) {
     : '💤 Suspend queued — waiting for running agents to finish';
 }
 
+/** The restart row's headline (relay-restart-ui.js renders the whole row). */
 export function relayShutdownBannerText(state) {
   if (!isRelayShutdownPending(state)) return '';
-  const action = state.action === 'restart' || state.restart ? 'restart' : 'shutdown';
-  const icon = action === 'restart' ? '🌄' : '⏻';
-  if (String(state.status || '') === 'shutting_down') {
-    return `${icon} Relay ${action === 'restart' ? 'restarting' : 'shutting down'} now…`;
-  }
-  // Only the processing turns hold it; queued messages wait for the restart.
-  const queue = state.queue || {};
-  const turns = Number(queue.processingCount || 0);
-  const held = Number(queue.pendingCount || 0) + Number(queue.parkedCount || 0);
-  const waiting = turns > 0 ? `waiting for ${turns} running turn${turns === 1 ? '' : 's'} to finish` : 'nothing is running, going down now';
-  const queued = held > 0 ? `; ${held} queued message${held === 1 ? '' : 's'} wait${held === 1 ? 's' : ''} for it` : '';
-  return `${icon} Relay ${action} queued — ${waiting}${queued}`;
+  return relayRestartHeadline(state);
 }
 
 function ensureBanner() {
@@ -165,30 +167,6 @@ async function runCancelHostSuspend() {
   }
 }
 
-async function runCancelRelayShutdown() {
-  if (cancelInFlight) return;
-  cancelInFlight = true;
-  renderPendingActionBanner();
-  try {
-    let result = null;
-    try {
-      result = await cancelRelayRestart();
-    } catch (error) {
-      showTransientRelayNotice(`Failed to cancel the queued relay restart: ${error?.message || 'unknown error'}`, 6000);
-      return;
-    }
-    if (!result?.ok) {
-      showTransientRelayNotice('Failed to cancel the queued relay restart.', 5000);
-      return;
-    }
-    applyRelayShutdownState(result);
-    showTransientRelayNotice(result.cancelled ? 'Queued relay restart cancelled.' : 'No relay restart was pending.', 4000);
-  } finally {
-    cancelInFlight = false;
-    renderPendingActionBanner();
-  }
-}
-
 function syncCountdownTimer() {
   const needsTicker = isHostSuspendPending() && String(hostSuspendState?.status || '') === 'countdown' && hostSuspendState?.fireAt;
   if (needsTicker && !countdownTimer) {
@@ -197,8 +175,27 @@ function syncCountdownTimer() {
     clearInterval(countdownTimer);
     countdownTimer = null;
   }
+  // The restart's waited time ticks in place: rebuilding the row every
+  // second would swallow a click on its buttons.
+  const needsWaitedTicker = String(relayShutdownState?.status || '') === 'queued';
+  if (needsWaitedTicker && !waitedTimer) {
+    waitedTimer = setInterval(() => refreshRelayRestartWaitedLabels(relayShutdownState), 15_000);
+    waitedTimer?.unref?.();
+  } else if (!needsWaitedTicker && waitedTimer) {
+    clearInterval(waitedTimer);
+    waitedTimer = null;
+  }
 }
 
+const relayRestartHandlers = {
+  onOpen: (conversationId) => {
+    if (conversationId && typeof window.openConversation === 'function') void window.openConversation(conversationId);
+  },
+  onRestartNow: () => openRestartNowConfirmation(relayShutdownState),
+  onKeepWaiting: () => keepWaitingForQueuedRelayRestart(),
+  onCancel: () => cancelQueuedRelayRestart(),
+};
+
 export function renderPendingActionBanner() {
   if (typeof document === 'undefined') return;
   const rows = [];
@@ -211,12 +208,9 @@ export function renderPendingActionBanner() {
     }));
   }
   if (isRelayShutdownPending()) {
-    const restarting = String(relayShutdownState?.status || '') === 'shutting_down';
-    rows.push(bannerRow({
-      key: 'relay-shutdown',
-      text: relayShutdownBannerText(relayShutdownState),
-      cancelLabel: restarting ? '' : 'Cancel',
-      onCancel: runCancelRelayShutdown,
+    rows.push(renderRelayRestartRow(relayShutdownState, {
+      handlers: relayRestartHandlers,
+      busy: isRelayRestartRequestInFlight(),
     }));
   }
   const banner = document.getElementById(BANNER_ID) || (rows.length ? ensureBanner() : null);
@@ -246,6 +240,7 @@ export function applyHostSuspendState(state) {
 
 export function applyRelayShutdownState(state) {
   relayShutdownState = state && typeof state === 'object' ? state : null;
+  noteRelayRestartStateForDialogs(relayShutdownState);
   renderPendingActionBanner();
 }
 
@@ -268,6 +263,11 @@ export function applyPendingActionsFromStatus(status) {
 }
 
 export function initHostSuspendUi() {
+  // A cancel, keep-waiting or restart-now answer carries the new state.
+  setRelayRestartStateSink((state, { rerenderOnly = false } = {}) => {
+    if (rerenderOnly) renderPendingActionBanner();
+    else applyRelayShutdownState(state);
+  });
   renderPendingActionBanner();
 }
 
@@ -276,6 +276,7 @@ export function __resetHostSuspendUiForTests() {
   relayShutdownState = null;
   cancelInFlight = false;
   if (countdownTimer) { clearInterval(countdownTimer); countdownTimer = null; }
+  if (waitedTimer) { clearInterval(waitedTimer); waitedTimer = null; }
   document.getElementById(BANNER_ID)?.remove();
   syncMenuLabels();
 }

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

@@ -82,6 +82,7 @@ import { mergeTailPage } from './transcript-reading-anchor.mjs';
 import { readWindowRetention } from './conversation-window-retention.mjs';
 import { MENU_SEPARATOR, bindLongPress, closeContextMenu, openContextMenu } from './context-menu.mjs';
 import {
+  isBackgroundTasksSnapshotCurrent,
   setBackgroundTasksConversation,
   setConversationBackgroundTasks,
   setConversationEndedBackgroundTasks,
@@ -777,6 +778,8 @@ export function toggleConversationGroupFold(event, groupId) {
 // rather than drawn anew (mergeMessagesIntoTranscript).
 // windowPayload: with keepTranscript, the window the page keeps, kept for
 // the next visit in place of nothing.
+// backgroundTasksAsOf: backgroundTasksSnapshotMark(id) as the request left;
+// the payload's task sets are left out when an event brought newer ones since.
 export function applyLoadedConversationState(id, response, {
   restoreScroll = false,
   savedScrollTop = null,
@@ -786,6 +789,7 @@ export function applyLoadedConversationState(id, response, {
   fromCache = false,
   mergeFrom = null,
   windowPayload = null,
+  backgroundTasksAsOf = null,
 } = {}) {
   if (!response) {
     if (!IS_SHARED_VIEW) conversationPayloadCache.forget(id);
@@ -892,9 +896,11 @@ export function applyLoadedConversationState(id, response, {
   setBackgroundTasksConversation(id);
   // Absent from an older relay's payload: the threshold keeps its default.
   if ('taskStallMinutes' in response) setConversationTaskStallMinutes(id, response.taskStallMinutes);
-  setConversationBackgroundTasks(id, response.backgroundTasks || []);
-  // Absent from an older relay's payload: keep what the socket said.
-  if (Array.isArray(response.endedBackgroundTasks)) setConversationEndedBackgroundTasks(id, response.endedBackgroundTasks);
+  if (isBackgroundTasksSnapshotCurrent(id, backgroundTasksAsOf)) {
+    setConversationBackgroundTasks(id, response.backgroundTasks || []);
+    // Absent from an older relay's payload: keep what the socket said.
+    if (Array.isArray(response.endedBackgroundTasks)) setConversationEndedBackgroundTasks(id, response.endedBackgroundTasks);
+  }
   setUsageLimitConversation(id, {
     // Absent from an older relay's payload: keep what the socket said.
     pause: 'usageLimitPause' in response ? response.usageLimitPause : undefined,

package/server/public/app/push-settings.js

@@ -11,6 +11,7 @@ const PUSH_EVENT_CONTROL_IDS = {
   board: 'push-event-board-toggle',
   cliOffline: 'push-event-cli-offline-toggle',
   hostSuspend: 'push-event-host-suspend-toggle',
+  relayRestart: 'push-event-relay-restart-toggle',
 };
 
 let pushUpdateInFlight = false;

package/server/public/app/relay-prompt-sanitizer.mjs

@@ -1,6 +1,6 @@
 import { stripRemotePromptHeader } from './remote-relay-shared.mjs';
 
-const RELAY_TOOL_GUIDANCE = [
+const RELAY_TOOL_GUIDANCE_LINES = [
   '# Relay Tool Guidance',
   'For any user-facing question or clarification, use the ask_user tool so the web relay can render question cards and buttons. Never ask questions in plain assistant text.',
   'When using ask_user, ALWAYS include a `choices` array with 2-6 answer options so the web relay can render clickable buttons. Only omit choices when the question genuinely requires freeform text input.',
@@ -8,7 +8,12 @@ const RELAY_TOOL_GUIDANCE = [
   'For relay restarts in extension-managed mode, require explicit user permission first, then use the authenticated localhost API `POST /api/relay/shutdown`. Do not restart by killing processes or using respawn scripts.',
   'Note: shutdown is queued and only completes when the current turn finishes, so it is pointless to wait for it to interrupt an active turn.',
   'Use `restart: true` in the request body when the user wants a real relay restart rather than a plain shutdown. Example request body: `{ "reason": "manual-restart", "requestedBy": "localhost-api", "restart": true }`.',
-].join(' ');
+  'Never pass `immediate` in that request body: it restarts without waiting for the running turns, which only the user may decide, with Restart now in the web UI.',
+];
+const RELAY_TOOL_GUIDANCE = RELAY_TOOL_GUIDANCE_LINES.join(' ');
+// Prompts stored before the `immediate` line was added carry the guidance
+// without it.
+const PREVIOUS_RELAY_TOOL_GUIDANCE = RELAY_TOOL_GUIDANCE_LINES.slice(0, -1).join(' ');
 
 const MODE_MARKERS = {
   plan: '[Relay mode: plan]',
@@ -94,6 +99,8 @@ function buildPromptPrefixPatterns(mode) {
     return [
       new RegExp(`^${whitespaceFlexiblePattern(currentFullPrefix)}\\s*`, 'i'),
       new RegExp(`^${whitespaceFlexiblePattern(legacyFullPrefix)}\\s*`, 'i'),
+      new RegExp(`^${whitespaceFlexiblePattern(`${marker} ${MODE_INSTRUCTIONS[key]} ${PREVIOUS_RELAY_TOOL_GUIDANCE}`)}\\s*`, 'i'),
+      new RegExp(`^${whitespaceFlexiblePattern(`${marker} ${LEGACY_MODE_INSTRUCTIONS[key]} ${PREVIOUS_RELAY_TOOL_GUIDANCE}`)}\\s*`, 'i'),
       new RegExp(`^${whitespaceFlexiblePattern(marker)}\\s*`, 'i'),
     ];
   });

package/server/public/app/relay-restart-note-view.mjs

@@ -0,0 +1,36 @@
+// The note the relay writes into a conversation whose turn a relay restart
+// cut off ("After a relay restart, tell interrupted sessions to carry on",
+// server/services/restart-resume-service.mjs): a compact row in the look of
+// the relay event rows, never a bubble of the user's.
+//
+// DOM-free, like relay-event-view.mjs: the caller owns the element.
+
+export const RESTART_RESUME_KIND = 'relay-restart-resume';
+export const RESTART_RESUME_LEAD = 'Automatic message from OAR, not from the user:';
+
+function defaultEscape(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+export function isRestartResumeNote(message) {
+  return message?.role === 'user' && String(message?.kind || '').trim() === RESTART_RESUME_KIND;
+}
+
+/** The row's markup: folded to one line, opened to the note as the agent got it. */
+export function renderRestartResumeNoteHtml(message, { escHtml = defaultEscape, timeText = '' } = {}) {
+  const text = String(message?.text ?? '').trim();
+  const body = text.startsWith(RESTART_RESUME_LEAD) ? text.slice(RESTART_RESUME_LEAD.length).trim() : text;
+  return '<details class="relay-event-row relay-restart-note">'
+    + '<summary class="relay-event-summary">'
+    + '<span class="relay-event-tag" title="An automated message of the relay, not from you.">relay</span>'
+    + '<span class="relay-event-text">Relay restarted · the interrupted turn was asked to carry on</span>'
+    + (timeText ? `<span class="relay-event-time">${escHtml(timeText)}</span>` : '')
+    + '</summary>'
+    + `<div class="relay-event-lines relay-restart-note-text">${escHtml(body)}</div>`
+    + '</details>';
+}