@oar-sh/oar 0.9.21 → 0.9.23

package/server/repositories/message-repository.mjs

@@ -361,6 +361,16 @@ export function createMessageRepository(db) {
           LIMIT ?
         `),
         countStatus:    db.prepare(`SELECT status, COUNT(*) as cnt FROM queue WHERE status IN ('pending','processing','parked') ${notHeldForUsageLimit()} GROUP BY status`),
+        // Stale recovery has nothing to look at while no row is processing.
+        hasProcessingRow: db.prepare(`SELECT 1 AS present FROM queue WHERE status = 'processing' LIMIT 1`),
+        // The earliest future retry time of a pending row (a backoff, a
+        // usage-limit hold): the relay wakes its queue then. A hold until the
+        // user resumes (year 9999) is no time.
+        nextPendingAttemptAt: db.prepare(`
+          SELECT MIN(next_attempt_at) AS due FROM queue
+          WHERE status = 'pending' AND next_attempt_at IS NOT NULL
+            AND next_attempt_at > ? AND next_attempt_at < '9999'
+        `),
         // Deferred host suspend: which conversations still hold live turns.
         listActiveQueueCountsByConversation: db.prepare(`
           SELECT q.conversation_id, COUNT(*) AS cnt, MAX(c.title) AS title

package/server/repositories/question-repository.mjs

@@ -1,12 +1,48 @@
 'use strict';
 
 import { createSubagentTimelineStatements } from './subagent-timeline-statements.mjs';
+import { hasTurnSeqColumn } from '../migrations/0038-turn-seq.mjs';
+
+const nextTurnSeqStatements = new WeakMap();
+
+/**
+ * The next number of a turn's shared order (migration 0038): one more than
+ * the highest turn_seq of its thoughts and tool lines together, 1 for a turn
+ * that has none. Call it inside the write transaction that inserts the row
+ * (BEGIN IMMEDIATE takes the write lock before this read), so two writers
+ * never get the same number.
+ */
+export function nextTurnSeq(db, queueMessageId) {
+    let statement = nextTurnSeqStatements.get(db);
+    if (!statement) {
+        statement = db.prepare(`
+          SELECT MAX(
+            COALESCE((SELECT MAX(turn_seq) FROM relay_activity WHERE queue_message_id = @id AND turn_seq IS NOT NULL), 0),
+            COALESCE((SELECT MAX(turn_seq) FROM relay_thought WHERE queue_message_id = @id AND turn_seq IS NOT NULL), 0)
+          ) AS max_seq
+        `);
+        nextTurnSeqStatements.set(db, statement);
+    }
+    return Math.max(0, Number(statement.get({ id: String(queueMessageId) })?.max_seq || 0)) + 1;
+}
 
 export function createQuestionRepository(db) {
     const subagentTimeline = createSubagentTimelineStatements(db);
     const runColumns = subagentTimeline.subagentRunSelectColumns;
     const runColumnsAs = (alias) => runColumns.split(', ').map((column) => `${alias}.${column}`).join(', ');
+    // Migration 0038 may have failed (it is retried next boot): without the
+    // column, rows are written without a number and read back without one,
+    // and every turn keeps the grouped layout.
+    const turnSeq = hasTurnSeqColumn(db, 'relay_activity') && hasTurnSeqColumn(db, 'relay_thought');
+    // The insert statements take turn_seq as their last value, which a caller
+    // may leave out (null); a database without the column drops it.
+    const fitValues = (statement, count) => ({
+        run: (...values) => statement.run(...values.slice(0, count), ...Array(Math.max(0, count - values.length)).fill(null)),
+    });
     return {
+        hasTurnSeq: turnSeq,
+        // The next turn_seq of a queue message, or null without the column.
+        nextTurnSeq: (queueMessageId) => (turnSeq ? nextTurnSeq(db, queueMessageId) : null),
         ...subagentTimeline,
         // 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, attempt_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', NULL, NULL, ?, ?, ?, ?, ?, NULL, ?, ?)`),
@@ -27,10 +63,14 @@ export function createQuestionRepository(db) {
         expireQuestions: db.prepare(`UPDATE relay_questions SET status = 'timed_out' WHERE status = 'pending' AND expires_at < ? RETURNING id, created_at`),
 
         // relay activity
-        insertActivity: db.prepare(`INSERT INTO relay_activity (queue_message_id, response_message_id, conversation_id, relay_mode, text, created_at, subagent_run_id, metadata_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`),
+        // (queue_message_id, response_message_id, conversation_id, relay_mode,
+        // text, created_at, subagent_run_id, metadata_json, turn_seq)
+        insertActivity: turnSeq
+            ? fitValues(db.prepare(`INSERT INTO relay_activity (queue_message_id, response_message_id, conversation_id, relay_mode, text, created_at, subagent_run_id, metadata_json, turn_seq) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`), 9)
+            : fitValues(db.prepare(`INSERT INTO relay_activity (queue_message_id, response_message_id, conversation_id, relay_mode, text, created_at, subagent_run_id, metadata_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`), 8),
         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`),
+        listActivityByResponse: db.prepare(`SELECT text, subagent_run_id, metadata_json${turnSeq ? ', turn_seq' : ''} FROM relay_activity WHERE response_message_id = ? ORDER BY id ASC`),
+        listActivityByQueueMessage: db.prepare(`SELECT text, subagent_run_id, metadata_json${turnSeq ? ', turn_seq' : ''} 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
@@ -73,8 +113,12 @@ export function createQuestionRepository(db) {
 
         // relay thoughts (agent reasoning)
         getLastThoughtSeqByQueueMessage: db.prepare(`SELECT COALESCE(MAX(seq), 0) AS max_seq FROM relay_thought WHERE queue_message_id = ?`),
-        getThoughtByQueueAndReasoning: db.prepare(`SELECT seq FROM relay_thought WHERE queue_message_id = ? AND reasoning_id = ? LIMIT 1`),
-        insertThought: db.prepare(`INSERT INTO relay_thought (queue_message_id, response_message_id, conversation_id, relay_mode, reasoning_id, seq, text, done, created_at, subagent_run_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`),
+        getThoughtByQueueAndReasoning: db.prepare(`SELECT seq${turnSeq ? ', turn_seq' : ''} FROM relay_thought WHERE queue_message_id = ? AND reasoning_id = ? LIMIT 1`),
+        // (queue_message_id, response_message_id, conversation_id, relay_mode,
+        // reasoning_id, seq, text, done, created_at, subagent_run_id, turn_seq)
+        insertThought: turnSeq
+            ? fitValues(db.prepare(`INSERT INTO relay_thought (queue_message_id, response_message_id, conversation_id, relay_mode, reasoning_id, seq, text, done, created_at, subagent_run_id, turn_seq) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`), 11)
+            : fitValues(db.prepare(`INSERT INTO relay_thought (queue_message_id, response_message_id, conversation_id, relay_mode, reasoning_id, seq, text, done, created_at, subagent_run_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`), 10),
         updateThoughtByQueueAndReasoning: db.prepare(`
           UPDATE relay_thought
           SET response_message_id = COALESCE(response_message_id, ?),
@@ -88,8 +132,8 @@ export function createQuestionRepository(db) {
             AND reasoning_id = ?
         `),
         linkThoughtsToResponse: db.prepare(`UPDATE relay_thought SET response_message_id = ? WHERE queue_message_id = ? AND response_message_id IS NULL`),
-        listThoughtsByResponse: db.prepare(`SELECT reasoning_id, seq, text, done, created_at, subagent_run_id FROM relay_thought WHERE response_message_id = ? ORDER BY seq ASC, id ASC`),
-        listThoughtsByQueueMessage: db.prepare(`SELECT reasoning_id, seq, text, done, created_at, subagent_run_id FROM relay_thought WHERE queue_message_id = ? ORDER BY seq ASC, id ASC`),
+        listThoughtsByResponse: db.prepare(`SELECT reasoning_id, seq, text, done, created_at, subagent_run_id${turnSeq ? ', turn_seq' : ''} FROM relay_thought WHERE response_message_id = ? ORDER BY seq ASC, id ASC`),
+        listThoughtsByQueueMessage: db.prepare(`SELECT reasoning_id, seq, text, done, created_at, subagent_run_id${turnSeq ? ', turn_seq' : ''} FROM relay_thought WHERE queue_message_id = ? ORDER BY seq ASC, id ASC`),
         deleteConvThoughts: db.prepare(`DELETE FROM relay_thought WHERE conversation_id = ?`),
 
         // subagent runs

package/server/repositories/relay-turn-rows.mjs

@@ -0,0 +1,56 @@
+// A turn's stored thought and tool-line rows as the browser receives them
+// (the message payload and the in-flight snapshot). Pure, so the payload
+// shape is tested without booting the relay (server-runtime.mjs uses these).
+
+export function sanitizeActivityText(value) {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  return text.slice(0, 200);
+}
+
+// A row's place in its turn's order (migration 0038), or null: a row from
+// before it, or a database without the column.
+function rowTurnSeq(row) {
+  if (row?.turn_seq === null || row?.turn_seq === undefined) return null;
+  const value = Number(row.turn_seq);
+  return Number.isInteger(value) && value > 0 ? value : null;
+}
+
+export function mapRelayActivityRow(row) {
+  const text = sanitizeActivityText(row?.text);
+  if (!text) return null;
+  const subagentRunId = row?.subagent_run_id ? String(row.subagent_run_id).trim() : null;
+  // Structured rows (compaction boundaries) carry their payload alongside the
+  // prose so the transcript can promote them to a break row; junk JSON is
+  // simply dropped back to a prose-only entry.
+  let metadata = null;
+  if (row?.metadata_json) {
+    try {
+      const parsed = JSON.parse(String(row.metadata_json));
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) metadata = parsed;
+    } catch { metadata = null; }
+  }
+  // Only a numbered row says so: the payload of an unnumbered one is as before.
+  const turnSeq = rowTurnSeq(row);
+  return {
+    text,
+    subagentRunId: subagentRunId || null,
+    ...(metadata ? { metadata } : {}),
+    ...(turnSeq !== null ? { turnSeq } : {}),
+  };
+}
+
+export function mapRelayThoughtRow(row) {
+  const seq = Math.max(0, Math.trunc(Number(row?.seq || 0)));
+  const subagentRunId = row?.subagent_run_id ? String(row.subagent_run_id).trim() : null;
+  const turnSeq = rowTurnSeq(row);
+  return {
+    reasoningId: row?.reasoning_id ? String(row.reasoning_id) : null,
+    seq,
+    text: String(row?.text || ''),
+    done: Number(row?.done || 0) === 1,
+    timestamp: row?.created_at || null,
+    subagentRunId: subagentRunId || null,
+    ...(turnSeq !== null ? { turnSeq } : {}),
+  };
+}

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

@@ -3,8 +3,8 @@
 import { createAskUserRoutingService } from '../services/ask-user-routing-service.mjs';
 import { admitRemoteRelayRequest, readRemoteRelayRequest } from '../services/remote-relay-inbound.mjs';
 import { REMOTE_RELAY_ERROR_CODES, isRemoteRelayApprovalQuestion } from '../../shared/remote-relay-contract.mjs';
-import { isRelayAskId, relayQuestionKind } from '../../shared/relay-asks.mjs';
-import { sendRelayAskError } from './relay-ask-routes.mjs';
+import { isPersonOnlyQuestion, isRelayAskId, relayQuestionKind } from '../../shared/relay-asks.mjs';
+import { askForPairedRelay, sendRelayAskError } from './relay-ask-routes.mjs';
 import { closedQuestionAnswer, questionAcceptsFreeText } from '../../shared/question-answer-rule.mjs';
 import {
   extractRequestedSchema,
@@ -56,6 +56,23 @@ function isRemoteRelayApprovalRow(row) {
   return envelope ? isRemoteRelayApprovalQuestion(envelope) : false;
 }
 
+/**
+ * A stored question row that is a Claude session's Safety check card: an
+ * ask Claude Code marks as person-only. Only the user answers it, never an
+ * agent of this relay (the loopback client counts as remote) or another.
+ */
+function isPersonOnlyRow(row) {
+  const envelope = parseRowJson(row?.request);
+  return envelope ? isPersonOnlyQuestion(envelope.context) : false;
+}
+
+const PERSON_ONLY_ANSWER_REFUSAL = 'This card is the user\'s to answer: Claude Code marks the call as person-only, so no agent may answer it.';
+
+/** A card no agent may list or answer. */
+function isUserOnlyRow(row) {
+  return isRemoteRelayApprovalRow(row) || isPersonOnlyRow(row);
+}
+
 /**
  * The choices of a stored card that takes no typed text (approval and
  * permission cards, and a card with choices that stored no flag, as the
@@ -167,13 +184,17 @@ export function registerAskUserRoutes(app, deps) {
     const conversationId = req.query.conversationId ? String(req.query.conversationId) : null;
     const status = String(req.query.status || 'pending').trim() || 'pending';
     let rows = stmts.listQuestions.all(status, conversationId, conversationId);
-    if (fromRemoteRelay(req)) rows = rows.filter((row) => !isRemoteRelayApprovalRow(row));
+    if (fromRemoteRelay(req)) rows = rows.filter((row) => !isUserOnlyRow(row));
     const questions = rows.map(formatQuestionRow).map((question) => ({ ...question, kind: relayQuestionKind(question) }));
     // Questions that don't block, on request (read_session's pendingQuestions):
     // the cards' own readers take only what a turn waits on.
     if (String(req.query.includeAsks || '') === '1' && relayAskService?.isAvailable?.() && status === 'pending') {
       const asks = conversationId ? relayAskService.listOf(conversationId) : relayAskService.listHere();
-      questions.push(...asks.filter((ask) => !ask.relayId && ask.status === 'pending' && (!conversationId || ask.conversationId === conversationId)));
+      // A paired relay's read_session never learns the asking turn's queue id.
+      const shown = fromRemoteRelay(req) ? askForPairedRelay : (ask) => ask;
+      questions.push(...asks
+        .filter((ask) => !ask.relayId && ask.status === 'pending' && (!conversationId || ask.conversationId === conversationId))
+        .map(shown));
     }
     res.json({ questions });
   });
@@ -181,7 +202,8 @@ export function registerAskUserRoutes(app, deps) {
   app.get('/api/relay-question/:id', auth, (req, res) => {
     if (isRelayAskId(req.params.id)) {
       const ask = relayAskService?.get?.(req.params.id) || null;
-      return ask ? res.json({ question: ask }) : res.status(404).json({ error: 'Not found' });
+      if (!ask) return res.status(404).json({ error: 'Not found' });
+      return res.json({ question: fromRemoteRelay(req) ? askForPairedRelay(ask) : ask });
     }
     const row = stmts.getQuestion.get(req.params.id);
     if (!row || (isRemoteRelayApprovalRow(row) && fromRemoteRelay(req))) {
@@ -343,6 +365,10 @@ export function registerAskUserRoutes(app, deps) {
       console.warn(`[${ts()}] QUESTION  reject id=${id.slice(0, 8)} reason=remote-relay-approval-from-remote`);
       return res.status(403).json({ error: 'Only this relay\'s user can answer a remote relay approval' });
     }
+    if (isPersonOnlyRow(row) && fromRemoteRelay(req)) {
+      console.warn(`[${ts()}] QUESTION  reject id=${id.slice(0, 8)} reason=person-only-from-agent`);
+      return res.status(403).json({ error: PERSON_ONLY_ANSWER_REFUSAL, code: REMOTE_RELAY_ERROR_CODES.forbidden });
+    }
     if (row.status !== 'pending') return res.status(409).json({ error: `Question already ${row.status}` });
 
     const schema = parseQuestionRequest(row.request_schema);
@@ -418,6 +444,9 @@ export function registerAskUserRoutes(app, deps) {
     if (isRemoteRelayApprovalRow(row) && fromRemoteRelay(req)) {
       return res.status(403).json({ error: 'Only this relay\'s user can answer a remote relay approval' });
     }
+    if (isPersonOnlyRow(row) && fromRemoteRelay(req)) {
+      return res.status(403).json({ error: PERSON_ONLY_ANSWER_REFUSAL, code: REMOTE_RELAY_ERROR_CODES.forbidden });
+    }
     if (row.status !== 'pending') return res.json({ ok: true, question: formatQuestionRow(row) });
 
     const result = stmts.timeoutQuestion.run(row.id);

package/server/routes/messages-routes.mjs

@@ -113,7 +113,9 @@ const OPAQUE_RESPONSE_TEXT_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-
 const OPAQUE_RESPONSE_RECOVERY_WAIT_MS = 600_000;
 const OPAQUE_RESPONSE_RECOVERY_POLL_MS = 250;
 const STRANDED_SESSION_PRIME_COOLDOWN_MS = 10_000;
-const STRANDED_SESSION_HEARTBEAT_FRESH_MS = 15_000;
+// An idle worker beats every 30 s (shared/worker-runtime/worker-keepalive.mjs):
+// its last beat may be that old and still prove it alive.
+export const STRANDED_SESSION_HEARTBEAT_FRESH_MS = 45_000;
 // Hold finalization after a relay question is answered so the SDK has time to fire the next
 // onUserInputRequest (multi-step ask_user). Without this, the transcript is used prematurely and
 // the queue row is marked done while additional questions are still pending.
@@ -161,6 +163,13 @@ export function shouldRequireNewOpenAIConversation({
   );
 }
 
+// The path a `{*splat}` route matched: express 5 hands it over as its
+// decoded segments, or not at all when the path ends at the slash.
+export function splatPath(req) {
+  const splat = req.params?.splat;
+  return Array.isArray(splat) ? splat.join('/') : String(splat || '');
+}
+
 function normalizeRequestedProviderType(value = '') {
   const normalized = String(value || '').trim().toLowerCase();
   if (normalized === 'openai' || normalized === 'openai-byok' || normalized === 'openai-image') return 'openai';
@@ -2140,8 +2149,6 @@ export function registerMessagesRoutes(app, deps) {
     deepseekClaudeConfigDir = '',
   } = deps;
 
-  const ttyConsoleActive = runtimeState?.ttyConsoleActive === true;
-
   // ─── Sub-agent runs: header, timeline, live events ─────────────────────────
   const subagentTimeline = createSubagentTimelineService({ db, stmts });
 
@@ -2253,18 +2260,6 @@ export function registerMessagesRoutes(app, deps) {
     LIMIT 1
   `);
 
-  function isAbnormalWorkerTelemetry(payload = {}, level = 'log') {
-    const normalizedLevel = String(level || 'log').trim().toLowerCase();
-    if (normalizedLevel === 'warn' || normalizedLevel === 'error') return true;
-    const event = String(payload?.event || '').trim().toLowerCase();
-    const state = String(payload?.state || '').trim().toLowerCase();
-    if (state === 'error') return true;
-    return event.includes('error')
-      || event.includes('failed')
-      || event.includes('failure')
-      || event.includes('blocked');
-  }
-
   function readBridgeIdentity(req) {
     return relayBridgeOwnerService?.normalizeIdentity?.({
       pid: req.headers['x-relay-process-pid'],
@@ -2338,8 +2333,6 @@ export function registerMessagesRoutes(app, deps) {
     const payload = extra && typeof extra === 'object'
       ? { ...envelope, ...extra }
       : envelope;
-    const shouldLog = !ttyConsoleActive || isAbnormalWorkerTelemetry(payload, level);
-    if (!shouldLog) return;
     const method = typeof console[level] === 'function' ? level : 'log';
     console[method](`[${ts()}] WORKER    ${JSON.stringify(payload)}`);
   }
@@ -4019,8 +4012,8 @@ export function registerMessagesRoutes(app, deps) {
     });
   });
 
-  app.get('/api/files/*', auth, (req, res) => {
-    const requestedPath = String(req.params?.[0] || '').trim();
+  app.get('/api/files/{*splat}', auth, (req, res) => {
+    const requestedPath = splatPath(req).trim();
     const rootOverride = resolveScopedWorkspaceRootPath(req);
     const filePath = resolveWorkspaceFilePath(requestedPath, rootOverride);
     if (!filePath) return res.status(400).json({ error: 'Invalid file path' });
@@ -4041,8 +4034,8 @@ export function registerMessagesRoutes(app, deps) {
     });
   });
 
-  app.get('/api/files-preview/*', auth, (req, res) => {
-    const requestedPath = String(req.params?.[0] || '').trim();
+  app.get('/api/files-preview/{*splat}', auth, (req, res) => {
+    const requestedPath = splatPath(req).trim();
     const normalizedPath = normalizeWorkspaceRelativePath(requestedPath);
     const rootOverride = resolveScopedWorkspaceRootPath(req);
     const filePath = resolveWorkspaceFilePath(requestedPath, rootOverride);
@@ -9179,16 +9172,28 @@ export function registerMessagesRoutes(app, deps) {
     const responseMessageId = q?.response_message_id || null;
     const normalizedSubagentRunId = subagentRunId ? String(subagentRunId).trim() : null;
     const normalizedMetadata = sanitizeActivityMetadata(metadata);
-    const activityRow = stmts.insertActivity.run(
-      messageId,
-      responseMessageId,
-      conversationId,
-      normalizeRelayMode(mode) || DEFAULT_RELAY_MODE,
-      activityText,
-      new Date().toISOString(),
-      normalizedSubagentRunId,
-      normalizedMetadata ? JSON.stringify(normalizedMetadata) : null,
-    );
+    // The row's place in the turn's order (thoughts and tool lines share
+    // it): numbered and written in one IMMEDIATE transaction, so two writers
+    // on the same turn never get the same number.
+    let turnSeq = null;
+    const insertActivityRow = () => {
+      turnSeq = stmts.nextTurnSeq?.(messageId) ?? null;
+      return stmts.insertActivity.run(
+        messageId,
+        responseMessageId,
+        conversationId,
+        normalizeRelayMode(mode) || DEFAULT_RELAY_MODE,
+        activityText,
+        new Date().toISOString(),
+        normalizedSubagentRunId,
+        normalizedMetadata ? JSON.stringify(normalizedMetadata) : null,
+        turnSeq,
+      );
+    };
+    const insertActivityTx = typeof db?.transaction === 'function' ? db.transaction(insertActivityRow) : null;
+    const activityRow = typeof insertActivityTx?.immediate === 'function'
+      ? insertActivityTx.immediate()
+      : insertActivityRow();
     if (normalizedSubagentRunId) {
       // The lane keeps the capped line; the timeline copy keeps what came in.
       mirrorSubagentFrame({
@@ -9206,6 +9211,7 @@ export function registerMessagesRoutes(app, deps) {
       timestamp: new Date().toISOString(),
       subagentRunId: normalizedSubagentRunId || undefined,
       ...(normalizedMetadata ? { metadata: normalizedMetadata } : {}),
+      ...(turnSeq !== null ? { turnSeq } : {}),
     });
     res.json({ ok: true });
   });
@@ -9363,6 +9369,9 @@ export function registerMessagesRoutes(app, deps) {
     const relayMode = normalizeRelayMode(mode) || DEFAULT_RELAY_MODE;
     const normalizedReasoningId = String(reasoningId || '').trim() || null;
     let seq = null;
+    // The thought's place in the turn's order: given on its first write and
+    // kept by every update, so a thought sits where its first chunk arrived.
+    let turnSeq = null;
     const shouldPersistThought = !!done || !!normalizedReasoningId;
     if (shouldPersistThought) {
       const isThoughtSeqConstraintError = (error) => {
@@ -9397,12 +9406,13 @@ export function registerMessagesRoutes(app, deps) {
                 messageId,
                 normalizedReasoningId,
               );
-              return existingSeq;
+              return { seq: existingSeq, turnSeq: existingThought.turn_seq == null ? null : Number(existingThought.turn_seq) };
             }
           }
           const row = stmts.getLastThoughtSeqByQueueMessage?.get(messageId);
           const maxSeq = Math.max(0, Number(row?.max_seq || 0));
           const nextSeq = maxSeq + 1;
+          const nextTurn = stmts.nextTurnSeq?.(messageId) ?? null;
           stmts.insertThought?.run(
             messageId,
             responseMessageId,
@@ -9414,8 +9424,9 @@ export function registerMessagesRoutes(app, deps) {
             done ? 1 : 0,
             now,
             normalizedSubagentRunId,
+            nextTurn,
           );
-          return nextSeq;
+          return { seq: nextSeq, turnSeq: nextTurn };
         });
         const runInsertThought = typeof insertThoughtTx?.immediate === 'function'
           ? insertThoughtTx.immediate.bind(insertThoughtTx)
@@ -9423,7 +9434,7 @@ export function registerMessagesRoutes(app, deps) {
         const maxRetries = 4;
         for (let attempt = 1; attempt <= maxRetries; attempt += 1) {
           try {
-            seq = runInsertThought();
+            ({ seq, turnSeq } = runInsertThought());
             break;
           } catch (error) {
             if (error?.code === 'THOUGHT_CONVERSATION_MISMATCH') {
@@ -9458,6 +9469,7 @@ export function registerMessagesRoutes(app, deps) {
       seq,
       timestamp: now,
       subagentRunId: normalizedSubagentRunId || undefined,
+      ...(turnSeq !== null ? { turnSeq } : {}),
     });
     res.json({ ok: true, seq });
   });

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

@@ -151,6 +151,16 @@ export function inboxItemOfPlanBoard(board, session, { forRemote = false } = {})
   };
 }
 
+/**
+ * An ask as a paired relay gets it: without `queueId`, the queue row of the
+ * turn that asked here, which means nothing there.
+ */
+export function askForPairedRelay(ask) {
+  if (!ask || typeof ask !== 'object') return ask;
+  const { queueId, ...rest } = ask;
+  return rest;
+}
+
 /** One Inbox item of an ask (relay-ask-service.mjs shape). */
 export function inboxItemOfAsk(ask) {
   const {
@@ -322,7 +332,7 @@ export function registerRelayAskRoutes(app, deps) {
     if (!relayAskService?.isAvailable?.()) return res.json({ available: false, asks: [], pending: 0 });
     const conversationId = toText(req.query.conversationId);
     const asks = conversationId
-      ? relayAskService.listOf(conversationId).filter((ask) => !ask.relayId && ask.conversationId === conversationId)
+      ? relayAskService.listIn(conversationId).filter((ask) => !ask.relayId && ask.conversationId === conversationId)
       : relayAskService.listHere();
     res.json({ available: true, asks, pending: relayAskService.pendingCount() });
   });
@@ -411,7 +421,7 @@ export function registerRelayAskRoutes(app, deps) {
         detail: body.detail,
         urgency: body.urgency,
       });
-      res.json({ ok: true, ask });
+      res.json({ ok: true, ask: askForPairedRelay(ask) });
     } catch (error) {
       sendRelayAskError(res, error, 'The ask');
     }
@@ -433,7 +443,7 @@ export function registerRelayAskRoutes(app, deps) {
     const caller = admitPairedRelay(req, res);
     if (!caller || !available(res)) return;
     try {
-      res.json({ ok: true, ask: relayAskService.withdraw(toText(asObject(req.body).id), { byRelayId: caller.relayId }) });
+      res.json({ ok: true, ask: askForPairedRelay(relayAskService.withdraw(toText(asObject(req.body).id), { byRelayId: caller.relayId })) });
     } catch (error) {
       sendRelayAskError(res, error, 'The withdrawal');
     }
@@ -447,7 +457,7 @@ export function registerRelayAskRoutes(app, deps) {
     const caller = admitPairedRelay(req, res, body.via);
     if (!caller || !available(res)) return;
     try {
-      res.json({ ok: true, ask: relayAskService.answer(toText(body.id), { answer: String(body.answer ?? ''), choice: String(body.choice ?? ''), via: caller.name }) });
+      res.json({ ok: true, ask: askForPairedRelay(relayAskService.answer(toText(body.id), { answer: String(body.answer ?? ''), choice: String(body.choice ?? ''), via: caller.name })) });
     } catch (error) {
       sendRelayAskError(res, error, 'The answer');
     }
@@ -458,7 +468,7 @@ export function registerRelayAskRoutes(app, deps) {
     const caller = admitPairedRelay(req, res, body.via);
     if (!caller || !available(res)) return;
     try {
-      res.json({ ok: true, ask: relayAskService.dismiss(toText(body.id), { via: caller.name }) });
+      res.json({ ok: true, ask: askForPairedRelay(relayAskService.dismiss(toText(body.id), { via: caller.name })) });
     } catch (error) {
       sendRelayAskError(res, error, 'The dismissal');
     }

package/server/routes/sessions-routes.mjs

@@ -78,6 +78,7 @@ import { createShareRepository } from '../repositories/share-repository.mjs';
 import { createShareAccessLog, readShareRequestViewer } from '../services/share-access-log-service.mjs';
 import { GROUP_NAME_MAX, resolveGroupDisplayName } from '../repositories/conversation-group-repository.mjs';
 import { conversationGroupPosition, conversationGroupRole, groupActivityTimes, pageConversationRows } from '../public/app/conversation-group-order.mjs';
+import { detailsVersion, parseHeldDetailsParam, thoughtFingerprint } from '../public/app/held-details.mjs';
 import { admitRemoteRelayRequest, publicRemoteRelayOrigin, readRemoteRelayRequest } from '../services/remote-relay-inbound.mjs';
 import {
   RELAUNCH_COALESCE_WINDOW_MS,
@@ -160,7 +161,7 @@ export { mapUsageSnapshotRow };
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const SESSION_WORKER_STATUS_QUEUE_STATES = Object.freeze(['pending', 'processing', 'parked']);
 // Registry statuses that mean "this worker is currently running" (same triple
-// as countActiveCliWorkers in server-runtime.mjs).
+// as ACTIVE_SESSION_CWD_STATUSES in server-runtime.mjs).
 const SESSION_WORKER_ACTIVE_STATUSES = Object.freeze(['starting', 'ready', 'processing']);
 // A shared attachment's URL names its bytes (sha256 or a fixed generated-image
 // path), so a kept answer stays right.
@@ -4706,6 +4707,59 @@ export function registerSessionsRoutes(app, deps) {
   });
 
   // GET /api/conversation/:id — get paginated conversation history
+  // The details version of each finished reply (held-details.mjs), one query
+  // per table for the whole window (the ids go in as one JSON parameter).
+  // Tool rows are only inserted: their count and highest row id. Thought rows
+  // are updated in place as they stream and when done: their rows are read
+  // (id, done, text) and fingerprinted, so any change shows.
+  let detailsVersionStatements = null;
+  function relayDetailsVersions(messageIds) {
+    const ids = [...new Set(messageIds.filter(Boolean))];
+    const versions = new Map();
+    if (!ids.length || typeof db?.prepare !== 'function') return versions;
+    try {
+      detailsVersionStatements ||= {
+        activity: db.prepare(`
+          SELECT response_message_id AS id, COUNT(*) AS n, MAX(rowid) AS max_rowid
+          FROM relay_activity
+          WHERE response_message_id IN (SELECT value FROM json_each(?))
+          GROUP BY response_message_id
+        `),
+        thought: db.prepare(`
+          SELECT response_message_id AS response_id, rowid AS row_id, done, text
+          FROM relay_thought
+          WHERE response_message_id IN (SELECT value FROM json_each(?))
+        `),
+      };
+      const idsJson = JSON.stringify(ids);
+      const activity = new Map();
+      for (const row of detailsVersionStatements.activity.all(idsJson) || []) {
+        activity.set(String(row?.id || ''), { n: Number(row.n) || 0, max: Number(row.max_rowid) || 0 });
+      }
+      const thoughtRows = new Map();
+      for (const row of detailsVersionStatements.thought.all(idsJson) || []) {
+        const id = String(row?.response_id || '');
+        if (!thoughtRows.has(id)) thoughtRows.set(id, []);
+        thoughtRows.get(id).push({ rowid: row.row_id, done: row.done, text: row.text });
+      }
+      for (const id of ids) {
+        const tools = activity.get(id) || { n: 0, max: 0 };
+        const thoughts = thoughtRows.get(id) || [];
+        versions.set(id, detailsVersion({
+          activityCount: tools.n,
+          activityMaxRowId: tools.max,
+          thoughtCount: thoughts.length,
+          thoughtMaxRowId: thoughts.reduce((max, row) => Math.max(max, Number(row.rowid) || 0), 0),
+          thoughtHash: thoughtFingerprint(thoughts),
+        }));
+      }
+    } catch {
+      // No versions: nothing is held, everything goes out in full.
+      return new Map();
+    }
+    return versions;
+  }
+
   app.get('/api/conversation/:id', auth, (req, res) => {
     const requestedId = String(req.params.id || '').trim();
     const limit = normalizeConversationHistoryLimit(req.query.limit, 20);
@@ -4729,7 +4783,9 @@ export function registerSessionsRoutes(app, deps) {
       supportedRelayModes: SUPPORTED_RELAY_MODES,
       defaultRelayMode: DEFAULT_RELAY_MODE,
     });
-    const inFlight = inFlightStateForConversation(resolvedConversationId);
+    // The running turn's tool lines: as many per thread as this page shows
+    // (its "Tool lines shown" setting); none given, the relay's default.
+    const inFlight = inFlightStateForConversation(resolvedConversationId, { activityCap: req.query.activityCap });
     const sdkSessionId = String(conv.sdk_session_id || resolvedConversationId || '').trim();
     const sessionUsageSummary = resolveSessionUsageSummaryForSdkSession({
       sdkSessionId,
@@ -4768,14 +4824,23 @@ export function registerSessionsRoutes(app, deps) {
         .map((row) => [String(row?.response_message_id || '').trim(), String(row?.id || '').trim()])
         .filter(([responseMessageId, sourceMessageId]) => !!responseMessageId && !!sourceMessageId),
     );
+    // The live poll names the finished replies whose tool lines and thoughts
+    // it holds (`heldDetails`, held-details.mjs); those whose details have
+    // not changed since (the same `detailsVersion`) go out without them.
+    const assistantIds = dbMessages.filter((m) => m.role === 'assistant').map((m) => String(m.id));
+    const detailsVersions = relayDetailsVersions(assistantIds);
+    const heldParam = parseHeldDetailsParam(req.query.heldDetails);
+    const heldNow = new Set(heldParam
+      ? assistantIds.filter((id) => heldParam.get(id) === detailsVersions.get(id))
+      : []);
     const relayActivitiesByMessageId = new Map(
       dbMessages
-        .filter((m) => m.role === 'assistant')
+        .filter((m) => m.role === 'assistant' && !heldNow.has(String(m.id)))
         .map((m) => [m.id, relayActivityForResponse(m.id)]),
     );
     const relayThoughtsByMessageId = new Map(
       dbMessages
-        .filter((m) => m.role === 'assistant')
+        .filter((m) => m.role === 'assistant' && !heldNow.has(String(m.id)))
         .map((m) => [m.id, relayThoughtsForResponse ? relayThoughtsForResponse(m.id) : []]),
     );
     const subagentRunsByMessageId = new Map(
@@ -4816,8 +4881,14 @@ export function registerSessionsRoutes(app, deps) {
     });
     messages = messages.map((message) => {
       if (message.role !== 'assistant') return message;
-      const sourceMessageId = responseMessageToSourceId.get(String(message.id || '').trim()) || message.sourceMessageId || undefined;
-      return sourceMessageId ? { ...message, sourceMessageId } : message;
+      const id = String(message.id || '').trim();
+      const sourceMessageId = responseMessageToSourceId.get(id) || message.sourceMessageId || undefined;
+      // Held: the page fills these from what it has. Otherwise the version
+      // the page keeps with them.
+      const details = heldNow.has(id)
+        ? { activities: [], thoughts: [], detailsHeld: true }
+        : (detailsVersions.has(id) ? { detailsVersion: detailsVersions.get(id) } : {});
+      return { ...message, ...(sourceMessageId ? { sourceMessageId } : {}), ...details };
     });
     const history = sqlPage
       ? { messages, pageInfo: sqlPage.pageInfo }