@oar-sh/oar 0.9.2 → 0.9.3

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

@@ -43,6 +43,8 @@ function insertEmojiAtCaret(emoji) {
   input.selectionEnd = nextCaret;
   autoResize(input);
   input.focus();
+  // Runs the composer's input pipeline, which saves the draft.
+  input.dispatchEvent(new Event('input', { bubbles: true }));
 }
 
 function handleEmojiChoice(emoji) {

package/server/public/app/font-scaling.js

@@ -1,3 +1,5 @@
+import { captureTranscriptAnchor, restoreTranscriptAnchor } from './transcript-viewport-anchor.mjs';
+
 const FONT_SCALE_STORAGE_KEY = 'copilot_font_scale';
 const FONT_SCALE_MIN = 0.5;
 const FONT_SCALE_MAX = 1.5;
@@ -53,41 +55,6 @@ function normalizeFontScaleSelectValue(raw = '') {
   return clampFontScale(numeric);
 }
 
-function getMessageViewportAnchor() {
-  const container = document.getElementById('messages');
-  if (!container) return null;
-  const containerRect = container.getBoundingClientRect();
-  const messages = Array.from(container.querySelectorAll('.msg[data-message-id]'));
-  for (const message of messages) {
-    const rect = message.getBoundingClientRect();
-    if (rect.bottom <= containerRect.top || rect.top >= containerRect.bottom) continue;
-    const messageId = String(message.dataset.messageId || '').trim();
-    if (!messageId) continue;
-    return {
-      messageId,
-      offsetTop: rect.top - containerRect.top,
-    };
-  }
-  return null;
-}
-
-function restoreMessageViewportAnchor(anchor) {
-  if (!anchor?.messageId) return;
-  const container = document.getElementById('messages');
-  if (!container) return;
-  const messageId = String(anchor.messageId || '').trim();
-  if (!messageId) return;
-  const message = Array.from(container.querySelectorAll('.msg[data-message-id]'))
-    .find((node) => String(node?.dataset?.messageId || '').trim() === messageId);
-  if (!message) return;
-  const containerRect = container.getBoundingClientRect();
-  const rect = message.getBoundingClientRect();
-  const delta = rect.top - containerRect.top - Number(anchor.offsetTop || 0);
-  if (Math.abs(delta) > 0.5) {
-    container.scrollTop += delta;
-  }
-}
-
 export function syncFontScaleSelect() {
   const select = document.getElementById('font-scale-select');
   if (!select) return;
@@ -117,7 +84,7 @@ export function setFontScale(nextScale, { persist = true, preserveMessageAnchor
     syncFontScaleSelect();
     return normalized;
   }
-  const anchor = preserveMessageAnchor ? getMessageViewportAnchor() : null;
+  const anchor = preserveMessageAnchor ? captureTranscriptAnchor(document.getElementById('messages')) : null;
   fontScaleValue = normalized;
   document.documentElement.style.setProperty('--font-scale', normalized.toFixed(4));
   document.documentElement.style.setProperty('--font-scale-percent', `${Math.round(normalized * 100)}%`);
@@ -125,7 +92,7 @@ export function setFontScale(nextScale, { persist = true, preserveMessageAnchor
   syncFontScaleSelect();
   if (anchor) {
     requestAnimationFrame(() => {
-      restoreMessageViewportAnchor(anchor);
+      restoreTranscriptAnchor(document.getElementById('messages'), anchor);
     });
   }
   return normalized;

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

@@ -36,7 +36,7 @@ import {
   loadGrokSettings,
   loadOpenAISettings,
 } from './api-client.js';
-import { renderMessages, restoreInFlightThinking, focusConversationMessageById, flushConversationDraft, hydrateConversationDraft } from './conversation-view.js';
+import { renderMessages, restoreInFlightThinking, focusConversationMessageById, flushConversationDraft, hydrateConversationDraft, beginConversationDraftSwitch } from './conversation-view.js';
 import { setBackgroundTasksConversation, setConversationBackgroundTasks } from './background-tasks-view.mjs';
 import { mergeConversationPreviews } from './preview-cards.mjs';
 import { loadRelayQuestions, getPendingQuestionCountsByConversation } from './ask-user-view.js';
@@ -58,6 +58,12 @@ import {
   conversationProviderIndicatorLabel,
 } from './conversation-provider-indicator.mjs';
 import { leaveStatusView } from './status-view.mjs';
+import {
+  normalizeConversationFilter,
+  filterConversations,
+  drainRemainingPages,
+  describeFilterMatchCount,
+} from './conversation-list-filter.mjs';
 
 const PROCESSING_DOT_FRAMES = ['   ', '.  ', '.. ', '...'];
 const PROCESSING_DOT_INTERVAL_MS = 1000;
@@ -74,9 +80,13 @@ const CLAUDE_LONG_CONTEXT_PATTERN = /\[1m\]$/i;
 const OPENAI_IMAGE_SIZE_STORAGE_KEY = 'copilot_openai_image_size';
 const NEW_CHAT_CWD_STORAGE_KEY = 'copilot_new_chat_cwd';
 const NEW_CHAT_CUSTOM_CWD_VALUE = '__custom__';
+const CONV_FILTER_DEBOUNCE_MS = 220;
 let processingDotFrame = 0;
 let processingDotTimer = null;
 let lastConvListHtml = '';
+let conversationListFilterText = '';
+let conversationFilterDrainActive = false;
+let conversationFilterGeneration = 0;
 let openConversationVersion = 0;
 let newConversationInFlight = false;
 
@@ -273,6 +283,11 @@ export async function refreshConversations(options = {}) {
   });
   renderConvList();
   updateCompactButton();
+  // A reset bumps the loader version, which aborts any in-flight filter drain;
+  // restart it so an active filter keeps covering the unloaded pages.
+  if (normalizeConversationFilter(conversationListFilterText)) {
+    void drainConversationListForFilter();
+  }
 }
 
 export function renderConvList() {
@@ -282,9 +297,19 @@ export function renderConvList() {
     if (updatedAtDelta !== 0) return updatedAtDelta;
     return String(b?.id || '').trim().localeCompare(String(a?.id || '').trim());
   });
+  const activeFilter = normalizeConversationFilter(conversationListFilterText);
+  const visible = activeFilter ? filterConversations(sorted, activeFilter) : sorted;
   const pendingByConversation = getPendingQuestionCountsByConversation();
   let hasProcessingConversation = false;
   const footerHtml = (() => {
+    if (activeFilter) {
+      // While a filter is active the drain loads older pages by itself; a
+      // "scroll for more" hint would point at a gesture that does nothing, and
+      // "Searching…" must only show while something is actually loading.
+      return (conversationFilterDrainActive || conversationListPaginationState.isLoading)
+        ? '<div class="conv-list-footer">Searching older conversations…</div>'
+        : '';
+    }
     if (conversationListPaginationState.isLoading) {
       return '<div class="conv-list-footer">Loading older conversations…</div>';
     }
@@ -293,10 +318,14 @@ export function renderConvList() {
     }
     return '';
   })();
-  if (sorted.length === 0) {
+  if (visible.length === 0) {
     ensureProcessingDotTimer(false);
-    list.innerHTML = '<div style="padding:12px;color:var(--muted);font-size:0.85rem;text-align:center">No conversations yet</div>';
+    const emptyText = activeFilter && sorted.length > 0
+      ? 'No conversations match your filter'
+      : 'No conversations yet';
+    list.innerHTML = `<div style="padding:12px;color:var(--muted);font-size:0.85rem;text-align:center">${emptyText}</div>${footerHtml}`;
     lastConvListHtml = '';
+    scheduleConversationListBoundaryCheck();
     return;
   }
   const conversationView = (conversation) => {
@@ -312,7 +341,7 @@ export function renderConvList() {
     if (processing) hasProcessingConversation = true;
     return { visualState, processing };
   };
-  const listHtml = `${sorted.map((c) => {
+  const listHtml = `${visible.map((c) => {
     const view = conversationView(c);
     const processingDots = view.processing ? PROCESSING_DOT_FRAMES[processingDotFrame] : '';
     const providerIndicatorLabel = conversationProviderIndicatorLabel(c);
@@ -427,6 +456,7 @@ export async function openConversation(id, options = {}) {
     await flushConversationDraft(previousConversationId);
     window.clearImageEditTarget?.();
   }
+  const switchingConversation = !!nextConversationId && previousConversationId !== nextConversationId;
   const capturedVersion = ++openConversationVersion;
   setCurrentConv(id);
   if (repoBrowserState.activeRoot === 'workspace') {
@@ -440,7 +470,13 @@ export async function openConversation(id, options = {}) {
     repoBrowserState.error = '';
   }
   closeSidebar();
-  clearAttachments();
+  // Reopening the conversation on screen (session bind, clicking it again, a
+  // push or search jump) must leave its composer alone: emptied attachments
+  // would read as a user edit and be saved, dropping them from the draft.
+  if (switchingConversation) {
+    clearAttachments();
+    beginConversationDraftSwitch(nextConversationId);
+  }
   document.getElementById('chat-title').textContent = conversations[id]?.title || id;
   if (didLeaveStatusView) {
     restoreInFlightThinking(null);
@@ -1145,11 +1181,115 @@ export function initConversationListLazyLoading() {
   scheduleConversationListBoundaryCheck();
 }
 
+// A title filter has to search conversations that only exist on unloaded pages,
+// so an active filter drains the remaining pages in the background. Each page
+// re-renders via applyPage, so matches appear as they load.
+// A filter change aborts the running drain and starts a fresh one, so the new
+// filter gets a full retry budget.
+async function drainConversationListForFilter() {
+  if (conversationFilterDrainActive) return;
+  conversationFilterDrainActive = true;
+  const generation = conversationFilterGeneration;
+  renderConvList();
+  try {
+    await drainRemainingPages(
+      conversationListLoader,
+      () => generation === conversationFilterGeneration
+        && !!normalizeConversationFilter(conversationListFilterText),
+    );
+  } finally {
+    conversationFilterDrainActive = false;
+    const filterActive = !!normalizeConversationFilter(conversationListFilterText);
+    if (filterActive && generation !== conversationFilterGeneration) {
+      void drainConversationListForFilter();
+    } else {
+      // The "Searching older conversations…" footer keys off the drain flag.
+      renderConvList();
+      if (filterActive) announceConversationFilterResults();
+    }
+  }
+}
+
+// Announced only when the (debounced) filter applies and when its drain ends,
+// not on every page render, so screen readers are not flooded while typing.
+// Unchanged text is not rewritten: refresh-triggered drains (session bind,
+// reconnect) must not re-announce without a user action.
+function announceConversationFilterResults() {
+  const status = document.getElementById('conv-filter-status');
+  if (!status) return;
+  const activeFilter = normalizeConversationFilter(conversationListFilterText);
+  let text = '';
+  if (activeFilter) {
+    const count = filterConversations(Object.values(conversations), activeFilter).length;
+    if (!conversationListLoader.getState().hasMore) {
+      text = describeFilterMatchCount(count);
+    } else if (conversationFilterDrainActive) {
+      text = `${describeFilterMatchCount(count)} so far, searching older conversations`;
+    } else {
+      // The drain gave up with pages left, so the search is not complete.
+      text = describeFilterMatchCount(count, { loadedOnly: true });
+    }
+  }
+  if (status.textContent !== text) status.textContent = text;
+}
+
+function setConversationListFilter(text) {
+  const next = String(text ?? '');
+  if (next === conversationListFilterText) return;
+  conversationListFilterText = next;
+  conversationFilterGeneration += 1;
+  const list = getConversationListElement();
+  if (list) list.scrollTop = 0;
+  renderConvList();
+  if (normalizeConversationFilter(next)) void drainConversationListForFilter();
+  announceConversationFilterResults();
+}
+
+export function initConversationFilter() {
+  const input = document.getElementById('conv-filter-input');
+  const clearButton = document.getElementById('conv-filter-clear');
+  if (!input || input.dataset.filterBound === '1') return;
+  input.dataset.filterBound = '1';
+  let debounceTimer = null;
+  const syncClearButton = () => {
+    if (clearButton) clearButton.hidden = input.value === '';
+  };
+  const applyFilterNow = () => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+      debounceTimer = null;
+    }
+    syncClearButton();
+    setConversationListFilter(input.value);
+  };
+  input.addEventListener('input', () => {
+    syncClearButton();
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(applyFilterNow, CONV_FILTER_DEBOUNCE_MS);
+  });
+  input.addEventListener('keydown', (event) => {
+    if (event.key !== 'Escape' || input.value === '') return;
+    event.stopPropagation();
+    input.value = '';
+    applyFilterNow();
+  });
+  clearButton?.addEventListener('click', () => {
+    input.value = '';
+    applyFilterNow();
+    input.focus();
+  });
+  syncClearButton();
+}
+
 export async function deleteConv(e, id) {
   e.stopPropagation();
   if (!confirm('Delete this conversation?')) return;
   const result = await deleteConversationApi(id);
   if (!result) return;
+  if (result.ok === false) {
+    showTransientRelayNotice(String(result.message || '').trim() || 'This conversation could not be deleted.', 6000);
+    return;
+  }
   delete conversations[id];
   renderConvList();
   if (currentConvId === id) {

package/server/public/app/model-selector-options.mjs

@@ -2,7 +2,7 @@ import { tokenLabel } from './context-tier-options.mjs';
 
 /**
  * The composer placeholder, decided by the MODEL FAMILY of the current
- * selection (Simon's rule: the hint names who answers, whatever runtime serves
+ * selection (maintainer's rule: the hint names who answers, whatever runtime serves
  * it — claude-* through Cursor's catalog still reads "Message Claude…").
  * Provider only breaks ties: Auto/empty follows the conversation's bound
  * provider, unknown families on the OpenAI BYOK provider read OpenAI, and

package/server/public/app/question-multi-select.mjs

@@ -0,0 +1,52 @@
+// Multi-select question cards: the pure rules the card renderer and its
+// submit path share, kept DOM-free so they are unit-testable.
+//
+// Two card hints ride the question's `context` (kept by the relay's
+// services/relay-question-context.mjs allow-list):
+//  - `multiSelect: true` — several answers are allowed. Claude states this on
+//    every AskUserQuestion question; Copilot models declare it through the
+//    relay's own `ask_user` (`multi_select`), and the worker falls back to the
+//    wording ("select all that apply").
+//  - `allowMultiSelect: true` — the provider cannot always tell (Copilot), so
+//    the card offers a "Select several" switch. Claude cards never carry it:
+//    they follow Claude's flag strictly (maintainer decision, 2026-09-25).
+// A multi-select card offers checkmarks and one "Reply with selection"; the
+// answer is the selected labels joined with ", " — plus whatever the user
+// typed as an extra answer — which is Claude's own multi-select answer format.
+
+function choiceCount(question) {
+  return Array.isArray(question?.choices) ? question.choices.length : 0;
+}
+
+/** Whether the card offers the "Select several" switch. */
+export function offersMultiSelectToggle(question) {
+  if (!question || typeof question !== 'object') return false;
+  return choiceCount(question) >= 2 && question?.context?.allowMultiSelect === true;
+}
+
+/**
+ * Whether the card renders checkmarks. `override` is the user's switch
+ * position for this card (true/false), or undefined while untouched — then the
+ * provider's flag decides. The switch only counts on cards that offer it.
+ */
+export function isMultiSelectQuestion(question, override = undefined) {
+  if (!question || typeof question !== 'object') return false;
+  if (choiceCount(question) < 2) return false;
+  if (typeof override === 'boolean' && offersMultiSelectToggle(question)) return override;
+  return question?.context?.multiSelect === true;
+}
+
+/**
+ * The answer string for a multi-select card: the selected labels in offer
+ * order, then the free-text answer (if any) as one more item. Empty when
+ * nothing was selected or typed.
+ */
+export function composeMultiSelectAnswer(selectedLabels, freeText = '') {
+  const labels = (Array.isArray(selectedLabels) ? selectedLabels : [])
+    .map((label) => String(label ?? '').trim())
+    .filter(Boolean)
+    .filter((label, index, all) => all.indexOf(label) === index);
+  const extra = String(freeText ?? '').trim();
+  if (extra && !labels.includes(extra)) labels.push(extra);
+  return labels.join(', ');
+}

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

@@ -108,6 +108,21 @@ function stripAttachmentPromptArtifacts(text) {
 // structurally — the heading plus its single paragraph — rather than verbatim.
 const MEDIA_EMBED_BLOCK_PATTERN = /##\s*Embedding media in replies\s+[\s\S]*?(?=\n\s*\n|$)/gi;
 
+// A steered message's hidden note (shared/steer-note.mjs) leads the prompt the
+// runtime stored, right after any mode marker. Matched by its stable opening
+// words, because the browser copy of this module cannot import shared/.
+const STEER_NOTE_PATTERN = /^\s*\[Sent while you were still working on my previous message\.[^\]\n]*\]\s*/;
+
+// The Claude worker's slash-command guard (shared/slash-command-guard.mjs): a
+// zero-width space in front of a "/x" it delivers as text. trim() keeps it, so
+// it is matched on its own, and only where it guards a "/".
+const SLASH_COMMAND_GUARD_PATTERN = /^\u200B(?=\s*\/)/;
+
+function stripLeadingRelayNotes(text) {
+  const stripped = String(text || '').replace(STEER_NOTE_PATTERN, '').replace(SLASH_COMMAND_GUARD_PATTERN, '');
+  return stripped.trim() ? stripped.trim() : String(text || '').trim();
+}
+
 export function stripRelayPromptContext(text, relayMode = '') {
   const value = stripAttachmentPromptArtifacts(text)
     .replace(MEDIA_EMBED_BLOCK_PATTERN, '')
@@ -116,7 +131,7 @@ export function stripRelayPromptContext(text, relayMode = '') {
   const patterns = buildPromptPrefixPatterns(relayMode);
   for (const pattern of patterns) {
     const stripped = value.replace(pattern, '').trim();
-    if (stripped && stripped !== value) return stripped;
+    if (stripped && stripped !== value) return stripLeadingRelayNotes(stripped);
   }
-  return value;
+  return stripLeadingRelayNotes(value);
 }

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

@@ -33,6 +33,7 @@ import {
   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';
@@ -152,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() {
@@ -353,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';
     }
   }
@@ -396,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,
     );

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

@@ -29,6 +29,7 @@ import {
   clearSubagentCancelInFlight,
   setConversationWatcherCount,
   setUpdateState,
+  applySessionWorkerSteering,
 } from './store.js';
 import { scheduleContextUsageRefresh } from './api-client.js';
 import { publishStatusEvent, recordStatusEvent } from './status-store.mjs';
@@ -66,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';
@@ -627,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);

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