@oar-sh/oar 0.9.1 → 0.9.3

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/relay.mjs

@@ -28,6 +28,7 @@ import {
 } from './windows-terminal-launcher.mjs';
 import { isValidModelId, normalizeModelIdCandidate } from '../shared/model-id.mjs';
 import {
+  buildModelSnapshotFields,
   extractModelDescriptors,
   normalizeContextLimitTokens,
 } from '../shared/model-descriptors.mjs';
@@ -662,17 +663,28 @@ async function getAvailableModels(session) {
     if (!isValidModelId(modelId)) continue;
     const existing = byModelId.get(modelId);
     const cached = cachedModelMetadataById.get(modelId);
+    // Highest-priority source wins per field; a lower-priority list only
+    // fills what the better one left null. Every field of the shared
+    // descriptor is carried, so the snapshot metadata is as rich as the
+    // richest list that answered.
+    const pick = (field, normalize = (value) => value ?? null) => existing?.[field]
+      ?? normalize(entry?.[field])
+      ?? cached?.[field]
+      ?? null;
     byModelId.set(modelId, {
       modelId,
-      contextLimitTokens: existing?.contextLimitTokens
-        ?? normalizeContextLimitTokens(entry?.contextLimitTokens)
-        ?? cached?.contextLimitTokens
-        ?? null,
-      longContextLimitTokens: existing?.longContextLimitTokens
-        ?? normalizeContextLimitTokens(entry?.longContextLimitTokens)
-        ?? cached?.longContextLimitTokens
-        ?? null,
+      contextLimitTokens: pick('contextLimitTokens', normalizeContextLimitTokens),
+      longContextLimitTokens: pick('longContextLimitTokens', normalizeContextLimitTokens),
       pricing: existing?.pricing || entry?.pricing || cached?.pricing || null,
+      displayName: pick('displayName'),
+      vendor: pick('vendor'),
+      pickerCategory: pick('pickerCategory'),
+      preview: existing?.preview === true || entry?.preview === true || cached?.preview === true,
+      contextWindowTokens: pick('contextWindowTokens', normalizeContextLimitTokens),
+      maxPromptTokens: pick('maxPromptTokens', normalizeContextLimitTokens),
+      supportedEfforts: Array.isArray(existing?.supportedEfforts)
+        ? existing.supportedEfforts
+        : (Array.isArray(entry?.supportedEfforts) ? entry.supportedEfforts : (cached?.supportedEfforts ?? null)),
     });
   }
   const models = byModelId.size ? [...byModelId.values()] : [...cachedModelMetadataById.values()];
