@oar-sh/oar 0.9.1 → 0.9.3

package/server/routes/messages-routes.mjs

@@ -2,6 +2,7 @@
 import express from 'express';
 import fs from 'fs';
 import path from 'path';
+import { randomUUID } from 'crypto';
 import { stripRelayPromptContext } from '../services/relay-prompt-sanitizer.mjs';
 import { resolveUploadMimeType } from '../services/mime-sniffer.mjs';
 import { applySafeServedContentHeaders } from '../services/safe-served-content.mjs';
@@ -14,6 +15,15 @@ import {
   persistConversationModelPreference as persistConversationModelPreferenceTx,
 } from '../services/conversation-preferences-service.mjs';
 import { killTmuxSession } from '../services/session-worker-launch-service.mjs';
+import { normalizeWorkerSteeringSnapshot } from '../services/session-worker-registry-service.mjs';
+import {
+  buildSteerSettleFailure,
+  steerAgentLabelForProvider,
+  STEER_SETTLE_FAILED_CODE,
+  STEER_SETTLE_FAILED_STABLE_CODE,
+} from '../../shared/steer-settle-failure.mjs';
+import { buildRelayStopFailure } from '../../shared/relay-stop-failure.mjs';
+import { stopSessionWorkerProcesses } from '../services/session-worker-stop-service.mjs';
 import {
   fetchUsageSummaryPromise,
   staleUsageSnapshotFromRow,
@@ -27,6 +37,8 @@ import { openAIReasoningEffortsForModel } from '../../shared/openai-reasoning.mj
 import { DEFAULT_CLAUDE_REASONING_EFFORTS } from '../services/provider-reasoning-effort.mjs';
 import { claudeBaseModelId, claudeLongContextModelId } from '../../shared/model-id.mjs';
 import { sanitizeSubagentRunId } from '../../shared/subagent-run-id.mjs';
+import { STEER_FOLDED_TEXT } from '../../shared/steer-settle-markers.mjs';
+import { isLiveResend } from '../services/steer-resend.mjs';
 import { resolveProviderModelSelection } from '../services/provider-model-selection.mjs';
 
 export const SESSION_WORKER_OWNER_LEASE_MS = 120_000;
@@ -175,12 +187,20 @@ function findRecentDuplicateUserMessage({
   text = '',
   now = Date.now(),
   windowMs = DUPLICATE_USER_MESSAGE_WINDOW_MS,
+  // A message the user deliberately sends again (Resend of a steer a Stop
+  // cut off) is not a duplicate of its own original, nor of an earlier Resend
+  // of it that was cancelled or failed.
+  exemptMessageIds = [],
 } = {}) {
   const fingerprint = normalizeDuplicateMessageText(text);
   if (!fingerprint) return null;
   const maxAgeMs = Math.max(60_000, Number(windowMs) || DUPLICATE_USER_MESSAGE_WINDOW_MS);
+  const exempt = new Set((Array.isArray(exemptMessageIds) ? exemptMessageIds : [])
+    .map((id) => String(id || '').trim()).filter(Boolean));
+  const isExempt = (row) => exempt.has(String(row?.id || '').trim());
 
   for (const row of Array.isArray(recentUserMessages) ? recentUserMessages : []) {
+    if (isExempt(row)) continue;
     const rowText = normalizeDuplicateMessageText(row?.text || '');
     if (!rowText || rowText !== fingerprint) continue;
     const rowTime = Date.parse(row?.timestamp || '');
@@ -191,6 +211,7 @@ function findRecentDuplicateUserMessage({
   }
 
   for (const row of Array.isArray(recentQueueRows) ? recentQueueRows : []) {
+    if (isExempt(row)) continue;
     const rowText = normalizeDuplicateMessageText(row?.text || '');
     if (!rowText || rowText !== fingerprint) continue;
     const rowTime = Date.parse(row?.timestamp || '');
@@ -831,23 +852,29 @@ export function dequeuePendingMessage({
         : stmts.findPending.get(currentIso);
     }
     if (!next) return null;
+    // One processing attempt = one attempt_id. Minted here for every claim —
+    // even for callers that never echo it back — so finalization, requeue, and
+    // question writes can be fenced to the attempt that actually owns the row.
+    const attemptId = randomUUID();
     if (routingEnabled && requesterSid && stmts.setProcessingWithWorkerLease) {
-      stmts.setProcessingWithWorkerLease.run(currentIso, requesterSid, currentIso, leaseExpiresAt, currentIso, next.id);
+      stmts.setProcessingWithWorkerLease.run(currentIso, attemptId, requesterSid, currentIso, leaseExpiresAt, currentIso, next.id);
       return {
         ...next,
         status: 'processing',
         processing_at: currentIso,
+        attempt_id: attemptId,
         owner_sdk_session_id: String(next.owner_sdk_session_id || '').trim() || requesterSid,
         owner_assigned_at: String(next.owner_assigned_at || '').trim() || currentIso,
         owner_lease_expires_at: leaseExpiresAt,
         owner_last_claimed_at: currentIso,
       };
     }
-    stmts.setProcessing.run(currentIso, next.id);
+    stmts.setProcessing.run(currentIso, attemptId, next.id);
     return {
       ...next,
       status: 'processing',
       processing_at: currentIso,
+      attempt_id: attemptId,
     };
   });
   return dequeue();
@@ -1127,6 +1154,7 @@ export function buildDequeuedRelayMessage({
     status: msg.status,
     timestamp: msg.timestamp,
     processingAt: msg.processing_at,
+    attemptId: String(msg.attempt_id || '').trim() || null,
     ownerSessionId: String(msg.owner_sdk_session_id || '').trim() || null,
     ownerAssignedAt: msg.owner_assigned_at || null,
     ownerLeaseExpiresAt: msg.owner_lease_expires_at || null,
@@ -1748,6 +1776,10 @@ export function registerMessagesRoutes(app, deps) {
     sanitizeActivityText,
     readSessionTranscriptMessages,
     inFlightStateForConversation,
+    // Resolves the live turn among a conversation's processing rows (mid-turn
+    // steering can leave more than one). Falls back to the newest-processing
+    // query for older wiring/tests that do not supply it.
+    resolveLiveTurnQueueRow = (conversationId) => stmts.getLatestProcessingQueueByConversation.get(conversationId) || null,
     emitToClientsExceptSessionId,
     relayBridgeOwnerService,
     relayRestartOrchestrator,
@@ -1756,6 +1788,10 @@ export function registerMessagesRoutes(app, deps) {
     sessionWorkerRegistry,
     sessionWorkerSupervisor,
     sessionWorkerProcessInspector,
+    // Seams for stopSessionWorkerProcesses (platform, killImpl, isPidAliveImpl,
+    // killTmuxSessionImpl). Tests must inject these instead of relying on the
+    // host OS, so the suite behaves identically on Windows and POSIX.
+    sessionWorkerStopOverrides = null,
     resolveSessionStateRoot,
     fetchUsageSummary = null,
     planUsageService = null,
@@ -1974,6 +2010,9 @@ export function registerMessagesRoutes(app, deps) {
     failureRecord,
     markWorkerError = true,
     executedProvider = null,
+    attemptId = null,
+    // Extra writes that must commit only with the (fenced) failure itself.
+    withinTransaction = null,
   }) {
     const now = new Date().toISOString();
     const responseId = uuidv4();
@@ -1983,9 +2022,13 @@ export function registerMessagesRoutes(app, deps) {
       || (modelOrigin === 'auto' ? 'unknown' : requestedModel)
       || null;
     const modelActual = String(model || '').trim() || null;
+    const fencedAttemptId = String(attemptId || '').trim() || null;
     const tx = db.transaction(() => {
-      const result = stmts.setFailed.run(JSON.stringify(failureRecord), messageId);
+      const result = fencedAttemptId
+        ? stmts.setFailedFenced.run(JSON.stringify(failureRecord), messageId, fencedAttemptId)
+        : stmts.setFailed.run(JSON.stringify(failureRecord), messageId);
       if (result.changes === 0) return false;
+      if (typeof withinTransaction === 'function') withinTransaction(now);
       stmts.setQueueResponseMessageId?.run(responseId, messageId);
       stmts.insertMsg.run(
         responseId,
@@ -2000,6 +2043,7 @@ export function registerMessagesRoutes(app, deps) {
         modelActual,
         modelOrigin,
       );
+      stmts.setMessageSourceId?.run(messageId, responseId);
       // Provenance travels with terminal failures too — the original hijack
       // incident's signature was stolen turns dying on 402, which exited
       // exactly here with no executed_provider recorded.
@@ -2092,41 +2136,87 @@ export function registerMessagesRoutes(app, deps) {
     return { responseId, now };
   }
 
+  // Cancels question cards left behind by a superseded processing attempt.
+  // Questions carry the attempt_id of the row state they were created under,
+  // so "stale" is exact: any pending card whose attempt differs from the
+  // attempt the row currently records. Cards belonging to that attempt stay
+  // pending — an answer may still be on its way in. A row with NO current
+  // attempt (finalized by a legacy responder after a requeue cleared it) makes
+  // every attempt-stamped card stale: the empty string matches none of them.
+  // The name the steer-settle wording uses for the runtime that took the
+  // prompt, from the conversation's provider type (the shared mapping the
+  // server runtime's recovery path uses too).
+  function steerSettleAgentLabelForConversation(conversationId) {
+    const id = String(conversationId || '').trim();
+    if (!id) return undefined;
+    return steerAgentLabelForProvider(stmts.getRuntimeSessionByConversation?.get?.(id)?.provider_type);
+  }
+
+  /**
+   * Terminal failure for a row whose prompt the worker's runtime already
+   * consumed — a folded or stopped steer whose settle never landed.
+   * At-most-once: every path that would requeue such a row comes here instead,
+   * since re-delivery would run the prompt a second time. `terminalError` lets
+   * a worker supply the path-accurate wording; the default is the fold wording.
+   */
+  function failConsumedQueueRow(queueRow, { reason = 'recovery', terminalError = null, attemptId = null } = {}) {
+    const agentLabel = steerSettleAgentLabelForConversation(queueRow?.conversation_id);
+    const failure = terminalError && typeof terminalError === 'object'
+      ? { ...buildSteerSettleFailure(queueRow, { agentLabel }), ...terminalError }
+      : buildSteerSettleFailure(queueRow, { agentLabel });
+    const failed = failQueueMessage({
+      queueRow,
+      messageId: queueRow.id,
+      conversationId: queueRow.conversation_id,
+      relayMode: normalizeRelayMode(queueRow.relay_mode) || DEFAULT_RELAY_MODE,
+      model: queueRow.model || null,
+      responseText: buildTerminalFailureTextForChat(failure),
+      failureRecord: {
+        ...failure,
+        kind: 'terminal',
+        error: 'terminal-error',
+        reason: String(reason || 'recovery'),
+        retryCount: Number(queueRow?.retry_count || 0),
+      },
+      markWorkerError: false,
+      attemptId,
+    });
+    if (failed) {
+      settleRelayAbortControlsForQueueMessage(queueRow.id, { ok: false, error: STEER_SETTLE_FAILED_CODE });
+      settleRelaySubagentAbortControlsForQueueMessage(queueRow.id, { ok: false, error: STEER_SETTLE_FAILED_CODE });
+      console.warn(`[${ts()}] FAILED    ${String(queueRow.id).slice(0, 8)} reason=${reason} code=${STEER_SETTLE_FAILED_STABLE_CODE} (consumed; never re-run)`);
+    }
+    return failed;
+  }
+
+  function normalizeConsumedSteerEntries(raw) {
+    const seen = new Set();
+    return (Array.isArray(raw) ? raw : [])
+      .map((entry) => (entry && typeof entry === 'object'
+        ? { id: String(entry.id || '').trim(), attemptId: String(entry.attemptId || '').trim() || null }
+        : { id: String(entry || '').trim(), attemptId: null }))
+      .filter((entry) => {
+        if (!entry.id || seen.has(entry.id)) return false;
+        seen.add(entry.id);
+        return true;
+      })
+      .slice(0, 100);
+  }
+
   function cancelPendingRelayQuestionsForMessage(messageId) {
     const targetMessageId = String(messageId || '').trim();
-    if (!targetMessageId || typeof stmts.cancelPendingQuestionsByMessage?.run !== 'function') return 0;
-    const pendingRows = typeof stmts.listPendingQuestionsByMessage?.all === 'function'
-      ? stmts.listPendingQuestionsByMessage.all(targetMessageId)
-      : [];
-    if (!pendingRows.length) return 0;
-    
-    // Get the message start time to determine which questions are "stale"
+    if (!targetMessageId || typeof stmts.cancelPendingQuestionsForStaleAttempts?.all !== 'function') return 0;
     const queueRow = stmts.findQById?.get(targetMessageId) || null;
-    const messageStartedAt = queueRow?.created_at || null;
-    
-    // Only cancel questions that were created BEFORE this turn started (stale orphans)
-    // Keep questions created during the turn - they might still be waiting for answers
+    const currentAttemptId = String(queueRow?.attempt_id || '').trim();
     const now = new Date().toISOString();
-    let cancelledCount = 0;
-    
-    for (const row of pendingRows) {
-      const questionCreatedAt = row.created_at || null;
-      const isStale = messageStartedAt && questionCreatedAt && questionCreatedAt < messageStartedAt;
-      
-      if (isStale) {
-        // This is an orphaned question from a previous attempt - cancel it
-        const result = db.prepare(`UPDATE relay_questions SET status = 'cancelled', answered_at = ? WHERE id = ? AND status = 'pending'`).run(now, row.id);
-        if ((result?.changes || 0) > 0) {
-          cancelledCount++;
-          const updated = stmts.getQuestion?.get(row.id) || null;
-          if (updated && typeof deps.formatQuestionRow === 'function') {
-            io.emit('relay_question_updated', { question: deps.formatQuestionRow(updated) });
-          }
-        }
+    const cancelledRows = stmts.cancelPendingQuestionsForStaleAttempts.all(now, targetMessageId, currentAttemptId);
+    for (const row of cancelledRows) {
+      const updated = stmts.getQuestion?.get(row.id) || null;
+      if (updated && typeof deps.formatQuestionRow === 'function') {
+        io.emit('relay_question_updated', { question: deps.formatQuestionRow(updated) });
       }
     }
-    
-    return cancelledCount;
+    return cancelledRows.length;
   }
 
   const strandedPrimeCooldownBySession = new Map();
@@ -2146,7 +2236,7 @@ export function registerMessagesRoutes(app, deps) {
           AND rs.sdk_session_id = ?
       )
       AND (q.next_attempt_at IS NULL OR q.next_attempt_at <= ?)
-    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
+    ORDER BY q.timestamp ASC, q.rowid ASC
     LIMIT 1
   `);
   const transferPendingOwnerToSession = db.prepare(`
@@ -2221,11 +2311,13 @@ export function registerMessagesRoutes(app, deps) {
     UPDATE queue
     SET status = 'pending',
         processing_at = NULL,
+        attempt_id = NULL,
         next_attempt_at = ?,
         owner_lease_expires_at = NULL
     WHERE id = ?
       AND owner_sdk_session_id = ?
       AND status = 'processing'
+      AND consumed_at IS NULL
   `);
   const findMostRecentConversationForSession = db.prepare(`
     SELECT conversation_id
@@ -2405,15 +2497,7 @@ export function registerMessagesRoutes(app, deps) {
   }
 
   function buildRelayStopFailurePayload() {
-    return {
-      kind: 'turn-aborted',
-      error: 'turn-aborted',
-      code: 'turn-aborted',
-      stableCode: 'relay.turn-aborted',
-      message: 'System note: This turn was stopped from the relay UI before completion.',
-      guidance: 'Send a new message to continue when you are ready.',
-      failedAt: new Date().toISOString(),
-    };
+    return buildRelayStopFailure();
   }
 
   function settleRelayAbortControlsForQueueMessage(queueMessageId, { ok = true, note = null, error = null } = {}) {
@@ -2496,6 +2580,10 @@ export function registerMessagesRoutes(app, deps) {
         io.emit('message_status', { messageId: row.id, conversationId: row.conversation_id, status: 'failed' });
         continue;
       }
+      if (row.consumed_at) {
+        failConsumedQueueRow(row, { reason });
+        continue;
+      }
       const relayActivityRows = stmts.listActivityByQueueMessage?.all?.(row.id);
       const relayStreamRows = stmts.listStreamEventsByQueueMessage?.all?.(row.id);
       const fallbackRelayActivities = Array.isArray(relayActivityRows)
@@ -2567,6 +2655,21 @@ export function registerMessagesRoutes(app, deps) {
     return rows;
   }
 
+  // A worker survives EPERM probes (alive, different owner), so only ESRCH
+  // and bad pids count as dead — the same read as the supervisor's probe.
+  function isWorkerPidAlive(pidValue) {
+    const pid = Number(pidValue);
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      const code = String(error?.code || '').trim().toUpperCase();
+      if (code === 'EPERM') return true;
+      return false;
+    }
+  }
+
   app.post('/api/session-worker/:sdkSessionId/kill', auth, async (req, res) => {
     const sdkSessionId = normalizeSessionWorkerId(req.params.sdkSessionId);
     if (!sdkSessionId) return res.status(400).json({ error: 'Missing session worker id' });
@@ -2574,73 +2677,52 @@ export function registerMessagesRoutes(app, deps) {
     const currentWorker = sessionWorkerRegistry?.getWorker?.(sdkSessionId) || null;
     sessionWorkerSupervisor?.markKilled?.(sdkSessionId);
     try {
-      await sessionWorkerSupervisor?.cancelPendingStart?.(sdkSessionId);
+      // Wait for an in-flight spawn to settle before enumerating processes:
+      // a fire-and-forget cancellation let the spawn's child appear right
+      // after the scan and survive the kill.
+      await sessionWorkerSupervisor?.cancelPendingStart?.(sdkSessionId, { wait: true });
     } catch {
       // If cancellation fails, keep going with the process kill cleanup.
     }
 
-    // Collect ALL matching PIDs (not just first)
-    const discoveredProcesses = process.platform === 'win32'
-      ? (
-          sessionWorkerProcessInspector?.findWindowsProcessTreeForSession?.(sdkSessionId)
-          || sessionWorkerProcessInspector?.findWindowsProcessesForSession?.(sdkSessionId)
-          || sessionWorkerProcessInspector?.findProcessesForSession?.(sdkSessionId)
-          || []
-        )
-      : (sessionWorkerProcessInspector?.findProcessesForSession?.(sdkSessionId) || []);
-    const allPids = [...new Set([
-      ...discoveredProcesses.map((p) => (p.processId ? Number(p.processId) : null)).filter(Boolean),
-      currentWorker?.pid ? Number(currentWorker.pid) : null,
-    ].filter(Boolean))];
+    // Deterministic stop — the shared service enumerates every matching PID,
+    // signals, polls, escalates once, and verifies, instead of the one-shot
+    // scan-and-signal pass that used to report success with survivors.
+    const stopped = await stopSessionWorkerProcesses({
+      sdkSessionId,
+      worker: currentWorker,
+      processInspector: sessionWorkerProcessInspector,
+      isPidAliveImpl: isWorkerPidAlive,
+      killTmuxSessionImpl: killTmuxSession,
+      ...(sessionWorkerStopOverrides || {}),
+    });
+    const allPids = stopped.pids || [];
+    const remainingPids = stopped.remainingPids || [];
+    const killedPids = allPids.filter((pid) => !remainingPids.includes(pid));
+    const processStatus = allPids.length
+      ? (stopped.ok ? 'killed' : 'kill-incomplete')
+      : 'not-running';
 
-    let processStatus = 'not-running';
-    let killedPids = [];
+    // Audit marker — always emitted before responding
+    console.log(`[KILL] session=${sdkSessionId} pids=${allPids.join(',') || 'none'} processStatus=${processStatus}${remainingPids.length ? ` remaining=${remainingPids.join(',')}` : ''}`);
 
-    if (allPids.length) {
-      try {
-        if (process.platform === 'win32') {
-          // On Windows, kill through PowerShell to avoid process-group edge-cases.
-          killedPids = sessionWorkerProcessInspector.stopWindowsPids(allPids);
-        } else {
-          killTmuxSession(sdkSessionId);
-          for (const pid of allPids) {
-            try {
-              process.kill(pid, 'SIGTERM');
-              killedPids.push(pid);
-            } catch {
-              // Ignore missing/already-dead processes.
-            }
-          }
-          await delay(150);
-          for (const pid of allPids) {
-            try {
-              process.kill(pid, 0);
-              process.kill(pid, 'SIGKILL');
-            } catch {
-              // Already exited or inaccessible.
-            }
-          }
-        }
-        processStatus = 'killed';
-      } catch (error) {
-        return res.status(500).json({ error: error?.message || 'Failed to kill session worker', pids: allPids });
-      }
+    if (!stopped.ok) {
+      // Verified survivors (or a failed stop pass): keep the registry entry
+      // and every owned queue row. Clearing them while a CLI is still alive is
+      // what let a "successful" kill leave an orphan worker holding the
+      // session's work.
+      return res.status(409).json({
+        ok: false,
+        error: stopped.error || 'Session worker processes survived the kill',
+        sdkSessionId,
+        killedPids,
+        remainingPids,
+        processStatus,
+        escalated: stopped.escalated === true,
+        timedOut: stopped.timedOut === true,
+      });
     }
 
-    // Audit marker — always emitted before responding
-    console.log(`[KILL] session=${sdkSessionId} pids=${allPids.join(',') || 'none'} processStatus=${processStatus}`);
-
-    // Post-kill verification — synchronous re-scan to confirm processes are gone
-    const remainingPids = allPids.length
-      ? (process.platform === 'win32'
-          ? (
-              sessionWorkerProcessInspector?.findWindowsProcessTreeForSession?.(sdkSessionId)
-              || sessionWorkerProcessInspector?.findWindowsProcessesForSession?.(sdkSessionId)
-              || []
-            ).map((p) => p.processId).filter(Boolean)
-          : ((sessionWorkerProcessInspector?.findProcessesForSession?.(sdkSessionId) || []).map((p) => p.processId).filter(Boolean)))
-      : [];
-
     sessionWorkerRegistry?.removeWorker?.(sdkSessionId);
     sessionWorkerSupervisor?.clearRestartSchedule?.(sdkSessionId);
     sessionWorkerSupervisor?.resetHealth?.(sdkSessionId, { clearFailureCount: false });
@@ -2749,7 +2831,10 @@ export function registerMessagesRoutes(app, deps) {
       return rejectSessionBinding(res, sessionState.status, sessionState.error);
     }
 
-    const queueRow = stmts.getLatestProcessingQueueByConversation.get(conversationId) || null;
+    // The live turn, not merely the newest processing row: a steered message
+    // folded into the running turn is also `processing`, and Stop must target
+    // the turn actually executing (which the worker interrupts as a whole).
+    const queueRow = resolveLiveTurnQueueRow(conversationId) || null;
     if (!queueRow) {
       return res.json({
         ok: true,
@@ -2948,6 +3033,44 @@ export function registerMessagesRoutes(app, deps) {
     });
   });
 
+  // The session worker that can still pull a processing row back out of its
+  // runtime: the row's owner first (the worker that claimed it), then the
+  // conversation's bound session. Only a worker whose latest heartbeat lists
+  // the id as cancellable qualifies — the relay never guesses at the runtime's
+  // queue state.
+  function findWorkerHoldingCancellableMessage({ queueRow, conversationId, messageId }) {
+    if (typeof sessionWorkerRegistry?.getWorker !== 'function') return null;
+    const conversation = stmts.getConvAnyStatus?.get?.(conversationId) || null;
+    const candidates = [...new Set([
+      normalizeSessionWorkerId(queueRow?.owner_sdk_session_id),
+      normalizeSessionWorkerId(conversation?.sdk_session_id),
+    ].filter(Boolean))];
+    for (const sessionId of candidates) {
+      const worker = sessionWorkerRegistry.getWorker(sessionId);
+      const cancellableIds = Array.isArray(worker?.steering?.cancellableIds) ? worker.steering.cancellableIds : [];
+      if (cancellableIds.includes(messageId)) return worker;
+    }
+    return null;
+  }
+
+  // Asks the owning worker to remove a pushed-but-unconsumed row from its
+  // runtime (`cancel_pushed_message`). True when the control went out over a
+  // live worker socket; the worker then settles the row through
+  // POST /api/queue-cancelled. False (no such worker, id not cancellable, or
+  // the socket is gone) leaves the row on its ordinary path.
+  function requestPushedMessageCancel({ queueRow, conversationId, messageId }) {
+    const worker = findWorkerHoldingCancellableMessage({ queueRow, conversationId, messageId });
+    if (!worker) return false;
+    const sent = sendWorkerControl?.(worker.sdkSessionId, {
+      type: 'cancel_pushed_message',
+      messageId,
+      conversationId,
+    });
+    if (!sent) return false;
+    console.log(`[${ts()}] UNSTEER REQ ${messageId.slice(0, 8)} conv=${conversationId.slice(0, 8)}`);
+    return true;
+  }
+
   app.post('/api/conversation/:conversationId/cancel-queued-turn', auth, (req, res) => {
     const conversationId = String(req.params.conversationId || '').trim();
     const requestedMessageId = String(req.body?.messageId || '').trim();
@@ -2981,6 +3104,19 @@ export function registerMessagesRoutes(app, deps) {
 
     const currentStatus = String(queueRow.status || '').trim().toLowerCase();
     if (currentStatus === 'processing') {
+      // Un-steer: a row the owning worker pushed into its runtime but reports
+      // as still unconsumed (heartbeat `steering.cancellableIds`) can be pulled
+      // back out. The worker answers through POST /api/queue-cancelled once the
+      // runtime confirms the removal; until then the row stays processing.
+      if (requestPushedMessageCancel({ queueRow, conversationId, messageId: requestedMessageId })) {
+        return res.json({
+          ok: true,
+          cancelled: false,
+          acknowledgement: 'cancel-requested',
+          requestedMessageId,
+          status: currentStatus,
+        });
+      }
       return res.json({
         ok: true,
         cancelled: false,
@@ -3853,6 +3989,52 @@ export function registerMessagesRoutes(app, deps) {
     });
   });
 
+  // A Resend of a steer a Stop cut off unanswered. Honored only for a user
+  // message of this conversation whose own settle marker is kind='stopped' and
+  // whose text is what is being sent; anything else is an ordinary send (and
+  // gets the ordinary duplicate guard). Returns { originId } to honor it,
+  // { alreadyResentAs } when an earlier Resend of it still stands (from any
+  // device, at any time), or null.
+  function resolveStoppedSteerResend(conversationId, rawMessageId, text) {
+    const messageId = String(rawMessageId || '').trim();
+    if (!messageId || !conversationId) return null;
+    try {
+      const original = db.prepare(`
+        SELECT id, text, mode FROM messages WHERE id = ? AND conversation_id = ? AND role = 'user'
+      `).get(messageId, conversationId);
+      if (!original) return null;
+      // Stored user text may carry the relay's prompt context; the incoming
+      // text is already stripped, so compare like with like.
+      const originalText = stripRelayPromptContext(original.text, original.mode);
+      if (normalizeDuplicateMessageText(originalText) !== normalizeDuplicateMessageText(text)) return null;
+      const stopped = db.prepare(`
+        SELECT 1 FROM messages
+        WHERE conversation_id = ? AND role = 'assistant' AND kind = 'stopped'
+          AND (source_message_id = ? OR id IN (SELECT response_message_id FROM queue WHERE id = ?))
+        LIMIT 1
+      `).get(conversationId, messageId, messageId);
+      if (!stopped) return null;
+      const earlier = db.prepare(`
+        SELECT m.id,
+          q.id AS queue_id,
+          q.status AS queue_status,
+          EXISTS (SELECT 1 FROM messages a WHERE a.role = 'assistant' AND a.source_message_id = m.id) AS answered
+        FROM messages m
+        LEFT JOIN queue q ON q.id = m.id
+        WHERE m.conversation_id = ? AND m.role = 'user' AND m.resend_of_message_id = ?
+      `).all(conversationId, messageId);
+      const standing = earlier.find((row) => isLiveResend({
+        hasQueueRow: !!row.queue_id,
+        queueStatus: row.queue_status,
+        answered: !!row.answered,
+      }));
+      if (standing) return { alreadyResentAs: standing.id };
+      return { originId: messageId, exemptIds: [messageId, ...earlier.map((row) => row.id)] };
+    } catch {
+      return null;
+    }
+  }
+
   // POST /api/message — browser sends a message
   app.post('/api/message', auth, async (req, res) => {
     const {
@@ -3879,6 +4061,10 @@ export function registerMessagesRoutes(app, deps) {
     const requestedRelayMode = normalizeRelayMode(relayMode || mode);
     const trimmedText = stripRelayPromptContext(text, requestedRelayMode || relayMode || mode);
     const normalizedAttachments = normalizeAttachments(rawAttachments);
+    const requestedAttachmentCount = Math.min(
+      MAX_UPLOAD_ATTACHMENTS,
+      Array.isArray(rawAttachments) ? rawAttachments.filter((item) => item && typeof item === 'object').length : (rawAttachments ? 1 : 0),
+    );
     const referenceResolution = collectReferenceAttachmentsFromText(trimmedText);
     const attachments = mergeMessageAttachments(normalizedAttachments, referenceResolution.attachments);
     const imageTarget = rawImageTarget && typeof rawImageTarget === 'object'
@@ -4348,6 +4534,19 @@ export function registerMessagesRoutes(app, deps) {
       }
     }
 
+    const resend = shouldCreateConversation
+      ? null
+      : resolveStoppedSteerResend(conversationId, req.body.resendOfMessageId, trimmedText);
+    if (resend?.alreadyResentAs) {
+      return res.json({
+        ok: true,
+        duplicate: true,
+        alreadyResent: true,
+        duplicateOfMessageId: resend.alreadyResentAs,
+        conversationId,
+      });
+    }
+    const resendOriginId = resend?.originId || null;
     if (!shouldCreateConversation) {
       const recentUserMessages = stmts.getRecentMessagesDesc.all(conversationId, 20);
       const recentQueueRows = db.prepare(`
@@ -4361,6 +4560,7 @@ export function registerMessagesRoutes(app, deps) {
         recentUserMessages,
         recentQueueRows,
         text: trimmedText,
+        exemptMessageIds: resend?.exemptIds || [],
       });
       if (duplicateMessage) {
         return res.json({
@@ -4466,27 +4666,32 @@ export function registerMessagesRoutes(app, deps) {
       );
       linkUploadReferences(convId, msgId, attachments);
       stmts.updateConvTime.run(now, convId);
-      if (typeof stmts.updateConvDraft?.run === 'function') {
-        stmts.updateConvDraft.run(null, now, sessionId || null, convId);
-      } else {
-        db.prepare(`
-          UPDATE conversations
-          SET draft_text = NULL, draft_updated_at = ?, draft_updated_by_client_id = ?
-          WHERE id = ?
-        `).run(now, sessionId || null, convId);
-      }
-      // The message now owns these blobs, so the draft placeholders can go. The
-      // sent-message references were just inserted above, so nothing is orphaned.
-      if (typeof stmts.updateConvDraftAttachments?.run === 'function') {
-        stmts.updateConvDraftAttachments.run(null, now, sessionId || null, convId);
-      } else {
-        db.prepare(`
-          UPDATE conversations
-          SET draft_attachments = NULL, draft_updated_at = ?, draft_updated_by_client_id = ?
-          WHERE id = ?
-        `).run(now, sessionId || null, convId);
+      if (resendOriginId) stmts.setMessageResendOf?.run(resendOriginId, msgId);
+      // A Resend never came from the composer: whatever the user is typing
+      // there stays their draft.
+      if (!resendOriginId) {
+        if (typeof stmts.updateConvDraft?.run === 'function') {
+          stmts.updateConvDraft.run(null, now, sessionId || null, convId);
+        } else {
+          db.prepare(`
+            UPDATE conversations
+            SET draft_text = NULL, draft_updated_at = ?, draft_updated_by_client_id = ?
+            WHERE id = ?
+          `).run(now, sessionId || null, convId);
+        }
+        // The message now owns these blobs, so the draft placeholders can go. The
+        // sent-message references were just inserted above, so nothing is orphaned.
+        if (typeof stmts.updateConvDraftAttachments?.run === 'function') {
+          stmts.updateConvDraftAttachments.run(null, now, sessionId || null, convId);
+        } else {
+          db.prepare(`
+            UPDATE conversations
+            SET draft_attachments = NULL, draft_updated_at = ?, draft_updated_by_client_id = ?
+            WHERE id = ?
+          `).run(now, sessionId || null, convId);
+        }
+        stmts.deleteDraftUploadRefs?.run?.(convId);
       }
-      stmts.deleteDraftUploadRefs?.run?.(convId);
       // Cursor allows per-turn model switching, so the pinned provider_model has
       // to follow the accepted model; otherwise the conversation list and the
       // composer keep restoring the model chosen at bootstrap.
@@ -4576,14 +4781,16 @@ export function registerMessagesRoutes(app, deps) {
       }
       throw error;
     }
-    io.emit('conversation_draft_updated', {
-      conversationId: convId,
-      draftText: '',
-      draftAttachments: [],
-      draftUpdatedAt: now,
-      draftUpdatedByClientId: sessionId || null,
-      senderClientId: sessionId || null,
-    });
+    if (!resendOriginId) {
+      io.emit('conversation_draft_updated', {
+        conversationId: convId,
+        draftText: '',
+        draftAttachments: [],
+        draftUpdatedAt: now,
+        draftUpdatedByClientId: sessionId || null,
+        senderClientId: sessionId || null,
+      });
+    }
     if (ownerSessionId) {
       const existingWorker = sessionWorkerRegistry?.getWorker?.(ownerSessionId) || null;
       sessionWorkerRegistry?.upsertWorker?.({
@@ -4699,6 +4906,9 @@ export function registerMessagesRoutes(app, deps) {
       ...workspaceRootPayload(),
       referenceAttachmentCount: referenceResolution.attachments.length,
       skippedReferenceAttachments: referenceResolution.skipped,
+      // Attachment references that no longer resolve (a deleted upload) are
+      // dropped silently by normalizeAttachments; the sender is told how many.
+      droppedAttachmentCount: Math.max(0, requestedAttachmentCount - normalizedAttachments.length),
       imageOperation: imageOperation
         ? {
             id: imageOperation.id,
@@ -4713,6 +4923,8 @@ export function registerMessagesRoutes(app, deps) {
     touchCli();
     const requester = readBridgeIdentity(req);
     const requesterSessionId = normalizeSessionWorkerId(requester?.sessionId);
+    const settleFailedHandled = [];
+    const settleFailedSkipped = [];
     const activeQueueMessageId = String(req.body?.activeQueueMessageId || '').trim();
     // A persistent-process worker can hold several live rows at once (the
     // running turn plus a delivered message queued behind it plus a
@@ -4748,7 +4960,71 @@ export function registerMessagesRoutes(app, deps) {
           pid: normalizedRequesterPid,
         });
       }
+      // The worker's composer-facing steering snapshot rides the heartbeat;
+      // store it on the registry entry (status payload spreads it to clients)
+      // only when it actually changed, so quiet heartbeats stay write-free.
+      // Normalized with the registry's own rules BEFORE comparing — comparing
+      // raw against stored would never converge for values the registry drops.
+      const steering = normalizeWorkerSteeringSnapshot(req.body?.steering);
+      if (steering) {
+        const workerForSteering = sessionWorkerRegistry?.getWorker?.(requesterSessionId) || null;
+        const stored = workerForSteering?.steering || null;
+        const storedCancellableIds = Array.isArray(stored?.cancellableIds) ? stored.cancellableIds : [];
+        const changed = !stored
+          || stored.turnActive !== steering.turnActive
+          || stored.canSteer !== steering.canSteer
+          || (stored.holdReason || null) !== (steering.holdReason || null)
+          || (stored.messageId || null) !== (steering.messageId || null)
+          // The Copilot SDK worker's opt-in and its un-steerable set: a flip
+          // in either must reach the status payload (composer gate, bubble
+          // Cancel), so it counts as a change like the hold fields do.
+          || (stored.supported === true) !== (steering.supported === true)
+          || storedCancellableIds.join('\n') !== steering.cancellableIds.join('\n');
+        if (workerForSteering && changed) {
+          sessionWorkerRegistry?.upsertWorker?.({ ...workerForSteering, steering });
+          // Pushed rather than left for the clients' status poll: the
+          // composer's Steer/Queue label and the pushed rows' Cancel read it,
+          // and the poll would add up to 4 s to a heartbeat that already lags.
+          io.emit('session_worker_steering', { sdkSessionId: requesterSessionId, steering });
+        }
+      }
       sessionWorkerSupervisor?.noteSessionHeartbeat?.(requesterSessionId);
+      // Consumed steers whose settle the worker could not save within its
+      // retry budget (e.g. its writes keep failing): the relay fails them
+      // itself with the worker's terminal error, never requeueing them.
+      const settleFailedEntries = Array.isArray(req.body?.settleFailed) ? req.body.settleFailed.slice(0, 50) : [];
+      const requesterConversationForSettle = String(requester?.conversationId || '').trim() || null;
+      for (const entry of settleFailedEntries) {
+        const id = String(entry?.id || '').trim();
+        const row = id ? stmts.findQById.get(id) : null;
+        if (!row || row.status !== 'processing') {
+          if (id) settleFailedHandled.push(id);
+          continue;
+        }
+        // Only the worker that owns the row may have it failed, and only in a
+        // conversation that worker serves.
+        // Anything else is acknowledged as skipped: the worker has no claim on
+        // the row, so it stops reporting it (and releases its hold), and the
+        // row takes the ordinary recovery path — where a consumed mark still
+        // fails it rather than re-running it.
+        const rowSession = normalizeSessionWorkerId(stmts.getRuntimeSessionByConversation?.get(row.conversation_id)?.sdk_session_id);
+        if (normalizeSessionWorkerId(row.owner_sdk_session_id) !== requesterSessionId
+          || (rowSession !== requesterSessionId && String(row.conversation_id) !== String(requesterConversationForSettle || ''))) {
+          settleFailedSkipped.push(id);
+          continue;
+        }
+        const attemptId = String(entry?.attemptId || '').trim() || null;
+        if (attemptId && String(row.attempt_id || '') !== attemptId) {
+          settleFailedHandled.push(id);
+          continue;
+        }
+        failConsumedQueueRow(row, {
+          reason: 'settle-failed',
+          terminalError: entry?.terminalError && typeof entry.terminalError === 'object' ? entry.terminalError : null,
+          attemptId,
+        });
+        settleFailedHandled.push(id);
+      }
       if (activeQueueMessageIds.length) {
         const now = new Date().toISOString();
         const leaseExpiresAt = addMsToIso(now, SESSION_WORKER_OWNER_LEASE_MS);
@@ -4767,7 +5043,91 @@ export function registerMessagesRoutes(app, deps) {
     }
     relayBridgeOwnerService?.observe?.(requester);
     const { pendingCount } = queueCounts();
-    res.json({ ok: true, pendingCount });
+    res.json({
+      ok: true,
+      pendingCount,
+      ...(settleFailedHandled.length ? { settleFailedHandled } : {}),
+      ...(settleFailedSkipped.length ? { settleFailedSkipped } : {}),
+    });
+  });
+
+  // POST /api/queue-consumed — the Claude worker marks rows whose prompt the
+  // CLI has taken when no response carries the mark (a turn the user stopped,
+  // a turn handed off mid-reply). Consumed rows are at-most-once: recovery
+  // fails them terminally instead of re-running them.
+  app.post('/api/queue-consumed', auth, (req, res) => {
+    touchCli();
+    const requesterSessionId = normalizeSessionWorkerId(readBridgeIdentity(req)?.sessionId);
+    if (!requesterSessionId) return res.status(403).json({ error: 'Worker identity required' });
+    const conversationId = String(req.body?.conversationId || '').trim();
+    const entries = normalizeConsumedSteerEntries(req.body?.entries);
+    if (!conversationId || !entries.length) return res.status(400).json({ error: 'Missing conversationId or entries' });
+    // `consumed: false` un-marks a steer the CLI then replayed as a turn of
+    // its own. Either way only the owning worker, on the row's current
+    // attempt, may touch the mark.
+    const statement = req.body?.consumed === false ? stmts.clearQueueConsumed : stmts.markQueueConsumed;
+    const at = new Date().toISOString();
+    let changed = 0;
+    for (const entry of entries) {
+      changed += Number(statement?.run({
+        at,
+        id: entry.id,
+        conversationId,
+        owner: requesterSessionId,
+        attemptId: entry.attemptId,
+      })?.changes || 0);
+    }
+    res.json({ ok: true, changed });
+  });
+
+  // POST /api/queue-cancelled — the owning worker reports that a pushed but
+  // still unconsumed row was removed from its runtime (an un-steer the user
+  // asked for through cancel-queued-turn → `cancel_pushed_message`). The row
+  // ends exactly like a pending cancel: deleted, its open cards cancelled, no
+  // assistant row, `message_status: cancelled`. Fenced like /api/queue-consumed:
+  // only the row's owner, on the row's current attempt, may settle it.
+  app.post('/api/queue-cancelled', auth, (req, res) => {
+    touchCli();
+    const requesterSessionId = normalizeSessionWorkerId(readBridgeIdentity(req)?.sessionId);
+    if (!requesterSessionId) return res.status(403).json({ error: 'Worker identity required' });
+    const conversationId = String(req.body?.conversationId || '').trim();
+    const messageId = String(req.body?.messageId || '').trim();
+    const attemptId = String(req.body?.attemptId || '').trim() || null;
+    if (!conversationId || !messageId) return res.status(400).json({ error: 'Missing conversationId or messageId' });
+
+    const row = stmts.findQById.get(messageId) || null;
+    if (!row) return res.status(404).json({ error: 'not-found' });
+    if (String(row.conversation_id || '').trim() !== conversationId) {
+      return res.status(409).json({ error: 'conversation-mismatch' });
+    }
+    const status = String(row.status || '').trim().toLowerCase();
+    if (status !== 'processing') return res.status(409).json({ error: 'not-processing', status });
+    if (normalizeSessionWorkerId(row.owner_sdk_session_id) !== requesterSessionId) {
+      return res.status(409).json({ error: 'not-owned' });
+    }
+    const rowAttemptId = String(row.attempt_id || '').trim() || null;
+    if (attemptId && rowAttemptId && attemptId !== rowAttemptId) {
+      console.warn(`[${ts()}] STALE ATTEMPT queue-cancelled ${messageId.slice(0, 8)} attempt=${attemptId.slice(0, 8)} current=${rowAttemptId.slice(0, 8)}`);
+      return res.status(409).json({ error: 'stale_attempt' });
+    }
+
+    // Same transaction shape as the pending cancel above: delete first, so the
+    // question cancel sees no current attempt and flips every pending card of
+    // the row (with foreign keys on, the cascade has already taken them).
+    const cancelPushedTurn = db.transaction(() => {
+      stmts.deleteQueueById.run(messageId);
+      cancelPendingRelayQuestionsForMessage(messageId);
+    });
+    cancelPushedTurn();
+    // A processing row may carry open Stop controls (the live-turn picker can
+    // land on it before it has output); they fail like on a requeue so no
+    // caller waits on a row that no longer exists.
+    settleRelayAbortControlsForQueueMessage(messageId, { ok: false, error: 'queue-cancelled' });
+    settleRelaySubagentAbortControlsForQueueMessage(messageId, { ok: false, error: 'queue-cancelled' });
+
+    io.emit('message_status', { messageId, conversationId, status: 'cancelled' });
+    console.log(`[${ts()}] UNSTEERED ${messageId.slice(0, 8)} conv=${conversationId.slice(0, 8)}`);
+    res.json({ ok: true, cancelled: true });
   });
 
   // POST /api/grok-native-session — Grok worker persists the ACP session id so
@@ -6056,10 +6416,49 @@ export function registerMessagesRoutes(app, deps) {
     });
   });
 
+  const SETTLED_STEER_KINDS = new Set(['folded', 'stopped']);
+
   // POST /api/response — CLI submits response
   app.post('/api/response', auth, async (req, res) => {
     touchCli();
     const { messageId, conversationId, text, model, mode, generatedImages: rawGeneratedImages } = req.body;
+    // A steering absorption (Claude worker): this reply ends where a message
+    // pushed mid-turn was picked up, and the turn continues on that message's
+    // own row. Stamped as kind='absorbed' so the transcript renders the two
+    // turns as one merged flow.
+    // A worker not yet respawned onto 0.9.3 still stamps its fold stubs
+    // absorbed:true; the stub text identifies them, and 'absorbed' on a fold
+    // would mis-merge the next ordinary message.
+    const staleFoldStub = req.body.absorbed === true && String(text || '').trim() === STEER_FOLDED_TEXT;
+    const absorbed = req.body.absorbed === true && !staleFoldStub;
+    // The other settle stubs of a consumed steer (never re-run — the CLI saw
+    // it): 'folded' was answered by the turn it was steered into and renders
+    // as a marker on its own message; 'stopped' was steered into a turn the
+    // user then stopped, so it went unanswered and the client offers Resend.
+    const requestedKind = staleFoldStub ? 'folded' : String(req.body.kind || '').trim();
+    const settledKind = absorbed
+      ? 'absorbed'
+      : (SETTLED_STEER_KINDS.has(requestedKind) ? requestedKind : null);
+    // Steers pushed into the turn this response finishes and not yet settled:
+    // the CLI has taken their prompts, so they are marked consumed together
+    // with this commit and no recovery path may ever re-run them.
+    const consumedSteerEntries = normalizeConsumedSteerEntries(req.body.consumedSteerIds)
+      .filter((entry) => entry.id !== String(messageId || '').trim());
+    // Runs inside the response's fenced write (both the success and the
+    // terminal-failure transaction), so a superseded attempt's late publish
+    // can never mark rows; the steers must share the finishing row's owner.
+    const markSteersConsumed = (conversationIdForMark, atIso) => {
+      const owner = normalizeSessionWorkerId(q?.owner_sdk_session_id);
+      for (const entry of consumedSteerEntries) {
+        stmts.markQueueConsumed?.run({
+          at: atIso,
+          id: entry.id,
+          conversationId: conversationIdForMark,
+          owner,
+          attemptId: entry.attemptId,
+        });
+      }
+    };
     const trimmedText = String(text || '').trim();
     const terminalFailure = resolveTerminalFailurePayload(req.body, { fallbackText: trimmedText });
     // Final digests of background workflows that settled during this turn —
@@ -6090,6 +6489,21 @@ export function registerMessagesRoutes(app, deps) {
     if (!targetConversationId) return res.status(400).json({ error: 'Missing conversationId' });
     const responseBridgeIdentity = readBridgeIdentity(req);
 
+    // Attempt fencing: a writer that names its processing attempt may only
+    // settle the row while that attempt is still the row's current one. A
+    // mismatch means the row was requeued (and possibly re-dequeued) after
+    // this writer started — its work is superseded, not mergeable. Writers
+    // that send no attemptId (the extension engine, mid-rollout workers) keep
+    // the legacy conditional semantics.
+    const claimedAttemptId = String(req.body.attemptId || '').trim() || null;
+    if (claimedAttemptId && q && String(q.attempt_id || '') !== claimedAttemptId) {
+      console.warn(`[${ts()}] STALE ATTEMPT ${messageId?.slice(0,8)} route=response claimed=${claimedAttemptId.slice(0,8)} current=${String(q.attempt_id || '').slice(0,8) || 'none'} status=${q.status}`);
+      return res.status(409).json({ error: 'stale_attempt', currentStatus: q.status });
+    }
+    if (!claimedAttemptId && q && q.status === 'processing') {
+      console.log(`[${ts()}] FENCE     ${messageId?.slice(0,8)} legacy unfenced response write`);
+    }
+
     if (q && q.status === 'done') {
       console.log(`[${ts()}] RESPONSE  ${messageId?.slice(0,8)} ignored=already_done`);
       return res.json({ ok: true, ignored: 'already_done' });
@@ -6145,8 +6559,16 @@ export function registerMessagesRoutes(app, deps) {
           requestId: terminalFailure.requestId || null,
           failedAt: new Date().toISOString(),
         },
+        attemptId: claimedAttemptId,
+        // An errored turn still took the steers pushed into it.
+        withinTransaction: (atIso) => markSteersConsumed(targetConversationId, atIso),
       });
       if (!failed) {
+        const currentRow = stmts.findQById?.get(messageId) || null;
+        if (claimedAttemptId && currentRow && String(currentRow.attempt_id || '') !== claimedAttemptId) {
+          console.warn(`[${ts()}] STALE ATTEMPT ${messageId?.slice(0,8)} route=response-terminal claimed=${claimedAttemptId.slice(0,8)} current=${String(currentRow.attempt_id || '').slice(0,8) || 'none'} status=${currentRow.status}`);
+          return res.status(409).json({ error: 'stale_attempt', currentStatus: String(currentRow.status || 'unknown') });
+        }
         console.log(`[${ts()}] RESPONSE  ${messageId?.slice(0,8)} ignored=not_pending_or_processing`);
         return res.json({ ok: true, ignored: 'not_pending_or_processing' });
       }
@@ -6243,8 +6665,11 @@ export function registerMessagesRoutes(app, deps) {
       ? stmts.getOperation?.get(q.image_operation_id)
       : null;
     const finalize = db.transaction(() => {
-      const result = stmts.setDone.run(resolvedText, messageId);
+      const result = claimedAttemptId
+        ? stmts.setDoneFenced.run(resolvedText, messageId, claimedAttemptId)
+        : stmts.setDone.run(resolvedText, messageId);
       if (result.changes === 0) return false;
+      markSteersConsumed(targetConversationId, now);
       stmts.setQueueResponseMessageId?.run(responseId, messageId);
       stmts.insertMsg.run(
         responseId,
@@ -6259,8 +6684,11 @@ export function registerMessagesRoutes(app, deps) {
         explicitModel,
         modelOrigin,
       );
+      stmts.setMessageSourceId?.run(messageId, responseId);
       if (String(q?.kind || '') === 'continuation') {
         stmts.setMessageKind?.run('continuation', responseId);
+      } else if (settledKind) {
+        stmts.setMessageKind?.run(settledKind, responseId);
       }
       // The workflow cards persist atomically with the assistant message they
       // annotate — keyed directly on the response id (see workflow_runs DDL).
@@ -6353,6 +6781,10 @@ export function registerMessagesRoutes(app, deps) {
       });
       const currentRow = stmts.findQById?.get(messageId) || null;
       const currentStatus = String(currentRow?.status || 'unknown');
+      if (claimedAttemptId && currentRow && String(currentRow.attempt_id || '') !== claimedAttemptId) {
+        console.warn(`[${ts()}] STALE ATTEMPT ${messageId?.slice(0,8)} route=response-finalize claimed=${claimedAttemptId.slice(0,8)} current=${String(currentRow.attempt_id || '').slice(0,8) || 'none'} status=${currentStatus}`);
+        return res.status(409).json({ error: 'stale_attempt', currentStatus });
+      }
       console.log(`[${ts()}] RESPONSE  ${messageId?.slice(0,8)} ignored=not_pending_or_processing actual_status=${currentStatus}`);
       // Ensure UI is updated even if the response was duplicate/late
       if (currentStatus === 'done') {
@@ -6484,6 +6916,9 @@ export function registerMessagesRoutes(app, deps) {
       messageId: responseId,
       message: {
         role: 'assistant',
+        // In the message too, as on reload: a stopped marker's Resend finds
+        // its original through it.
+        sourceMessageId: messageId,
         text: resolvedText,
         attachments: emittedImageAttachments.length ? emittedImageAttachments : undefined,
         model: resolvedAssistantModel,
@@ -6495,18 +6930,25 @@ export function registerMessagesRoutes(app, deps) {
         activities,
         thoughts,
         executedProvider,
-        kind: String(q?.kind || '') === 'continuation' ? 'continuation' : undefined,
+        kind: String(q?.kind || '') === 'continuation'
+          ? 'continuation'
+          : (settledKind || undefined),
         // Live-appended messages must show their workflow cards without a
         // reload; conversation reloads serve the same digests from the DB.
         workflowRuns: workflowRuns.length ? workflowRuns : undefined,
       },
     });
     io.emit('message_status', { messageId, conversationId: targetConversationId, status: 'done' });
-    void pushDispatchService?.notifyTurnComplete?.({
-      conversationId: targetConversationId,
-      messageId: responseId,
-      text: resolvedText,
-    });
+    // An absorbed row is not a finished turn — the reply continues on the
+    // steered message's row, whose own completion sends the one notification.
+    // A stopped steer has no reply at all.
+    if (!settledKind) {
+      void pushDispatchService?.notifyTurnComplete?.({
+        conversationId: targetConversationId,
+        messageId: responseId,
+        text: resolvedText,
+      });
+    }
     cancelPendingRelayQuestionsForMessage(messageId);
     res.json({ ok: true });
   });
@@ -6547,27 +6989,56 @@ export function registerMessagesRoutes(app, deps) {
       || normalizeSessionWorkerId(req.body?.sdkSessionId)
       || String(conversation.sdk_session_id || conversationId);
     const relayMode = normalizeRelayMode(req.body?.relayMode) || DEFAULT_RELAY_MODE;
+    // Idempotent registration: the worker mints one operation id before its
+    // first attempt and repeats it on every retry, so a retry whose previous
+    // request committed but lost its response resolves to the same row
+    // instead of minting a twin that nobody will ever settle.
+    const operationId = String(req.body?.operationId || '').trim() || null;
+    const respondWithExistingRow = (row) => {
+      if (String(row.conversation_id || '') !== conversationId) {
+        return res.status(409).json({ error: 'Continuation operation id is bound to another conversation' });
+      }
+      console.log(`[${ts()}] CONTINUATION ${String(row.id).slice(0, 8)} conv=${conversationId.slice(0, 8)} reused op=${operationId.slice(0, 8)}`);
+      return res.json({ ok: true, messageId: row.id, conversationId: row.conversation_id, attemptId: row.attempt_id || null, existing: true });
+    };
+    if (operationId) {
+      const existing = stmts.findQByContinuationOp?.get?.(operationId) || null;
+      if (existing) return respondWithExistingRow(existing);
+    }
     const messageId = uuidv4();
+    const attemptId = uuidv4();
     const now = new Date().toISOString();
     const leaseExpiresAt = addMsToIso(now, SESSION_WORKER_OWNER_LEASE_MS);
-    stmts.insertContinuationQ.run(
-      messageId,
-      conversationId,
-      runtimeSession?.id || null,
-      String(req.body?.model || '').trim() || null,
-      relayMode,
-      '[background continuation]',
-      now,
-      now,
-      ownerSessionId,
-      now,
-      leaseExpiresAt,
-      now,
-    );
-    console.log(`[${ts()}] CONTINUATION ${messageId.slice(0, 8)} conv=${conversationId.slice(0, 8)} owner=${ownerSessionId.slice(0, 8)} trigger=${String(req.body?.trigger || 'background_task')}`);
+    try {
+      stmts.insertContinuationQ.run(
+        messageId,
+        conversationId,
+        runtimeSession?.id || null,
+        String(req.body?.model || '').trim() || null,
+        relayMode,
+        '[background continuation]',
+        now,
+        now,
+        ownerSessionId,
+        now,
+        leaseExpiresAt,
+        now,
+        attemptId,
+        operationId,
+      );
+    } catch (error) {
+      // Lost the race against a concurrent duplicate registration: the unique
+      // index on continuation_op_id guarantees the winner's row exists now.
+      if (operationId && String(error?.code || '').startsWith('SQLITE_CONSTRAINT')) {
+        const existing = stmts.findQByContinuationOp?.get?.(operationId) || null;
+        if (existing) return respondWithExistingRow(existing);
+      }
+      throw error;
+    }
+    console.log(`[${ts()}] CONTINUATION ${messageId.slice(0, 8)} conv=${conversationId.slice(0, 8)} owner=${ownerSessionId.slice(0, 8)} trigger=${String(req.body?.trigger || 'background_task')}${operationId ? ` op=${operationId.slice(0, 8)}` : ''}`);
     io.emit('message_status', { messageId, conversationId, status: 'processing', kind: 'continuation' });
     io.emit('queue_updated', { continuation: 1 });
-    res.json({ ok: true, messageId, conversationId });
+    res.json({ ok: true, messageId, conversationId, attemptId });
   });
 
   // POST /api/background-tasks — a session worker publishes its live
@@ -6585,10 +7056,14 @@ export function registerMessagesRoutes(app, deps) {
         startedAt: Number(task?.startedAt) || null,
         summary: String(task?.summary || '').trim().slice(0, 500) || null,
         lastToolName: String(task?.lastToolName || '').trim() || null,
+        lastToolCall: String(task?.lastToolCall || '').replace(/\s+/g, ' ').trim().slice(0, 300) || null,
         totalTokens: Number.isFinite(Number(task?.totalTokens)) ? Number(task.totalTokens) : null,
         subagentType: String(task?.subagentType || '').trim().slice(0, 120) || null,
         model: String(task?.model || '').trim().slice(0, 120) || null,
         modelInherited: task?.modelInherited === true,
+        // Copilot detached shells cannot be stopped from the host side; the
+        // panel hides the Stop button for them. Absent/true = stoppable.
+        stoppable: task?.stoppable !== false,
         // Sanitized digest or undefined: JSON serialization (store broadcast,
         // conversation payload) drops the key entirely for flat rows.
         workflowProgress: sanitizeWorkflowProgress(task?.workflowProgress) || undefined,
@@ -6616,6 +7091,23 @@ export function registerMessagesRoutes(app, deps) {
   });
 
   // POST /api/activity — relay sends in-flight activity updates (tool/search sections)
+  // Optional attempt fence for the live lanes (stream/thought/activity/
+  // subagent): a writer that names its processing attempt is rejected once
+  // the row's current attempt differs — the row was requeued or re-dequeued
+  // after this writer started, and its output belongs to a superseded turn.
+  // Same-attempt writes pass regardless of row status (trailing writes right
+  // after finalization are legitimate), and writers without an attemptId keep
+  // legacy behavior until the extension engine is retired.
+  function rejectStaleAttemptWrite({ req, res, queueRow, route }) {
+    const claimed = String(req.body?.attemptId || '').trim();
+    if (!claimed || !queueRow) return false;
+    const current = String(queueRow.attempt_id || '');
+    if (current === claimed) return false;
+    console.warn(`[${ts()}] STALE ATTEMPT ${String(queueRow.id || '').slice(0,8)} route=${route} claimed=${claimed.slice(0,8)} current=${current.slice(0,8) || 'none'} status=${queueRow.status}`);
+    res.status(409).json({ error: 'stale_attempt', currentStatus: String(queueRow.status || 'unknown') });
+    return true;
+  }
+
   app.post('/api/activity', auth, (req, res) => {
     touchCli();
     const { messageId, conversationId, text, mode, subagentRunId, metadata } = req.body || {};
@@ -6625,6 +7117,7 @@ export function registerMessagesRoutes(app, deps) {
     }
 
     const q = stmts.findQById.get(messageId);
+    if (rejectStaleAttemptWrite({ req, res, queueRow: q, route: 'activity' })) return;
     const responseMessageId = q?.response_message_id || null;
     const normalizedSubagentRunId = subagentRunId ? String(subagentRunId).trim() : null;
     const normalizedMetadata = sanitizeActivityMetadata(metadata);
@@ -6671,6 +7164,7 @@ export function registerMessagesRoutes(app, deps) {
     if (!queueConversationId || queueConversationId !== requestedConversationId) {
       return res.status(409).json({ error: 'Stream conversationId does not match queue conversation' });
     }
+    if (rejectStaleAttemptWrite({ req, res, queueRow, route: 'stream' })) return;
 
     const isStreamSeqConstraintError = (error) => {
       const message = String(error?.message || '').toLowerCase();
@@ -6791,6 +7285,7 @@ export function registerMessagesRoutes(app, deps) {
     if (!queueConversationId || queueConversationId !== requestedConversationId) {
       return res.status(409).json({ error: 'Thought conversationId does not match queue conversation' });
     }
+    if (rejectStaleAttemptWrite({ req, res, queueRow, route: 'thought' })) return;
 
     const relayMode = normalizeRelayMode(mode) || DEFAULT_RELAY_MODE;
     const normalizedReasoningId = String(reasoningId || '').trim() || null;
@@ -6900,6 +7395,7 @@ export function registerMessagesRoutes(app, deps) {
     }
 
     const q = stmts.findQById.get(messageId);
+    if (rejectStaleAttemptWrite({ req, res, queueRow: q, route: 'subagent-run' })) return;
     const existingRun = stmts.getSubagentRun?.get(normalizedSubagentRunId);
     const binding = validateSubagentRunBinding({
       queueRow: q,
@@ -6953,6 +7449,14 @@ export function registerMessagesRoutes(app, deps) {
     const { messageId } = req.body;
     const q = stmts.findQById.get(messageId);
     const terminalFailure = resolveTerminalFailurePayload(req.body);
+    // A fenced requeue from a superseded attempt is refused outright: honoring
+    // it would yank the row out from under the attempt that now owns it (or
+    // terminal-fail a row that has already been requeued to someone else).
+    const claimedAttemptId = String(req.body?.attemptId || '').trim() || null;
+    if (claimedAttemptId && q && String(q.attempt_id || '') !== claimedAttemptId) {
+      console.warn(`[${ts()}] STALE ATTEMPT ${messageId?.slice(0,8)} route=requeue claimed=${claimedAttemptId.slice(0,8)} current=${String(q.attempt_id || '').slice(0,8) || 'none'} status=${q.status}`);
+      return res.status(409).json({ error: 'stale_attempt', currentStatus: String(q.status || 'unknown') });
+    }
     const ownerSessionId = isSessionWorkerRoutingEnabled(featureFlags)
       ? normalizeSessionWorkerId(q?.owner_sdk_session_id)
       : null;
@@ -6980,6 +7484,7 @@ export function registerMessagesRoutes(app, deps) {
           retryCount: Number(q?.retry_count || 0),
           failedAt: new Date().toISOString(),
         },
+        attemptId: claimedAttemptId,
       });
       if (failed) {
         settleRelayAbortControlsForQueueMessage(messageId, {
@@ -7004,6 +7509,11 @@ export function registerMessagesRoutes(app, deps) {
       console.log(`[${ts()}] CONTINUATION DROPPED ${messageId?.slice(0,8)} reason=requeue`);
       return res.json({ ok: true, dropped: 'continuation' });
     }
+    if (q && q.status === 'processing' && q.consumed_at) {
+      // The CLI already took this prompt: any requeue class would run it again.
+      failConsumedQueueRow(q, { reason: 'requeue', attemptId: claimedAttemptId });
+      return res.json({ ok: true, terminal: true, code: STEER_SETTLE_FAILED_STABLE_CODE });
+    }
     if (q && q.status === 'processing' && String(req.body?.code || '').trim() === 'relay.provider-mismatch') {
       // A routing refusal, not a delivery failure: the legacy relay handed
       // back a turn that belongs to a session worker. No retry increment and
@@ -7011,13 +7521,32 @@ export function registerMessagesRoutes(app, deps) {
       // instead of paying a 60s ladder for the relay's mistake.
       db.prepare(`
         UPDATE queue
-        SET status = 'pending', processing_at = NULL, next_attempt_at = NULL, owner_lease_expires_at = NULL
-        WHERE id = ? AND status = 'processing'
-      `).run(messageId);
+        SET status = 'pending', processing_at = NULL, attempt_id = NULL, next_attempt_at = NULL, owner_lease_expires_at = NULL
+        WHERE id = ? AND status = 'processing'${claimedAttemptId ? ` AND attempt_id = ?` : ''}
+      `).run(...(claimedAttemptId ? [messageId, claimedAttemptId] : [messageId]));
       io.emit('message_status', { messageId, conversationId: q.conversation_id, status: 'pending' });
       console.log(`[${ts()}] REQUEUED  ${messageId?.slice(0,8)} class=provider-mismatch retry=${Number(q.retry_count || 0)}`);
       return res.json({ ok: true, mismatch: true });
     }
+    if (q && q.status === 'processing' && String(req.body?.class || '').trim() === 'steering-held') {
+      // The worker refused to push the message because its live turn is
+      // holding steering (an open question card, a compaction, an adoption).
+      // Not a failure: no retry increment, no backoff, and the owner is kept —
+      // the same worker takes it again the moment it signals ready, which is
+      // when the hold ends, so the message steers into the resumed turn.
+      const result = db.prepare(`
+        UPDATE queue
+        SET status = 'pending', processing_at = NULL, attempt_id = NULL, next_attempt_at = NULL, owner_lease_expires_at = NULL
+        WHERE id = ? AND status = 'processing'${claimedAttemptId ? ` AND attempt_id = ?` : ''}
+      `).run(...(claimedAttemptId ? [messageId, claimedAttemptId] : [messageId]));
+      if (result.changes > 0) {
+        settleRelayAbortControlsForQueueMessage(messageId, { ok: false, error: 'queue-requeued' });
+        settleRelaySubagentAbortControlsForQueueMessage(messageId, { ok: false, error: 'queue-requeued' });
+        io.emit('message_status', { messageId, conversationId: q.conversation_id, status: 'pending' });
+        console.log(`[${ts()}] REQUEUED  ${messageId?.slice(0,8)} class=steering-held retry=${Number(q.retry_count || 0)}`);
+      }
+      return res.json({ ok: true, held: true });
+    }
     if (q && q.status === 'processing') {
       const retryCount = Number(q.retry_count || 0) + 1;
       if (retryCount >= MAX_REQUEUE_RETRIES) {
@@ -7056,6 +7585,7 @@ export function registerMessagesRoutes(app, deps) {
           SET
             status = ?,
             processing_at = NULL,
+            attempt_id = NULL,
             retry_count = ?,
             next_attempt_at = ?,
             owner_lease_expires_at = NULL,
@@ -7063,7 +7593,7 @@ export function registerMessagesRoutes(app, deps) {
             parked_target_session_id = ?,
             parked_transaction_id = ?,
             parked_reason = ?
-          WHERE id = ? AND status = 'processing'
+          WHERE id = ? AND status = 'processing'${claimedAttemptId ? ` AND attempt_id = ?` : ''}
         `).run(
           parkForRestart ? 'parked' : 'pending',
           retryCount,
@@ -7072,7 +7602,7 @@ export function registerMessagesRoutes(app, deps) {
           parkForRestart ? (restartState?.targetSessionId || null) : null,
           parkForRestart ? (restartState?.transactionId || null) : null,
           parkForRestart ? (restartState?.lastError || 'session-rebind-pending') : null,
-          messageId,
+          ...(claimedAttemptId ? [messageId, claimedAttemptId] : [messageId]),
         );
         if (result.changes > 0) {
           settleRelayAbortControlsForQueueMessage(messageId, {