@oar-sh/oar 0.9.1 → 0.9.3

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

@@ -29,7 +29,11 @@ import {
   updateTurnCeilingSetting as requestTurnCeilingSetting,
   loadBackgroundTaskTimeoutSetting,
   updateBackgroundTaskTimeoutSetting as requestBackgroundTaskTimeoutSetting,
+  loadFeatureFlagSettings,
+  updateFeatureFlagSetting as requestFeatureFlagSetting,
+  requestRelayRestart,
 } from './api-client.js';
+import { DEFAULT_BACKGROUND_TASK_TIMEOUT_MINUTES } from './background-task-timeout-options.mjs';
 import { syncFontScaleSelect } from './font-scaling.js';
 import { syncPwaAppNameInput } from './pwa-install.js';
 import { normalizeKnownCwdPath } from './cwd-picker.js';
@@ -38,6 +42,7 @@ import { selectSettingsTab } from './settings-tabs.js';
 import { refreshClaudeAuthSection } from './claude-auth-ui.js';
 import { refreshGrokAuthSection } from './grok-auth-ui.js';
 import { refreshCliInstallSections } from './cli-install-ui.js';
+import { refreshUpdateSection } from './update-ui.js';
 import {
   getPreviews,
   renderPreviewRowsInto,
@@ -69,7 +74,8 @@ function ensureOpenAISettingsInputTracking() {
   }
 }
 let windowsAutostartUpdateInFlight = false;
-let windowsAutostartEnabled = false;
+let windowsAutostartState = null;
+let windowsAutostartPollTimer = null;
 
 // Mirrors shared/turn-ceiling.mjs, which the browser cannot import — only
 // server/public is served. The authoritative bounds come from the API response;
@@ -147,9 +153,10 @@ export async function updateTurnCeilingSetting(value) {
   }
 }
 
-// Mirrors shared/background-task-timeout.mjs (the browser cannot import it).
-// Bounds come from the API response; these are just pre-response defaults.
-let backgroundTaskTimeoutMinutes = 0;
+// Starts at the default the relay enforces, so the slider tells the truth while
+// the settings request is in flight or after it failed. Bounds come from the
+// API response.
+let backgroundTaskTimeoutMinutes = DEFAULT_BACKGROUND_TASK_TIMEOUT_MINUTES;
 let backgroundTaskTimeoutUpdateInFlight = false;
 
 function syncBackgroundTaskTimeoutSlider() {
@@ -348,8 +355,8 @@ export function applyCopilotSettingsState(settings = {}, { error = '' } = {}) {
       status.dataset.state = 'error';
     } else {
       status.textContent = copilotSettingsState.engine === 'sdk'
-        ? 'New Copilot conversations run on the experimental headless SDK worker. No tmux inspector for these sessions.'
-        : 'New Copilot conversations run on the Copilot CLI with the web-relay extension (current default).';
+        ? 'New Copilot conversations run on the headless SDK worker. No tmux inspector for these sessions.'
+        : 'New Copilot conversations run on the Copilot CLI with the web-relay extension.';
       status.dataset.state = copilotSettingsState.engine === 'sdk' ? 'active' : 'unconfigured';
     }
   }
@@ -391,7 +398,7 @@ export async function saveCopilotSettings() {
     settled = result;
     showTransientRelayNotice(
       String(result.engine) === 'sdk'
-        ? 'Copilot engine set to SDK (experimental). New conversations use the headless worker; running sessions keep the extension until they restart.'
+        ? 'Copilot engine set to SDK. New conversations use the headless worker; running sessions keep their engine until they restart.'
         : 'Copilot engine set to Extension. New conversations use the Copilot CLI.',
       6000,
     );
@@ -1250,15 +1257,79 @@ export async function removeOpenAISettings() {
   }
 }
 