@@ -723,19 +735,9 @@ async function publishModelSnapshot(session, reason = 'standalone-relay', force
   try {
     const currentModel = await getCurrentModelId(session);
     const availableModels = await getAvailableModels(session);
-    const modelIds = availableModels.map((entry) => entry.modelId);
-    const contextLimitsByModel = Object.fromEntries(
-      availableModels
-        .filter((entry) => entry.contextLimitTokens !== null)
-        .map((entry) => [entry.modelId, entry.contextLimitTokens]),
-    );
-    const modelMetadataByModel = Object.fromEntries(
-      availableModels.map((entry) => [entry.modelId, {
-        defaultContextLimitTokens: entry.contextLimitTokens,
-        longContextLimitTokens: entry.longContextLimitTokens,
-        pricing: entry.pricing,
-      }]),
-    );
+    // Same shared builder as the SDK worker and the server-side discovery:
+    // one definition of the per-model metadata the relay publishes.
+    const { models: modelIds, contextLimitsByModel, modelMetadataByModel } = buildModelSnapshotFields(availableModels);
     await apiJson('POST', '/api/models/snapshot', {
       source: `standalone-relay:${reason}`,
       models: modelIds,

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.
@@ -112,12 +115,33 @@ export function createMessageRepository(db) {
         // A background-continuation turn: born 'processing' and owned by its
         // session worker — the CLI already started it on its own, so it must
         // never be handed out as deliverable work.
-        insertContinuationQ: db.prepare(`INSERT INTO queue (id, conversation_id, runtime_session_id, is_new_conversation, model, relay_mode, text, status, kind, timestamp, processing_at, retry_count, owner_sdk_session_id, owner_assigned_at, owner_lease_expires_at, owner_last_claimed_at) VALUES (?, ?, ?, 0, ?, ?, ?, 'processing', 'continuation', ?, ?, 0, ?, ?, ?, ?)`),
+        insertContinuationQ: db.prepare(`INSERT INTO queue (id, conversation_id, runtime_session_id, is_new_conversation, model, relay_mode, text, status, kind, timestamp, processing_at, retry_count, owner_sdk_session_id, owner_assigned_at, owner_lease_expires_at, owner_last_claimed_at, attempt_id, continuation_op_id) VALUES (?, ?, ?, 0, ?, ?, ?, 'processing', 'continuation', ?, ?, 0, ?, ?, ?, ?, ?, ?)`),
+        // Idempotent continuation registration: a worker retry after a lost
+        // 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
@@ -149,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(`
@@ -195,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(`
@@ -217,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(`
@@ -267,12 +285,13 @@ export function createMessageRepository(db) {
         `),
         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 = ?`),
+        setProcessing:  db.prepare(`UPDATE queue SET status = 'processing', processing_at = ?, attempt_id = ? WHERE id = ?`),
         setProcessingWithWorkerLease: db.prepare(`
           UPDATE queue
           SET
             status = 'processing',
             processing_at = ?,
+            attempt_id = ?,
             owner_sdk_session_id = COALESCE(NULLIF(owner_sdk_session_id, ''), ?),
             owner_assigned_at = COALESCE(owner_assigned_at, ?),
             owner_lease_expires_at = ?,
@@ -281,15 +300,23 @@ export function createMessageRepository(db) {
         `),
         setQueueRuntimeSession: db.prepare(`UPDATE queue SET runtime_session_id = ? WHERE id = ?`),
         setQueueResponseMessageId: db.prepare(`UPDATE queue SET response_message_id = ? WHERE id = ?`),
+        // Legacy (unfenced) finalization keeps 'pending' in the set so a
+        // response landing after a stale-sweep requeue still finalizes; fenced
+        // finalization deliberately does not — a fenced writer whose row went
+        // back to pending has by definition been superseded.
         setDone:        db.prepare(`UPDATE queue SET status = 'done', response = ?, processing_at = NULL, next_attempt_at = NULL, owner_lease_expires_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, owner_lease_expires_at = NULL WHERE id = ?`),
+        setDoneFenced:  db.prepare(`UPDATE queue SET status = 'done', response = ?, processing_at = NULL, next_attempt_at = NULL, owner_lease_expires_at = NULL WHERE id = ? AND status = 'processing' AND attempt_id = ?`),
+        // The status set mirrors canTerminalFail (processing/pending/parked):
+        // failure must never overwrite a row another attempt already settled.
+        setFailed:      db.prepare(`UPDATE queue SET status = 'failed', response = ?, processing_at = NULL, next_attempt_at = NULL, owner_lease_expires_at = NULL WHERE id = ? AND status IN ('processing', 'pending', 'parked')`),
+        setFailedFenced: db.prepare(`UPDATE queue SET status = 'failed', response = ?, processing_at = NULL, next_attempt_at = NULL, owner_lease_expires_at = NULL WHERE id = ? AND status = 'processing' AND attempt_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)`),
         // 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, 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
@@ -299,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'
@@ -313,12 +340,14 @@ export function createMessageRepository(db) {
           UPDATE queue
           SET status = 'pending',
               processing_at = NULL,
+              attempt_id = NULL,
               next_attempt_at = @requeueAt,
               owner_lease_expires_at = NULL,
               owner_last_claimed_at = NULL,
               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)
@@ -334,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, '') = ?
@@ -343,11 +372,33 @@ export function createMessageRepository(db) {
           UPDATE queue
           SET status = 'pending',
               processing_at = NULL,
+              attempt_id = NULL,
               next_attempt_at = ?,
               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
@@ -376,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

@@ -3,7 +3,7 @@
 export function createQuestionRepository(db) {
     return {
         // relay questions
-        insertQuestion: db.prepare(`INSERT INTO relay_questions (id, queue_id, conversation_id, message_id, relay_mode, prompt, choices, request, request_schema, status, answer, structured_answer, sdk_session_id, owner_worker_id, continuation_id, continuation_question_id, created_at, answered_at, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', NULL, NULL, ?, ?, ?, ?, ?, NULL, ?)`),
+        insertQuestion: db.prepare(`INSERT INTO relay_questions (id, queue_id, conversation_id, message_id, relay_mode, prompt, choices, request, request_schema, status, answer, structured_answer, sdk_session_id, owner_worker_id, continuation_id, continuation_question_id, created_at, answered_at, expires_at, attempt_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', NULL, NULL, ?, ?, ?, ?, ?, NULL, ?, ?)`),
         getQuestion:    db.prepare(`SELECT * FROM relay_questions WHERE id = ?`),
         findPendingQuestionByMessage: db.prepare(`SELECT * FROM relay_questions WHERE message_id = ? AND status = 'pending' ORDER BY created_at DESC LIMIT 1`),
         listPendingQuestionsByMessage: db.prepare(`SELECT * FROM relay_questions WHERE message_id = ? AND status = 'pending' ORDER BY created_at ASC`),
@@ -11,6 +11,9 @@ export function createQuestionRepository(db) {
         listQuestions:  db.prepare(`SELECT * FROM relay_questions WHERE status = ? AND (? IS NULL OR conversation_id = ?) ORDER BY created_at ASC`),
         timeoutQuestion:db.prepare(`UPDATE relay_questions SET status = 'timed_out' WHERE id = ? AND status = 'pending'`),
         cancelPendingQuestionsByMessage: db.prepare(`UPDATE relay_questions SET status = 'cancelled', answered_at = COALESCE(answered_at, ?) WHERE message_id = ? AND status = 'pending'`),
+        // Cards left behind by a superseded processing attempt. NULL-attempt
+        // rows (created before the fencing deploy) are deliberately left alone.
+        cancelPendingQuestionsForStaleAttempts: db.prepare(`UPDATE relay_questions SET status = 'cancelled', answered_at = COALESCE(answered_at, ?) WHERE message_id = ? AND status = 'pending' AND attempt_id IS NOT NULL AND attempt_id != ? RETURNING id`),
         deleteConvQuestions: db.prepare(`DELETE FROM relay_questions WHERE conversation_id = ?`),
         // RETURNING (run via .all) so the expiry log names exactly the rows
         // that flipped — a separate pre-SELECT could race an answer landing
@@ -22,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 = ?`),

package/server/routes/ask-user-routes.mjs

@@ -128,6 +128,15 @@ export function registerAskUserRoutes(app, deps) {
     if (!q || q.status !== 'processing') {
       return res.status(409).json({ error: 'No active relay turn' });
     }
+    // Attempt fencing: a caller that names its processing attempt may only
+    // open a card while that attempt still owns the row. The stored value is
+    // always the row's own attempt_id (server-authoritative), so stale-attempt
+    // cleanup covers questions from unfenced callers too.
+    const claimedAttemptId = String(req.body.attemptId || '').trim() || null;
+    if (claimedAttemptId && String(q.attempt_id || '') !== claimedAttemptId) {
+      console.warn(`[${ts()}] STALE ATTEMPT ${String(q.id).slice(0,8)} route=relay-question claimed=${claimedAttemptId.slice(0,8)} current=${String(q.attempt_id || '').slice(0,8) || 'none'}`);
+      return res.status(409).json({ error: 'stale_attempt' });
+    }
 
     const effectiveMessageId = messageId || q.id;
     
@@ -199,6 +208,7 @@ export function registerAskUserRoutes(app, deps) {
       continuation.continuationQuestionId,
       now,
       expiresAt,
+      String(q.attempt_id || '').trim() || null,
     );
 
     const question = formatQuestionRow(stmts.getQuestion.get(questionId));