[Bug]: Delegated-task notifications cancel queued Claude tool calls and tell the agent the user refused #15351

Before submitting

• I searched existing issues and did not find a duplicate.
• I included enough detail to reproduce or investigate the problem.

Area

apps/server

Steps to reproduce

In T3 Code:

1. In a Claude thread, start a delegate_task child with mode: "async".
2. While the child runs, have the parent send a tool batch in which the second call has to wait for the first. Example: a slow Bash command, then a Bash command that writes a file.
3. Let the child finish while the first call is still running.

The script below reproduces it without T3. It sends the same message ClaudeAdapterV2.steerTurn sends, partway through that kind of tool batch. Run it with now, then with next.

// node repro.mjs <now|next>   (set CLAUDE_PATH to use a specific claude binary; Ctrl-C to exit)
import { randomUUID } from "node:crypto";
import { query } from "@anthropic-ai/claude-agent-sdk";

const priority = process.argv[2];
const pending = [];
let wake = null;
const offer = (m) => (pending.push(m), wake?.());
async function* input() {
  for (;;) {
    if (pending.length === 0) await new Promise((r) => (wake = r));
    while (pending.length > 0) yield pending.shift();
  }
}
const user = (text, extra = {}) => ({
  type: "user",
  message: { role: "user", content: [{ type: "text", text }] },
  parent_tool_use_id: null,
  session_id: "",
  uuid: randomUUID(),
  ...extra,
});

offer(
  user(
    "Run these two tool calls together in ONE message, in this order: " +
      "(1) Bash: `sleep 12 && echo slept`; (2) Bash: `echo second > second.txt && cat second.txt`. " +
      "Then report what each tool returned.",
  ),
);

const q = query({
  prompt: input(),
  options: {
    model: "claude-opus-5-5",
    permissionMode: "bypassPermissions",
    allowDangerouslySkipPermissions: true,
    settingSources: [],
    ...(process.env.CLAUDE_PATH ? { pathToClaudeCodeExecutable: process.env.CLAUDE_PATH } : {}),
  },
});

let steered = false;
for await (const m of q) {
  for (const b of m.type === "assistant" || m.type === "user" ? m.message.content : []) {
    if (b.type === "tool_result") console.log("tool_result:", JSON.stringify(b.content).slice(0, 200));
    if (b.type === "text") console.log(`${m.type}:`, b.text.slice(0, 300));
    if (b.type === "tool_use" && !steered) {
      steered = true;
      // The text and priority T3 steers in for a delegated-task completion.
      setTimeout(
        () =>
          offer(
            user(
              "Delegated task task-123 reached a terminal state. Use task_status with taskId task-123 to read the result.",
              { priority },
            ),
          ),
        4000,
      );
    }
  }
  if (m.type === "result") console.log("result:", m.terminal_reason);
}

Expected behavior

The notification reaches the agent and every tool call still runs. The orchestrator promises this in the comment above its steer_active routing in apps/server/src/orchestration-v2/Orchestrator.ts: "Never interrupt/restart a turn for a notification."

Actual behavior

The queued call never runs. Its tool result is:

The user doesn't want to take this action right now. STOP what you are doing and wait for the user to tell you how to proceed.

The agent takes that as an instruction from the user. In two real threads it replied "I've paused, as you asked" and waited for a user who never came. For an autonomous thread that's the end of it, because nobody is around to send the next message.

A milder version hits MCP tools that are already running, such as t3_thread_wait. Those fail with "The tool call was interrupted before a result was received". Agents usually retry that one.

Script results on Claude Code 2.1.288:

In two more now runs the second call was read-only, so Claude Code ran it in parallel with the first and nothing was cancelled. Those turns still ended with aborted_tools.

Cause:

• For a delegated-task completion, the orchestrator picks steer_active when the session reports supportsActiveSteering. The Claude adapter reports true.
• ClaudeAdapterV2.steerTurn sends every steer with priority: "now". On now, Claude Code ends the current turn and cancels calls that haven't started.
• The refusal text comes from Claude Code, not from T3. Claude Code 2.1.288 already has a neutral message for this case, "[Tool call skipped: the turn ended to deliver the message that follows before this call ran. Nothing refused it; re-run it if still needed.]" A feature flag that is off by default gates it, so T3 can't count on it.

I think the fix is to send notification steers with priority: "next". Claude Code delivers those at the next tool boundary without ending the turn, which is what the next runs above show. User steers should keep "now", because #12541 explains why users want their own steers to land right away. I can open a PR once this is triaged.

Impact

Major degradation or frequent failure

Version or commit

Observed on the desktop app, 0.0.46-nightly.20261003.2632 on Linux. Code read against main @ 65731f9.

Environment

Linux on WSL2, Claude Code 2.1.288, @anthropic-ai/claude-agent-sdk 0.3.276, claude-opus-5-5, full-access runtime mode.

Logs or stack traces

Timeline from one affected thread, in UTC:

01:00:00.7  Bash call starts (about 7s)
01:00:01.3  Read of a .jpg in the same batch, waiting on the Bash call
01:00:05.0  Delegated-task completion notification steered into the turn
01:00:07.5  Bash finishes normally; Read fails with "The user doesn't want to take this action right now. STOP ..."
01:00:16.9  Agent: "I've paused, as you asked." The thread waits until someone sends a message.

A second thread showed the same sequence: the notification arrived at 02:07:16.9 and the queued Read was cancelled at 02:07:19.2.

Workaround

Tell agents in their prompt that this tool result means the call was cancelled and that they should retry it.

Related: #12541 covers Claude steer timing, and #15173 covers a Claude parent waiting on a delegate_task child.

Investigated with Opus 5.5 in Claude Code, running inside T3 Code.