+function windowsAutostartStatusText() {
+  const boot = windowsAutostartState?.boot;
+  if (boot?.pendingElevation) {
+    return 'Confirm the admin prompt on the PC… (it only appears on the physical desktop)';
+  }
+  if (boot?.lastError) return boot.lastError;
+  if (windowsAutostartState?.mode === 'boot' && windowsAutostartState?.signinEnabled) {
+    return 'A sign-in Startup entry also exists and can double-start the relay. Re-select "At system startup" to clean it up.';
+  }
+  if (boot?.taskStatus === 'foreign') {
+    return `A task named "${boot.taskName}" exists but was not created by OAR. Selecting "At system startup" replaces it.`;
+  }
+  if (boot?.legacyTaskPresent && windowsAutostartState?.mode !== 'boot') {
+    return 'A pre-rebrand boot task exists. Selecting "At system startup" migrates it (one admin confirmation).';
+  }
+  return '';
+}
+
 function syncWindowsAutostartSetting() {
   const container = document.getElementById('windows-autostart-setting');
-  const checkbox = document.getElementById('windows-autostart-toggle');
   const supported = serverPlatform === 'win32';
   if (container) container.hidden = !supported;
-  if (checkbox instanceof HTMLInputElement) {
-    checkbox.checked = windowsAutostartEnabled;
-    checkbox.disabled = !supported || windowsAutostartUpdateInFlight;
+  const mode = windowsAutostartState?.mode || 'off';
+  const pending = !!windowsAutostartState?.boot?.pendingElevation;
+  for (const radio of document.querySelectorAll('input[name="windows-autostart-mode"]')) {
+    radio.checked = radio.value === mode;
+    radio.disabled = !supported || windowsAutostartUpdateInFlight || pending;
   }
+  const status = document.getElementById('windows-autostart-status');
+  if (status) {
+    const text = windowsAutostartStatusText();
+    status.hidden = !text;
+    status.textContent = text;
+  }
+  const manual = document.getElementById('windows-autostart-manual');
+  const manualCommand = document.getElementById('windows-autostart-manual-command');
+  const showManual = !!windowsAutostartState?.boot?.lastError && !!windowsAutostartState?.boot?.manualCommand;
+  if (manual) manual.hidden = !showManual;
+  if (manualCommand && showManual) manualCommand.textContent = windowsAutostartState.boot.manualCommand;
+}
+
+function stopWindowsAutostartPoll() {
+  if (windowsAutostartPollTimer) {
+    clearTimeout(windowsAutostartPollTimer);
+    windowsAutostartPollTimer = null;
+  }
+}
+
+/**
+ * The UAC prompt renders on the PC's own desktop, so a remote browser can
+ * only wait: poll until the elevation resolves either way, bounded to the
+ * service's own 120s timeout.
+ */
+function pollWindowsAutostartWhilePending(deadline) {
+  stopWindowsAutostartPoll();
+  if (!windowsAutostartState?.boot?.pendingElevation || Date.now() > deadline) return;
+  windowsAutostartPollTimer = setTimeout(async () => {
+    try {
+      windowsAutostartState = await loadWindowsAutostartSetting();
+    } catch {
+      // transient; the next tick retries
+    }
+    syncWindowsAutostartSetting();
+    if (windowsAutostartState?.boot?.pendingElevation) {
+      pollWindowsAutostartWhilePending(deadline);
+    } else if (!windowsAutostartState?.boot?.lastError) {
+      showTransientRelayNotice(
+        windowsAutostartState?.mode === 'boot'
+          ? 'System-startup autostart enabled.'
+          : 'Boot task removed.',
+      );
+    }
+  }, 2_000);
 }
 
 export async function refreshWindowsAutostartSetting() {
@@ -1272,16 +1343,19 @@ export async function refreshWindowsAutostartSetting() {
       alert('Failed to read the Windows autostart setting.');
       return;
     }
-    windowsAutostartEnabled = !!result.enabled;
+    windowsAutostartState = result;
   } catch (error) {
     alert(error?.message || 'Failed to read the Windows autostart setting.');
   } finally {
     windowsAutostartUpdateInFlight = false;
     syncWindowsAutostartSetting();
+    if (windowsAutostartState?.boot?.pendingElevation) {
+      pollWindowsAutostartWhilePending(Date.now() + 120_000);
+    }
   }
 }
 
