[Feature]: Stop on a running turn also cancels background subagents; allow stopping just the turn

[nkoynov]

With OpenCode 2 threads, pressing Stop while a turn is running also interrupts every background subagent the thread started. This is intended (OpenCode2AdapterV2.interruptTurn → stopBackground when requestRuntimeRestart is set, and ProviderTurnControlService.interrupt always sets it). But Stop is also how you redirect an agent that's heading the wrong way, and then losing the background work isn't what you want.

What happened to us (nightly 0.0.46-nightly.20261006.2735, OpenCode 2.0.24): the parent had three background subagents that had been working for about 80 minutes. The parent's turn started going down the wrong path, so the user pressed Stop and, 35 s later, sent a correction. The Stop interrupted all three child sessions 58–85 ms before the parent. OpenCode then queued three <subagent … state="cancelled">Subagent cancelled</subagent> reports, which reached the parent together with the correction, and the parent model overlooked them. Two minutes later it told the user the three were "still running". Nothing in the UI warned that Stop would cancel them.

Repro (deterministic, about 1 minute):

1. In an OpenCode 2 thread, ask the agent to launch a background subagent (subagent tool, background: true) whose task runs sleep 25 four times, then counts lines. Right after launching it, the parent should run sleep 25 three times in the foreground.
2. While both are sleeping, press Stop, then send any message.
3. The child session ends interrupted within a few ms of the Stop, and the parent receives Subagent cancelled.

The same setup with the message sent mid-turn instead of pressing Stop keeps the child alive with every delivery: steer, auto, queue, and restart (restart_active interrupts the parent's turn but doesn't pass requestRuntimeRestart, so stopBackground doesn't run). In each case the child finished and reported its result.

Ideas, from least to most change:

• Warn on Stop when background work is running: "Stop also cancels 3 background agents", with a "Stop turn only" option.
• Two-stage Stop: the first Stop on a running turn interrupts only the foreground turn and leaves background subagents running. The background-work banner (and its mobile equivalent from [Bug]: Mobile has no way to stop background work after the turn settles #14655) stops them. This needs settleBackgroundWork after a run.interrupt to skip the work the adapter left running.
• Expose restart in the composer: offer "interrupt and send" (restart_active) next to queue and steer. It already redirects without touching background subagents, but web and mobile only offer queue and steer, and mobile sends "restart" as auto.

Two smaller mobile points from the same incident:

• When the composer is empty, the send button becomes Stop (showStopAction = !hasContent && canStopThread), so tapping it before the text is in stops everything.
• The long-press "Steer now" subtitle reads "Interrupt what the agent is doing". A steer doesn't interrupt anything, and an actual interrupt (Stop) also cancels background agents, so that wording points users the wrong way.

Model: Claude Opus 5.5 (1M). Harness: OpenCode 2 in T3 Code.

[nkoynov]

Where this comes from in the code, and a proposed split (checked on nightly 20261007.2761):

• ProviderTurnControlService.ts: interrupt always calls the adapter with requestRuntimeRestart: true, for a running turn as well as a settled one. fix(server): Stop always ends the background work a thread shows #14636 added that so the "Waiting on …" Stop always reaches background work, which was the right fix for a settled turn.
• OpenCode2AdapterV2.ts: interruptTurn runs stopBackground whenever that flag is set, interrupting every background child session. OpenCode itself doesn't do this: interrupting the parent session leaves its background subagents running (in 2.0.24, session/execution.ts cancels only the session's own job). A mid-turn message also keeps them alive.
• ClaudeAdapterV2.ts: a Stop on the active turn does query.interrupt and then query.close, so the thread's Claude Code process exits and its background shells and agents go with it. In the Claude Code CLI, Esc interrupts only the turn; background work is stopped separately (/tasks, Ctrl+X Ctrl+K).

Proposal:

1. Stop on a running turn interrupts only that turn: no requestRuntimeRestart, no stopBackground, and no query.close for Claude. Background work keeps running and stays on the "Waiting on …" strip.
2. Stop on that strip (or on a settled turn) keeps today's behaviour and ends everything, as fix(server): Stop ends a Claude thread's background work after the turn settles #13792/fix(server): Stop always ends the background work a thread shows #14636 intended.
3. Optionally, a "Stop all" entry next to Stop for ending the turn and the background work in one go.

That matches the Claude Code CLI and OpenCode's own behaviour, and keeps the fix for background work that couldn't be stopped. If this direction works for you, I'm happy to open a PR.

Found and written with Claude Opus 5.5 in T3 Code (OpenCode 2 + cursor-opencode-provider).

[nkoynov]

Following up now that #16852 was closed for size. This still reproduces on main (339179f): replaying the recorded opencode2_background run, a Stop while the parent turn is still answering makes the OpenCode 2 adapter stop the background child session too, and the subagent ends interrupted.

Here's a much smaller fix, OpenCode 2 only: compare. About 100 source lines across 5 files, plus tests. interruptTurn skips stopBackground when the Stop hits a turn that's still running, as it already does for a restart. An optional runtime flag, interruptKeepsBackgroundWork (set only by the OpenCode 2 adapter), tells the orchestrator that work the adapter still reports is still running, so the post-Stop settle leaves it alone and the stopped run keeps ingesting it instead of marking it interrupted. Other providers are unchanged.

Stop still ends the turn with its foreground tool calls and subagents, holds the queue, and stops delegated tasks and PR watches. Background subagents stay on the banner above the composer, and its Stop, or any Stop after the turn ended, still stops them. One known gap: if the turn finishes on its own between the Stop and the interrupt reaching OpenCode, background work is stopped as before.

Would you take this as a PR?