@oar-sh/oar 0.9.2 → 0.9.3

package/server/public/index.html

@@ -210,6 +210,13 @@
     document.documentElement.style.setProperty('--font-scale', String(value));
     document.documentElement.style.setProperty('--font-scale-percent', `${Math.round(value * 100)}%`);
   })();
+  // Mirrored by syncScreenShortSide in app/store.js.
+  (function applyScreenShortSideEarly() {
+    const shortSide = Math.min(Number(screen.width) || 0, Number(screen.height) || 0);
+    if (!shortSide) return;
+    document.documentElement.style.setProperty('--screen-short-side', `${shortSide}px`);
+    document.documentElement.toggleAttribute('data-phone-screen', shortSide <= 500);
+  })();
 </script>
 <style>
   * { box-sizing: border-box; margin: 0; padding: 0; }
@@ -318,6 +325,20 @@
 
   html {
     font-size: var(--font-scale-percent, 100%);
+    /* Mobile browsers otherwise inflate text on rotation. */
+    -webkit-text-size-adjust: 100%;
+    text-size-adjust: 100%;
+  }
+  /* A rotated phone must keep its portrait text size. Portrait scales with
+     the width (3.4vw, phone rule below), which is the screen's short side;
+     landscape uses that short side directly. No viewport unit or height
+     works here: with interactive-widget=resizes-content the on-screen
+     keyboard shrinks the viewport, and would shrink the text with it (and
+     make a portrait phone match this landscape query mid-typing). :root
+     outranks the later width-based html rule, which a narrow phone still
+     matches in landscape. */
+  @media (pointer: coarse) and (orientation: landscape) and (max-height: 500px) {
+    :root[data-phone-screen] { font-size: calc(clamp(12px, calc(var(--screen-short-side) * 0.034), 14px) * var(--font-scale, 1)); }
   }
   html, body {
     height: 100%;
@@ -508,6 +529,65 @@
     box-shadow: 0 0 0 1px rgba(210, 153, 34, 0.42), 0 0 8px rgba(210, 153, 34, 0.35);
   }
 
+  #conv-filter-row {
+    position: relative;
+    padding: 10px 16px;
+  }
+  #conv-filter-input {
+    width: 100%;
+    box-sizing: border-box;
+    height: 36px;
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    background: var(--bg2);
+    color: var(--text);
+    padding: 0 38px 0 10px;
+    font-size: var(--fs-meta-md);
+  }
+  /* iOS Safari zooms the page on focus for inputs under 16px, and the mobile
+     root font is 12-14px, so 1rem alone is not enough. */
+  @media (pointer: coarse), (max-width: 680px) {
+    #conv-filter-input { font-size: max(16px, 1rem); }
+  }
+  #conv-filter-input:focus {
+    outline: none;
+    border-color: var(--accent);
+  }
+  #conv-filter-clear {
+    position: absolute;
+    top: 50%;
+    right: 20px;
+    transform: translateY(-50%);
+    width: 28px;
+    height: 28px;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    border: none;
+    border-radius: 6px;
+    background: transparent;
+    color: var(--muted);
+    cursor: pointer;
+    font-size: 1rem;
+    line-height: 1;
+    padding: 0;
+  }
+  #conv-filter-clear:hover { color: var(--text); background: var(--bg3); }
+  /* The display rule above outranks the UA [hidden] rule, same trap as the
+     other [hidden] overrides in this file. */
+  #conv-filter-clear[hidden] { display: none; }
+  #conv-filter-status {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    margin: -1px;
+    padding: 0;
+    overflow: hidden;
+    clip: rect(0 0 0 0);
+    white-space: nowrap;
+    border: 0;
+  }
+
   #new-conv-btn {
     margin: 0; padding: 10px 14px; background: var(--accent); color: #000;
     border: none; border-radius: 8px; cursor: pointer; font-weight: 600; font-size: var(--fs-meta-md);
@@ -1408,12 +1488,23 @@
     width: 100%; max-width: 100%; box-sizing: border-box;
     min-width: 0;
   }
+  /* Sticky inside the scroller: Stop on the live bubble is the only way to
+     stop a turn, and a long turn must stay stoppable without scrolling back
+     up. It sticks within its own bubble only, so it never rides over the
+     messages steered in below it. The bubble's background keeps streamed
+     text from showing through; `top` cancels #messages' padding-top (sticky
+     insets start at the padding edge), so nothing scrolls visibly above it. */
   .thinking-bubble-header {
     display: flex;
     align-items: center;
     justify-content: space-between;
     gap: 12px;
     margin-bottom: 4px;
+    position: sticky;
+    top: -20px;
+    z-index: 2;
+    background: var(--bot-bg);
+    padding: 4px 0;
   }
   .thinking-bubble-header:empty { display: none; margin-bottom: 0; }
   .bubble-action-btn {
@@ -2239,6 +2330,19 @@
     pointer-events: none;
   }
   #relay-toast.visible { display: block; }
