@oar-sh/oar 0.9.2 → 0.9.3

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

@@ -5,6 +5,8 @@
 // `backgroundTasks` on reload; hidden whenever the set is empty.
 
 import { apiFetch } from './api-client.js';
+import { humanizeModelLabel } from './model-selector-options.mjs';
+import { prefixToolActivityEmoji } from './tool-activity-emoji.mjs';
 import {
   getPreviewsForConversation,
   renderPreviewRowsInto,
@@ -69,11 +71,26 @@ function taskKindLabel(task) {
   return label === 'Subagent' && subagentType ? subagentType : label;
 }
 
-function formatTaskModel(task) {
-  const model = String(task?.model || '').trim();
-  if (!model) return '';
-  const short = model.replace(/^claude-/, '');
-  return task?.modelInherited === true ? `${short} (inherited)` : short;
+// "claude-opus-5-5" → "Opus 5.5". A bare alias ("opus") is what a spawn pin
+// carries until the subagent's first answer names the real model.
+export function formatTaskModelLabel(model) {
+  const value = String(model || '').trim();
+  if (!value) return '';
+  if (/^claude-/i.test(value)) return humanizeModelLabel(value);
+  if (/^[a-z]+(\[[^\]]+\])?$/i.test(value)) return value.charAt(0).toUpperCase() + value.slice(1);
+  return humanizeModelLabel(value);
+}
+
+// Detail line: the live tool call when the worker saw one ("🪓 Tool
+// (PowerShell): cd …", cropped to the row by CSS), else the SDK's progress
+// summary, else the bare tool name.
+export function taskActivityText(task) {
+  const toolCall = String(task?.lastToolCall || '').trim();
+  if (toolCall) return { text: prefixToolActivityEmoji(toolCall), toolCall: true };
+  const summary = String(task?.summary || '').trim();
+  if (summary) return { text: summary, toolCall: false };
+  const lastToolName = String(task?.lastToolName || '').trim();
+  return { text: lastToolName ? `using ${lastToolName}` : '', toolCall: false };
 }
 
 // Compact token counts: "812 tok", "62.2k tok", "1.2M tok". Exported for the
@@ -180,7 +197,7 @@ function buildWorkflowAgentRow(agent) {
   const activityText = state === 'running' && lastToolName ? `— using ${lastToolName}` : '';
 
   const meta = [];
-  const model = String(agent.model ?? '').trim().replace(/^claude-/, '');
+  const model = formatTaskModelLabel(agent.model);
   if (model) meta.push(model);
   const tokens = formatTaskTokens(agent.tokens);
   if (tokens) meta.push(tokens);
@@ -364,16 +381,11 @@ function renderTaskRow(conversationId, task) {
   const key = `${conversationId}:${task.taskId}`;
   const stopping = stopsInFlight.has(key);
   const elapsed = formatElapsed(task.startedAt);
-  // Second line: progress first ("using Bash" prefixed so a bare tool name
-  // can't read as the task's kind), then model. Token usage renders as its
-  // own always-visible element on the row's right side instead of riding
-  // this clampable line, so a long summary can never crowd it out.
-  const summary = String(task.summary || '').trim();
-  const lastToolName = String(task.lastToolName || '').trim();
-  const detail = [
-    summary || (lastToolName ? `using ${lastToolName}` : ''),
-    formatTaskModel(task),
-  ].filter(Boolean).join(' · ');
+  // Token usage and the model render on the row's right side instead of
+  // riding the detail line, so a long tool call can never crowd them out.
+  const activity = taskActivityText(task);
+  const modelLabel = formatTaskModelLabel(task.model);
+  const modelTitle = task.modelInherited === true ? `${task.model} (inherited from the session)` : task.model;
   const tokens = formatTaskTokens(task.totalTokens);
   // Workflow rows with a digest get a fold chevron plus an (initially empty)
   // tree container right below the row; renderBackgroundTasksPanel fills the
@@ -392,10 +404,13 @@ function renderTaskRow(conversationId, task) {
       ${foldButton}<span class="bg-task-icon" title="${escHtml(task.taskType || 'task')}">${taskIcon(task.taskType)}</span>
       <span class="bg-task-main">
         <span class="bg-task-desc">${escHtml(task.description || task.taskId)}</span>
-        ${detail ? `<span class="bg-task-detail">${escHtml(detail)}</span>` : ''}
+        ${activity.text ? `<span class="bg-task-detail${activity.toolCall ? ' bg-task-toolcall' : ''}" title="${escHtml(activity.text)}">${escHtml(activity.text)}</span>` : ''}
       </span>
       <span class="bg-task-side">
-        <span class="bg-task-badge">${escHtml(taskKindLabel(task))}</span>
+        <span class="bg-task-side-head">
+          ${modelLabel ? `<span class="bg-task-model" title="${escHtml(modelTitle)}">${escHtml(modelLabel)}</span>` : ''}
+          <span class="bg-task-badge">${escHtml(taskKindLabel(task))}</span>
+        </span>
         <span class="bg-task-side-status">
           ${tokens ? `<span class="bg-task-tokens">${escHtml(tokens)}</span>` : ''}
           <span class="bg-task-elapsed">${escHtml(elapsed)}</span>

package/server/public/app/bootstrap.js

@@ -51,6 +51,7 @@ import {
   imageEditTarget,
   hasPendingUserMessageForConversation,
 } from './store.js';
+import { createTranscriptResizeKeeper } from './transcript-viewport-anchor.mjs';
 import {
   verifyExistingSession,
   verifyToken,
@@ -76,7 +77,7 @@ import {
   reportSharedViewerPresence,
   setNetworkRequestsEnabled,
 } from './api-client.js';
-import { loadConversations, refreshConversations, openConversation, renderConvList, applyLoadedConversationState, initConversationListLazyLoading } from './journal-view.js';
+import { loadConversations, refreshConversations, openConversation, renderConvList, applyLoadedConversationState, initConversationListLazyLoading, initConversationFilter } from './journal-view.js';
 import {
   newConversation,
   confirmNewConversationModel,
@@ -87,7 +88,7 @@ import {
   loadRelayQuestions,
   getPendingQuestionCountsByConversation,
 } from './ask-user-view.js';
-import { openPendingQuestionFromBanner, submitRelayQuestionChoice, submitRelayQuestionAnswer, submitRelayStructuredAnswer, onRelayQuestionDraftInput, handleRelayQuestionKey } from './ask-user-view.js';
+import { openPendingQuestionFromBanner, submitRelayQuestionChoice, submitRelayQuestionAnswer, submitRelayQuestionMultiSelect, submitRelayStructuredAnswer, onRelayQuestionDraftInput, onRelayQuestionMultiSelectChange, setRelayQuestionMultiMode, handleRelayQuestionKey } from './ask-user-view.js';
 import { loadRelayBoards, submitRelayBoardAction } from './relay-board-view.js';
 import {
   restoreInFlightThinking,
@@ -99,7 +100,10 @@ import {
   updateComposerSlashMenu,
   getConversationLoadedMessageCount,
   loadOlderConversationMessages,
-  syncComposerControlState,
+  syncComposerButtonState,
+  syncCancellableSteerButtons,
+  syncComposerAfterUserEdit,
+  isConversationDraftHeldBySend,
   persistComposerAttachments,
   flushConversationDraft,
   initConversationHistoryLazyLoading,
@@ -1139,7 +1143,7 @@ function syncModelMetadataBlocker(message = '') {
     reasoningSelect.disabled = blocked;
     reasoningSelect.title = blocked ? 'Reasoning metadata unavailable' : 'Reasoning effort';
   }
-  window.syncComposerControlState?.();
+  window.syncComposerButtonState?.();
 }
 
 function currentConversationHasMessages() {
@@ -3240,6 +3244,10 @@ async function refreshSessionWorkerStatus() {
   syncQueueStatusMenuEntry(status);
   if (setSessionWorkerStatesFromStatusPayload(status.sessionWorker)) {
     renderConvList();
+    // A worker steering snapshot may have changed; the composer's Steer
+    // button (gate, hold) and the pushed rows' Cancel controls derive from it.
+    syncComposerButtonState();
+    syncCancellableSteerButtons();
   }
   updateCliStatus();
   const nextWorkerState = currentSdkSessionId ? getSessionWorkerState(currentSdkSessionId) : null;
@@ -3311,9 +3319,18 @@ function startLiveConversationPolling() {
   }, 900);
 }
 
+const transcriptResizeKeeper = createTranscriptResizeKeeper({
+  getElement: () => document.getElementById('messages'),
+});
+
 function setupViewportTracking() {
   syncViewportMetrics();
-  const update = () => syncViewportMetrics();
+  // After the metrics: --app-height decides the transcript's height, and the
+  // keeper's restore reads the post-resize layout.
+  const update = () => {
+    syncViewportMetrics();
+    transcriptResizeKeeper.handleResize();
+  };
   window.addEventListener('resize', update, { passive: true });
   window.addEventListener('orientationchange', update, { passive: true });
   if (window.visualViewport) {
@@ -3352,7 +3369,7 @@ function setupViewportTracking() {
   if (input && input.dataset.viewportBound !== '1') {
     input.dataset.viewportBound = '1';
     input.addEventListener('input', () => {
-      syncComposerControlState();
+      syncComposerAfterUserEdit();
     }, { passive: true });
     input.addEventListener('focus', () => {
       document.body.classList.add('keyboard-open');
@@ -3427,6 +3444,7 @@ function initMessageScrollPersistence() {
   if (!el || el.dataset.scrollPersistenceBound === '1') return;
   el.dataset.scrollPersistenceBound = '1';
   el.addEventListener('scroll', () => {
+    transcriptResizeKeeper.recordScroll();
     const convId = String(currentConvId || '').trim();
     if (!convId) return;
     saveConversationScrollTop(convId, el.scrollTop);
@@ -3944,7 +3962,11 @@ async function initApp() {
     // The direct flush below can be killed mid-flight by the browser; the
     // queued copy survives and is replayed by Background Sync. If the direct
     // write wins, the replay hits a draft version conflict and is dropped.
-    if (!appSharedMode) void enqueueDraftFlushForBackgroundSync(currentConvId);
+    if (!appSharedMode) {
+      void enqueueDraftFlushForBackgroundSync(currentConvId, {
+        afterPendingSend: isConversationDraftHeldBySend(currentConvId),
+      });
+    }
     void flushConversationDraft(currentConvId);
     closeTmuxInspectorView();
   });
@@ -4164,6 +4186,7 @@ async function initApp() {
   initEmojiPicker();
   initSlashAutocomplete();
   initConversationListLazyLoading();
+  initConversationFilter();
   initConversationHistoryLazyLoading();
   initBubbleActionHandlers();
   initMessageScrollPersistence();
@@ -4358,14 +4381,17 @@ window.confirmRepoBrowserCwdPick = confirmRepoBrowserCwdPick;
 window.toggleEmojiPicker = toggleEmojiPicker;
 window.submitRelayQuestionChoice = submitRelayQuestionChoice;
 window.submitRelayQuestionAnswer = submitRelayQuestionAnswer;
+window.submitRelayQuestionMultiSelect = submitRelayQuestionMultiSelect;
 window.submitRelayStructuredAnswer = submitRelayStructuredAnswer;
 window.onRelayQuestionDraftInput = onRelayQuestionDraftInput;
+window.onRelayQuestionMultiSelectChange = onRelayQuestionMultiSelectChange;
+window.setRelayQuestionMultiMode = setRelayQuestionMultiMode;
 window.handleRelayQuestionKey = handleRelayQuestionKey;
 window.openPendingQuestionFromBanner = openPendingQuestionFromBanner;
 window.submitRelayBoardAction = submitRelayBoardAction;
 window.compactCurrentConversation = compactCurrentConversation;
 window.sendMessage = sendMessage;
-window.syncComposerControlState = syncComposerControlState;
+window.syncComposerButtonState = syncComposerButtonState;
 window.syncComposerPlaceholder = syncComposerPlaceholder;
 window.persistComposerAttachments = persistComposerAttachments;
 window.appendMessage = appendMessage;

package/server/public/app/composer-control-state.mjs

@@ -19,19 +19,51 @@ export function hasUploadingAttachments(attachments = []) {
   return countUploadingAttachments(attachments) > 0;
 }
 
+// Why a message sent right now queues instead of steering — worker-reported
+// hold reasons mapped to a human title. Stopping a turn lives on the message
+// bubbles, never here, so every state below is a Send/Steer/Queue shape.
+const STEERING_HOLD_TITLES = Object.freeze({
+  question: 'Will steer in after you answer the question',
+  compaction: 'Will steer in once the conversation finishes compacting',
+  adoption: 'Will steer in once the compaction recovery finishes',
+  delivery: 'Will steer in once the current delivery lands',
+});
+
 export function deriveComposerControlState({
   hasActiveTurn = false,
-  cancelRequested = false,
   hasDraft = false,
   sendInFlight = false,
   modelMetadataBlocked = false,
   attachmentsUploading = false,
+  // The conversation's session worker delivers a message typed during a live
+  // turn INTO that turn (mid-turn steering, advertised on its heartbeat
+  // snapshot) rather than queueing it behind — so the control says "Steer",
+  // not "Queue". Workers that do not advertise it keep the queue wording.
+  steeringSupported = false,
+  // The worker reports steering as momentarily held (open question card or
+  // plan approval, compaction, post-compaction adoption). A send stays allowed
+  // and reads "Queue": the relay holds the message and it steers in once the
+  // hold clears.
+  steeringHeld = false,
+  steeringHoldReason = null,
 } = {}) {
   const active = !!hasActiveTurn;
-  const stopping = !!cancelRequested;
   const draft = !!hasDraft;
   const metadataBlocked = !!modelMetadataBlocked;
   const uploading = !!attachmentsUploading;
+  const held = active && !!steeringSupported && !!steeringHeld;
+  // The label/title/action for a draft typed during a live turn: steer into it
+  // where the provider supports that (queued while steering is held), queue
+  // behind it otherwise.
+  const steerNow = !!steeringSupported && !held;
+  const midTurnAction = steerNow ? 'steer' : 'queue';
+  const midTurnLabel = steerNow ? 'Steer' : 'Queue';
+  const midTurnTitle = held
+    ? (STEERING_HOLD_TITLES[String(steeringHoldReason || '').trim()]
+      || 'Will steer in once steering resumes')
+    : (steeringSupported
+      ? 'Steer message into the running turn'
+      : 'Queue message behind current turn');
 
   if (metadataBlocked && !active) {
     return {
@@ -42,59 +74,45 @@ export function deriveComposerControlState({
     };
   }
 
-  // Uploads are eager, so the blocking window is short. Keeping the button
-  // labelled Send/Queue (rather than switching to Stop) avoids the control
-  // flipping meaning mid-upload while a turn is running.
+  // Uploads are eager, so the blocking window is short. The control keeps its
+  // Send/Steer/Queue meaning while it waits.
   if (uploading) {
-    const queueing = active && draft;
+    const midTurn = active && draft;
     return {
-      action: queueing ? 'queue' : 'send',
-      label: queueing ? 'Queue' : 'Send',
+      action: midTurn ? midTurnAction : 'send',
+      label: midTurn ? midTurnLabel : 'Send',
       title: 'Waiting for attachments to finish uploading',
       disabled: true,
     };
   }
 
   if (sendInFlight) {
-    if (active && draft) {
-      return {
-        action: 'queue',
-        label: 'Queue',
-        title: 'Queue message behind current turn',
-        disabled: true,
-      };
-    }
-    if (active) {
-      return {
-        action: 'stop',
-        label: stopping ? 'Stopping…' : 'Stop',
-        title: stopping ? 'Stopping the current turn' : 'Stop the current turn',
-        disabled: true,
-      };
-    }
     return {
-      action: 'send',
-      label: 'Send',
-      title: 'Send message',
+      action: active && draft ? midTurnAction : 'send',
+      label: active && draft ? midTurnLabel : 'Send',
+      title: active && draft ? midTurnTitle : 'Send message',
       disabled: true,
     };
   }
 
   if (active && draft) {
     return {
-      action: 'queue',
-      label: 'Queue',
-      title: 'Queue message behind current turn',
+      action: midTurnAction,
+      label: midTurnLabel,
+      title: midTurnTitle,
       disabled: false,
     };
   }
 
   if (active) {
+    // Empty composer during a live turn: nothing to send, nothing to steer.
+    // The label stays "Send" (it only reads "Steer" with text present) and
+    // re-enables the moment the user types or the turn ends.
     return {
-      action: 'stop',
-      label: stopping ? 'Stopping…' : 'Stop',
-      title: stopping ? 'Stopping the current turn' : 'Stop the current turn',
-      disabled: stopping,
+      action: 'send',
+      label: 'Send',
+      title: 'Type a message to send',
+      disabled: true,
     };
   }
 

package/server/public/app/conversation-draft-sync.mjs

@@ -0,0 +1,187 @@
+// Per-conversation record of the server draft this client's composer last
+// agreed with. The composer text is local state that changes on every
+// keystroke; this record changes only when the server acknowledges a save or
+// the composer adopts a remote draft. Its updatedAt is the base version every
+// draft save is checked against, so it must never be touched by a local edit.
+
+import { serializeDraftAttachments } from './composer-attachment-cache.mjs';
+import { normalizeDraftTimestampMs } from './conversation-draft-timestamp-utils.mjs';
+
+// Sent with every draft save. It is what lets the server conflict-check an
+// explicit null base: clients from before this protocol also send null (JSON
+// keeps it), and for them null has to keep meaning "unconditional".
+export const DRAFT_SYNC_PROTOCOL_VERSION = 2;
+
+// Must equal the server's MAX_CONVERSATION_DRAFT_LENGTH (a test pins it). The
+// server truncates longer drafts, so the client saves and compares only this
+// prefix; otherwise a long composer never matches its acknowledged draft and
+// is re-saved on every refresh. The composer itself (and the message) is not
+// limited — only what survives as a draft.
+export const MAX_DRAFT_TEXT_LENGTH = 20_000;
+
+// Cuts at a code-point boundary, exactly like the server: a cut through a
+// surrogate pair would store a lone surrogate, which SQLite hands back as
+// U+FFFD — a different text at the same version.
+export function draftTextForSync(text) {
+  const value = String(text || '');
+  if (value.length <= MAX_DRAFT_TEXT_LENGTH) return value;
+  const cut = value.slice(0, MAX_DRAFT_TEXT_LENGTH);
+  const last = cut.charCodeAt(cut.length - 1);
+  return last >= 0xd800 && last <= 0xdbff ? cut.slice(0, -1) : cut;
+}
+
+const syncedDraftsByConversation = new Map();
+
+function conversationKey(conversationId) {
+  return String(conversationId || '').trim();
+}
+
+/** Order-sensitive fingerprint of a draft attachment list; null when absent. */
+export function draftAttachmentsKey(attachments) {
+  if (attachments === undefined || attachments === null) return null;
+  return serializeDraftAttachments(Array.isArray(attachments) ? attachments : [], { max: Number.MAX_SAFE_INTEGER })
+    .map((row) => row.sha256)
+    .join(',');
+}
+
+export function getSyncedDraft(conversationId) {
+  return syncedDraftsByConversation.get(conversationKey(conversationId)) || null;
+}
+
+export function recordSyncedDraft(conversationId, {
+  text = '',
+  attachments = undefined,
+  updatedAt = null,
+} = {}) {
+  const id = conversationKey(conversationId);
+  if (!id) return null;
+  const previous = syncedDraftsByConversation.get(id) || null;
+  const incomingKey = draftAttachmentsKey(attachments);
+  const record = {
+    text: String(text || ''),
+    attachmentsKey: incomingKey === null ? (previous?.attachmentsKey ?? null) : incomingKey,
+    updatedAt: updatedAt || null,
+  };
+  syncedDraftsByConversation.set(id, record);
+  return record;
+}
+
+export function forgetSyncedDraft(conversationId) {
+  syncedDraftsByConversation.delete(conversationKey(conversationId));
+}
+
+/**
+ * A save is a no-op when the server already holds exactly this text (and,
+ * for saves that carry attachments, exactly these attachments) — but only
+ * while no newer server version is known. If one is (a remote draft deferred
+ * while the user typed), the save must still go out so its version check
+ * surfaces that draft instead of silently keeping a stale base.
+ */
+export function isDraftSaveNoop({ synced = null, text = '', attachmentsKey = null, knownUpdatedAt = null } = {}) {
+  if (!synced) return false;
+  if (normalizeDraftTimestampMs(knownUpdatedAt) > normalizeDraftTimestampMs(synced.updatedAt)) return false;
+  if (String(text || '') !== synced.text) return false;
+  if (attachmentsKey === null) return true;
+  return synced.attachmentsKey !== null && attachmentsKey === synced.attachmentsKey;
+}
+
+/**
+ * Decides a 409 draft conflict.
+ * - converged: the server already holds what we wanted to save.
+ * - adopt: the local text is unchanged since the last sync, so the remote
+ *   draft simply wins.
+ * - keep-local: both sides edited; the local (newest) keystroke wins and the
+ *   remote text becomes the one offered for restore.
+ */
+export function resolveDraftConflict({
+  localText = '',
+  localAttachmentsKey = null,
+  baseText = null,
+  baseAttachmentsKey = null,
+  serverText = '',
+  serverAttachmentsKey = null,
+} = {}) {
+  const local = String(localText || '');
+  const attachmentsMatch = (other) => localAttachmentsKey === null || localAttachmentsKey === other;
+  if (local === String(serverText || '') && attachmentsMatch(serverAttachmentsKey)) return 'converged';
+  if (baseText !== null && local === baseText && attachmentsMatch(baseAttachmentsKey)) return 'adopt';
+  return 'keep-local';
+}
+
+/**
+ * Whether an incoming remote draft may replace the composer of the
+ * conversation on screen. Only an unmodified composer (text and attachments
+ * still equal to the last synced draft) adopts it, focused or not. A modified
+ * one never does — not even for an equal or newer version: its edit is unsaved
+ * (a failed flush leaves exactly this state), and the caller re-saves it so the
+ * version check decides. An upload still in flight counts as a modification.
+ * With nothing synced yet there is no saved edit to protect.
+ * Attachment keys are null when unknown and then do not take part.
+ */
+export function shouldApplyIncomingDraftToComposer({
+  inputText = '',
+  incomingText = '',
+  syncedText = null,
+  inputAttachmentsKey = null,
+  incomingAttachmentsKey = null,
+  syncedAttachmentsKey = null,
+  attachmentsUploading = false,
+} = {}) {
+  if (attachmentsUploading) return false;
+  const current = draftTextForSync(inputText);
+  const sameAttachments = (other) => inputAttachmentsKey === null || other === null || inputAttachmentsKey === other;
+  if (current === String(incomingText || '') && sameAttachments(incomingAttachmentsKey)) return true;
+  if (syncedText === null) return true;
+  return current === syncedText && sameAttachments(syncedAttachmentsKey);
+}
+
+/**
+ * PATCH body for the pagehide Background Sync copy of a draft flush, or null
+ * when the composer holds nothing unsaved. Compared against the synced draft,
+ * not the local text (which every keystroke updates).
+ */
+export function draftFlushRequestBody({
+  inputText = '',
+  synced = null,
+  fallbackText = '',
+  fallbackUpdatedAt = null,
+  clientId = null,
+  afterPendingSend = false,
+} = {}) {
+  const draftText = draftTextForSync(inputText);
+  const serverText = synced ? synced.text : draftTextForSync(fallbackText);
+  if (draftText === serverText) return null;
+  if (afterPendingSend) {
+    // An emptied composer after a send is what the send leaves anyway.
+    if (!draftText.trim()) return null;
+    // The send will move the server's version past this base. acceptOwnSend
+    // lets the replay through only while that move is this client's own (the
+    // send transaction records the sender); anyone else's newer draft still
+    // wins with a 409.
+    return {
+      draftText,
+      clientId,
+      draftSyncVersion: DRAFT_SYNC_PROTOCOL_VERSION,
+      baseDraftUpdatedAt: (synced ? synced.updatedAt : fallbackUpdatedAt) || null,
+      acceptOwnSend: true,
+    };
+  }
+  return {
+    draftText,
+    clientId,
+    draftSyncVersion: DRAFT_SYNC_PROTOCOL_VERSION,
+    baseDraftUpdatedAt: (synced ? synced.updatedAt : fallbackUpdatedAt) || null,
+  };
+}
+
+// A queued draft flush replayed later than this (Firefox/Safari replay the
+// outbox only on the next page load, possibly hours on) would write text
+// nobody is looking at over whatever the draft became meanwhile. sw.js
+// mirrors this value; a test pins them together.
+export const DRAFT_FLUSH_MAX_AGE_MS = 5 * 60 * 1000;
+
+export function isStaleDraftFlushEntry(entry, now = Date.now()) {
+  if (String(entry?.kind || '') !== 'draft-flush') return false;
+  const createdAt = Number(entry?.createdAt || 0);
+  return !Number.isFinite(createdAt) || createdAt <= 0 || now - createdAt > DRAFT_FLUSH_MAX_AGE_MS;
+}

package/server/public/app/conversation-list-filter.mjs

@@ -0,0 +1,86 @@
+// Title filtering for the conversation sidebar. Kept DOM-free so it can be unit
+// tested; journal-view.js touches window/document at module scope and cannot be
+// imported from node:test.
+
+// NFC first so a decomposed "é" (e + U+0301, as some IMEs and pasted text
+// produce) matches a precomposed one. Case folding is toLocaleLowerCase only, so
+// multi-char folds are a known limit: "ß" does not match "SS".
+function foldForMatch(text) {
+  return String(text ?? '').normalize('NFC').toLocaleLowerCase();
+}
+
+export function normalizeConversationFilter(text) {
+  return foldForMatch(text).trim();
+}
+
+export function conversationMatchesFilter(conversation, normalizedFilter) {
+  if (!normalizedFilter) return true;
+  return foldForMatch(conversation?.title).includes(normalizedFilter);
+}
+
+export function filterConversations(conversations, filterText) {
+  const list = Array.isArray(conversations) ? conversations : [];
+  const normalized = normalizeConversationFilter(filterText);
+  if (!normalized) return list;
+  return list.filter((conversation) => conversationMatchesFilter(conversation, normalized));
+}
+
+export function describeFilterMatchCount(count, { loadedOnly = false } = {}) {
+  const n = Math.max(0, Number(count) || 0);
+  const noun = loadedOnly ? 'loaded conversation' : 'conversation';
+  if (n === 0) return `No ${noun}s match`;
+  return n === 1 ? `1 ${noun} matches` : `${n} ${noun}s match`;
+}
+
+function cursorKey(state) {
+  try {
+    return JSON.stringify(state?.nextCursor ?? null);
+  } catch {
+    return '';
+  }
+}
+
+// While a filter is active the sidebar has to search conversations that only
+// exist on unloaded pages, so pull every remaining page through the loader.
+// shouldContinue() is checked before each page so clearing the filter (or
+// switching it) aborts the drain. loadMore() resolving falsy is ambiguous:
+// - the loader is busy (a boundary-check load/prefetch is in flight): wait it
+//   out without spending idle retries, so the drain does not give up while the
+//   list is still loading. busyRetries caps a genuinely stuck fetch.
+// - a reset bumped the loader version mid-fetch, or the fetch failed: retry,
+//   but stop after maxIdleRetries consecutive no-progress attempts so a failing
+//   endpoint is not hammered forever.
+// An advanced cursor counts as progress even when the page was empty.
+export async function drainRemainingPages(loader, shouldContinue = () => true, {
+  retryDelayMs = 200,
+  maxIdleRetries = 10,
+  maxBusyRetries = 300,
+  delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+} = {}) {
+  if (!loader || typeof loader.loadMore !== 'function' || typeof loader.getState !== 'function') {
+    return false;
+  }
+  let loadedAnything = false;
+  let idleRetries = 0;
+  let busyRetries = 0;
+  while (loader.getState().hasMore && shouldContinue()) {
+    const cursorBefore = cursorKey(loader.getState());
+    const loaded = await loader.loadMore();
+    const state = loader.getState();
+    if (loaded) loadedAnything = true;
+    if (loaded || cursorKey(state) !== cursorBefore) {
+      idleRetries = 0;
+      busyRetries = 0;
+      continue;
+    }
+    if (state.isLoading || state.isPrefetching) {
+      busyRetries += 1;
+      if (busyRetries > maxBusyRetries) break;
+    } else {
+      idleRetries += 1;
+      if (idleRetries > maxIdleRetries) break;
+    }
+    await delay(retryDelayMs);
+  }
+  return loadedAnything;
+}

package/server/public/app/conversation-provider-indicator.mjs

@@ -35,6 +35,14 @@ export function conversationProviderIndicatorLabel(conversation = null) {
   return '';
 }
 
+// A question card names the runtime that asks, the way the list pill names it.
+// Unresolved reads plain "Question": every card used to say "Copilot question",
+// Claude's and Cursor's included.
+export function questionCardHeadLabel(conversation = null) {
+  const provider = conversationProviderIndicatorLabel(conversation);
+  return provider ? `${provider} question` : 'Question';
+}
+
 const SESSION_LOCK_LABELS = {
   github: 'GitHub Copilot',
   openai: 'OpenAI',