-export async function updateWindowsAutostartSettingFromToggle(enabled) {
+export async function updateWindowsAutostartMode(mode) {
   if (serverPlatform !== 'win32' || windowsAutostartUpdateInFlight) {
     syncWindowsAutostartSetting();
     return;
@@ -1289,17 +1363,21 @@ export async function updateWindowsAutostartSettingFromToggle(enabled) {
   windowsAutostartUpdateInFlight = true;
   syncWindowsAutostartSetting();
   try {
-    const result = await updateWindowsAutostartSetting(!!enabled);
+    const result = await updateWindowsAutostartSetting(String(mode));
     if (!result?.supported) {
       alert('Failed to update the Windows autostart setting.');
       return;
     }
-    windowsAutostartEnabled = !!result.enabled;
-    showTransientRelayNotice(
-      windowsAutostartEnabled
-        ? 'Windows autostart enabled.'
-        : 'Windows autostart disabled.',
-    );
+    windowsAutostartState = result;
+    if (result?.boot?.pendingElevation) {
+      pollWindowsAutostartWhilePending(Date.now() + 120_000);
+    } else if (!result?.boot?.lastError) {
+      showTransientRelayNotice(
+        result.mode === 'signin' ? 'Sign-in autostart enabled.'
+          : result.mode === 'off' ? 'Windows autostart disabled.'
+            : 'Windows autostart updated.',
+      );
+    }
   } catch (error) {
     alert(error?.message || 'Failed to update the Windows autostart setting.');
   } finally {
@@ -1308,6 +1386,131 @@ export async function updateWindowsAutostartSettingFromToggle(enabled) {
   }
 }
 
+// ─── Features tab ─────────────────────────────────────────────────────────────
+// Flags are resolved once at relay boot; the rows here render entirely from the
+// server's registry payload (labels and descriptions live in server/features.mjs),
+// and the restart notice appears whenever a stored value differs from the
+// running snapshot. Rows are dynamic, so listeners are attached during render
+// instead of via inline onchange globals.
+
+let featureFlagsState = null;
+let featureFlagsUpdateInFlight = false;
+let featuresRestartButtonBound = false;
+
+function featureToggleId(name) {
+  return `feature-toggle-${String(name || '').toLowerCase()}`;
+}
+
+function syncFeatureFlagsSection() {
+  const list = document.getElementById('features-flag-list');
+  if (!list) return;
+  list.textContent = '';
+  const flags = Array.isArray(featureFlagsState?.flags) ? featureFlagsState.flags : [];
+  for (const flag of flags) {
+    const row = document.createElement('div');
+    row.className = 'settings-row';
+    row.style.marginTop = '12px';
+    row.style.marginBottom = '0';
+
+    const label = document.createElement('label');
+    label.htmlFor = featureToggleId(flag.name);
+    label.textContent = flag.label || flag.name;
+    row.appendChild(label);
+
+    const checkbox = document.createElement('input');
+    checkbox.id = featureToggleId(flag.name);
+    checkbox.type = 'checkbox';
+    checkbox.checked = flag.effectiveNext === true;
+    checkbox.disabled = featureFlagsUpdateInFlight || flag.envOverride !== null;
+    checkbox.setAttribute('aria-label', flag.label || flag.name);
+    checkbox.addEventListener('change', () => {
+      void updateFeatureFlagFromToggle(flag.name, checkbox.checked);
+    });
+    row.appendChild(checkbox);
+    list.appendChild(row);
+
+    const help = document.createElement('div');
+    help.className = 'settings-help';
+    help.style.marginTop = '6px';
+    let text = String(flag.description || '');
+    if (flag.envOverride !== null) {
+      text += ` Pinned ${flag.envOverride ? 'on' : 'off'} by COPILOT_REMOTE_${flag.name} in the relay's environment; the toggle is locked while that variable is set.`;
+    }
+    if (flag.restartRequired) {
+      text += ' Restart pending: the saved value takes effect after the relay restarts.';
+    }
+    help.textContent = text;
+    list.appendChild(help);
+  }
+
+  const notice = document.getElementById('features-restart-notice');
+  if (notice) notice.hidden = featureFlagsState?.restartRequired !== true;
+  const restartBtn = document.getElementById('features-restart-btn');
+  if (restartBtn) {
+    restartBtn.disabled = featureFlagsUpdateInFlight;
+    if (!featuresRestartButtonBound) {
+      featuresRestartButtonBound = true;
+      restartBtn.addEventListener('click', () => { void restartRelayForFeatureFlags(); });
+    }
+  }
+}
+
+function setFeaturesSettingsStatus(text) {
+  const status = document.getElementById('features-settings-status');
+  if (!status) return;
+  status.hidden = !text;
+  status.textContent = text || '';
+}
+
+export async function refreshFeatureFlagsSection() {
+  syncFeatureFlagsSection();
+  const result = await loadFeatureFlagSettings();
+  if (!result || !Array.isArray(result.flags)) {
+    setFeaturesSettingsStatus('Failed to load feature flags from the relay.');
+    return;
+  }
+  featureFlagsState = result;
+  setFeaturesSettingsStatus('');
+  syncFeatureFlagsSection();
+}
+
+async function updateFeatureFlagFromToggle(name, enabled) {
+  if (featureFlagsUpdateInFlight) {
+    syncFeatureFlagsSection();
+    return;
+  }
+  featureFlagsUpdateInFlight = true;
+  syncFeatureFlagsSection();
+  try {
+    const result = await requestFeatureFlagSetting(name, enabled);
+    if (!result || !Array.isArray(result.flags)) {
+      alert('Failed to update the feature flag.');
+      return;
+    }
+    featureFlagsState = result;
+  } finally {
+    featureFlagsUpdateInFlight = false;
+    syncFeatureFlagsSection();
+  }
+}
+
+async function restartRelayForFeatureFlags() {
+  if (featureFlagsUpdateInFlight) return;
+  featureFlagsUpdateInFlight = true;
+  syncFeatureFlagsSection();
+  try {
+    const result = await requestRelayRestart({ reason: 'feature-flags-changed' });
+    if (!result) {
+      alert('Failed to request a relay restart. Restarts can only be requested from the relay host itself.');
+      return;
+    }
+    showTransientRelayNotice('Relay restart requested. It will restart once the queue is idle.');
+  } finally {
+    featureFlagsUpdateInFlight = false;
+    syncFeatureFlagsSection();
+  }
+}
+
 function readShowSuspendHostSetting() {
   const stored = String(readLocalStorage(SHOW_SUSPEND_HOST_STORAGE_KEY) || '').trim().toLowerCase();
   if (!stored) return true;
@@ -1473,6 +1676,8 @@ export function openSettingsModal(tab, providerTab) {
   void refreshBackgroundTaskTimeoutSetting();
   void refreshPushSettingsSection();
   void refreshPreviewsSection();
+  void refreshFeatureFlagsSection();
+  void refreshUpdateSection();
   modal?.classList.add('visible');
   modal?.setAttribute('aria-hidden', 'false');
 }

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

@@ -1,7 +1,7 @@
 const SETTINGS_TAB_STORAGE_KEY = 'copilot_settings_tab';
 const SETTINGS_PROVIDER_TAB_STORAGE_KEY = 'copilot_settings_provider_tab';
 
-const SETTINGS_TABS = ['general', 'providers', 'previews', 'notifications'];
+const SETTINGS_TABS = ['general', 'providers', 'previews', 'notifications', 'features'];
 // Copilot leads: it is the default provider, and `SETTINGS_PROVIDER_TABS[0]`
 // is also the sub-tab a first-time visitor lands on.
 const SETTINGS_PROVIDER_TABS = ['copilot', 'openai', 'claude', 'grok', 'cursor'];

package/server/public/app/socket-handlers.js

@@ -28,6 +28,8 @@ import {
   addSubagentThought,
   clearSubagentCancelInFlight,
   setConversationWatcherCount,
+  setUpdateState,
+  applySessionWorkerSteering,
 } from './store.js';
 import { scheduleContextUsageRefresh } from './api-client.js';
 import { publishStatusEvent, recordStatusEvent } from './status-store.mjs';
@@ -43,6 +45,7 @@ import { setPreviews } from './preview-cards.mjs';
 import { applyClaudeAuthState } from './claude-auth-ui.js';
 import { applyGrokAuthState } from './grok-auth-ui.js';
 import { applyCliInstallState } from './cli-install-ui.js';
+import { renderUpdateSection } from './update-ui.js';
 import {
   showThinking,
   removeThinking,
@@ -53,6 +56,7 @@ import {
   appendThinkingActivity,
   appendThinkingThought,
   applyRelayStreamEvent,
+  clearRelayStreamState,
   clearRelayStreamStateForMessage,
   applyConversationTurnStatus,
   renderMessages,
@@ -63,6 +67,8 @@ import {
   removeUserBubbleCancelButton,
   updateSubagentBubbleFromStatus,
   markSubagentStopUnsupported,
+  syncComposerButtonState,
+  syncCancellableSteerButtons,
 } from './conversation-view.js';
 import { loadRepoBrowserTree, refreshRepoBrowserIfWorkspaceOpen } from './attachments-view.js';
 import { clearMessageSearchRuntimeState } from './message-search-view.js';
@@ -376,6 +382,12 @@ export async function connectSocket(overrideDeps) {
   socket.on('cli_install_state', (payload) => {
     applyCliInstallState(payload || null);
   });
+  // Self-update transitions AND npm log chunks; same whole-buffer contract as
+  // cli_install_state, so a client connecting mid-update renders the full log.
+  socket.on('update_state', (payload) => {
+    setUpdateState(payload || null);
+    renderUpdateSection();
+  });
   socket.on('grok_settings_updated', (payload) => {
     deps?.applyGrokSettingsState?.(payload || {});
     if (Number(payload?.reconciliation?.updatedUnstartedConversations || 0) > 0) {
@@ -437,8 +449,12 @@ export async function connectSocket(overrideDeps) {
   socket.on('assistant_message', ({ conversationId, message, messageId, sourceMessageId }) => {
     const isCurrentConversation = conversationId === currentConvId;
     const autoScroll = isCurrentConversation ? isMessagesAtBottom() : false;
-    collapseThinkingThoughts();
-    removeThinking();
+    // A background conversation finishing its turn must not wipe the viewed
+    // conversation's live bubble.
+    if (isCurrentConversation) {
+      collapseThinkingThoughts();
+      removeThinking();
+    }
     if ((!message?.activities || !message.activities.length) && sourceMessageId) {
       const cached = relayActivities.get(sourceMessageId) || [];
       if (cached.length) message.activities = cached.slice(0, 48);
@@ -614,11 +630,27 @@ export async function connectSocket(overrideDeps) {
         runtimeSessionId: String(runtimeSessionId || conversations[id].runtimeSessionId || '').trim() || null,
       };
     }
+    // The composer reads the worker's steering snapshot under the session id
+    // just bound; fetch it now rather than on the next status poll.
+    refreshSessionWorkerStatus().catch(() => {});
     await refreshConversations();
     if (currentConvId === id) {
       await openConversation(id);
     }
   });
+  // A worker's steering snapshot changed (its heartbeat): the composer's
+  // Steer/Queue label and the pushed rows' Cancel follow it at once instead of
+  // on the next status poll.
+  socket.on('session_worker_steering', ({ sdkSessionId, steering } = {}) => {
+    const changed = applySessionWorkerSteering(sdkSessionId, steering);
+    if (changed === null) {
+      refreshSessionWorkerStatus().catch(() => {});
+      return;
+    }
+    if (!changed) return;
+    syncComposerButtonState();
+    syncCancellableSteerButtons();
+  });
   socket.on('message_status', ({ messageId, conversationId, status }) => {
     const normalizedStatus = String(status || '').trim().toLowerCase();
     const clearsProcessingStatus = ['done', 'failed', 'dropped', 'pending', 'parked', 'cancelled'].includes(normalizedStatus);
@@ -650,9 +682,20 @@ export async function connectSocket(overrideDeps) {
       if (messageId) renderRestoredSubagentBubbles(messageId);
       if (messageId) removeUserBubbleCancelButton(messageId);
     }
-    if (clearsProcessingStatus) {
+    if (normalizedStatus === 'processing') {
+      // A worker owns the message now: dropping the pending entry re-arms the
+      // duplicate-send guard and hands poll liveness over to localTurnStatus.
       clearPendingUserMessage(messageId);
-      if (messageId) clearRelayStreamStateForMessage(messageId);
+    }
+    if (clearsProcessingStatus) {
+      // 'pending'/'parked' mean the message is (still) queued: its pending
+      // entry keeps the live poll armed while it waits, and only a genuinely
+      // terminal status may blacklist the id from relay_stream frames — the
+      // server acks every enqueue with 'pending', which would otherwise mute
+      // live streaming for the whole turn.
+      if (isTerminalStatus) clearPendingUserMessage(messageId);
+      if (messageId && isTerminalStatus) clearRelayStreamStateForMessage(messageId);
+      else if (messageId) clearRelayStreamState(messageId);
       if (messageId) clearBubbleCancelState(messageId);
       if (messageId) removeUserBubbleCancelButton(messageId);
     }

package/server/public/app/steered-turn-merge.mjs

@@ -0,0 +1,100 @@
+// Mid-turn steering: a message sent while a Claude turn was running is pushed
+// into the live turn. Three settle shapes reach the transcript:
+// - handoff: the interrupted reply settles with kind='absorbed', and the rest
+//   of the turn (with the final reply) lands on the steered message's own row.
+//   Those rows render as ONE flow — absorbed reply, steered user bubble,
+//   continuing reply.
+// - fold: the CLI answered the steer inside the running turn; its row settles
+//   with a kind='folded' stub, a compact marker under its own user message.
+//   It never merges forward — the next message is an ordinary turn.
+// - stopped: the steer was pushed into a turn the user then stopped, so it
+//   went unanswered (kind='stopped', a marker with Resend).
+// The steered user message of a fold or stop is still classed as steered.
+//
+// One idempotent DOM pass, same contract as syncTranscriptSeparators: every
+// insertion path (full render, live append, prepended history page) re-runs it,
+// so classes heal when the pair arrives across two loads and un-apply when a
+// re-render drops the absorbed marker. Kept DOM-only and import-light so it is
+// jsdom-testable (conversation-view.js touches window at module scope).
+import { SEPARATOR_CLASS } from './transcript-separators.mjs';
+
+export const ABSORBED_MSG_CLASS = 'msg-absorbed';
+export const STEERED_MSG_CLASS = 'msg-steered';
+export const STEERED_CONTINUATION_CLASS = 'msg-steered-continuation';
+export const FOLDED_MSG_CLASS = 'msg-folded';
+export const STEER_STOPPED_MSG_CLASS = 'msg-steer-stopped';
+
+/** The assistant row kinds that are settle markers of a steer, not replies. */
+export const STEER_MARKER_CLASS_BY_KIND = Object.freeze({
+  folded: FOLDED_MSG_CLASS,
+  stopped: STEER_STOPPED_MSG_CLASS,
+});
+
+function isSteerMarker(node) {
+  return !!node?.classList
+    && node.classList.contains('assistant')
+    && (node.classList.contains(FOLDED_MSG_CLASS) || node.classList.contains(STEER_STOPPED_MSG_CLASS));
+}
+
+/**
+ * The `.msg` row above, refusing to cross a separator row: a steering pair is
+ * seconds apart, so a day or compaction break between two rows proves they are
+ * NOT that pair, and pulling them together across it would look broken.
+ */
+function previousMessageNode(node) {
+  for (let prev = node?.previousElementSibling; prev; prev = prev.previousElementSibling) {
+    if (prev.classList?.contains(SEPARATOR_CLASS)) return null;
+    if (prev.classList?.contains('msg')) return prev;
+  }
+  return null;
+}
+
+/** The `.msg` row below, refusing to cross a separator row. */
+function nextMessageNode(node) {
+  for (let next = node?.nextElementSibling; next; next = next.nextElementSibling) {
+    if (next.classList?.contains(SEPARATOR_CLASS)) return null;
+    if (next.classList?.contains('msg')) return next;
+  }
+  return null;
+}
+
+function setClass(node, className, on) {
+  if (!node?.classList) return 0;
+  if (node.classList.contains(className) === on) return 0;
+  node.classList.toggle(className, on);
+  return 1;
+}
+
+/**
+ * Sync the merge classes over the container's rows. Returns the number of
+ * class changes (0 = the pass was a no-op), which the tests assert on.
+ */
+export function syncSteeredTurnMerge(container) {
+  if (!container || !container.children) return 0;
+  let changes = 0;
+  for (const node of container.children) {
+    if (!node.classList?.contains('msg')) continue;
+    if (node.classList.contains('user')) {
+      // A user row is steered iff the row above it is an absorbed reply, or
+      // its own settle marker (fold/stop) sits right below it.
+      const previous = previousMessageNode(node);
+      const steered = (!!previous
+        && previous.classList.contains('assistant')
+        && previous.classList.contains(ABSORBED_MSG_CLASS))
+        || isSteerMarker(nextMessageNode(node));
+      changes += setClass(node, STEERED_MSG_CLASS, steered);
+      continue;
+    }
+    if (node.classList.contains('assistant')) {
+      // The reply continuing a steered message keeps the group together. A
+      // settle marker is not a reply: it keeps its own compact styling.
+      const previous = previousMessageNode(node);
+      const continues = !isSteerMarker(node)
+        && !!previous
+        && previous.classList.contains('user')
+        && previous.classList.contains(STEERED_MSG_CLASS);
+      changes += setClass(node, STEERED_CONTINUATION_CLASS, continues);
+    }
+  }
+  return changes;
+}