+  #relay-toast.has-action { pointer-events: auto; }
+  .relay-toast-action {
+    margin-left: 10px;
+    border: 1px solid var(--warn);
+    background: transparent;
+    color: var(--warn);
+    border-radius: 999px;
+    padding: 4px 12px;
+    font-size: var(--fs-meta-sm);
+    font-weight: 600;
+    cursor: pointer;
+  }
+  .relay-toast-action:hover { background: rgba(210, 153, 34, 0.2); }
   #model-metadata-blocker {
     display: none;
     align-items: center;
@@ -2439,6 +2543,16 @@
      (badge above tokens/elapsed/Stop) so the badge cannot float mid-row when
      the wrapped description spans two lines. */
   .bg-task-side { display: flex; flex-direction: column; align-items: flex-end; gap: 4px; flex-shrink: 0; }
+  .bg-task-side-head { display: flex; align-items: center; gap: 8px; }
+  .bg-task-model { color: var(--text); font-size: var(--fs-meta-sm); white-space: nowrap; }
+  /* Many tasks or previews must not push the composer off-screen: both lists
+     scroll together inside the panel while the summary line stays put. The dvh term keeps the whole
+     composer on screen in phone landscape, where 45vh alone left the input
+     row clipped below the fold (header + the rest of the composer take ~296px). */
+  #background-panel-body {
+    max-height: clamp(64px, calc(100dvh - 296px), min(45vh, 420px));
+    overflow-y: auto; overscroll-behavior: contain;
+  }
   .bg-task-side-status { display: flex; align-items: center; gap: 10px; }
   /* Mobile readability: bounded wrapping instead of single-line ellipsis.
      Long text clamps to two lines so the tail (the part that distinguishes
@@ -2454,6 +2568,19 @@
     background: var(--bg3); white-space: nowrap;
   }
   .bg-task-detail { color: var(--muted); font-size: var(--fs-meta-sm); }
+  /* A live tool call is one line cropped to the row: the command's head is
+     what identifies it, and wrapping would make rows jump on every call. */
+  .bg-task-detail.bg-task-toolcall {
+    display: block; white-space: nowrap; text-overflow: ellipsis; overflow: hidden;
+  }
+  /* A phone row is too narrow for one line to say anything; two clamped lines
+     fit beside the side column's height anyway. */
+  @media (max-width: 680px) {
+    .bg-task-detail.bg-task-toolcall {
+      display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical;
+      white-space: normal; overflow-wrap: anywhere;
+    }
+  }
   .bg-task-tokens { color: var(--muted); flex-shrink: 0; font-variant-numeric: tabular-nums; }
   .bg-task-elapsed { color: var(--muted); flex-shrink: 0; font-variant-numeric: tabular-nums; }
   .bg-task-stop {
@@ -2535,6 +2662,30 @@
     background: rgba(63, 185, 80, 0.12); color: var(--relay-tone-online);
     border-radius: 6px; padding: 0 6px; font-size: var(--fs-meta-sm);
   }
+  /* Mid-turn steering. The CLI usually FOLDS a steered message into the
+     running turn and answers everything with one reply; the steered row then
+     settles as a compact marker under its own message (kind='folded'). More
+     rarely the turn is handed off: the interrupted reply settles as
+     kind='absorbed' and the steered message carries the continuing reply. A
+     steer cut off by Stop settles as kind='stopped' with a Resend button.
+     Markers are notes, not answers, so they render muted and compact.
+     steered-turn-merge.mjs adds the adjacency classes. */
+  .msg.assistant.msg-absorbed .msg-bubble,
+  .msg.assistant.msg-folded .msg-bubble,
+  .msg.assistant.msg-steer-stopped .msg-bubble {
+    font-size: var(--fs-meta-md); color: var(--muted); font-style: italic;
+    padding: 6px 12px; opacity: 0.85;
+  }
+  .msg.assistant.msg-absorbed { margin-top: -4px; }
+  /* Attached to the steered message above it (the transcript gap is 12px). */
+  .msg.assistant.msg-folded,
+  .msg.assistant.msg-steer-stopped { margin-top: -8px; }
+  .msg.assistant.msg-folded .msg-label,
+  .msg.assistant.msg-steer-stopped .msg-label { display: none; }
+  .msg.assistant.msg-steer-stopped .msg-bubble-actions { font-style: normal; }
+  .msg.user.msg-steered .msg-bubble { border-style: dashed; }
+  .msg.user.msg-steered .msg-label::after { content: ' · steered mid-turn'; }
+  .msg.assistant.msg-steered-continuation { margin-top: -2px; }
   body.shared-reader-mode #background-tasks-panel { display: none; }
   #model-pricing-details {
     display: none; margin-top: 6px; color: var(--muted); font-size: var(--fs-meta-sm);
