@oar-sh/oar 0.9.4 → 0.9.6

package/server/copilot-worker/copilot-sdk-session-process.mjs

@@ -48,6 +48,7 @@ import { randomUUID } from 'crypto';
 
 import {
   USER_INPUT_UNSUPPORTED_ANSWER,
+  COPILOT_TURN_CONTINUE_GUIDANCE,
   classifyCopilotSessionError,
   classifyCopilotTurnException,
   copilotAgentModeForRelayMode,
@@ -76,6 +77,11 @@ import {
   normalizeRelayEffort,
 } from './copilot-model-switch.mjs';
 import { createCopilotQuestionBridge } from './copilot-question-bridge.mjs';
+import {
+  describeCommandsBeingStopped,
+  runtimeStopLeavesCommands,
+  watchCopilotRuntimeTree,
+} from './copilot-runtime-tree.mjs';
 import {
   RELAY_ASK_USER_TOOL_DESCRIPTION,
   RELAY_ASK_USER_TOOL_NAME,
@@ -85,7 +91,7 @@ import {
   parseAskUserToolArguments,
 } from './copilot-ask-user-tool.mjs';
 import { buildCopilotRemoteRelayTool } from './copilot-remote-relay-tool.mjs';
-import { createRemoteRelayToolGate } from '../../shared/remote-relay-tool-core.mjs';
+import { createRemoteRelayToolGate, isRemoteRelayToolName } from '../../shared/remote-relay-tool-core.mjs';
 import {
   EXIT_PLAN_BOARD_POSTED_FEEDBACK,
   EXIT_PLAN_NO_BOARD_FEEDBACK,
@@ -102,10 +108,17 @@ import {
 import { EMPTY_TURN_COMPLETION_NOTE } from '../../shared/empty-turn-completion.mjs';
 import { buildModelSnapshotFields, extractModelDescriptors } from '../../shared/model-descriptors.mjs';
 import { buildRelayStopFailure } from '../../shared/relay-stop-failure.mjs';
-import { STEER_FOLDED_TEXT, STEER_STOPPED_TEXT } from '../../shared/steer-settle-markers.mjs';
+import { STEER_FOLDED_TEXT, STEER_STOPPED_TEXT, STEER_TURN_FAILED_TEXT } from '../../shared/steer-settle-markers.mjs';
 import { buildSteerSettleFailure } from '../../shared/steer-settle-failure.mjs';
 import { shouldEmitStreamUpdate } from '../../shared/stream-emit-gating.mjs';
 import { withSteerNote } from '../../shared/steer-note.mjs';
+import { isTransientRelayError } from '../../shared/worker-runtime/relay-errors.mjs';
+import {
+  createTurnLiveness,
+  createTurnStalledError,
+  probeRuntime,
+  resolveTurnStallWindows,
+} from '../../shared/worker-runtime/turn-liveness.mjs';
 
 // How long the runtime may sit with no session activity before the worker
 // closes it. The worker process itself stays up and reconnects lazily on the
@@ -114,11 +127,18 @@ import { withSteerNote } from '../../shared/steer-note.mjs';
 // holding a runtime subprocess per idle conversation is not.
 const DEFAULT_IDLE_SHUTDOWN_MS = 10 * 60_000;
 const DEFAULT_LIFECYCLE_POLL_MS = 5_000;
-// Mirrors the Cursor adapter's `stallTimeoutMs`. Emphatically NOT 0: the
-// worker's 10s heartbeat keeps renewing the relay's processing lease
-// (messages-routes.mjs), so without a stall ceiling a turn whose runtime went
-// quiet holds its queue row open indefinitely and no watchdog can free it.
-const DEFAULT_TURN_STALL_TIMEOUT_MS = 120_000;
+/** How long the runtime may take to answer the stall watchdog's ping. */
+const DEFAULT_STALL_PROBE_TIMEOUT_MS = 5_000;
+/**
+ * How long the runtime may take to answer a request of the worker's own: a
+ * Stop, a read of its task registry or its message queue. None of them has a
+ * timeout in the SDK, and a healthy runtime answers within milliseconds even
+ * while it is busy (it answered a ping in 2 ms through a 150 s silent tool
+ * call, runtime 1.0.88).
+ */
+const DEFAULT_RUNTIME_RPC_TIMEOUT_MS = 10_000;
+/** Failed reads of the task registry in a row before its last answer stops counting. */
+const MAX_TASK_REFRESH_FAILURES = 5;
 /**
  * How long live background shells ALONE may keep the runtime up (0 = no limit).
  *
@@ -143,10 +163,47 @@ const DEFAULT_BACKGROUND_TASK_TIMEOUT_MS = 30 * 60_000;
  * worker's `notificationGraceMs`, same value.
  */
 const DEFAULT_CONTINUATION_GRACE_MS = 60_000;
-/** Retry spacing for the synthetic-row registration (3 attempts). */
+/**
+ * Retry spacing for the synthetic-row registration: 3 attempts while the relay
+ * answers without minting a row, and the first step of the backoff while it
+ * cannot be reached at all.
+ */
 const DEFAULT_CONTINUATION_RETRY_DELAY_MS = 500;
+/**
+ * How long the registration keeps trying while the relay cannot be reached. A
+ * relay restart takes seconds; three attempts half a second apart gave up
+ * inside it, and the whole continuation (the report of a background agent
+ * that had worked for an hour) was dropped.
+ */
+const DEFAULT_CONTINUATION_OUTAGE_WINDOW_MS = 120_000;
+/** One registration request; the transport itself would wait 300 s. */
+const DEFAULT_CONTINUATION_REQUEST_TIMEOUT_MS = 15_000;
 /** How long a continuation's actions may buffer before its row is abandoned. */
 const CONTINUATION_REGISTRATION_TIMEOUT_MS = 10_000;
+/**
+ * How long a finished reply is offered to a relay that cannot be reached
+ * before the row is given up. The reply exists once; a requeue runs the
+ * prompt again, in a session that already holds it and its answer.
+ */
+const DEFAULT_RESPONSE_RETRY_WINDOW_MS = 5 * 60_000;
+/**
+ * One attempt to save a reply, or to requeue its row. Without a limit of its
+ * own an attempt lasts as long as the transport lets it (300 s), which is the
+ * whole window: a relay that took the connection and did not answer got one
+ * attempt and then a requeue. Generous, because the route may hold a reply
+ * for a while before it answers (a question card that was just answered).
+ */
+const DEFAULT_RESPONSE_REQUEST_TIMEOUT_MS = 90_000;
+/**
+ * Live output (stream, thoughts, activity lines) is posted from the dispatch
+ * chain, one event after the other. A relay that accepts the connection and
+ * then does not answer held every later event, the turn's terminator
+ * included, for the transport's 300 s. One post waits this long; after one
+ * that ran out, live output is skipped for the pause below. The reply itself
+ * does not go this way.
+ */
+const DEFAULT_LIVE_POST_TIMEOUT_MS = 10_000;
+const DEFAULT_LIVE_POST_PAUSE_MS = 30_000;
 /** Cap on activity lines carried between turns, so a chatty runtime cannot grow them. */
 const MAX_PENDING_ACTIVITIES = 20;
 /**
@@ -188,7 +245,16 @@ const DEFAULT_TASK_PUBLISH_THROTTLE_MS = 2_000;
  * Claude worker's fold grace, for the same reason.
  */
 const DEFAULT_ORPHAN_GRACE_MS = 2_000;
-
+/**
+ * How long a runtime teardown may wait on the runtime itself. A healthy one
+ * answers `session.detach` and stops in well under a second; one whose model
+ * stream had stalled took 180 s to answer the detach alone (runtime 1.0.88,
+ * 2026-09-27), and the SDK puts no timeout on that request. Past the first
+ * window the session is left to the stop, past the second the process is
+ * killed (`forceStop`).
+ */
+const DEFAULT_RUNTIME_DETACH_TIMEOUT_MS = 10_000;
+const DEFAULT_RUNTIME_STOP_TIMEOUT_MS = 25_000;
 /**
  * Appended to the partial answer when the RUNTIME interrupted the turn on its
  * own (as opposed to the user aborting through the relay). The row has to be
@@ -325,11 +391,19 @@ export function createCopilotSdkSessionRunner({
   infiniteSessionConfig = DEFAULT_INFINITE_SESSION_CONFIG,
   idleShutdownMs = DEFAULT_IDLE_SHUTDOWN_MS,
   lifecyclePollMs = DEFAULT_LIFECYCLE_POLL_MS,
-  // 0 disables (matching the background-task timeout's 0 = no-limit
-  // convention). When set, a turn that goes this long without a single event
-  // fails terminally instead of holding the queue row until the relay's own
-  // delivery watchdog gives up.
-  turnStallTimeoutMs = DEFAULT_TURN_STALL_TIMEOUT_MS,
+  // How long a turn may go without a single event before it fails terminally
+  // (shared/worker-runtime/turn-liveness.mjs): `turnStallTimeoutMs` with
+  // nothing in flight, the two others while a model request or a tool is.
+  // 0 disables (the background-task timeout's 0 = no-limit convention).
+  // Emphatically NOT off by default: the worker's 10s heartbeat keeps renewing
+  // the relay's processing lease (messages-routes.mjs), so without a ceiling a
+  // turn whose runtime went quiet holds its queue row open until the relay's
+  // turn ceiling.
+  turnStallTimeoutMs = undefined,
+  turnStallModelTimeoutMs = undefined,
+  turnStallToolTimeoutMs = undefined,
+  stallProbeTimeoutMs = DEFAULT_STALL_PROBE_TIMEOUT_MS,
+  runtimeRpcTimeoutMs = DEFAULT_RUNTIME_RPC_TIMEOUT_MS,
   // How long a `deferred: true` model switch may wait for its
   // `session.model_change` drain before the explicit selection counts as
   // unconfirmed and fails the row (`COPILOT_SDK_RELAY_MODEL_SWITCH_TIMEOUT_MS`).
@@ -344,11 +418,24 @@ export function createCopilotSdkSessionRunner({
   // How long a settled continuation waits for its row before giving up on it.
   // Must outlast the registration's own retries; a test shortens it.
   continuationRegistrationTimeoutMs = CONTINUATION_REGISTRATION_TIMEOUT_MS,
+  continuationOutageWindowMs = DEFAULT_CONTINUATION_OUTAGE_WINDOW_MS,
+  continuationRequestTimeoutMs = DEFAULT_CONTINUATION_REQUEST_TIMEOUT_MS,
+  responseRetryWindowMs = DEFAULT_RESPONSE_RETRY_WINDOW_MS,
+  responseRequestTimeoutMs = DEFAULT_RESPONSE_REQUEST_TIMEOUT_MS,
+  livePostTimeoutMs = DEFAULT_LIVE_POST_TIMEOUT_MS,
+  livePostPauseMs = DEFAULT_LIVE_POST_PAUSE_MS,
   compactionStaleMs = DEFAULT_COMPACTION_STALE_MS,
   settleRetryDelaysMs = DEFAULT_SETTLE_RETRY_DELAYS_MS,
   maxTerminalSettleAttempts = DEFAULT_MAX_TERMINAL_SETTLE_ATTEMPTS,
   queueLaneRefreshMs = DEFAULT_QUEUE_LANE_REFRESH_MS,
   orphanGraceMs = DEFAULT_ORPHAN_GRACE_MS,
+  runtimeDetachTimeoutMs = DEFAULT_RUNTIME_DETACH_TIMEOUT_MS,
+  runtimeStopTimeoutMs = DEFAULT_RUNTIME_STOP_TIMEOUT_MS,
+  // The watch over the runtime's process tree (copilot-runtime-tree.mjs): what
+  // a runtime that was killed leaves running is stopped. Tests pass one with a
+  // fake process list; the fake client has no process, so nothing is watched
+  // without one.
+  watchRuntimeTreeImpl = watchCopilotRuntimeTree,
   // Register the relay's own `ask_user` (with `multi_select`) over the
   // runtime's built-in one. A runtime that refuses the override falls back
   // to the built-in for the rest of this worker's life.
@@ -378,6 +465,12 @@ export function createCopilotSdkSessionRunner({
   let client = null;
   let session = null;
   let sdkPaths = null;
+  const stallWindows = resolveTurnStallWindows({
+    env,
+    idleMs: turnStallTimeoutMs,
+    modelMs: turnStallModelTimeoutMs,
+    toolMs: turnStallToolTimeoutMs,
+  });
   // The single owner of "what model/effort is the live session CONFIRMED to be
   // on" (audit #9/#13): tracks the last confirmed pair, caches the per-session
   // model catalog for effort validation, and observes `session.model_change`
@@ -415,8 +508,20 @@ export function createCopilotSdkSessionRunner({
   // test seam only: the turn path never awaits a snapshot.
   let modelSnapshotChain = Promise.resolve();
   let starting = null;
+  // The teardown of the previous runtime while it is still in flight. The next
+  // runtime waits for it: the relay session id IS the SDK session id, so a
+  // second runtime resuming the session while the first still holds it would
+  // have two processes writing one event log.
+  let runtimeStopping = null;
+  // Counts runtime stops, so a session that finishes opening after its
+  // runtime was stopped is recognised and let go instead of adopted.
+  let runtimeGeneration = 0;
+  // The session open in flight, if any (see ensureSession).
+  let opening = null;
   let disposed = false;
   let detachRuntimeExit = () => {};
+  // The process tree of the live runtime, or null where its pid is not known.
+  let runtimeTree = null;
   // A compaction in progress (`session.compaction_start` seen, no `_complete`
   // yet). Holds steering: a message pushed now would land inside the
   // compaction's replay. `compactingSince` backs the stale cap.
@@ -424,6 +529,10 @@ export function createCopilotSdkSessionRunner({
   // The last readiness value reported to `onDeliveryReadinessChange`, so the
   // link only hears about flips.
   let lastReportedDeliveryReady = null;
+  // Deliveries handed back because a tool of the main agent was running (see
+  // mainToolsInFlight), counted until that hold ends. Only for the log: the
+  // messages themselves wait in the relay's queue.
+  let heldForRunningTool = 0;
   // Rows whose prompt the runtime consumed and whose settle marker is being
   // saved (id → { message, variant }). Reported by the heartbeat WITH a
   // terminal error until the publish lands, so recovery can never re-run them
@@ -507,6 +616,15 @@ export function createCopilotSdkSessionRunner({
   const agentDetails = new Map();
   let taskRefreshTimer = null;
   let taskRefreshChain = Promise.resolve();
+  // Reads of the registry that failed in a row. While there are some, "no
+  // live task" is not known but assumed, and the runtime is not closed over
+  // it: an idle shutdown on the strength of a failed read killed the shells
+  // and agents the read would have found.
+  let taskRefreshFailures = 0;
+  // A read that is on its way counts the same: its answer is not in yet.
+  let taskRefreshInFlight = false;
+  // Reads that are due but have not asked the runtime yet.
+  let taskRefreshQueued = 0;
   let lastTaskRefreshAt = 0;
   let taskPublishTimer = null;
   let lastPublishedTasksSignature = '';
@@ -703,16 +821,38 @@ export function createCopilotSdkSessionRunner({
 
   // ---------------------------------------------------------------- publish --
 
+  // Until when live output is skipped (see DEFAULT_LIVE_POST_TIMEOUT_MS).
+  let livePostsPausedUntil = 0;
+
+  /**
+   * One post of live output. Never rejects and never waits longer than
+   * `livePostTimeoutMs`; `droppable` output is skipped while the relay is
+   * known not to answer. A subagent's status is not droppable: a run left
+   * "running" in the transcript is worse than a late post.
+   */
+  async function postLive(routePath, body, { droppable = true } = {}) {
+    if (droppable && Date.now() < livePostsPausedUntil) return;
+    try {
+      await api('POST', routePath, body, livePostTimeoutMs > 0 ? { signal: AbortSignal.timeout(livePostTimeoutMs) } : {});
+    } catch (error) {
+      if (error?.name !== 'TimeoutError') return;
+      if (Date.now() >= livePostsPausedUntil) {
+        dbg(`the relay did not answer ${routePath} within ${livePostTimeoutMs}ms; live output is skipped for ${livePostPauseMs}ms`);
+      }
+      livePostsPausedUntil = Date.now() + livePostPauseMs;
+    }
+  }
+
   async function postActivity(message, text, subagentRunId = null) {
     if (!text) return;
-    await api('POST', '/api/activity', {
+    await postLive('/api/activity', {
       messageId: message.id,
       conversationId: message.conversationId,
       mode: message.relayMode || 'agent',
       text,
       ...(subagentRunId ? { subagentRunId } : {}),
       ...attemptFields(message),
-    }).catch(() => {});
+    });
   }
 
   async function dispatchAction(message, action, state) {
@@ -726,7 +866,7 @@ export function createCopilotSdkSessionRunner({
       // Only main-thread text can stand in for the answer on the abort/error
       // fallback paths; subagent text would publish as the reply.
       if (!payload.subagentRunId) state.lastStreamedText = payload.text;
-      await api('POST', '/api/stream', {
+      await postLive('/api/stream', {
         messageId: message.id,
         conversationId: message.conversationId,
         mode: message.relayMode || 'agent',
@@ -734,11 +874,11 @@ export function createCopilotSdkSessionRunner({
         done: payload.done === true,
         ...(payload.subagentRunId ? { subagentRunId: payload.subagentRunId } : {}),
         ...attemptFields(message),
-      }).catch(() => {});
+      });
       return;
     }
     if (channel === 'thought') {
-      await api('POST', '/api/thought', {
+      await postLive('/api/thought', {
         messageId: message.id,
         conversationId: message.conversationId,
         mode: message.relayMode || 'agent',
@@ -747,7 +887,7 @@ export function createCopilotSdkSessionRunner({
         done: payload.done === true,
         ...(payload.subagentRunId ? { subagentRunId: payload.subagentRunId } : {}),
         ...attemptFields(message),
-      }).catch(() => {});
+      });
       return;
     }
     if (channel === 'activity') {
@@ -758,7 +898,7 @@ export function createCopilotSdkSessionRunner({
       // Same body as every sibling worker's, so the lane bubbles, the
       // `subagent_status` broadcast and the UI's grouping behave identically
       // whichever provider produced the run.
-      await api('POST', '/api/subagent-run', {
+      await postLive('/api/subagent-run', {
         messageId: message.id,
         conversationId: message.conversationId,
         subagentRunId: payload.subagentRunId,
@@ -766,7 +906,7 @@ export function createCopilotSdkSessionRunner({
         ...(payload.displayName ? { displayName: payload.displayName } : {}),
         status: payload.status,
         ...attemptFields(message),
-      }).catch(() => {});
+      }, { droppable: false });
     }
   }
 
@@ -882,14 +1022,14 @@ export function createCopilotSdkSessionRunner({
   }
 
   async function publishFinalStream(message, text) {
-    await api('POST', '/api/stream', {
+    await postLive('/api/stream', {
       messageId: message.id,
       conversationId: message.conversationId,
       mode: message.relayMode || 'agent',
       text: String(text || ''),
       done: true,
       ...attemptFields(message),
-    }).catch(() => {});
+    }, { droppable: false });
   }
 
   /**
@@ -906,48 +1046,95 @@ export function createCopilotSdkSessionRunner({
    */
   async function publishResponse(message, {
     text, model, terminalError = null, modelOrigin, kind = null, consumedSteerIds = null,
-    requeueOnFailure = true,
+    requeueOnFailure = true, partialText = '',
   }) {
     const consumed = Array.isArray(consumedSteerIds)
       ? consumedSteerIds
         .map((entry) => ({ id: String(entry?.id || '').trim(), attemptId: entry?.attemptId || null }))
         .filter((entry) => entry.id)
       : [];
-    try {
-      await api('POST', '/api/response', {
-        messageId: message.id,
-        conversationId: message.conversationId,
-        text: String(text || ''),
-        model: model || null,
-        modelOrigin: modelOrigin
-          || (String(message?.model || '').trim().toLowerCase() === 'auto' ? 'auto' : 'manual'),
-        ...(terminalError ? { terminalError } : {}),
-        ...(kind ? { kind } : {}),
-        ...(consumed.length ? { consumedSteerIds: consumed } : {}),
-        ...attemptFields(message),
-      });
-      return 'published';
-    } catch (error) {
-      // A stale_attempt 409 means the row already moved on to another attempt
-      // (requeued and re-delivered); the requeue would 409 the same way, and
-      // the newer attempt owes the row its answer — drop this one.
-      if (isStaleAttemptError(error)) {
-        dbg('response refused as stale_attempt; dropping', message.id);
-        return 'stale';
+    const body = {
+      messageId: message.id,
+      conversationId: message.conversationId,
+      text: String(text || ''),
+      model: model || null,
+      modelOrigin: modelOrigin
+        || (String(message?.model || '').trim().toLowerCase() === 'auto' ? 'auto' : 'manual'),
+      ...(terminalError ? { terminalError } : {}),
+      // What the turn had written before it failed; the relay keeps it
+      // above the failure note.
+      ...(terminalError && String(partialText || '').trim() ? { partialText: String(partialText).trim() } : {}),
+      ...(kind ? { kind } : {}),
+      ...(consumed.length ? { consumedSteerIds: consumed } : {}),
+      ...attemptFields(message),
+    };
+    // A row's own reply is offered again while the relay cannot be reached:
+    // it exists once, and the route answers a repeat of one it already saved
+    // with `already_done`. Settle markers carry their own ladder
+    // (publishSettleMarker), and a Stop's note is not worth a wait.
+    const patient = !kind && requeueOnFailure;
+    const requestLimit = () => (responseRequestTimeoutMs > 0 ? { signal: AbortSignal.timeout(responseRequestTimeoutMs) } : {});
+    const startedAt = Date.now();
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        await api('POST', '/api/response', body, requestLimit());
+        if (attempt) dbg('response saved after the relay came back', message.id, `attempt ${attempt + 1}`);
+        return 'published';
+      } catch (error) {
+        // A stale_attempt 409 means the row already moved on to another attempt
+        // (requeued and re-delivered); the requeue would 409 the same way, and
+        // the newer attempt owes the row its answer — drop this one.
+        if (isStaleAttemptError(error)) {
+          dbg('response refused as stale_attempt; dropping', message.id);
+          return 'stale';
+        }
+        if (patient && !disposed && isTransientRelayError(error) && Date.now() - startedAt < responseRetryWindowMs) {
+          if (!attempt) dbg('the relay did not take the response; trying again', message.id, error?.message || String(error));
+          await sleep(settleRetryDelaysMs[Math.min(attempt, settleRetryDelaysMs.length - 1)] ?? 8_000);
+          continue;
+        }
+        dbg('response could not be saved', message.id, error?.message || String(error));
+        if (kind || !requeueOnFailure) return 'failed';
+        const requeued = await api('POST', '/api/requeue', { messageId: message.id, ...attemptFields(message) }, requestLimit())
+          .then(() => true, () => false);
+        return requeued ? 'requeued' : 'failed';
       }
-      if (kind || !requeueOnFailure) return 'failed';
-      const requeued = await api('POST', '/api/requeue', { messageId: message.id, ...attemptFields(message) })
-        .then(() => true, () => false);
-      return requeued ? 'requeued' : 'failed';
     }
   }
 
-  function terminalErrorRecord(message, classified) {
+  /**
+   * How many commands the runtime of a failed turn had running when its
+   * teardown began, as far as it was known at that moment: the note does not
+   * wait for a process list. On Linux the list is read at once; on Windows
+   * it takes a PowerShell start, so the note there knows what the last read
+   * knew. 0 where nothing is known or the runtime was kept.
+   */
+  function commandsLeftRunning(turn) {
+    return Number(turn?.commandsLeft) || 0;
+  }
+
+  /**
+   * `toolCalls` is how many tool calls the failed turn had started. They ran,
+   * and what they changed stays changed, so the note says so: a failure that
+   * reads as if nothing happened sends the user back to the start of work
+   * that is mostly done.
+   */
+  function terminalErrorRecord(message, classified, { toolCalls = 0, commandsLeft = 0 } = {}) {
+    const worked = toolCalls > 0;
+    const work = worked
+      ? ` Before that the agent made ${toolCalls} tool call${toolCalls === 1 ? '' : 's'}; what they changed is still in place.`
+      : '';
+    // `commandsLeft` is how many commands were running when the turn failed.
+    // They are stopped with the runtime, and a command that was cut short is
+    // something the user has to know whatever the failure was.
+    const stopping = describeCommandsBeingStopped(commandsLeft);
+    const guidance = worked && classified.guidance ? COPILOT_TURN_CONTINUE_GUIDANCE : classified.guidance;
     return {
       kind: 'copilot-turn-failed',
       code: classified.code,
       stableCode: classified.stableCode,
-      message: classified.text,
+      message: `${classified.text}${classified.guidance ? work : ''}${stopping ? ` ${stopping}` : ''}`,
+      ...(guidance ? { guidance } : {}),
       failedAt: new Date().toISOString(),
       queueMessageId: String(message.id || '') || null,
     };
@@ -1196,6 +1383,9 @@ export function createCopilotSdkSessionRunner({
     // days ago.
     if (replayGate.isReplay(event)) {
       dbg('dropping a replayed event', String(event?.type || ''), String(event?.timestamp || ''));
+      // History, but a sign of life all the same: a long resume replays for
+      // as long as it takes, and the turn waiting on it is not stalled.
+      activeTurn?.liveness?.traffic('replay');
       return;
     }
     touch();
@@ -1235,6 +1425,10 @@ export function createCopilotSdkSessionRunner({
       if (!isContinuationOpeningEvent(event)) return;
       turn = openContinuationTurn();
     }
+    // Liveness is noted on RECEIPT. The dispatch chain below awaits relay
+    // POSTs, and a watchdog fed from there measures the relay, not the
+    // runtime: one slow POST would fail a turn whose runtime never paused.
+    observeLiveness(turn, event);
     // The owner is captured HERE, synchronously, but settlement happens later
     // on the dispatch chain — so an event can be captured to a turn that is
     // settled by the time its link runs. `handleTurnEvent`'s settled guard
@@ -1247,6 +1441,57 @@ export function createCopilotSdkSessionRunner({
       .catch((error) => { dbg('event dispatch failed', error?.message || String(error)); });
   }
 
+  /** A stage of the bring-up finished: the turn waiting on it is not stalled. */
+  function liveTurnTraffic(what) {
+    const turn = activeTurn;
+    if (turn && !turn.settled) turn.liveness.traffic(what);
+  }
+
+  /**
+   * What the runtime is busy with, for the stall watchdog: a tool or a model
+   * request that has started and not finished, per agent (a subagent's events
+   * carry its `agentId` on the envelope). `model.call_*` is what runtime
+   * 1.0.88 emits around a request; `assistant.turn_start`/`turn_end` bracket
+   * the same span on runtimes that do not.
+   */
+  function observeLiveness(turn, event) {
+    const liveness = turn?.liveness;
+    if (!liveness || turn.settled) return;
+    const type = String(event?.type || '');
+    const data = event?.data && typeof event.data === 'object' ? event.data : {};
+    const agent = String(event?.agentId || '').trim() || 'root';
+    liveness.traffic(type);
+    switch (type) {
+      case 'tool.execution_start':
+        liveness.begin('tool', `${agent}:${data.toolCallId || ''}`, data.toolName);
+        break;
+      case 'tool.execution_complete':
+        liveness.end('tool', `${agent}:${data.toolCallId || ''}`);
+        break;
+      case 'assistant.turn_start':
+      case 'model.call_start':
+        liveness.begin('model', agent);
+        break;
+      case 'assistant.message':
+      case 'assistant.turn_end':
+      case 'model.call_finished':
+      case 'model.call_failure':
+        liveness.end('model', agent);
+        break;
+      case 'subagent.completed':
+      case 'subagent.failed':
+        // Whatever the agent had open ended with it.
+        liveness.endAgent(agent);
+        break;
+      default:
+        break;
+    }
+    // A tool of the main agent that starts or ends moves the steering gate
+    // (see mainToolsInFlight). Told on receipt, like the liveness itself: the
+    // relay must stop delivering before the next message is on its way.
+    if (agent === 'root' && type.startsWith('tool.execution_')) syncDeliveryReadiness();
+  }
+
   /**
    * Keep the detached-shell set current and note when one settles.
    *
@@ -1417,7 +1662,11 @@ export function createCopilotSdkSessionRunner({
     if (!sessionRpc.tasks || taskRefreshTimer) return;
     taskRefreshTimer = setTimeout(() => {
       taskRefreshTimer = null;
-      taskRefreshChain = taskRefreshChain.then(() => refreshBackgroundTasks()).catch(() => {});
+      taskRefreshQueued += 1;
+      taskRefreshChain = taskRefreshChain
+        .then(() => refreshBackgroundTasks())
+        .catch(() => {})
+        .finally(() => { taskRefreshQueued -= 1; });
     }, taskRefreshMs);
     taskRefreshTimer.unref?.();
   }
@@ -1434,13 +1683,18 @@ export function createCopilotSdkSessionRunner({
     if (!target || !sessionRpc.tasks) return;
     lastTaskRefreshAt = Date.now();
     let listed;
+    taskRefreshInFlight = true;
     try {
-      listed = await target.rpc.tasks.list();
+      listed = await askRuntime('tasks.list', () => target.rpc.tasks.list());
     } catch (error) {
       dbg('tasks.list failed', error?.message || String(error));
+      if (session === target) taskRefreshFailures += 1;
       return;
+    } finally {
+      taskRefreshInFlight = false;
     }
     if (session !== target) return;
+    taskRefreshFailures = 0;
     const next = new Map();
     for (const task of Array.isArray(listed?.tasks) ? listed.tasks : []) {
       const id = String(task?.id || '').trim();
@@ -1462,7 +1716,7 @@ export function createCopilotSdkSessionRunner({
     if (typeof target.rpc.tasks.getProgress === 'function') {
       for (const task of next.values()) {
         try {
-          const progress = (await target.rpc.tasks.getProgress({ id: task.id }))?.progress || null;
+          const progress = (await askRuntime('tasks.getProgress', () => target.rpc.tasks.getProgress({ id: task.id })))?.progress || null;
           task.progressSummary = summarizeTaskProgress(progress);
         } catch { /* a card without a progress line */ }
       }
@@ -1586,7 +1840,7 @@ export function createCopilotSdkSessionRunner({
     const target = session;
     if (!target || !sessionRpc.queue) return;
     try {
-      const snapshot = await target.rpc.queue.pendingItems();
+      const snapshot = await askRuntime('queue.pendingItems', () => target.rpc.queue.pendingItems());
       const next = new Map();
       for (const item of Array.isArray(snapshot?.items) ? snapshot.items : []) {
         const runtimeId = String(item?.messageId || '').trim();
@@ -1710,6 +1964,9 @@ export function createCopilotSdkSessionRunner({
         turn = openContinuationTurn();
       }
     }
+    // Noted at receipt on the turn that owned the stream then; the turn that
+    // takes the event over has to learn from it what is in flight.
+    observeLiveness(turn, event);
     await handleTurnEvent(turn, event);
   }
 
@@ -1718,7 +1975,11 @@ export function createCopilotSdkSessionRunner({
       await redispatchSettledEvent(event);
       return;
     }
-    turn.armStall?.();
+    if (String(event?.type || '') === 'tool.execution_start') {
+      turn.toolCalls += 1;
+      // A command may be starting: its process is read once it is there.
+      runtimeTree?.commandStarting();
+    }
     // Root work ends on the runtime's own terminator, so a question-only
     // continuation it joins no longer closes itself (whileAwaitingHuman).
     if (isContinuationOpeningEvent(event)) turn.rootWork = true;
@@ -1876,6 +2137,7 @@ export function createCopilotSdkSessionRunner({
   }
 
   function buildSessionConfig(model, reasoningEffort = null) {
+    const generation = runtimeGeneration;
     // Built once per session, not per request. Reads the mode off the LIVE turn
     // rather than closing over the one the session was built with, because one
     // session serves every turn and the user can switch modes between them.
@@ -1936,7 +2198,10 @@ export function createCopilotSdkSessionRunner({
       clientName,
       // The runtime's own defaults, pinned. See DEFAULT_INFINITE_SESSION_CONFIG.
       ...(infiniteSessionConfig ? { infiniteSessions: { ...infiniteSessionConfig } } : {}),
-      onEvent: routeEvent,
+      // Events of a runtime that is being stopped are not this session's any
+      // more: the SDK keeps delivering them until the detach is answered, and
+      // by then the next delivery may already be waiting as the active turn.
+      onEvent: (event) => { if (generation === runtimeGeneration) routeEvent(event); },
       // The relay's own tools (`relaySessionTools`); omitted when there are none.
       ...(tools.length ? { tools } : {}),
       // Permission policy follows the conversation's relay mode: agent and
@@ -2077,9 +2342,13 @@ export function createCopilotSdkSessionRunner({
     dbg('copilot runtime exited', detail);
     const turn = activeTurn;
     if (turn && !turn.settled) {
-      // driveTurn tears the runtime down and publishes the failure record
-      // onto every row the turn owns.
-      turn.fail(new Error(`the Copilot runtime exited before the turn completed (${detail})`));
+      // The turn's `fail` drops the dead handles, whatever kind of turn it
+      // is, and the drive path publishes the failure record onto every row
+      // the turn owns.
+      turn.fail(Object.assign(
+        new Error(`the Copilot runtime exited before the turn completed (${detail})`),
+        { runtimeGone: true },
+      ));
       return;
     }
     // No turn to fail: drop the dead handles so the next delivery rebuilds
@@ -2087,7 +2356,43 @@ export function createCopilotSdkSessionRunner({
     void stopRuntime('runtime-exit').catch(() => {});
   }
 
+  /**
+   * Start watching the commands of a runtime that has just started. Advisory:
+   * a watch that cannot be set up costs the clean-up after a killed runtime,
+   * never the turn.
+   */
+  function watchRuntimeTree(startedClient) {
+    try {
+      return watchRuntimeTreeImpl({
+        client: startedClient,
+        // Commands run inside a turn, or as background work between turns. A
+        // runtime with neither is not read.
+        isBusy: () => !disposed && (
+          !!activeTurn || publishingTurns.size > 0 || backgroundShells.size() > 0 || backgroundTasks.size > 0
+        ),
+        dbg,
+      }) || null;
+    } catch (error) {
+      dbg('the copilot runtime process tree is not watched', error?.message || String(error));
+      return null;
+    }
+  }
+
+  /**
+   * After the runtime is gone: stop what it left running, where it did not
+   * end in good order (see `runtimeStopLeavesCommands`). Never rejects.
+   */
+  async function releaseRuntimeTree(tree, reason) {
+    if (!tree) return;
+    if (!runtimeStopLeavesCommands(reason)) {
+      tree.close();
+      return;
+    }
+    await tree.stop(reason);
+  }
+
   async function ensureClient() {
+    while (runtimeStopping) await runtimeStopping;
     if (client) return client;
     if (starting) return starting;
     starting = (async () => {
@@ -2095,6 +2400,7 @@ export function createCopilotSdkSessionRunner({
       const started = await startClientImpl({ paths: sdkPaths, cwd, clientName, logLevel, dbg });
       client = started.client;
       detachRuntimeExit = observeRuntimeExit(client, handleRuntimeExit);
+      runtimeTree = watchRuntimeTree(client);
       // Diagnostics only, and deliberately not awaited — see startCopilotClient.
       Promise.resolve(started.versionReady)
         .then((info) => {
@@ -2166,14 +2472,43 @@ export function createCopilotSdkSessionRunner({
     modelSwitch.reset();
     // Disconnect first so the runtime is not holding two handles on one
     // session id while the resume runs.
-    try { await closing?.disconnect?.(); } catch (error) {
-      dbg('session disconnect before model switch failed', error?.message || String(error));
-    }
-    return ensureSession(model, effort);
+    const detached = await withTimeout(
+      Promise.resolve().then(() => closing?.disconnect?.()).then(() => true, (error) => {
+        dbg('session disconnect before model switch failed', error?.message || String(error));
+        return true;
+      }),
+      runtimeDetachTimeoutMs,
+      false,
+    );
+    if (!detached) dbg(`session disconnect before model switch did not answer within ${runtimeDetachTimeoutMs}ms`);
+    return openSessionOnce(model, effort);
   }
 
+  /**
+   * One session open at a time. A turn can end before its bring-up does (the
+   * stall watchdog, a Stop), and the open it started goes on without it; the
+   * next turn must wait for that one rather than issue a second resume of the
+   * same session id on the same client.
+   */
   async function ensureSession(model, effort) {
+    while (opening) await opening.catch(() => {});
+    if (session) return applySelection(model, effort);
+    return openSessionOnce(model, effort);
+  }
+
+  async function openSessionOnce(model, effort) {
+    const open = openFreshSession(model, effort);
+    opening = open;
+    try {
+      return await open;
+    } finally {
+      if (opening === open) opening = null;
+    }
+  }
+
+  async function openFreshSession(model, effort) {
     await ensureClient();
+    liveTurnTraffic('client-ready');
     if (!session) {
       // The tool list is part of the session: wait for the worker's first
       // registration answer (bounded, and it fails closed).
@@ -2186,8 +2521,16 @@ export function createCopilotSdkSessionRunner({
       // deliberately not cached: once `createSession` succeeds, the state
       // exists and the NEXT reconnect must resume it.
       let resumed = false;
+      const generation = runtimeGeneration;
+      // The turn this session was being opened for can end first (the stall
+      // watchdog, a Stop), and its failure stops the runtime.
+      const adopt = (opened) => {
+        if (generation === runtimeGeneration) return opened;
+        Promise.resolve().then(() => opened?.disconnect?.()).catch(() => {});
+        throw new Error('the Copilot runtime was stopped while its session was opening');
+      };
       try {
-        session = await openSession((cfg) => client.resumeSession(sdkSessionId, cfg), config);
+        session = adopt(await openSession((cfg) => client.resumeSession(sdkSessionId, cfg), config));
         resumed = true;
         dbg(`resumed copilot session ${sdkSessionId.slice(0, 8)}`);
       } catch (error) {
@@ -2196,14 +2539,15 @@ export function createCopilotSdkSessionRunner({
         // transient, and starting fresh over live state would silently throw
         // the conversation's whole history away — so it fails the turn
         // instead, which is retryable and loses nothing.
-        if (!isSessionNotFoundError(error)) {
+        if (!isSessionNotFoundError(error) || generation !== runtimeGeneration) {
           dbg('copilot session resume failed transiently', error?.message || String(error));
           throw error;
         }
         dbg('copilot session state not found, creating', error?.message || String(error));
-        session = await openSession((cfg) => client.createSession(cfg), config);
+        session = adopt(await openSession((cfg) => client.createSession(cfg), config));
         dbg(`created copilot session ${sdkSessionId.slice(0, 8)}`);
       }
+      liveTurnTraffic('session-open');
       // Which experimental surfaces THIS runtime has (it auto-updates under
       // the relay): decides un-steer and the targeted Stop for the session.
       probeSessionRpc(session);
@@ -2243,6 +2587,7 @@ export function createCopilotSdkSessionRunner({
   }
 
   async function stopRuntime(reason) {
+    runtimeGeneration += 1;
     stopLifecycleTimer();
     // The next session is built from a fresh registration answer.
     void remoteRelayGate.refresh();
@@ -2250,8 +2595,10 @@ export function createCopilotSdkSessionRunner({
     detachRuntimeExit = () => {};
     const closingSession = session;
     const closingClient = client;
+    const closingTree = runtimeTree;
     session = null;
     client = null;
+    runtimeTree = null;
     modelSwitch.reset();
     // Detached shells are children of the runtime process, so stopping it ends
     // them: the tracked set is state about a process that no longer exists and
@@ -2281,17 +2628,86 @@ export function createCopilotSdkSessionRunner({
     waitingSteers = 0;
     queuedItemCount = 0;
     steerSendsInFlight = 0;
+    taskRefreshFailures = 0;
+    taskRefreshInFlight = false;
+    // A removal this runtime never answered must not hold the next runtime's.
+    unsteerChain = Promise.resolve();
     sessionRpc = { queue: false, interruptMainTurn: false, tasks: false };
     askUserOverrideRejected = false;
     syncDeliveryReadiness();
-    if (!closingSession && !closingClient) return;
+    if (!closingSession && !closingClient) {
+      // Nothing of its own to close, but a caller that asked for a stopped
+      // runtime (the worker's shutdown) gets one.
+      closingTree?.close();
+      if (runtimeStopping) await runtimeStopping;
+      return;
+    }
     dbg(`stopping the copilot runtime (${reason})`);
-    try { await closingSession?.disconnect?.(); } catch (error) {
-      dbg('session disconnect failed', error?.message || String(error));
+    // Read before the runtime is told to stop, in this very tick: what is
+    // running now is what the failure note names (`turn.fail`), and a runtime
+    // that has to be killed leaves it behind.
+    const leavesCommands = !!closingTree && runtimeStopLeavesCommands(reason);
+    if (leavesCommands) void closingTree.snapshot();
+    const previous = runtimeStopping;
+    const closing = (async () => {
+      if (previous) await previous;
+      // A runtime that has already ended stops nothing any more, and the
+      // teardown below still waits out its windows on a connection that has
+      // nobody behind it (10 s, measured): its commands are stopped at once.
+      const early = leavesCommands
+        ? closingTree.runtimeEnded().then((ended) => (ended ? closingTree.stop(reason) : null))
+        : null;
+      await closeRuntime(closingSession, closingClient, closingTree);
+      await early;
+      // Part of the teardown the next runtime waits for: a command of the old
+      // one must not still be writing into the workspace the new one works in.
+      await releaseRuntimeTree(closingTree, reason);
+    })();
+    runtimeStopping = closing;
+    try {
+      await closing;
+    } finally {
+      if (runtimeStopping === closing) runtimeStopping = null;
+    }
+  }
+
+  /**
+   * Close a runtime whose handles were already dropped. Every step is bounded:
+   * the callers are the failure paths, where the runtime is the thing that
+   * stopped answering. Never rejects.
+   */
+  async function closeRuntime(closingSession, closingClient, closingTree = null) {
+    const startedAt = Date.now();
+    const bounded = (work, ms) => withTimeout(
+      Promise.resolve().then(work).then((value) => {
+        // `client.stop()` reports what it could not close instead of throwing.
+        for (const error of Array.isArray(value) ? value : []) dbg('runtime stop reported', error?.message || String(error));
+        return 'done';
+      }, (error) => error),
+      ms,
+      'timeout',
+    );
+    if (closingSession?.disconnect) {
+      const detached = await bounded(() => closingSession.disconnect(), runtimeDetachTimeoutMs);
+      if (detached === 'timeout') dbg(`session disconnect did not answer within ${runtimeDetachTimeoutMs}ms; stopping the runtime without it`);
+      else if (detached !== 'done') dbg('session disconnect failed', detached?.message || String(detached));
     }
-    try { await closingClient?.stop?.(); } catch (error) {
-      dbg('client stop failed', error?.message || String(error));
+    if (closingClient?.stop) {
+      const stopped = await bounded(() => closingClient.stop(), runtimeStopTimeoutMs);
+      if (stopped === 'timeout') {
+        dbg(`client stop did not finish within ${runtimeStopTimeoutMs}ms; killing the runtime`);
+        // The last moment the runtime's commands can be told from anybody
+        // else's: a killed runtime leaves them to pid 1.
+        if (closingTree) await closingTree.snapshot();
+        const killed = closingClient.forceStop
+          ? await bounded(() => closingClient.forceStop(), runtimeDetachTimeoutMs)
+          : 'done';
+        if (killed !== 'done') dbg('runtime kill did not finish', killed === 'timeout' ? 'timeout' : killed?.message || String(killed));
+      } else if (stopped !== 'done') {
+        dbg('client stop failed', stopped?.message || String(stopped));
+      }
     }
+    dbg(`copilot runtime stopped after ${Date.now() - startedAt}ms`);
   }
 
   // -------------------------------------------------------------- lifecycle --
@@ -2335,8 +2751,23 @@ export function createCopilotSdkSessionRunner({
       // re-read once per lifecycle poll catches state the events miss (a
       // shell that exited after a cancel emits no notification).
       const capMs = Number(getBackgroundTaskTimeoutMs()) || 0;
+      if (taskRefreshFailures >= MAX_TASK_REFRESH_FAILURES && backgroundTasks.size) {
+        // The runtime has not answered for its tasks for that many reads in a
+        // row: the set is what it was when it last did, and holds nothing.
+        dbg('the task registry cannot be read; its last answer no longer holds the runtime');
+        backgroundTasks = new Map();
+        publishBackgroundTasks({ immediate: true });
+      }
       const live = runningBackgroundTasks();
-      if (!live.length) return false;
+      if (!live.length) {
+        // Nothing live as far as the last read that worked. While a read is
+        // due or under way, or reads fail, that is not known: read again, and
+        // hold the runtime meanwhile.
+        if (taskRefreshTimer || taskRefreshQueued > 0 || taskRefreshInFlight) return true;
+        if (!taskRefreshFailures || taskRefreshFailures >= MAX_TASK_REFRESH_FAILURES) return false;
+        if (now - lastTaskRefreshAt >= lifecyclePollMs) scheduleTaskRefresh();
+        return true;
+      }
       if (capMs > 0) {
         for (const task of live) {
           const startedAt = Date.parse(String(task.startedAt || '')) || agentDetails.get(task.id)?.startedAt || 0;
@@ -2488,6 +2919,19 @@ export function createCopilotSdkSessionRunner({
       // The row the user pressed Stop on (from the abort control), when known.
       abortedRowId: null,
       stallTimer: null,
+      stallChecking: false,
+      liveness: createTurnLiveness({ windows: stallWindows }),
+      // The runtime teardown a failure started (see `fail`).
+      teardown: null,
+      // Until when a continuation's registration may still get its row from a
+      // relay it cannot reach (0: it is not in that state).
+      registrationDeadline: 0,
+      // Tool calls this turn started, whichever agent made them. Told in the
+      // failure note when the turn fails.
+      toolCalls: 0,
+      // What the runtime had running when the turn failed (a promise of the
+      // tree watch's read), for the failure note.
+      commandsLeft: null,
       planBoardPosted: false,
       // Set when a mutating tool was actually approved and run this turn.
       acted: false,
@@ -2596,6 +3040,41 @@ export function createCopilotSdkSessionRunner({
       if (turn.settled) return;
       turn.settled = true;
       turn.disarmStall();
+      // A delivered turn that failed (a stall, a runtime death, a setup
+      // failure) leaves a runtime nothing else can use. The teardown drops the
+      // handles in this very tick, before the turn gives up the event stream
+      // and the worker reads as ready again, so the next delivery rebuilds
+      // instead of sending into it. It is awaited only after the failure is
+      // published (driveTurn): a runtime that stopped answering also takes
+      // its time to stop, and the user waited three minutes for a failure
+      // that was already decided (2026-09-27).
+      //
+      // An UNCONFIRMED MODEL SWITCH is the exception: the session is healthy
+      // and merely still on its previous model, and tearing the runtime down
+      // over it would kill any live background work for a selection problem
+      // the user fixes by picking another model.
+      //
+      // A turn the runtime opened by itself keeps its runtime through a
+      // failure, because the background work that opened it may still be
+      // running there — unless the runtime itself is what went: it exited, or
+      // it no longer answers. Those handles served nobody, and the next
+      // message failed on them.
+      const runtimeGone = error?.runtimeGone === true || error?.stall?.unresponsive === true;
+      if ((turn.kind === 'delivered' || runtimeGone) && !isModelSwitchUnconfirmedError(error)) {
+        if (session || client) {
+          const tree = runtimeTree;
+          turn.teardown = stopRuntime(runtimeGone ? 'runtime-gone' : 'turn-failure').catch(() => {});
+          // What the runtime had running, as far as it is known now
+          // (`stopRuntime` has just read the list where that takes no time):
+          // the failure note is published before the teardown ends, and says
+          // what is being stopped.
+          turn.commandsLeft = tree ? tree.commandCount() : 0;
+        } else {
+          // Nothing to stop yet: the runtime was still starting. What it opens
+          // for this turn from here on is let go rather than adopted.
+          runtimeGeneration += 1;
+        }
+      }
       beginPublishing(turn);
       turn.resolvePrimaryReady();
       syncDeliveryReadiness();
@@ -2606,29 +3085,83 @@ export function createCopilotSdkSessionRunner({
       clearTimeout(turn.stallTimer);
       turn.stallTimer = null;
     };
+    // The window restarts: the turn opens, or a hold on it ends.
     turn.armStall = () => {
-      if (!(turnStallTimeoutMs > 0) || turn.settled) return;
-      turn.disarmStall();
-      turn.stallTimer = setTimeout(() => {
-        // A human staring at a question card is not a stalled runtime. Re-arm
-        // rather than fail: the card has its own (much longer) timeout, and
-        // failing the row here would settle it while the answer is still coming.
-        // A remote_relay call waiting on another relay is the same kind of
-        // silence; the relay bounds that wait itself.
-        if (pendingHumanRequests > 0 || pendingRelayToolCalls > 0) {
-          turn.armStall();
-          return;
-        }
-        turn.fail(new Error(
-          `copilot worker watchdog: the runtime produced no events for ${Math.round(turnStallTimeoutMs / 1000)}s; `
-          + 'the row is failed — resend the message to retry',
-        ));
-      }, turnStallTimeoutMs);
-      turn.stallTimer.unref?.();
+      if (!(stallWindows.idle > 0) || turn.settled) return;
+      turn.liveness.traffic('armed');
+      // A check in progress schedules the next one itself.
+      if (!turn.stallTimer && !turn.stallChecking) scheduleStallCheck(turn, turn.liveness.check().waitMs);
     };
     return turn;
   }
 
+  /**
+   * The stall watchdog. One timer per turn, never re-armed by traffic: an
+   * event only moves the turn's clock, and a check that comes early looks
+   * again when the window is due (a model request emits thousands of deltas).
+   */
+  function scheduleStallCheck(turn, waitMs) {
+    turn.stallTimer = setTimeout(() => {
+      turn.stallTimer = null;
+      turn.stallChecking = true;
+      void checkStall(turn)
+        .catch((error) => { dbg('stall check failed', error?.message || String(error)); })
+        .finally(() => {
+          turn.stallChecking = false;
+          // A check that ended without deciding (it threw) must not be the last.
+          if (!turn.settled && !turn.stallTimer) scheduleStallCheck(turn, turn.liveness.check().waitMs || stallWindows.idle);
+        });
+    }, Math.max(1, waitMs));
+    turn.stallTimer.unref?.();
+  }
+
+  async function checkStall(turn) {
+    if (turn.settled) return;
+    // A human staring at a question card is not a stalled runtime: the card
+    // has its own (much longer) timeout, and failing the row here would
+    // settle it while the answer is still coming. A remote_relay call waiting
+    // on another relay is the same kind of silence; the relay bounds that
+    // wait itself. So is a compaction, bounded by its stale cap, and the wait
+    // for the previous runtime to stop, bounded by the teardown's own limits.
+    if (pendingHumanRequests > 0 || pendingRelayToolCalls > 0 || isCompacting() || runtimeStopping) {
+      turn.liveness.traffic('held');
+      scheduleStallCheck(turn, turn.liveness.check().waitMs);
+      return;
+    }
+    let verdict = turn.liveness.check();
+    let unresponsive = false;
+    if (!verdict.stalled && verdict.quietMs >= stallWindows.idle) {
+      // Quiet for longer than a runtime with nothing to do may be, and kept
+      // only because a tool or a model request is in flight. That is worth
+      // one question: is the runtime still there?
+      const probing = client;
+      const ask = () => probeRuntime(
+        typeof probing?.ping === 'function' ? () => probing.ping('stall-check') : null,
+        stallProbeTimeoutMs,
+      );
+      let answer = await ask();
+      // Asked twice before a turn with minutes left is given up: one ping
+      // that came at a bad moment is not a runtime that is gone.
+      if (answer === 'gone' && !turn.settled) answer = await ask();
+      if (turn.settled) return;
+      verdict = turn.liveness.check();
+      unresponsive = answer === 'gone' && verdict.quietMs >= stallWindows.idle;
+      if (!unresponsive && !verdict.stalled) dbg('turn is quiet, the runtime answers; keeping it', turn.liveness.describe());
+    }
+    if (!verdict.stalled && !unresponsive) {
+      scheduleStallCheck(turn, verdict.waitMs);
+      return;
+    }
+    dbg(`turn stalled${unresponsive ? ' (runtime not answering)' : ''}`, turn.liveness.describe());
+    turn.fail(createTurnStalledError({
+      agentLabel: SETTLE_AGENT_LABEL,
+      quietMs: verdict.quietMs,
+      phase: verdict.phase,
+      tools: turn.liveness.toolsInFlight(),
+      unresponsive,
+    }));
+  }
+
   // ----------------------------------------------------- prompt boundaries --
 
   function claimSegment(turn, index, owner) {
@@ -2754,6 +3287,21 @@ export function createCopilotSdkSessionRunner({
       .catch((error) => { dbg('silent continuation drop failed', entry.message.id, error?.message || String(error)); });
   }
 
+  /**
+   * A row whose run is over and whose outcome reached the relay neither as a
+   * response nor as a requeue. Releasing it as it is would leave it to the
+   * relay's recovery, which runs the prompt again or fails it as a blocked
+   * replay, whichever it finds. It is handed to the heartbeat instead, to be
+   * failed with a note that says what happened: the run is not repeated.
+   */
+  function noteResponseOutcome(message, outcome, variant = 'replyLost') {
+    const id = String(message?.id || '').trim();
+    if (outcome !== 'failed' || !id) return;
+    dbg('the outcome could not be saved or requeued; handing the row to the heartbeat', id, variant);
+    claimSettling(message, variant);
+    settleFailedTerminals.set(id, buildSteerSettleFailure(message, { variant, agentLabel: SETTLE_AGENT_LABEL }));
+  }
+
   /**
    * Decide and publish one row's outcome. Idempotent per entry. A run owner's
    * settle also settles the steers folded into its run (they were answered by
@@ -2782,11 +3330,11 @@ export function createCopilotSdkSessionRunner({
             await publishPlanBoard(turn, text, 'plan-mode-fallback');
           }
           await publishFinalStream(entry.message, published);
-          await publishResponse(entry.message, {
+          noteResponseOutcome(entry.message, await publishResponse(entry.message, {
             text: published,
             model,
             consumedSteerIds: folded.map((other) => other.message),
-          });
+          }));
           break;
         }
         case 'aborted-by-user': {
@@ -2825,23 +3373,38 @@ export function createCopilotSdkSessionRunner({
           const own = finalTextFor(turn, entry, turn.result);
           const text = own ? `${own}\n\n${RUNTIME_INTERRUPTED_NOTE}` : RUNTIME_INTERRUPTED_NOTE;
           await publishFinalStream(entry.message, text);
-          await publishResponse(entry.message, { text, model, consumedSteerIds: folded.map((other) => other.message) });
+          noteResponseOutcome(
+            entry.message,
+            await publishResponse(entry.message, { text, model, consumedSteerIds: folded.map((other) => other.message) }),
+          );
           break;
         }
         case 'error': {
           const { classified } = outcome;
-          await publishFinalStream(entry.message, entry.state.lastStreamedText);
-          await publishResponse(entry.message, {
-            text: classified.text,
+          const written = finalTextFor(turn, entry, turn.result);
+          const terminalError = terminalErrorRecord(entry.message, classified, {
+            toolCalls: turn.toolCalls,
+            commandsLeft: commandsLeftRunning(turn),
+          });
+          await publishFinalStream(entry.message, written || entry.state.lastStreamedText);
+          noteResponseOutcome(entry.message, await publishResponse(entry.message, {
+            text: terminalError.message,
             model,
-            terminalError: terminalErrorRecord(entry.message, classified),
+            terminalError,
+            partialText: written,
             consumedSteerIds: folded.map((other) => other.message),
-          });
+          }), 'failureLost');
           break;
         }
         case 'folded':
           await publishSettleMarker(entry.message, { text: STEER_FOLDED_TEXT, model, kind: 'folded', variant: 'folded' });
           break;
+        case 'failed-with-turn':
+          // The runtime had taken this steer into a run that failed. The
+          // failure is told on that run's reply; this row only says where to
+          // look, and offers Resend like the steer of a stopped turn.
+          await publishSettleMarker(entry.message, { text: STEER_TURN_FAILED_TEXT, model, kind: 'stopped', variant: 'turnFailed' });
+          break;
         case 'stopped':
           await publishSettleMarker(entry.message, { text: STEER_STOPPED_TEXT, model, kind: 'stopped', variant: 'stopped' });
           break;
@@ -2850,7 +3413,11 @@ export function createCopilotSdkSessionRunner({
           // it will be answered at the start of the next interaction — a
           // requeue would run it twice.
           await publishFinalStream(entry.message, STEERED_ROW_MERGED_NOTE);
-          await publishResponse(entry.message, { text: STEERED_ROW_MERGED_NOTE, model });
+          noteResponseOutcome(
+            entry.message,
+            await publishResponse(entry.message, { text: STEERED_ROW_MERGED_NOTE, model, requeueOnFailure: false }),
+            'folded',
+          );
           break;
         case 'cancelled':
         case 'discarded':
@@ -2866,7 +3433,7 @@ export function createCopilotSdkSessionRunner({
     for (const other of folded) {
       const foldOutcome = outcome.type === 'completed' || outcome.type === 'merged-note'
         ? { type: 'folded' }
-        : outcome.type === 'error' ? outcome : { type: 'stopped' };
+        : outcome.type === 'error' ? { type: 'failed-with-turn' } : { type: 'stopped' };
       await settleEntry(turn, other, foldOutcome);
     }
   }
@@ -2879,7 +3446,8 @@ export function createCopilotSdkSessionRunner({
       const itemId = queuedLane.get(entry.runtimeId);
       if (!itemId) continue;
       try {
-        await session.rpc.queue.removeAt({ id: itemId });
+        const target = session;
+        await askRuntime('queue.removeAt', () => target.rpc.queue.removeAt({ id: itemId }));
         dbg('removed a stopped prompt from the runtime queue', entry.message.id);
       } catch (error) {
         dbg('queue.removeAt after Stop failed', entry.message.id, error?.message || String(error));
@@ -2917,21 +3485,36 @@ export function createCopilotSdkSessionRunner({
     const pending = turn.entries.filter((entry) => !entry.settled && entry.turn === turn);
     if (!pending.length) return;
 
-    if (failure) {
+    // A turn the user stopped ends as stopped, whatever happened to it
+    // afterwards: a runtime that died or went silent under a Stop used to put
+    // the watchdog's failure on every row instead.
+    if (failure && !turn.aborted) {
       const classified = classifyCopilotTurnException(failure);
       dbg('copilot turn failed', turn.message?.id || '(continuation)', classified.detail);
+      const running = turn.currentOwner || turn.primaryEntry;
       for (const entry of pending) {
         if (entry.settled) continue;
-        await settleEntry(turn, entry, { type: 'error', classified });
+        // The failure is told once, on the row whose run it ended. A message
+        // pushed into the turn gets the marker, whether the runtime had
+        // folded it in (settled with its run's row) or never started it.
+        const ownsRun = entry === running || entry.role !== 'steer' || (entry.consumed && !entry.foldedInto);
+        // A steer whose `send()` has not come back never reached the runtime
+        // as far as anyone knows. Its send is about to fail on the teardown
+        // and requeues the row from there; a marker now would end a message
+        // that can simply be delivered again.
+        if (!ownsRun && !entry.runtimeId && !entry.consumed) continue;
+        await settleEntry(turn, entry, ownsRun ? { type: 'error', classified } : { type: 'failed-with-turn' });
       }
       return;
     }
     if (result?.isError) {
       const classified = classifyCopilotSessionError(result.errorData || { message: result.errorMessage });
       dbg('turn failed', turn.message?.id || '(continuation)', classified.stableCode);
+      const running = turn.currentOwner || turn.primaryEntry;
       for (const entry of pending) {
         if (entry.settled) continue;
-        await settleEntry(turn, entry, { type: 'error', classified });
+        const ownsRun = entry === running || entry.role !== 'steer' || (entry.consumed && !entry.foldedInto);
+        await settleEntry(turn, entry, ownsRun ? { type: 'error', classified } : { type: 'failed-with-turn' });
       }
       return;
     }
@@ -3084,24 +3667,62 @@ export function createCopilotSdkSessionRunner({
     // and stops waiting on the remote, and the watchdog hold is released.
     turn.remoteRelayStop?.abort();
     // While `ensureSession` is still connecting there is no session to abort
-    // and this would be a silent no-op; `runTurn` re-checks `turn.aborted`
-    // once the session exists and settles there instead.
-    if (!session) return;
+    // and no prompt was sent: the turn settles here, as stopped, and `runTurn`
+    // sends nothing once the session exists. Waiting for the session instead
+    // left the Stop without effect for as long as the runtime took to answer.
+    if (!session) {
+      if (!turn.primarySent) {
+        dbg('turn stopped before its session was ready', turn.message?.id || '');
+        turn.settle();
+      }
+      return;
+    }
+    // Both requests are bounded. A Stop is what the user reaches for when a
+    // turn is stuck, and a runtime that is stuck does not answer it either:
+    // the Stop then did nothing until the stall watchdog failed the turn.
+    const target = session;
+    const unanswered = Symbol('unanswered');
+    const bounded = (request) => withTimeout(Promise.resolve().then(request), runtimeRpcTimeoutMs, unanswered);
+    let answered = true;
     if (sessionRpc.interruptMainTurn) {
       try {
-        const outcome = await session.rpc.interruptMainTurn({ flushQueued: false });
-        if (outcome?.interrupted === false) {
-          // Nothing was processing: no aborted idle will come. The turn is
-          // over as far as the runtime is concerned.
-          dbg('interruptMainTurn found no main turn in flight; settling locally', turn.message?.id || '');
-          turn.settle();
+        const outcome = await bounded(() => target.rpc.interruptMainTurn({ flushQueued: false }));
+        if (outcome !== unanswered) {
+          if (outcome?.interrupted === false) {
+            // Nothing was processing: no aborted idle will come. The turn is
+            // over as far as the runtime is concerned.
+            dbg('interruptMainTurn found no main turn in flight; settling locally', turn.message?.id || '');
+            turn.settle();
+          }
+          return;
         }
-        return;
+        answered = false;
       } catch (error) {
         dbg('interruptMainTurn failed; falling back to abort()', error?.message || String(error));
       }
     }
-    await session.abort?.();
+    if (answered) {
+      // A rejection is an answer of a kind the turn cannot use either: the
+      // connection is gone (the runtime exited, or a teardown disposed it).
+      // Thrown on from here, it reached the relay as a Stop that failed, and
+      // the row was settled by nobody.
+      answered = (await bounded(async () => { await target.abort?.(); }).catch((error) => {
+        dbg('abort() failed', error?.message || String(error));
+        return unanswered;
+      })) !== unanswered;
+    }
+    if (answered || turn.settled) return;
+    // No aborted idle is coming from a runtime that does not take the
+    // request. The turn ends here, as stopped (finishTurn), and the runtime
+    // goes with it.
+    dbg('the runtime did not answer the Stop; ending the turn without it', turn.message?.id || '');
+    turn.fail(createTurnStalledError({
+      agentLabel: SETTLE_AGENT_LABEL,
+      quietMs: turn.liveness.quietMs(),
+      phase: turn.liveness.phase(),
+      tools: turn.liveness.toolsInFlight(),
+      unresponsive: true,
+    }));
   }
 
   /**
@@ -3134,8 +3755,23 @@ export function createCopilotSdkSessionRunner({
     }) || null;
     turn.drive = driveTurn(turn);
     try {
-      await ensureSession(model, effort);
-      if (turn.aborted) {
+      // The watchdog covers the bring-up as well. None of the requests that
+      // open a session (resume, create, the model switch) has a timeout in
+      // the SDK, and a runtime that never answered one held the row in
+      // `processing` with no turn to fail and nothing for a Stop to stop.
+      turn.armStall();
+      const settledFirst = Symbol('turn-settled');
+      const building = ensureSession(model, effort);
+      // Still observed when the turn ends first and nothing awaits it.
+      building.catch(() => {});
+      const built = await Promise.race([
+        building,
+        turn.done.then(() => settledFirst, () => settledFirst),
+      ]);
+      if (built === settledFirst) {
+        // Failed or stopped while the session was being built; nothing is sent.
+        dbg('turn ended before its session was ready', message.id);
+      } else if (turn.aborted) {
         // The abort landed while the session was still being built. Nothing
         // was sent, so there is no runtime turn to interrupt — settle locally
         // rather than sending a prompt the user just cancelled.
@@ -3161,7 +3797,6 @@ export function createCopilotSdkSessionRunner({
         // A send that never resolves (a wedged runtime) must not hold this
         // delivery hostage once the watchdog has failed the turn: the id is
         // still recorded if it ever arrives, but the wait ends with the turn.
-        const settledFirst = Symbol('turn-settled');
         const runtimeId = await Promise.race([
           sending,
           turn.done.then(() => settledFirst, () => settledFirst),
@@ -3182,16 +3817,8 @@ export function createCopilotSdkSessionRunner({
         }
       }
     } catch (error) {
-      // A failure that killed the session (or came from starting it) leaves a
-      // handle nothing else can use; drop it so the next delivery rebuilds and
-      // resumes rather than sending into a dead runtime. An UNCONFIRMED MODEL
-      // SWITCH is the exception: the session is healthy and merely still on
-      // its previous model, and tearing the runtime down over it would kill
-      // any live background work for a selection problem the user fixes by
-      // picking another model.
-      if (!isModelSwitchUnconfirmedError(error)) {
-        await stopRuntime('turn-failure').catch(() => {});
-      }
+      // A failure that killed the session (or came from starting it); the
+      // turn's own `fail` drops the handles nothing else can use.
       turn.fail(error);
     }
     // `send()` resolving is NOT the turn's completion; the event stream is.
@@ -3237,11 +3864,6 @@ export function createCopilotSdkSessionRunner({
     if (!turn.aborted && !turn.failure && turn.humanRequests > 0) await turn.humansIdle;
     try {
       await quiesceTurn(turn);
-      if (turn.failure && turn.kind === 'delivered' && !isModelSwitchUnconfirmedError(turn.failure) && session) {
-        // A stall or a runtime death mid-turn (a setup failure already tore
-        // the runtime down in runTurn).
-        await stopRuntime('turn-failure').catch(() => {});
-      }
       if (turn.kind === 'continuation') {
         // Nothing can be published before the row exists. The buffer is
         // drained by the registration itself; this only covers actions that
@@ -3274,6 +3896,8 @@ export function createCopilotSdkSessionRunner({
       // Early settles still in flight must land before the rows stop being
       // reported (settleEntry never rejects, but this is the ordering guard).
       await Promise.allSettled(turn.settlePromises);
+      // The rows are settled; the runner is quiescent once the runtime is gone.
+      if (turn.teardown) await turn.teardown;
       controlPoller?.stop?.(turn.controlState);
       turn.controlState = null;
       // Every path through the turn — published, failed, aborted, threw — has
@@ -3451,25 +4075,54 @@ export function createCopilotSdkSessionRunner({
     const signal = turn.registrationAbort?.signal || null;
     const abandoned = () => turn.discarded || signal?.aborted === true;
     let response = null;
-    for (let attempt = 0; attempt < 3 && !response?.messageId; attempt += 1) {
+    // Two ways of not getting a row, counted apart. The relay ANSWERED without
+    // one (it refused, or sent an empty body): three attempts, as ever. The
+    // relay could not be REACHED (it is restarting): the attempts go on, spaced
+    // further apart, for the outage window — the turn's output is buffered
+    // meanwhile and nothing else can tell the user what the runtime did.
+    let refusals = 0;
+    let outageSince = 0;
+    let outageDelayMs = continuationRetryDelayMs;
+    while (!response?.messageId) {
       if (abandoned()) return;
+      let failure = null;
+      // The drive path waits at least as long as the request in flight may
+      // take: a relay that took the connection and is slow to answer is not
+      // one that refused.
+      if (continuationOutageWindowMs > 0) {
+        turn.registrationDeadline = Math.max(turn.registrationDeadline || 0, Date.now() + continuationRequestTimeoutMs);
+      }
       response = await api('POST', '/api/continuation-turn', {
         conversationId: sdkSessionId,
         sdkSessionId,
         relayMode: turn.message.relayMode,
         trigger: CONTINUATION_TRIGGER,
         operationId,
-      }).catch((error) => {
+      }, continuationRequestTimeoutMs > 0 ? { signal: AbortSignal.timeout(continuationRequestTimeoutMs) } : {}).catch((error) => {
+        failure = error;
         dbg('continuation turn registration failed', error?.message || String(error));
         return null;
       });
-      if (!response?.messageId) {
-        if (abandoned()) return;
-        await new Promise((resolve) => { setTimeout(resolve, continuationRetryDelayMs); });
+      if (response?.messageId) break;
+      if (abandoned()) return;
+      if (failure && continuationOutageWindowMs > 0 && isTransientRelayError(failure)) {
+        outageSince = outageSince || Date.now();
+        if (Date.now() - outageSince >= continuationOutageWindowMs) break;
+        // The drive path waits for as long as this loop may still succeed.
+        turn.registrationDeadline = outageSince + continuationOutageWindowMs + continuationRequestTimeoutMs;
+        await sleep(outageDelayMs);
+        outageDelayMs = Math.min(outageDelayMs * 2, 8_000);
+        continue;
       }
+      refusals += 1;
+      if (refusals >= 3) break;
+      await sleep(continuationRetryDelayMs);
     }
+    turn.registrationDeadline = 0;
     if (!response?.messageId) {
-      abandonContinuationRegistration(turn, 'no relay message id after 3 attempts');
+      abandonContinuationRegistration(turn, outageSince && refusals < 3
+        ? `the relay could not be reached for ${Math.round((Date.now() - outageSince) / 1000)}s`
+        : 'no relay message id after 3 attempts');
       return;
     }
     const messageId = String(response.messageId);
@@ -3518,17 +4171,24 @@ export function createCopilotSdkSessionRunner({
    */
   async function awaitContinuationRow(turn, timeoutMs = continuationRegistrationTimeoutMs) {
     if (turn.registered || turn.discarded) return;
-    let timer = null;
-    const expired = new Promise((resolve) => {
-      timer = setTimeout(() => resolve('expired'), timeoutMs);
-      timer.unref?.();
-    });
-    // `turn.registration` is the caught chain and never rejects.
-    const outcome = await Promise.race([turn.registration || Promise.resolve(), expired]);
-    clearTimeout(timer);
-    if (outcome === 'expired' && !turn.registered && !turn.message.id) {
-      abandonContinuationRegistration(turn, 'registration outlived the local deadline');
+    let waitMs = timeoutMs;
+    while (true) {
+      let timer = null;
+      const expired = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('expired'), waitMs);
+        timer.unref?.();
+      });
+      // `turn.registration` is the caught chain and never rejects.
+      const outcome = await Promise.race([turn.registration || Promise.resolve(), expired]);
+      clearTimeout(timer);
+      if (outcome !== 'expired' || turn.registered || turn.message.id) return;
+      // Still trying against a relay that cannot be reached: the deadline is
+      // the registration's own, not this wait's.
+      const remainingMs = (turn.registrationDeadline || 0) - Date.now();
+      if (remainingMs <= 0) break;
+      waitMs = remainingMs;
     }
+    abandonContinuationRegistration(turn, 'registration outlived the local deadline');
   }
 
   // --------------------------------------------------------------- steering --
@@ -3564,6 +4224,11 @@ export function createCopilotSdkSessionRunner({
       dbg('turn settled while steering was preparing; running it as a fresh turn', message.id);
       return NOT_STEERED;
     }
+    // The same for a tool that started meanwhile: the message goes back to
+    // the queue and comes again when the tool has ended.
+    if (mainToolsInFlight(turn).length > 0 && canHandBackHeldDelivery() !== false) {
+      return handBackHeldDelivery(message);
+    }
     const entry = createEntry(turn, message, 'steer');
     dbg('steering a mid-turn delivery into the running turn', message.id);
     let runtimeId;
@@ -3611,7 +4276,8 @@ export function createCopilotSdkSessionRunner({
    * would settle the continuation's reply against no row while its buffered
    * output flushed into the steered one); a question card, ask-mode approval
    * or elicitation is open (the relay must not push past a card); a
-   * compaction is running.
+   * compaction is running; a tool of the main agent is running (see
+   * mainToolsInFlight).
    */
   function canAcceptSteering() {
     if (disposed || !session) return false;
@@ -3620,9 +4286,60 @@ export function createCopilotSdkSessionRunner({
     if (!turn.primarySent || awaitingRow(turn)) return false;
     if (pendingHumanRequests > 0) return false;
     if (isCompacting()) return false;
+    if (mainToolsInFlight(turn).length > 0) return false;
     return true;
   }
 
+  /**
+   * The tool hold: the names of the tools the MAIN agent of this turn has
+   * started and not finished. While there is one, nothing is steered in.
+   *
+   * The runtime answers a steer that arrives while it waits for a foreground
+   * shell command by ending the tool call ("moved to background by the user")
+   * and asking the model again. Seen live twice (2026-09-29): the turn then
+   * ended with the answer to the steer alone, or failed on an empty reply
+   * ("No response was returned"), and the command's result came later in a
+   * continuation. Held back until the tool boundary, the steer lands where
+   * the runtime would have injected it anyway and the command is left alone.
+   *
+   * There is no time limit on purpose: steering in after a wait would be the
+   * same interruption, only later. A held message shows as queued, and the
+   * end of the turn releases it like every other hold.
+   *
+   * Not counted:
+   *  - tools of subagents (their events carry an `agentId`). A background
+   *    agent works beside the main turn and for much longer; the main agent
+   *    is not waiting for its tools, so a steer interrupts nothing. A
+   *    subagent the main agent runs in the foreground is covered by the main
+   *    agent's own tool call that started it.
+   *  - `remote_relay`, which holds the stall watchdog but never held steering
+   *    (see `pendingRelayToolCalls`).
+   */
+  function mainToolsInFlight(turn = activeTurn) {
+    if (!turn || turn.settled) return [];
+    return turn.liveness.toolsOf('root').filter((name) => !isRemoteRelayToolName(name));
+  }
+
+  /** Why the live turn takes no steer right now ('other': it is being stopped). */
+  function steeringHoldReason(turn) {
+    if (pendingHumanRequests > 0) return 'question';
+    if (isCompacting()) return 'compaction';
+    if (!turn.primarySent || awaitingRow(turn)) return 'delivery';
+    if (mainToolsInFlight(turn).length > 0) return 'tool';
+    return 'other';
+  }
+
+  /**
+   * The tool hold ended (the tool did, or the turn) and deliveries were
+   * handed back for it: say so once. The relay sends them again on the
+   * readiness `syncDeliveryReadiness` reports.
+   */
+  function noteRunningToolHoldEnd() {
+    if (heldForRunningTool < 1 || mainToolsInFlight().length > 0) return;
+    dbg('the running tool ended; steering no longer held for it', `handed back=${heldForRunningTool}`);
+    heldForRunningTool = 0;
+  }
+
   /** A continuation whose synthetic row is still being minted (and not given up on). */
   function awaitingRow(turn) {
     return turn.kind === 'continuation' && !turn.registered && !turn.discarded;
@@ -3643,6 +4360,7 @@ export function createCopilotSdkSessionRunner({
   }
 
   function syncDeliveryReadiness() {
+    noteRunningToolHoldEnd();
     const ready = !isDeliveryHeld();
     if (ready === lastReportedDeliveryReady) return;
     lastReportedDeliveryReady = ready;
@@ -3660,7 +4378,14 @@ export function createCopilotSdkSessionRunner({
    * hold instead would bypass the question card or land inside a compaction.
    */
   async function handBackHeldDelivery(message) {
-    dbg('steering held; handing the delivery back to the queue', message.id || '(no id)');
+    const turn = activeTurn;
+    if (turn && !turn.settled && steeringHoldReason(turn) === 'tool') {
+      heldForRunningTool += 1;
+      const tools = [...new Set(mainToolsInFlight(turn).map((name) => name || 'tool'))];
+      dbg('steering held while a tool runs; handing the delivery back to the queue', message.id || '(no id)', `tools=${tools.join(', ')}`);
+    } else {
+      dbg('steering held; handing the delivery back to the queue', message.id || '(no id)');
+    }
     if (!message.id) return false;
     await api('POST', '/api/requeue', {
       messageId: message.id,
@@ -3708,13 +4433,7 @@ export function createCopilotSdkSessionRunner({
     const turn = activeTurn;
     const turnActive = Boolean(turn && !turn.settled);
     const canSteer = canAcceptSteering();
-    let holdReason = null;
-    if (turnActive && !canSteer) {
-      if (pendingHumanRequests > 0) holdReason = 'question';
-      else if (isCompacting()) holdReason = 'compaction';
-      else if (!turn.primarySent || awaitingRow(turn)) holdReason = 'delivery';
-      else holdReason = 'other';
-    }
+    const holdReason = turnActive && !canSteer ? steeringHoldReason(turn) : null;
     const messageId = String(turn?.currentOwner?.message?.id || turn?.message?.id || '').trim() || null;
     return { turnActive, canSteer, holdReason, messageId, supported: true, cancellableIds: cancellableIds() };
   }
@@ -3762,6 +4481,18 @@ export function createCopilotSdkSessionRunner({
     }
   }
 
+  /**
+   * A request to the runtime that has to come back. Rejects when the runtime
+   * does not answer in time, so the caller's own failure path runs instead of
+   * a chain that waits for ever.
+   */
+  async function askRuntime(label, request) {
+    const unanswered = Symbol('unanswered');
+    const answer = await withTimeout(Promise.resolve().then(request), runtimeRpcTimeoutMs, unanswered);
+    if (answer === unanswered) throw new Error(`the runtime did not answer ${label} within ${runtimeRpcTimeoutMs}ms`);
+    return answer;
+  }
+
   function withTimeout(promise, ms, fallback) {
     let timer = null;
     return Promise.race([
@@ -3850,12 +4581,12 @@ export function createCopilotSdkSessionRunner({
   async function handlePendingPayload(pending) {
     const message = pending?.message || null;
     if (!message) return false;
-    // Held (a card is open, a compaction is running, the turn-opening prompt
-    // is not sent yet): hand the row back with no retry penalty; the relay
-    // re-delivers it when the hold ends. An older relay (the worker updated on
-    // disk before the relay restarted) treats the hand-back as a failed
-    // delivery — retry, backoff, worker marked errored — so against one the
-    // message is pushed the legacy way.
+    // Held (a card is open, a compaction is running, a tool of the main agent
+    // is running, the turn-opening prompt is not sent yet): hand the row back
+    // with no retry penalty; the relay re-delivers it when the hold ends. An
+    // older relay (the worker updated on disk before the relay restarted)
+    // treats the hand-back as a failed delivery — retry, backoff, worker
+    // marked errored — so against one the message is pushed the legacy way.
     if (isDeliveryHeld() && canHandBackHeldDelivery() !== false) return handBackHeldDelivery(message);
     // Legacy path only: never send a second prompt before the turn-opening one
     // (it would invert the runs), and never start a second turn beside one