@oar-sh/oar 0.9.4 → 0.9.5

package/CHANGELOG.md

@@ -5,6 +5,37 @@ All notable changes to OAR are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.9.5] — 2026-09-27
+
+Highlights: a Claude reply on the wrong row no longer blocks the conversation,
+workers on Windows write a log, and agents can set the effort of a session on
+another relay.
+
+### Added
+
+- **Remote relays**: an agent can set the reasoning effort of a session it starts or
+  prompts on another relay (`effort` on `create_session` and `send`), and `relay_info`
+  lists the efforts each model there takes.
+
+### Changed
+
+- Session workers on Windows now write the same `worker-<session>.log` as on
+  Linux, in the relay's log directory; the console window keeps showing the
+  output.
+
+### Fixed
+
+- **Remote relays:** waiting for a remote agent's reply no longer stops at an
+  interim answer ("still waiting for …") while the agent goes on in a turn of
+  its own without a background task, for example while its subagents work.
+- A Claude reply published as a *background continuation* instead of under
+  your message no longer blocks the conversation for up to 5 minutes: after
+  about 45 seconds of silence your message closes with a small muted note
+  naming that reply, and the next message runs normally. The note sends no
+  second notification, and an agent on a paired relay receives the reply
+  itself, not the note. A stray re-init of the Claude CLI between turns no
+  longer sends the reply there in the first place.
+
 ## [0.9.4] — 2026-09-27
 
 Highlights: remote relays (pair OAR relays and let an agent on one work on the

package/README.md

@@ -78,7 +78,7 @@ curl -fsSL oar.sh/install | sh
 The script checks for Node.js 22.13 or newer, runs `npm install -g @oar-sh/oar`, and then hands off to `oar setup` (with `--defaults` when there is no terminal to ask questions in). It refuses to run as root, because OAR installs per user. `OAR_VERSION=x.y.z` pins a version, `OAR_CHANNEL=beta` follows the beta channel, and `OAR_DRY_RUN=1` only prints what it would do:
 
 ```bash
-curl -fsSL oar.sh/install | OAR_VERSION=0.9.4 sh
+curl -fsSL oar.sh/install | OAR_VERSION=0.9.5 sh
 ```
 
 Read it before you run it: [oar.sh/install](https://oar.sh/install).
@@ -89,7 +89,7 @@ Read it before you run it: [oar.sh/install](https://oar.sh/install).
 irm oar.sh/install.ps1 | iex
 ```
 
-The PowerShell installer (PowerShell 5 or newer) does the same: it checks Node.js, runs `npm install -g @oar-sh/oar`, then `oar setup`. It reads the same `OAR_VERSION`, `OAR_CHANNEL`, and `OAR_DRY_RUN` variables, for example `$env:OAR_VERSION = '0.9.4'` before the command.
+The PowerShell installer (PowerShell 5 or newer) does the same: it checks Node.js, runs `npm install -g @oar-sh/oar`, then `oar setup`. It reads the same `OAR_VERSION`, `OAR_CHANNEL`, and `OAR_DRY_RUN` variables, for example `$env:OAR_VERSION = '0.9.5'` before the command.
 
 ### npm
 
@@ -326,6 +326,13 @@ Use **🤗 Select Models** to choose which variants show up in the composer, the
 
 ## Highlights
 
+### New in 0.9.5
+
+- **A misplaced Claude reply no longer blocks the conversation**: when a reply is published as a *background continuation* instead of under your message, the message closes after about 45 seconds of silence with a small note naming that reply, and the next message runs normally. It used to hold every later message for up to 5 minutes.
+- **Effort for remote sessions**: an agent can set the reasoning effort of a session it starts or prompts on another relay; a new session takes the calling session's effort when the model there supports it. See [Remote relays](#remote-relays).
+- **Waiting on another relay is steadier**: the wait no longer stops at an interim answer while the remote agent goes on in a turn of its own, for example while its subagents work.
+- **Worker logs on Windows**: session workers now write the same `worker-<session>.log` as on Linux, in the relay's log directory, while the console window keeps showing the output.
+
 ### New in 0.9.4
 
 - **Remote relays**: pair two OAR relays in **Settings → Relays** by pasting the other relay's web address; the pairing works both ways. An agent in any session can then work on the other relay when you ask it to: list and read its sessions, prompt one, start a new one, wait for the reply, and pass a question the remote agent asks back to you. See [Remote relays](#remote-relays).
@@ -442,7 +449,9 @@ Use **➡️ Share conversation** in the `⋯` menu to publish a read-only link.
 
 ### The conversation menu
 
-Besides the entries above, the `⋯` menu holds **✍️ Edit conversation title**, **🖥️ Inspect tmux console** (a read-only view of the session's tmux pane), **🤗 Select Models**, **⚙️ Settings**, **🌄 Restart web relay** (queued until the current turn is idle), **💤 Suspend host**, and **☠️ Kill session** (stops the conversation's worker; an active turn then needs a retry or a new message). Its header shows the queue counts with **🚮 Empty queue**.
+Besides the entries above, the `⋯` menu holds **✍️ Edit conversation title**, **🖥️ Inspect tmux console** (a read-only view of the session's tmux pane), **🤗 Select Models**, **⚙️ Settings**, **🌄 Restart web relay** (queued until the current turn is idle), **💤 Suspend host** (Windows; see below), and **☠️ Kill session** (stops the conversation's worker; an active turn then needs a retry or a new message). Its header shows the queue counts with **🚮 Empty queue**.
+
+**💤 Suspend host** puts the machine the relay runs on to sleep, once the work is done. The confirmation lists what is still active. The relay then queues the suspend and fires it after 2 minutes with nothing active: no queued, running or parked turn, no background task of a live worker, and no open GitHub Actions run in the repository of a conversation that was busy since the request (read through `gh`; a repository whose state cannot be read blocks for 15 minutes, then is ignored). With nothing running when you confirm, it fires after a 30-second countdown. While a suspend is queued, every device shows a banner with the blockers or the countdown and a **Cancel** button, and a push notification reports the suspend. A relay restart drops a queued suspend and says so. **Show Suspend host action** in Settings hides the entry per browser.
 
 ## Settings and configuration reference
 
@@ -539,6 +548,8 @@ The config file is `server/config.json` in a git checkout and `~/.oar/config.jso
 | `COPILOT_WEB_RELAY_LOG_DIR` | Log directory |
 | `OAR_STATE_ROOT` | State root of a global install, instead of `~/.oar` / `%APPDATA%\oar` |
 | `OAR_NO_UPDATE_CHECK=1` | Never contact oar.sh, not even for a manual update check |
+| `OAR_HOST_SUSPEND_DRY_RUN=1` | **Suspend host** logs the suspend instead of sleeping the machine |
+| `OAR_MCP_SERVER=0` | Do not attach OAR's MCP server to Grok and the Copilot extension engine; they get the preview instructions as text again, and no `remote_relay` tool |
 | `COPILOT_SDK_PATH` | The Copilot CLI runtime's `copilot-sdk` directory, instead of the newest one in the CLI's package cache |
 | `COPILOT_PKG_DIR` | An additional Copilot CLI package cache to search |
 | `GH_TOKEN`, `GITHUB_TOKEN` | GitHub token for the Copilot usage card, instead of `gh auth token` |
@@ -673,7 +684,9 @@ chain of relays prompting relays stops after two hops.
 Copilot directly; Grok and the Copilot extension engine through OAR's MCP server). Per paired
 relay, **Agents may** limits it to *read only*, *read and prompt* (existing sessions) or *full*
 (also create sessions, answer questions, stop turns, archive). In the *ask* and *plan* relay
-modes, every write action first asks you with a question card.
+modes, every write action first asks you with a question card. For a session it starts, an agent
+can set the provider, model, relay mode and reasoning effort; what it leaves out follows the
+session it works in, as far as the other relay offers it.
 
 When an agent prompts a session on another relay, that relay shows a **↗ from …** badge with the
 sending relay, session and model on the message, and marks sessions an agent created in the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oar-sh/oar",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "type": "module",
   "description": "OAR — Open Agent Relay: drive your local coding agents from any browser",
   "license": "MIT",

package/server/claude-worker/claude-remote-relay-tool.mjs

@@ -63,6 +63,7 @@ export const REMOTE_RELAY_TOOL_ZOD_SHAPE = {
   model: text('model'),
   cwd: text('cwd'),
   mode: choice('mode', REMOTE_RELAY_MODES),
+  effort: text('effort'),
   title: text('title'),
   question_id: text('question_id'),
   answer: text('answer'),

package/server/claude-worker/claude-session-process.mjs

@@ -37,7 +37,12 @@ import {
 import { createAskUserBridge } from '../../shared/ask-user-bridge.mjs';
 import { createRemoteRelayToolGate } from '../../shared/remote-relay-tool-core.mjs';
 import { buildRelayStopFailure } from '../../shared/relay-stop-failure.mjs';
-import { STEER_FOLDED_TEXT, STEER_STOPPED_TEXT } from '../../shared/steer-settle-markers.mjs';
+import {
+  ANSWERED_ELSEWHERE_KIND,
+  DELIVERY_ANSWERED_ELSEWHERE_TEXT,
+  STEER_FOLDED_TEXT,
+  STEER_STOPPED_TEXT,
+} from '../../shared/steer-settle-markers.mjs';
 import { stripSteerNote, withSteerNoteContent } from '../../shared/steer-note.mjs';
 import {
   stripSlashCommandGuard,
@@ -464,6 +469,17 @@ export function createClaudeSessionRunner({
   // takes to distinguish a fold from a queued run. Far below the watchdog so a
   // folded row settles as answered, not failed with a "resend" error.
   steeredFoldGraceMs = 2_000,
+  // How long a NON-steered entry may sit unattached after a continuation that
+  // opened over it has published its answer, with the stream quiet and no
+  // turn starting, before it is settled as answered by that continuation. The
+  // CLI starts the turn of a message queued behind another one when that
+  // turn ends, and every turn opens with an init, which takes the entry out
+  // of this settle for good. So the window only has to outlast the gap up to
+  // that init (input processing, hooks); it is sized well above it because a
+  // settle that comes too early costs the user the real answer's place.
+  // Without the settle the row held every later message out of the worker
+  // until the watchdog failed it minutes later. 0 = disabled.
+  strandedSettleMs = 45_000,
   // Backstop for the compaction hold. A compaction is announced ONCE by
   // `status: 'compacting'` (the CLI's periodic re-emit is gated on the
   // remote-control client's activity callback, which the plain SDK `query()`
@@ -793,6 +809,8 @@ export function createClaudeSessionRunner({
   function attachDeliveredContext(index = 0, { provisional = false } = {}) {
     const [entry] = proc.pendingDelivered.splice(index, 1);
     entry.ctx.deliveredEntry = entry;
+    // It has a turn now; an adoption that is unwound puts it back unmarked.
+    entry.overtakenBy = null;
     // A provisional (post-compaction) attach may still be unwound back onto
     // the queue; its un-mark waits for the adoption to commit.
     if (!provisional) unmarkConsumedOnOwnTurn(entry);
@@ -869,7 +887,89 @@ export function createClaudeSessionRunner({
   function handBackAdoptedContext(ctx) {
     restoreAdoptedContext(ctx);
     dbg('post-compaction adoption handed back to a task continuation', ctx.message?.id || '(no id)');
-    return openContinuationContext();
+    return openContinuationContext({ evidence: 'a task notification replayed into the adopted turn' });
+  }
+
+  /**
+   * Mark the next turn as one the CLI opened by itself. `corroborated` says
+   * whether the signal proves that on its own (a turn opener's replay, the
+   * Stop guard standing down) or only suggests it (a bare init, which the CLI
+   * also emits for reasons of its own). Sticky until the boundary is spent: a
+   * weaker signal behind a proven one does not take the proof back.
+   *
+   * Every marking starts with nothing superseding it, a re-marking of an
+   * armed boundary included. A bare init marks only with nothing queued, so
+   * it precedes any later push; and a boundary can stay armed with the flag
+   * set, when the message whose init set it was failed by the watchdog
+   * without a turn ever opening. Left standing, that flag made the next turn
+   * the CLI opened by itself look superseded by an init it never saw.
+   */
+  function markSelfOpenedBoundary(reason, { corroborated = false } = {}) {
+    if (proc.lastBoundary === 'self-opened' && proc.boundaryCorroborated) return;
+    proc.lastBoundary = 'self-opened';
+    proc.boundarySuperseded = false;
+    proc.boundaryCorroborated = corroborated;
+    proc.boundaryReason = reason;
+  }
+
+  /**
+   * What says the CLI really opened the turn the boundary announces, or ''
+   * when nothing does. Beyond the signal itself:
+   *  - a task settled and no continuation has opened since. Counted, not
+   *    timed, and not reset by a turn ending: a task that settles early in a
+   *    long turn has its continuation open after that turn, by which time
+   *    both the notification grace and `settleSeqAtTurnEnd` have moved on.
+   *    Over-long by design: a settle whose notification was silent or folded
+   *    into another turn stays evidence until the next continuation opens,
+   *    which only keeps a boundary the way it was always kept;
+   *  - a live task, which can report back without settling;
+   *  - order: the init that armed the boundary came before the waiting
+   *    message was pushed (an init arms it only with nothing queued), so that
+   *    turn is not the message's own, and no later init has started another
+   *    turn in its place (see `boundarySuperseded`).
+   */
+  function selfOpenedEvidence() {
+    if (proc.boundaryCorroborated) return proc.boundaryReason;
+    if (proc.taskSettleSeq !== proc.settleSeqAtContinuationOpen) {
+      return 'a background task settled and no continuation has opened since';
+    }
+    if (proc.liveTasks.size > 0) return 'a live background task can report back';
+    if (!proc.boundarySuperseded) return 'its init came before the message was pushed and no turn has started since';
+    return '';
+  }
+
+  /**
+   * A self-opened boundary diverts the next turn's answer to a continuation
+   * row. One armed by a bare init stays armed until a turn opens, however
+   * long that takes, and the CLI inits for reasons of its own: read as
+   * self-opened, a settings re-init published the user's answer on a
+   * continuation and left the delivered row unattached, holding every later
+   * message out until the watchdog failed it (see the init handler).
+   *
+   * Every turn opens with an init, so what tells a stale boundary from a live
+   * one is what follows the push. Traffic with no init in between belongs to
+   * the turn the armed init opened: a continuation, as before. A SECOND init,
+   * after the push, starts a newer turn; the armed one never produced
+   * anything, and unless a task corroborates it the boundary is dropped here
+   * and the turn attaches to the waiting message, as if it had never been
+   * marked. Steered entries do not count: they settle by the fold reaper. A
+   * boundary marked by a replay is never dropped; if that one is false, the
+   * settle in reapOvertakenDeliveredEntries recovers.
+   */
+  function disownUnprovenBoundary() {
+    if (proc.lastBoundary !== 'self-opened') return;
+    const waiting = proc.pendingDelivered.find((entry) => !entry.steered);
+    if (!waiting || selfOpenedEvidence()) return;
+    dbg(
+      'self-opened boundary has no corroboration; the turn goes to the waiting message',
+      shortMessageId(waiting.ctx.message),
+      `boundary=${proc.boundaryReason}`,
+    );
+    proc.lastBoundary = null;
+  }
+
+  function shortMessageId(message) {
+    return String(message?.id || '').slice(0, 8) || '(no id)';
   }
 
   /**
@@ -879,7 +979,7 @@ export function createClaudeSessionRunner({
    * discards the turn's relay output (it still lands in the native
    * transcript) rather than failing the process.
    */
-  function openContinuationContext() {
+  function openContinuationContext({ evidence = '' } = {}) {
     const ctx = createContext('continuation', {
       id: null,
       conversationId: sdkSessionId,
@@ -887,6 +987,26 @@ export function createClaudeSessionRunner({
       model: '',
     });
     ctx.registered = false;
+    // Delivered messages this turn opens over. Remembered on the entry: if
+    // this turn turns out to have taken their prompt, nothing will ever open
+    // for them (see reapOvertakenDeliveredEntries). Read before the
+    // activation below spends the boundary.
+    const overtaken = proc.pendingDelivered.filter((entry) => !entry.steered);
+    if (overtaken.length) {
+      const selfOpened = proc.lastBoundary === 'self-opened';
+      dbg(
+        'continuation opens while a delivered message waits unattached',
+        overtaken.map((entry) => shortMessageId(entry.ctx.message)).join(','),
+        `boundary=${selfOpened ? proc.boundaryReason : 'none'}`,
+        `reason=${evidence || (selfOpened && selfOpenedEvidence()) || 'none'}`,
+      );
+      for (const entry of overtaken) {
+        entry.overtakenBy = ctx;
+        entry.overtakenSince = 0;
+      }
+    }
+    // Whatever settled up to here has its continuation now.
+    proc.settleSeqAtContinuationOpen = proc.taskSettleSeq;
     activateContext(ctx);
     (async () => {
       // One idempotency key for the whole loop: a retry whose predecessor was
@@ -1149,11 +1269,21 @@ export function createClaudeSessionRunner({
       // A turn the CLI opened on its own (task-notification replay). The
       // context opens lazily on its first real traffic so a bookkeeping
       // replay that ends in a phantom result never creates a relay turn.
-      proc.lastBoundary = 'self-opened';
+      // A turn opener that matched no delivered message proves the turn is
+      // the CLI's own, tagged or not: the adoption rules above rest on that.
+      const originKind = String(sdkMessage?.origin?.kind || '').trim();
+      markSelfOpenedBoundary(
+        isTaskNotificationReplay(sdkMessage)
+          ? 'a task notification replay'
+          : `an unmatched user replay (origin ${originKind || 'none'})`,
+        { corroborated: true },
+      );
+      turnStartedForWaitingDeliveries();
       return null;
     }
 
     if (type === 'assistant' || type === 'stream_event' || type === 'user') {
+      disownUnprovenBoundary();
       if (proc.lastBoundary !== 'self-opened') {
         // A background subagent's frames arrive at top level carrying
         // `parent_tool_use_id` (same marker the adoption commit checks): they
@@ -1177,6 +1307,7 @@ export function createClaudeSessionRunner({
         proc.lastBoundary = null;
         return null;
       }
+      disownUnprovenBoundary();
       if (proc.lastBoundary !== 'self-opened' && proc.pendingDelivered.length && !sdkMessage?.parent_tool_use_id) {
         return attachDeliveredContext();
       }
@@ -1971,11 +2102,21 @@ export function createClaudeSessionRunner({
     if (type !== 'system') return;
     const subtype = String(sdkMessage.subtype || '');
     if (subtype === 'init') {
-      // The FIRST init of a process is the spawn's, and a spawn is always
-      // driven by a delivered message; a LATER one is the CLI opening a turn
-      // by itself.
+      // The CLI emits an init at the start of EVERY turn, after it has taken
+      // the turn's input and before the API request (read in the CLI, 2.1.282):
+      // a delivered message's own turn opens init → traffic, with no user
+      // replay, exactly like a continuation the CLI opens by itself. The
+      // FIRST init of a process is the spawn's, and a spawn is always driven
+      // by a delivered message.
       const firstInit = !proc.sawInit;
       proc.sawInit = true;
+      // A turn is starting while delivered messages wait, and it may be
+      // theirs: they leave the overtaken settle for good. Whether a context is
+      // still active does not matter. A continuation whose result arrived
+      // while its row was still registering is active when the next turn's
+      // init lands, and skipping that init settled the message with a pointer
+      // and dropped its real answer.
+      if (!firstInit && proc.pendingDelivered.length) turnStartedForWaitingDeliveries();
       persistNativeSessionId(sdkSessionId, sdkMessage.session_id).catch(() => {});
       // Tracked on the process too (not only through the persist round-trip):
       // the workflow poller needs the native id to find the session dir even
@@ -2010,17 +2151,20 @@ export function createClaudeSessionRunner({
         // same way.
         if (settingsReinitsOwed > 0) settingsReinitsOwed -= 1;
         else if (!settingsWindowOpen || proc.taskSettleSeq !== proc.settleSeqAtTurnEnd) {
-          proc.lastBoundary = 'self-opened';
+          markSelfOpenedBoundary('a bare init with nothing queued');
         }
       } else if (!proc.activeCtx && !firstInit) {
-        // A LATER init, with a delivered row waiting, is the CLI opening a turn
-        // of its own — the live-verified continuation shape is a bare init with
-        // no user replay at all. A delivered turn cannot produce one: the
-        // process is already running, and only a spawn inits (which is
-        // `firstInit`, and always has its row queued before the stream is
-        // read). A compaction inside such a turn would otherwise see no
-        // turn-level boundary and adopt the queued row — and in this shape
-        // nothing later replays to correct it.
+        // A LATER init, with a delivered row waiting: a turn is starting, and
+        // the init cannot say whose. It may be the CLI opening a turn of its
+        // own (the live-verified continuation shape is a bare init with no
+        // user replay at all) or the waiting message's own turn, which opens
+        // with an init just the same. For a compaction inside that turn the
+        // flag errs toward the continuation: adopting the queued row for a
+        // turn that was the CLI's own closes it with another turn's answer,
+        // and in this shape nothing later replays to correct it. When the
+        // turn was the message's own, its answer publishes on a continuation
+        // row instead and the row is settled with a pointer to it (see
+        // reapOvertakenDeliveredEntries).
         //
         // Structural, not a clock. Gating this on "a task settled recently"
         // fails twice over: the grace (60 s) is shorter than a compaction
@@ -2036,6 +2180,9 @@ export function createClaudeSessionRunner({
         // continuation). This suppresses adoption and nothing else; if the turn
         // really is the delivered message's, it attaches exactly as before.
         proc.continuationInitPending = true;
+        // A boundary an earlier init armed announced a turn that never
+        // produced anything: this init starts a newer one in its place.
+        if (proc.lastBoundary === 'self-opened') proc.boundarySuperseded = true;
       }
       return;
     }
@@ -2341,7 +2488,9 @@ export function createClaudeSessionRunner({
     if (suppressed === 'observe-only') return;
     // Its traffic opens a continuation of its own instead of attaching to the
     // stopped steer waiting in pendingDelivered (which still settles stopped).
-    if (suppressed === 'continuation') proc.lastBoundary = 'self-opened';
+    if (suppressed === 'continuation') {
+      markSelfOpenedBoundary('the stop guard stood down for a task continuation', { corroborated: true });
+    }
     const ctx = resolveContext(sdkMessage);
     if (proc.handoffSettling) {
       // An absorbed-steering handoff just settled the previous context;
@@ -2530,6 +2679,112 @@ export function createClaudeSessionRunner({
     }
   }
 
+  /**
+   * A turn is starting while delivered messages wait. Whatever opened over
+   * them before, they are no longer known to be left behind: this turn may be
+   * theirs, and its first traffic can take longer than the settle window.
+   */
+  function turnStartedForWaitingDeliveries() {
+    for (const entry of proc.pendingDelivered) entry.overtakenBy = null;
+  }
+
+  /** The continuation ran to a clean end and its answer is on the relay. */
+  function publishedItsAnswer(ctx) {
+    return Boolean(ctx)
+      && ctx.finalized
+      && ctx.registered
+      && !ctx.discarded
+      && !ctx.interrupted
+      && Boolean(ctx.message?.id)
+      && Boolean(ctx.state.result)
+      && !ctx.state.result.isError;
+  }
+
+  /**
+   * Settle delivered messages whose prompt a continuation's turn took. A
+   * continuation opened over a waiting NON-steered entry either ran ahead of
+   * the entry's own turn, which then follows at once, or WAS that turn: a
+   * false boundary published the answer on the continuation row, or the CLI
+   * folded the queued prompt into the turn it had already begun. In the
+   * second case nothing attaches the entry anymore, and it held every later
+   * message out of the worker until the watchdog failed it with a "resend"
+   * error for a message that had been answered (seen live 2026-09-27).
+   *
+   * Told apart by silence: the continuation published its answer, no turn
+   * started since (any init takes the entry out, see the init handler), and
+   * the stream stayed quiet for the settle window, counted from whichever is
+   * latest: the continuation's end, the entry's push, the last stream event.
+   * Same gates as the fold reaper, so never during a compaction, an API
+   * retry, an open control round-trip or a task continuation that is due. A
+   * continuation that was stopped, failed or never reached the relay settles
+   * nothing: the marker points at its reply, and the watchdog keeps those
+   * rows.
+   */
+  function reapOvertakenDeliveredEntries(now) {
+    if (!proc || !proc.pendingDelivered.length) return;
+    if (!(strandedSettleMs > 0)) return;
+    if (proc.activeCtx || proc.pendingControlRequests > 0 || isCompacting() || isContinuationImminent()
+      || isApiRetryPending() || isStopFollowUpPending(now)) {
+      for (const entry of proc.pendingDelivered) entry.overtakenSince = 0;
+      return;
+    }
+    const answered = [];
+    proc.pendingDelivered = proc.pendingDelivered.filter((entry) => {
+      if (entry.steered || !publishedItsAnswer(entry.overtakenBy)) return true;
+      if (!entry.overtakenSince) { entry.overtakenSince = now; return true; }
+      // Any stream event restarts the wait: a CLI that still talks is not done.
+      const quietSince = Math.max(entry.overtakenSince, entry.pushedAt || 0, proc.lastEventAt);
+      if (now - quietSince < strandedSettleMs) return true;
+      answered.push(entry);
+      // Owned until the marker is committed (same claim as a folded steer).
+      claimSettling(entry.ctx.message, 'answeredElsewhere');
+      return false;
+    });
+    if (!answered.length) return;
+    void (async () => {
+      for (const entry of answered) {
+        dbg(
+          'delivered message was answered on a continuation row; settling it',
+          shortMessageId(entry.ctx.message),
+          `continuation=${shortMessageId(entry.overtakenBy.message)}`,
+        );
+        try {
+          await settleOvertakenDeliveredEntry(entry);
+        } catch (error) {
+          dbg('overtaken-delivery settle failed', error?.message || String(error));
+        }
+      }
+    })();
+  }
+
+  async function settleOvertakenDeliveredEntry(entry) {
+    const ctx = entry.ctx;
+    if (ctx.finalized) {
+      releaseSettling(ctx.message?.id);
+      return;
+    }
+    ctx.finalized = true;
+    const model = entry.overtakenBy.state.responseModel || proc?.model || null;
+    try {
+      // Marked consumed BEFORE the first publish attempt: should the worker
+      // die while the marker is retried, the relay fails the row instead of
+      // running its prompt again. Never rejects (best-effort).
+      await markConsumed(ctx.message?.conversationId, [ctx.message]);
+      // The row closes with a pointer to the answer, under a kind of its own:
+      // a marker, not a reply. Not requeued (the prompt would run twice) and
+      // not failed (it was answered).
+      await publishSettleMarker(ctx.message, {
+        text: DELIVERY_ANSWERED_ELSEWHERE_TEXT,
+        model,
+        kind: ANSWERED_ELSEWHERE_KIND,
+        variant: 'answeredElsewhere',
+      });
+    } finally {
+      // Spliced out of pendingDelivered already: nothing else resolves it.
+      ctx.resolveDone?.(true);
+    }
+  }
+
   const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
   /**
@@ -2563,7 +2818,14 @@ export function createClaudeSessionRunner({
     const workflowRuns = publisher.drainWorkflowRuns();
     try {
       for (let attempt = 0; ; attempt += 1) {
-        const outcome = await publisher.publishResponse(message, { text, model, kind, workflowRuns });
+        // Never requeued, with or without a kind: the CLI has the prompt.
+        const outcome = await publisher.publishResponse(message, {
+          text,
+          model,
+          kind,
+          workflowRuns,
+          requeueOnFailure: false,
+        });
         reportFirstAttempt();
         if (outcome !== 'failed') return;
         if (attempt >= settleRetryDelaysMs.length) break;
@@ -2659,6 +2921,9 @@ export function createClaudeSessionRunner({
     // Before the 5-minute watchdog: a folded steered entry settles as merged
     // within the short fold grace instead of failing over.
     reapFoldedSteeredEntries(now);
+    // Also before the watchdog: a message a continuation answered settles as
+    // answered instead of failing over minutes later.
+    reapOvertakenDeliveredEntries(now);
     reapStalePendingDelivered(now);
     if (hasLiveWork()) {
       // Track how long background tasks alone have held the process, for the
@@ -2855,6 +3120,16 @@ export function createClaudeSessionRunner({
       activeCtx: null,
       pendingDelivered: [],
       lastBoundary: null,
+      // What marked the boundary, and whether that alone proves the CLI
+      // opened the turn; read only while lastBoundary is 'self-opened'.
+      boundaryReason: '',
+      boundaryCorroborated: false,
+      // An init arrived after the boundary was armed, with a delivered
+      // message waiting: a newer turn started in place of the announced one.
+      boundarySuperseded: false,
+      // taskSettleSeq when a continuation context last opened: a settle since
+      // then still has its continuation coming.
+      settleSeqAtContinuationOpen: 0,
       pendingControlRequests: 0,
       lastEventAt: Date.now(),
       heldForTasksSince: 0,

package/server/claude-worker/claude-session-worker.mjs

@@ -13,6 +13,7 @@ import {
 import { createApiClient } from '../../shared/worker-runtime/api-client.mjs';
 import { createWorkerWebSocketLink } from '../../shared/worker-runtime/worker-websocket-link.mjs';
 import { createHeartbeatController } from '../../shared/worker-runtime/heartbeat.mjs';
+import { installWorkerLogFile } from '../../shared/worker-runtime/worker-log-file.mjs';
 import { createControlPoller } from '../../shared/control-poller.mjs';
 import { resolveDeliveredAutoCompactWindow } from '../../shared/auto-compact-window.mjs';
 import { resolveDeliveredThinking } from '../../shared/claude-thinking.mjs';
@@ -20,6 +21,10 @@ import { installWorkerCrashGuard } from '../../shared/worker-crash-guard.mjs';
 import { createClaudeSessionRunner } from './claude-session-process.mjs';
 import { createRunnerLinkBridge, failSettlingRowsOnShutdown } from './claude-worker-link-wiring.mjs';
 
+// Windows console launch: the launcher names the worker log, this copies
+// stdout/stderr into it. A no-op wherever the launcher redirects instead.
+installWorkerLogFile();
+
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const HEARTBEAT_MS = 10_000;
 

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

@@ -20,6 +20,7 @@ import {
 import { createApiClient } from '../../shared/worker-runtime/api-client.mjs';
 import { createWorkerWebSocketLink } from '../../shared/worker-runtime/worker-websocket-link.mjs';
 import { createHeartbeatController } from '../../shared/worker-runtime/heartbeat.mjs';
+import { installWorkerLogFile } from '../../shared/worker-runtime/worker-log-file.mjs';
 import {
   createRunnerLinkBridge,
   failSettlingRowsOnShutdown,
@@ -33,6 +34,10 @@ import {
 } from '../../shared/worker-bootstrap.mjs';
 import { createCopilotSdkSessionRunner } from './copilot-sdk-session-process.mjs';
 
+// Windows console launch: the launcher names the worker log, this copies
+// stdout/stderr into it. A no-op wherever the launcher redirects instead.
+installWorkerLogFile();
+
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const HEARTBEAT_MS = 10_000;
 

package/server/cursor-worker/cursor-session-worker.mjs

@@ -13,10 +13,15 @@ import {
 import { createApiClient } from '../../shared/worker-runtime/api-client.mjs';
 import { createWorkerWebSocketLink } from '../../shared/worker-runtime/worker-websocket-link.mjs';
 import { createHeartbeatController } from '../../shared/worker-runtime/heartbeat.mjs';
+import { installWorkerLogFile } from '../../shared/worker-runtime/worker-log-file.mjs';
 import { createControlPoller } from '../../shared/control-poller.mjs';
 import { installWorkerCrashGuard } from '../../shared/worker-crash-guard.mjs';
 import { createCursorTurnRunner } from './cursor-turn-runner.mjs';
 
+// Windows console launch: the launcher names the worker log, this copies
+// stdout/stderr into it. A no-op wherever the launcher redirects instead.
+installWorkerLogFile();
+
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const HEARTBEAT_MS = 10_000;
 

package/server/grok-worker/grok-session-worker.mjs

@@ -12,10 +12,15 @@ import {
 import { createApiClient } from '../../shared/worker-runtime/api-client.mjs';
 import { createWorkerWebSocketLink } from '../../shared/worker-runtime/worker-websocket-link.mjs';
 import { createHeartbeatController } from '../../shared/worker-runtime/heartbeat.mjs';
+import { installWorkerLogFile } from '../../shared/worker-runtime/worker-log-file.mjs';
 import { createControlPoller } from '../../shared/control-poller.mjs';
 import { installWorkerCrashGuard } from '../../shared/worker-crash-guard.mjs';
 import { createGrokTurnRunner } from './grok-turn-runner.mjs';
 
+// Windows console launch: the launcher names the worker log, this copies
+// stdout/stderr into it. A no-op wherever the launcher redirects instead.
+installWorkerLogFile();
+
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const HEARTBEAT_MS = 10_000;
 

package/server/public/app/conversation-view.js

@@ -1277,6 +1277,8 @@ function createMessageNode(msg, msgId = null, force = false) {
   // The settle marker of a steer the CLI consumed without a turn of its own:
   // folded into (and answered by) the turn above, or cut off unanswered by a
   // Stop. Compact, attached to its own user message, never merging forward.
+  // Also the marker of a message answered on a continuation row, which only
+  // shares the look.
   const steerMarkerClass = msg.role === 'assistant' ? STEER_MARKER_CLASS_BY_KIND[messageKind] : null;
   if (steerMarkerClass) div.classList.add(steerMarkerClass);
   const isStoppedSteer = msg.role === 'assistant' && messageKind === 'stopped';