@@ -4197,6 +4348,43 @@
     color: #000;
     font-weight: 700;
   }
+  /* Multi-select cards: the same pills, with a checkmark instead of one-shot
+     buttons, so several answers can be ticked before one Reply. */
+  .relay-question-choice-check {
+    display: inline-flex;
+    align-items: center;
+    gap: 8px;
+    user-select: none;
+  }
+  .relay-question-choice-check input[type="checkbox"] {
+    margin: 0;
+    width: 16px;
+    height: 16px;
+    accent-color: var(--accent);
+    cursor: pointer;
+  }
+  .relay-question-choice-check:has(input:checked) {
+    border-color: var(--accent);
+    background: rgba(88, 166, 255, 0.12);
+  }
+  /* The "Select several" switch on Copilot choice cards. */
+  .relay-question-multi-toggle {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    margin-top: 8px;
+    font-size: var(--fs-meta-sm);
+    color: var(--muted, var(--text));
+    cursor: pointer;
+    user-select: none;
+  }
+  .relay-question-multi-toggle input[type="checkbox"] {
+    margin: 0;
+    width: 16px;
+    height: 16px;
+    accent-color: var(--accent);
+    cursor: pointer;
+  }
   .relay-question-reply {
     display: flex;
     gap: 8px;
@@ -4397,10 +4585,12 @@
       font-size: var(--fs-meta-md);
       min-height: 36px;
     }
-    .thinking-bubble-header { margin-bottom: 6px; }
+    .thinking-bubble-header { margin-bottom: 6px; top: -12px; }
     .sidebar-header { padding: var(--sidebar-header-top-pad-mobile) 12px 12px; gap: 8px; }
     #new-conv-btn { padding: 9px 12px; border-radius: 8px; font-size: var(--fs-meta-md); }
     #status-btn { min-width: 72px; padding: 9px 10px; font-size: var(--fs-meta-md); }
