fix(agent): decide the setup-window cancel on the counter alone

The bail also required `session.cancelled`, which any turn's activation
clears. A local-only command skips the pre-prompt status check the stalled
prompt is parked in, so it can queue and activate in that window; the reset
erased the very cancel the check exists to catch, and the cancelled prompt
went to the SDK anyway.

`cancelSeq` is monotonic and incremented only in `cancel()`, in the same
synchronous block that sets `cancelled`, so comparing it against the entry
snapshot survives an unrelated activation. The flag stays untouched here,
because an earlier turn may still be settling against it.

Claude-Session: https://claude.ai/code/session_01KT3ZQ47bqT9mW4fi458Q6V

Author: haacked

packages/agent/src/adapters/claude/claude-agent.cancel-during-setup.test.ts

@@ -1,5 +1,8 @@
 import type { AgentSideConnection } from "@agentclientprotocol/sdk";
-import type { SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
+import type {
+  SDKMessage,
+  SDKUserMessage,
+} from "@anthropic-ai/claude-agent-sdk";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import {
   createMockQuery,
@@ -42,9 +45,15 @@ interface Harness {
   finishSetup: () => void;
   /** Drives the queued turn to a normal completion. */
   completeTurn: () => Promise<void>;
+  /** Promotes the queued turn the way a local-only command's output does. */
+  activateQueuedTurn: () => Promise<void>;
+  /** Ends the active turn with the SDK's terminal result. */
+  finishTurn: () => void;
   /** Whether anything was handed to the SDK. */
   sdkReceivedMessage: () => boolean;
-  prompt: () => Promise<{ stopReason: string; _meta?: unknown }>;
+  /** The text of every message handed to the SDK, in order. */
+  sdkPromptTexts: () => string[];
+  prompt: (text?: string) => Promise<{ stopReason: string; _meta?: unknown }>;
 }
 
 /**
@@ -124,11 +133,22 @@ function makeHarness(): Harness {
     session,
     inSetup,
     finishSetup: () => releaseSetup([]),
-    prompt: () =>
+    prompt: (text = "do the thing") =>
       agent.prompt({
         sessionId: SESSION_ID,
-        prompt: [{ type: "text", text: "do the thing" }],
+        prompt: [{ type: "text", text }],
       }) as Promise<{ stopReason: string; _meta?: unknown }>,
+    activateQueuedTurn: async () => {
+      query._mockHelpers.sendMessage({
+        type: "system",
+        subtype: "local_command_output",
+        content: "context report",
+        uuid: crypto.randomUUID(),
+        session_id: SESSION_ID,
+      } as SDKMessage);
+      await tick();
+    },
+    finishTurn: () => query._mockHelpers.complete(createSuccessResult()),
     // Echo the turn's own user message back, then send the terminal result, the
     // way the SDK would for a turn that ran to completion.
     completeTurn: async () => {
@@ -138,6 +158,16 @@ function makeHarness(): Harness {
       query._mockHelpers.complete(createSuccessResult());
     },
     sdkReceivedMessage: () => pushToSdk.mock.calls.length > 0,
+    sdkPromptTexts: () =>
+      pushToSdk.mock.calls.map(([message]) => {
+        const content = message.message.content;
+        if (typeof content === "string") {
+          return content;
+        }
+        return content
+          .map((block) => (block.type === "text" ? block.text : ""))
+          .join("");
+      }),
   };
 }
 
@@ -218,6 +248,30 @@ describe("cancel arriving while a prompt is being set up", () => {
     expect(h.session.cancelled).toBe(false);
   });
 
+  it("drops the prompt even when a later turn activates during setup", async () => {
+    const h = makeHarness();
+
+    const cancelled = h.prompt();
+    await h.inSetup;
+    await h.agent.cancel({ sessionId: SESSION_ID });
+
+    // A local-only command skips the pre-prompt status check the first prompt is
+    // parked in, so it queues and activates while that prompt is still stalled.
+    // Activation clears `session.cancelled`, leaving the count as the only record
+    // that a cancel landed.
+    const local = h.prompt("/context");
+    await h.activateQueuedTurn();
+    expect(h.session.cancelled).toBe(false);
+
+    h.finishSetup();
+
+    await expect(cancelled).resolves.toMatchObject({ stopReason: "cancelled" });
+    expect(h.sdkPromptTexts()).toEqual(["/context"]);
+
+    h.finishTurn();
+    await expect(local).resolves.toMatchObject({ stopReason: "end_turn" });
+  });
+
   it("leaves a mismatched cancel uncounted", async () => {
     const h = makeHarness();
 

packages/agent/src/adapters/claude/claude-agent.ts

@@ -525,10 +525,13 @@ export class ClaudeAcpAgent extends BaseAcpAgent {
 
     // A cancel counted during setup targets this prompt. It is not queued yet, so
     // `interrupt()` had nothing to stop and armed no backstop; returning here,
-    // before the message reaches the SDK, is what actually cancels it. Leave
-    // `cancelled` standing: an earlier turn may still be settling against it, and
-    // `activateTurn` clears it for the next turn that runs.
-    if (this.session.cancelSeq > cancelSeqAtEntry && this.session.cancelled) {
+    // before the message reaches the SDK, is what actually cancels it. The counter
+    // alone decides: `session.cancelled` belongs to the session, and `activateTurn`
+    // clears it for whichever turn runs next, so a prompt that raced past this one
+    // into the queue would otherwise erase the cancel this check exists to catch.
+    // The flag is left standing here, because an earlier turn may still be settling
+    // against it.
+    if (this.session.cancelSeq > cancelSeqAtEntry) {
       return this.cancelledResponse();
     }