+    #conv-filter-row { padding: 8px 12px; }
+    #conv-filter-clear { right: 16px; }
     #conv-list { padding: 0 5px 8px; }
     .conv-item { padding: 6px 11px; border-radius: 8px; }
     .conv-title {
@@ -4928,6 +5118,11 @@
         <button id="install-btn" class="header-icon-btn" onclick="promptInstallApp()" title="Install app to home screen" aria-label="Install app">⬇</button>
       </div>
     </div>
+    <div id="conv-filter-row">
+      <input id="conv-filter-input" type="text" placeholder="Filter conversations…" autocomplete="off" spellcheck="false" aria-label="Filter conversations by title">
+      <button id="conv-filter-clear" type="button" title="Clear filter" aria-label="Clear filter" hidden>×</button>
+      <div id="conv-filter-status" role="status" aria-live="polite"></div>
+    </div>
     <div id="conv-list"></div>
   </div>
   <div id="sidebar-resizer" role="separator" aria-orientation="vertical" aria-label="Resize conversations sidebar"></div>
@@ -4993,8 +5188,10 @@
       <div id="slash-autocomplete-popup" aria-hidden="true" role="listbox"></div>
       <details id="background-tasks-panel" hidden>
         <summary id="background-tasks-summary"></summary>
-        <div id="background-previews-list"></div>
-        <div id="background-tasks-list"></div>
+        <div id="background-panel-body">
+          <div id="background-previews-list"></div>
+          <div id="background-tasks-list"></div>
+        </div>
       </details>
       <div class="input-row">
         <input id="image-input" type="file" multiple hidden onchange="handleAttachmentInput(this.files); this.value='';">
@@ -5214,20 +5411,20 @@
         </div>
         <div class="settings-help" style="margin-top: 6px;">A hard cap on how long one turn may run before the relay requeues it. Turns are already kept alive by worker heartbeats, and a turn waiting on your answer to a question is never cut off — so this only catches a worker that has hung. Set to 0 for no limit.</div>
         <div class="settings-row settings-row-column" style="margin-top: 12px; margin-bottom: 0;">
-          <label for="background-task-timeout-slider">Background task timeout <span id="background-task-timeout-value">No limit</span></label>
+          <label for="background-task-timeout-slider">Background task timeout <span id="background-task-timeout-value">4 h</span></label>
           <input
             id="background-task-timeout-slider"
             type="range"
             min="0"
             max="600"
             step="5"
-            value="0"
+            value="240"
             aria-label="Background task timeout in minutes"
             oninput="previewBackgroundTaskTimeoutSetting(this.value)"
             onchange="updateBackgroundTaskTimeoutSetting(this.value)"
           >
         </div>
-        <div class="settings-help" style="margin-top: 6px;">How long background tasks (backgrounded commands, subagents, monitors) may keep a Claude session's CLI process alive after its turn ends. When the limit is reached the tasks are stopped and the agent reports what they left behind. Set to 0 for no limit — tasks then run until they finish or you stop them from the composer panel.</div>
+        <div class="settings-help" style="margin-top: 6px;">How long background tasks may keep a session alive after its turn ends: backgrounded commands, subagents and monitors on Claude; background agents and detached shells on Copilot's SDK engine. When the limit is reached the tasks are stopped. Set to 0 for no limit — tasks then run until they finish or you stop them from the composer panel.</div>
         <div id="windows-autostart-setting" hidden>
           <div class="settings-row settings-row-column" style="margin-top: 12px; margin-bottom: 0;">
             <label>Autostart (Windows)</label>
@@ -5402,14 +5599,14 @@
           <div class="settings-row settings-row-column" style="margin-top: 12px; margin-bottom: 0;">
             <label for="copilot-engine-select">Copilot engine</label>
             <select id="copilot-engine-select" aria-label="Copilot engine">
-              <option value="extension">Extension — current</option>
-              <option value="sdk">SDK — experimental</option>
+              <option value="extension">Extension</option>
+              <option value="sdk">SDK — default</option>
             </select>
             <div id="copilot-settings-status" class="settings-help settings-provider-status">Loading Copilot settings…</div>
             <div style="display: flex; gap: 8px; margin-top: 8px;">
               <button id="copilot-save-btn" type="button" class="summary-btn" onclick="saveCopilotSettings()">Save Copilot settings</button>
             </div>
-            <div class="settings-help">Chooses how GitHub Copilot conversations run. <strong>Extension</strong> is the current default: the Copilot CLI in a terminal session, which you can attach to with the tmux inspector. <strong>SDK</strong> is experimental and headless — no CLI extension to install, but no tmux inspector for those sessions. Applies to newly started conversations; sessions already running keep their engine until their worker restarts.</div>
+            <div class="settings-help">Chooses how GitHub Copilot conversations run. <strong>SDK</strong> is the default: a headless worker per conversation with mid-turn steering and background task cards — no CLI extension to install, but no tmux inspector for those sessions. <strong>Extension</strong> runs the Copilot CLI in a terminal session, which you can attach to with the tmux inspector. A relay that cannot run the SDK engine uses Extension. Applies to newly started conversations; sessions already running keep their engine until their worker restarts.</div>
           </div>
         </div>
         <div

package/server/public/sw.js

@@ -205,6 +205,9 @@ const SYNC_DB_VERSION = 1;
 const SYNC_STORE_NAME = 'outbox';
 const SYNC_TAG = 'copilot-outbox';
 const SYNC_MAX_REPLAY_ATTEMPTS = 10;
+// Mirrors DRAFT_FLUSH_MAX_AGE_MS in app/conversation-draft-sync.mjs: a draft
+// flush replayed later than this would overwrite whatever the draft became.
+const SYNC_DRAFT_FLUSH_MAX_AGE_MS = 5 * 60 * 1000;
 
 function openSyncDb() {
   return new Promise((resolve, reject) => {
@@ -271,6 +274,10 @@ async function replaySyncOutbox() {
   try {
     const entries = await readSyncEntries(db);
     for (const { key, value } of entries) {
+      if (value?.kind === 'draft-flush' && !(Date.now() - Number(value.createdAt || 0) <= SYNC_DRAFT_FLUSH_MAX_AGE_MS)) {
+        await deleteSyncEntry(db, key);
+        continue;
+      }
       let response = null;
       try {
         response = await fetch(scopeUrl(String(value.path || '').replace(/^\//, '')), {

package/server/relay-tools.md

@@ -12,6 +12,8 @@ When using ask_user, ALWAYS include a `choices` array with 2-6 answer options so
 At runtime, inject the question and choices from a random item in your quiz pool.
 Only omit choices when the question genuinely requires freeform text input (e.g., "What is your name?").
 
+When the user may pick several of the choices (they are not mutually exclusive), set `"multi_select": true` if your ask_user tool offers that field; otherwise begin the question with "Select all that apply:". Either way, expect an answer that lists several choices separated by ", ".
+
 In autopilot, still call ask_user when user input is truly blocking, because the relay bridge can surface the question even when the direct SDK question hook is bypassed.
 
 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.

package/server/repositories/message-repository.mjs

@@ -7,6 +7,9 @@ export function createMessageRepository(db) {
     const shareVisibility = createShareVisibilityStatements(db);
     const queueHasImageOperationId = db.prepare(`PRAGMA table_info(queue)`).all()
         .some((column) => column.name === 'image_operation_id');
+    const messageColumns = new Set(db.prepare(`PRAGMA table_info(messages)`).all().map((column) => column.name));
+    const messagesHaveSourceId = messageColumns.has('source_message_id');
+    const messagesHaveResendOf = messageColumns.has('resend_of_message_id');
     const insertQueueSql = queueHasImageOperationId
         ? `INSERT INTO queue (id, conversation_id, runtime_session_id, is_new_conversation, model, model_variant_id, reasoning_effort, context_tier, relay_mode, text, attachments, status, timestamp, retry_count, next_attempt_at, owner_sdk_session_id, owner_assigned_at, owner_lease_expires_at, owner_last_claimed_at, image_operation_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, 0, NULL, ?, ?, ?, ?, ?)`
         : `INSERT INTO queue (id, conversation_id, runtime_session_id, is_new_conversation, model, model_variant_id, reasoning_effort, context_tier, relay_mode, text, attachments, status, timestamp, retry_count, next_attempt_at, owner_sdk_session_id, owner_assigned_at, owner_lease_expires_at, owner_last_claimed_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, 0, NULL, ?, ?, ?, ?)`;
@@ -17,7 +20,7 @@ export function createMessageRepository(db) {
         getMessageByConversation: db.prepare(`SELECT * FROM messages WHERE id = ? AND conversation_id = ? LIMIT 1`),
         setMessageShareVisibility: shareVisibility.setMessageShareVisibility,
         getLatestConversationModel: db.prepare(`SELECT model FROM messages WHERE conversation_id = ? AND model IS NOT NULL AND model != '' ORDER BY timestamp DESC LIMIT 1`),
-        getRecentMessagesDesc: db.prepare(`SELECT role, text, timestamp FROM messages WHERE conversation_id = ? ORDER BY timestamp DESC LIMIT ?`),
+        getRecentMessagesDesc: db.prepare(`SELECT id, role, text, timestamp FROM messages WHERE conversation_id = ? ORDER BY timestamp DESC LIMIT ?`),
         insertMsg:      db.prepare(`INSERT INTO messages (id, conversation_id, role, text, model, mode, attachments, timestamp, model_requested, model_actual, model_origin) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`),
         // Provenance is derived from the authenticated responder identity at
         // /api/response time, never from the response payload.
@@ -117,10 +120,28 @@ export function createMessageRepository(db) {
         // response resolves to the row its operation id already created.
         findQByContinuationOp: db.prepare(`SELECT * FROM queue WHERE continuation_op_id = ?`),
         setMessageKind: db.prepare(`UPDATE messages SET kind = ? WHERE id = ?`),
+        // The durable answer→prompt link (the queue's copy is pruned), so a
+        // reload still anchors the reply under the message it answers.
+        setMessageSourceId: messagesHaveSourceId
+            ? db.prepare(`UPDATE messages SET source_message_id = ? WHERE id = ?`)
+            : null,
+        setMessageResendOf: messagesHaveResendOf
+            ? db.prepare(`UPDATE messages SET resend_of_message_id = ? WHERE id = ?`)
+            : null,
         // Quiet teardown for a continuation whose worker died: there is no
         // user to answer, so it fails without the terminal-failure ceremony.
         dropStaleContinuation: db.prepare(`UPDATE queue SET status = 'failed', processing_at = NULL, next_attempt_at = NULL, owner_lease_expires_at = NULL WHERE id = ? AND status = 'processing' AND kind = 'continuation'`),
-        findPending:    db.prepare(`SELECT * FROM queue WHERE status = 'pending' AND COALESCE(kind, '') != 'continuation' AND (next_attempt_at IS NULL OR next_attempt_at <= ?) ORDER BY retry_count ASC, CASE WHEN next_attempt_at IS NULL THEN 0 ELSE 1 END ASC, COALESCE(next_attempt_at, timestamp) ASC, timestamp ASC LIMIT 1`),
+        // Claim ordering (all findPending* variants and the owner-transfer
+        // scan): strict send order, rowid breaking same-millisecond ties.
+        // Neither retry_count nor next_attempt_at may rank rows: dead-worker
+        // recovery and /api/requeue bump retry_count, so ranking by it ran a
+        // recovered OLDER message after newer ones in the same conversation,
+        // and ranking expired-backoff rows behind fresh arrivals starved them
+        // for as long as new messages kept coming (live 2026-09-19: a
+        // steer-recovered row waited 5 minutes while newer messages jumped
+        // it). Head-of-line protection is the WHERE clause's next_attempt_at
+        // backoff plus MAX_REQUEUE_RETRIES, which fails a row for good.
+        findPending:    db.prepare(`SELECT * FROM queue WHERE status = 'pending' AND COALESCE(kind, '') != 'continuation' AND (next_attempt_at IS NULL OR next_attempt_at <= ?) ORDER BY timestamp ASC, rowid ASC LIMIT 1`),
         // Global fallback for requesters without a session identity (the legacy
         // Copilot relay CLI). Conversations bound to a session-worker provider
         // (claude/cursor/grok) are excluded outright: handing one of their turns
@@ -152,10 +173,8 @@ export function createMessageRepository(db) {
               'github'
             )) NOT IN (${sessionWorkerProviderSqlList()})
           ORDER BY
-            q.retry_count ASC,
-            CASE WHEN q.next_attempt_at IS NULL THEN 0 ELSE 1 END ASC,
-            COALESCE(q.next_attempt_at, q.timestamp) ASC,
-            q.timestamp ASC
+            q.timestamp ASC,
+            q.rowid ASC
           LIMIT 1
         `),
         findPendingForWorker: db.prepare(`
@@ -198,10 +217,8 @@ export function createMessageRepository(db) {
               ) = ? THEN 0
               ELSE 1
             END ASC,
-            q.retry_count ASC,
-            CASE WHEN q.next_attempt_at IS NULL THEN 0 ELSE 1 END ASC,
-            COALESCE(q.next_attempt_at, q.timestamp) ASC,
-            q.timestamp ASC
+            q.timestamp ASC,
+            q.rowid ASC
           LIMIT 1
         `),
         findPendingForSessionAffinity: db.prepare(`
@@ -220,10 +237,8 @@ export function createMessageRepository(db) {
               NULLIF(c.sdk_session_id, '')
             ) = ?
           ORDER BY
-            q.retry_count ASC,
-            CASE WHEN q.next_attempt_at IS NULL THEN 0 ELSE 1 END ASC,
-            COALESCE(q.next_attempt_at, q.timestamp) ASC,
-            q.timestamp ASC
+            q.timestamp ASC,
+            q.rowid ASC
           LIMIT 1
         `),
         countQueueWorkForSessionAffinity: db.prepare(`
@@ -301,7 +316,7 @@ export function createMessageRepository(db) {
         // Recovery clears only the lease, never the owner: a recovered row must
         // stay routed to its provider worker so the primer respawns that worker
         // instead of the row becoming claimable by the global relay poll.
-        recoverStale:   db.prepare(`UPDATE queue SET status = 'pending', processing_at = NULL, attempt_id = NULL, next_attempt_at = ?, owner_lease_expires_at = NULL, owner_last_claimed_at = NULL WHERE status = 'processing' AND COALESCE(kind, '') != 'continuation' AND processing_at < ?`),
+        recoverStale:   db.prepare(`UPDATE queue SET status = 'pending', processing_at = NULL, attempt_id = NULL, next_attempt_at = ?, owner_lease_expires_at = NULL, owner_last_claimed_at = NULL WHERE status = 'processing' AND COALESCE(kind, '') != 'continuation' AND consumed_at IS NULL AND processing_at < ?`),
         // Staleness is inactivity, not elapsed turn time: owner_last_claimed_at is
         // refreshed by every worker heartbeat for the message it is working on, so a
         // long-but-alive turn keeps moving the cutoff. processing_at is only the
@@ -311,7 +326,7 @@ export function createMessageRepository(db) {
         // A turn blocked on an unanswered AskUserQuestion is never stale — it is
         // waiting on the human, and relay_questions carries its own expiry.
         listRecoverableProcessing: db.prepare(`
-          SELECT id, conversation_id, kind, relay_mode, model, retry_count
+          SELECT id, conversation_id, kind, relay_mode, model, retry_count, consumed_at
           FROM queue
           WHERE status = 'processing'
             AND COALESCE(kind, '') != 'continuation'
@@ -332,6 +347,7 @@ export function createMessageRepository(db) {
               retry_count = retry_count + 1
           WHERE status = 'processing'
             AND COALESCE(kind, '') != 'continuation'
+            AND consumed_at IS NULL
             AND (
               COALESCE(owner_last_claimed_at, processing_at, timestamp) < @inactiveBefore
               OR (@ceilingBefore IS NOT NULL AND COALESCE(processing_at, timestamp) < @ceilingBefore)
@@ -347,7 +363,7 @@ export function createMessageRepository(db) {
         // worker can never collect its answer, so holding the row would leak
         // both the row and the question.
         listProcessingRowsForOwner: db.prepare(`
-          SELECT id, conversation_id, kind, retry_count
+          SELECT id, conversation_id, kind, retry_count, consumed_at, relay_mode, model
           FROM queue
           WHERE status = 'processing'
             AND NULLIF(owner_sdk_session_id, '') = ?
@@ -361,7 +377,28 @@ export function createMessageRepository(db) {
               owner_lease_expires_at = NULL,
               owner_last_claimed_at = NULL,
               retry_count = retry_count + 1
-          WHERE id = ? AND status = 'processing'
+          WHERE id = ? AND status = 'processing' AND consumed_at IS NULL
+        `),
+        // See the queue.consumed_at migration: at-most-once rows.
+        // Fenced like every other worker write: the row must be processing in
+        // this conversation, owned by the same worker session (NULL-safe, for
+        // routing-disabled installs), and — when the caller names one — still
+        // on the attempt it was pushed under.
+        markQueueConsumed: db.prepare(`
+          UPDATE queue
+          SET consumed_at = COALESCE(consumed_at, @at)
+          WHERE id = @id AND conversation_id = @conversationId AND status = 'processing'
+            AND NULLIF(owner_sdk_session_id, '') IS @owner
+            AND (@attemptId IS NULL OR attempt_id = @attemptId)
+        `),
+        // A consumed steer the CLI then replayed as a turn of its own is an
+        // ordinary in-flight row again.
+        clearQueueConsumed: db.prepare(`
+          UPDATE queue
+          SET consumed_at = NULL
+          WHERE id = @id AND conversation_id = @conversationId AND status = 'processing'
+            AND NULLIF(owner_sdk_session_id, '') IS @owner
+            AND (@attemptId IS NULL OR attempt_id = @attemptId)
         `),
         listProcessingOwnerSessionIds: db.prepare(`
           SELECT DISTINCT NULLIF(owner_sdk_session_id, '') AS sdk_session_id
@@ -390,6 +427,12 @@ export function createMessageRepository(db) {
         listConversationIdsWithActiveQueue: db.prepare(`SELECT DISTINCT conversation_id FROM queue WHERE status IN ('pending', 'processing', 'parked')`),
         deleteQueueById: db.prepare(`DELETE FROM queue WHERE id = ?`),
         getLatestProcessingQueueByConversation: db.prepare(`SELECT id, relay_mode, timestamp, processing_at FROM queue WHERE conversation_id = ? AND status = 'processing' ORDER BY COALESCE(processing_at, timestamp) DESC LIMIT 1`),
+        // All processing rows, oldest first. Mid-turn steering means a
+        // conversation can have more than one processing row at once (the live
+        // turn plus a steered message folded into it), so the single-row query
+        // above is ambiguous — callers that need "the live turn" resolve it
+        // from this list by which row is actually producing output.
+        listProcessingQueueByConversation: db.prepare(`SELECT id, relay_mode, timestamp, processing_at FROM queue WHERE conversation_id = ? AND status = 'processing' ORDER BY COALESCE(processing_at, timestamp) ASC`),
         parkPendingQueueForRestart: db.prepare(`
           UPDATE queue
           SET

package/server/repositories/question-repository.mjs

@@ -25,6 +25,21 @@ export function createQuestionRepository(db) {
         linkActivityToResponse: db.prepare(`UPDATE relay_activity SET response_message_id = ? WHERE queue_message_id = ? AND response_message_id IS NULL`),
         listActivityByResponse: db.prepare(`SELECT text, subagent_run_id, metadata_json FROM relay_activity WHERE response_message_id = ? ORDER BY id ASC`),
         listActivityByQueueMessage: db.prepare(`SELECT text, subagent_run_id, metadata_json FROM relay_activity WHERE queue_message_id = ? ORDER BY id ASC`),
+        // When a queue row last produced output — its newest stream snapshot
+        // (rows are rewritten in place and re-stamped per update) or activity
+        // line. The live-turn picker compares rows by this, never by the
+        // per-row stream seq. `stream_done` is 1 once the row's main-thread
+        // snapshot is final: a row settling after a handoff re-stamps its
+        // snapshot with done=1, which must not read as live output.
+        getLastOutputAtByQueueMessage: db.prepare(`
+          SELECT
+            (SELECT MAX(at) FROM (
+              SELECT MAX(created_at) AS at FROM relay_stream_events WHERE queue_message_id = @id
+              UNION ALL
+              SELECT MAX(created_at) AS at FROM relay_activity WHERE queue_message_id = @id
+            )) AS last_output_at,
+            (SELECT MAX(done) FROM relay_stream_events WHERE queue_message_id = @id AND subagent_run_id IS NULL) AS stream_done
+        `),
         deleteConvActivity: db.prepare(`DELETE FROM relay_activity WHERE conversation_id = ?`),
 
         // relay stream events — every update carries the full text-so-far

package/server/repositories/session-repository.mjs

@@ -1,9 +1,6 @@
 'use strict';
 
-import { createShareVisibilityStatements } from './share-visibility-statements.mjs';
-
 export function createSessionRepository(db) {
-    const shareVisibility = createShareVisibilityStatements(db);
     const runtimeSessionColumns = new Set(
       db.prepare(`PRAGMA table_info(runtime_sessions)`).all().map((column) => String(column?.name || '').trim()),
     );
@@ -36,36 +33,15 @@ export function createSessionRepository(db) {
         archiveConv:    db.prepare(`UPDATE conversations SET archived = 1, updated_at = ? WHERE id = ?`),
         deleteConv:     db.prepare(`DELETE FROM conversations WHERE id = ?`),
 
-        // messages
-        getMessages:    db.prepare(`SELECT * FROM messages WHERE conversation_id = ? ORDER BY timestamp ASC`),
-        getSharedMessages: shareVisibility.getSharedMessages,
-        getMessageByConversation: db.prepare(`SELECT * FROM messages WHERE id = ? AND conversation_id = ? LIMIT 1`),
-        setMessageShareVisibility: shareVisibility.setMessageShareVisibility,
+        // Queue and message statements live in message-repository.mjs — the
+        // single source of truth. Copies used to live here too; the runtime's
+        // {...sessionRepo, ...messageRepo} spread shadowed all of them, and the
+        // dead copies silently fossilized (this one's findPending predated the
+        // continuation-row exclusion — claiming through it would have replayed
+        // a background continuation as a user prompt). The two counts below are
+        // the only message/queue statements this repository actually owns.
         getConversationMessageCount: db.prepare(`SELECT COUNT(*) AS count FROM messages WHERE conversation_id = ?`),
         getConversationActiveQueueCount: db.prepare(`SELECT COUNT(*) AS count FROM queue WHERE conversation_id = ? AND status IN ('pending', 'processing', 'parked')`),
-        getLatestConversationModel: db.prepare(`SELECT model FROM messages WHERE conversation_id = ? AND model IS NOT NULL AND model != '' ORDER BY timestamp DESC LIMIT 1`),
-        getRecentMessagesDesc: db.prepare(`SELECT role, text, timestamp FROM messages WHERE conversation_id = ? ORDER BY timestamp DESC LIMIT ?`),
-        insertMsg:      db.prepare(`INSERT INTO messages (id, conversation_id, role, text, model, mode, attachments, timestamp, model_requested, model_actual, model_origin) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`),
-
-        // queue
-        insertQ:        db.prepare(`INSERT INTO queue (id, conversation_id, runtime_session_id, is_new_conversation, model, model_variant_id, reasoning_effort, relay_mode, text, attachments, status, timestamp, retry_count, next_attempt_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, 0, NULL)`),
-        findPending:    db.prepare(`SELECT * FROM queue WHERE status = 'pending' AND (next_attempt_at IS NULL OR next_attempt_at <= ?) ORDER BY retry_count ASC, CASE WHEN next_attempt_at IS NULL THEN 0 ELSE 1 END ASC, COALESCE(next_attempt_at, timestamp) ASC, timestamp ASC LIMIT 1`),
-        countStatus:    db.prepare(`SELECT status, COUNT(*) as cnt FROM queue WHERE status IN ('pending','processing','parked') GROUP BY status`),
-        countRuntimeSessions: db.prepare(`SELECT COUNT(*) AS cnt FROM runtime_sessions WHERE status = 'active'`),
-        setProcessing:  db.prepare(`UPDATE queue SET status = 'processing', processing_at = ? WHERE id = ?`),
-        setQueueRuntimeSession: db.prepare(`UPDATE queue SET runtime_session_id = ? WHERE id = ?`),
-        setQueueResponseMessageId: db.prepare(`UPDATE queue SET response_message_id = ? WHERE id = ?`),
-        setDone:        db.prepare(`UPDATE queue SET status = 'done', response = ?, processing_at = NULL, next_attempt_at = NULL WHERE id = ? AND status IN ('processing', 'pending')`),
-        setFailed:      db.prepare(`UPDATE queue SET status = 'failed', response = ?, processing_at = NULL, next_attempt_at = NULL WHERE id = ?`),
-        deleteConvQ:    db.prepare(`DELETE FROM queue WHERE conversation_id = ?`),
-        findQById:      db.prepare(`SELECT * FROM queue WHERE id = ?`),
-        pruneQueue:     db.prepare(`DELETE FROM queue WHERE status = 'done' AND id NOT IN (SELECT id FROM queue WHERE status = 'done' ORDER BY timestamp DESC LIMIT 200)`),
-        recoverStale:   db.prepare(`UPDATE queue SET status = 'pending', processing_at = NULL, next_attempt_at = ? WHERE status = 'processing' AND processing_at < ?`),
-        listRecoverableProcessing: db.prepare(`SELECT id, conversation_id FROM queue WHERE status = 'processing' AND processing_at < ?`),
-        recoverProcessingBefore: db.prepare(`UPDATE queue SET status = 'pending', processing_at = NULL, next_attempt_at = ? WHERE status = 'processing' AND processing_at < ?`),
-        listQueueForPauseDrop: db.prepare(`SELECT id, conversation_id FROM queue WHERE status IN ('pending', 'processing', 'parked')`),
-        deleteQueueById: db.prepare(`DELETE FROM queue WHERE id = ?`),
-        getLatestProcessingQueueByConversation: db.prepare(`SELECT id, relay_mode, timestamp, processing_at FROM queue WHERE conversation_id = ? AND status = 'processing' ORDER BY COALESCE(processing_at, timestamp) DESC LIMIT 1`),
 
         // runtime sessions
         getRuntimeSessionByConversation: db.prepare(`SELECT * FROM runtime_sessions WHERE conversation_id = ?`),