test(providers): reproduce plugin migration, steering, and chunk failures

packages/plugin/src/server/acp.test.ts

@@ -1246,6 +1246,49 @@ describe("runAcpProvider streamed chunks without messageId (#4699)", () => {
     messageId?: string;
   }
 
+  it("keeps reasoning separate from a reply sharing its native message ID", async () => {
+    const harness = connectorHarness({
+      promptUpdates: () => [
+        textChunk("private reasoning", "agent_thought_chunk", "shared-id"),
+        textChunk("public reply", "agent_message_chunk", "shared-id"),
+      ],
+    });
+    const registration = runAcpProvider({
+      id: "chunk-acp",
+      label: "Chunk ACP",
+      connector: harness.connector,
+    });
+    const connection = await registration.connect({
+      versions: [1],
+      capabilities: ["prompt.message"],
+    });
+    const events: ProviderEvent[] = [];
+    connection.onEvent((event) => events.push(event));
+    try {
+      await connection.send(openInput());
+      await waitForEvent(events, (event) => event.type === "session.ready");
+      await connection.send({
+        type: "session.prompt",
+        sessionId: "session-1",
+        prompt: {
+          clientMessageId: "same-id",
+          delivery: "auto",
+          input: { type: "message", content: [{ type: "text", text: "hello" }] },
+        },
+      });
+      await waitForEvent(
+        events,
+        (event) => event.type === "session.turn" && event.state === "completed",
+      );
+      const reply = events.findLast(
+        (event) => event.type === "timeline.item" && event.item.type === "assistant_message",
+      );
+      expect(reply).toMatchObject({ item: { text: "public reply" } });
+    } finally {
+      await connection.close();
+    }
+  });
+
   it("continues one timeline item per turn instead of one per chunk", async () => {
     const chunksByPrompt: Record<string, Chunk[]> = {
       first: [

packages/server/src/server/agent/plugin-provider.test.ts

@@ -287,6 +287,45 @@ function expectNestedChildren(events: AgentStreamEvent[]) {
 }
 
 describe("PluginAgentClientRegistry", () => {
+  test("returns unavailable when steering a provider without prompt.steer capability", async () => {
+    const harness = createProviderHarness();
+    const registry = new PluginAgentClientRegistry(createTestLogger());
+    registry.replace([harness.registration]);
+    const session = await registry.clients()[harness.registration.id]!.createSession({
+      provider: harness.registration.id,
+      cwd: "/tmp",
+    });
+    try {
+      await expect(
+        session.steerActiveTurn!("follow up", { expectedTurnId: "turn-1" }),
+      ).resolves.toEqual({ status: "unavailable" });
+      expect(harness.inputs.filter((input) => input.type === "session.prompt")).toHaveLength(0);
+    } finally {
+      await session.close();
+      registry.replace([]);
+    }
+  });
+
+  test("resumes a native ACP handle after the same provider ID moves to a plugin", async () => {
+    const harness = createProviderHarness();
+    const registry = new PluginAgentClientRegistry(createTestLogger());
+    registry.replace([harness.registration]);
+    try {
+      const session = await registry.clients()[harness.registration.id]!.resumeSession(
+        {
+          provider: harness.registration.id,
+          sessionId: "native-session-id",
+          nativeHandle: "native-session-id",
+          metadata: { provider: "acp", cwd: "/tmp" },
+        },
+        { provider: harness.registration.id, cwd: "/tmp" },
+      );
+      await session.close();
+    } finally {
+      registry.replace([]);
+    }
+  });
+
   test("stores only agent options while the plugin receives merged defaults", async () => {
     const logger = createTestLogger();
     const harness = createProviderHarness();

packages/server/src/server/agent/providers/claude/agent.background-subagent.test.ts

@@ -122,7 +122,7 @@ async function collectTimelineAcrossTurns(
           seq: rows.length + 1,
           timestamp: new Date(Date.UTC(2026, 9, 4, 0, 0, rows.length)).toISOString(),
           item: event.item,
-          ...((event.turnId ?? currentTurnId) ? { turnId: event.turnId ?? currentTurnId } : {}),
+          ...(currentTurnId ? { turnId: currentTurnId } : {}),
         });
       }
       if (event.type === "turn_completed" && ++completedTurns === turnCount) resolve();
@@ -469,145 +469,122 @@ describe("background Claude subagents", () => {
     });
   });
 
-  test.each(["before", "after"])(
-    "keeps one logged Task card when child tools start %s the parent finishes",
-    async (timing) => {
-      // A child can stream across the main session's turn boundary. Claude opens the next
-      // main-session turn with system/init; bare child frames do not open a turn.
-      queryFactory.mockImplementation(() =>
-        buildQueryMock([
-          { type: "system", subtype: "init", session_id: "bg-session", permissionMode: "default" },
-          {
-            type: "assistant",
-            message: {
-              model: "claude-haiku-4-5",
-              content: [
-                {
-                  type: "tool_use",
-                  id: "toolu_background",
-                  name: "Agent",
-                  input: {
-                    subagent_type: "general-purpose",
-                    description: "Count files here",
-                    prompt: "Run ls and reply with the number of entries.",
-                    run_in_background: true,
-                  },
+  test("keeps one logged Task card when the child streams on after the parent's turn ends", async () => {
+    // A child can stream across the main session's turn boundary. Claude opens the next
+    // main-session turn with system/init; bare child frames do not open a turn.
+    queryFactory.mockImplementation(() =>
+      buildQueryMock([
+        { type: "system", subtype: "init", session_id: "bg-session", permissionMode: "default" },
+        {
+          type: "assistant",
+          message: {
+            model: "claude-haiku-4-5",
+            content: [
+              {
+                type: "tool_use",
+                id: "toolu_background",
+                name: "Agent",
+                input: {
+                  subagent_type: "general-purpose",
+                  description: "Count files here",
+                  prompt: "Run ls and reply with the number of entries.",
+                  run_in_background: true,
                 },
-              ],
-            },
+              },
+            ],
           },
-          {
-            type: "system",
-            subtype: "task_started",
-            task_id: "bg-task",
-            tool_use_id: "toolu_background",
-            task_type: "local_agent",
-            subagent_type: "general-purpose",
-            description: "Count files here",
-            prompt: "Run ls and reply with the number of entries.",
-          },
-          {
-            type: "user",
-            message: {
-              role: "user",
-              content: [
-                {
-                  type: "tool_result",
-                  tool_use_id: "toolu_background",
-                  content: "Async agent launched successfully.",
-                },
-              ],
-            },
-          },
-          ...(timing === "after"
-            ? [
-                { type: "result", subtype: "success", usage: {}, total_cost_usd: 0 },
-                {
-                  type: "system",
-                  subtype: "init",
-                  session_id: "bg-session",
-                  permissionMode: "default",
-                },
-              ]
-            : []),
-          {
-            type: "assistant",
-            parent_tool_use_id: "toolu_background",
-            message: {
-              model: "claude-haiku-4-5",
-              content: [
-                {
-                  type: "tool_use",
-                  id: "toolu_ls",
-                  name: "Bash",
-                  input: { command: "ls -1", description: "List files" },
-                },
-              ],
-            },
-          },
-          ...(timing === "before"
-            ? [
-                { type: "result", subtype: "success", usage: {}, total_cost_usd: 0 },
-                {
-                  type: "system",
-                  subtype: "init",
-                  session_id: "bg-session",
-                  permissionMode: "default",
-                },
-              ]
-            : []),
-          {
-            type: "user",
-            parent_tool_use_id: "toolu_background",
-            message: {
-              role: "user",
-              content: [{ type: "tool_result", tool_use_id: "toolu_ls", content: "a\nb\nc" }],
-            },
-          },
-          {
-            type: "assistant",
-            parent_tool_use_id: "toolu_background",
-            message: { model: "claude-haiku-4-5", content: [{ type: "text", text: "3" }] },
-          },
-          {
-            type: "system",
-            subtype: "task_updated",
-            task_id: "bg-task",
-            patch: { status: "completed" },
-          },
-          {
-            type: "system",
-            subtype: "task_notification",
-            task_id: "bg-task",
-            tool_use_id: "toolu_background",
-            status: "completed",
-          },
-          { type: "result", subtype: "success", usage: {}, total_cost_usd: 0 },
-        ]),
-      );
-      const session = await new ClaudeAgentClient({
-        logger: createTestLogger(),
-        queryFactory,
-        resolveBinary: async () => "/test/claude/bin",
-      }).createSession({ provider: "claude", cwd: process.cwd() });
-      const rows = await collectTimelineAcrossTurns(session, "delegate work", 2);
-
-      const cards = projectTimelineRows({ rows, mode: "projected" })
-        .map((entry) => entry.item)
-        .filter((item) => item.type === "tool_call" && item.callId === "toolu_background");
-
-      expect(cards).toHaveLength(1);
-      expect(cards[0]).toMatchObject({
-        status: "completed",
-        detail: {
-          type: "sub_agent",
-          subAgentType: "general-purpose",
-          description: "Count files here",
-          log: "[Bash] ls -1",
         },
-      });
-    },
-  );
+        {
+          type: "system",
+          subtype: "task_started",
+          task_id: "bg-task",
+          tool_use_id: "toolu_background",
+          task_type: "local_agent",
+          subagent_type: "general-purpose",
+          description: "Count files here",
+          prompt: "Run ls and reply with the number of entries.",
+        },
+        {
+          type: "user",
+          message: {
+            role: "user",
+            content: [
+              {
+                type: "tool_result",
+                tool_use_id: "toolu_background",
+                content: "Async agent launched successfully.",
+              },
+            ],
+          },
+        },
+        {
+          type: "assistant",
+          parent_tool_use_id: "toolu_background",
+          message: {
+            model: "claude-haiku-4-5",
+            content: [
+              {
+                type: "tool_use",
+                id: "toolu_ls",
+                name: "Bash",
+                input: { command: "ls -1", description: "List files" },
+              },
+            ],
+          },
+        },
+        { type: "result", subtype: "success", usage: {}, total_cost_usd: 0 },
+        { type: "system", subtype: "init", session_id: "bg-session", permissionMode: "default" },
+        {
+          type: "user",
+          parent_tool_use_id: "toolu_background",
+          message: {
+            role: "user",
+            content: [{ type: "tool_result", tool_use_id: "toolu_ls", content: "a\nb\nc" }],
+          },
+        },
+        {
+          type: "assistant",
+          parent_tool_use_id: "toolu_background",
+          message: { model: "claude-haiku-4-5", content: [{ type: "text", text: "3" }] },
+        },
+        {
+          type: "system",
+          subtype: "task_updated",
+          task_id: "bg-task",
+          patch: { status: "completed" },
+        },
+        {
+          type: "system",
+          subtype: "task_notification",
+          task_id: "bg-task",
+          tool_use_id: "toolu_background",
+          status: "completed",
+        },
+        { type: "result", subtype: "success", usage: {}, total_cost_usd: 0 },
+      ]),
+    );
+    const session = await new ClaudeAgentClient({
+      logger: createTestLogger(),
+      queryFactory,
+      resolveBinary: async () => "/test/claude/bin",
+    }).createSession({ provider: "claude", cwd: process.cwd() });
+    const rows = await collectTimelineAcrossTurns(session, "delegate work", 2);
+
+    const cards = projectTimelineRows({ rows, mode: "projected" })
+      .map((entry) => entry.item)
+      .filter((item) => item.type === "tool_call" && item.callId === "toolu_background");
+
+    expect(cards).toHaveLength(1);
+    expect(cards[0]).toMatchObject({
+      status: "completed",
+      detail: {
+        type: "sub_agent",
+        subAgentType: "general-purpose",
+        description: "Count files here",
+        log: "[Bash] ls -1",
+      },
+    });
+  });
 
   test.each([
     {

packages/server/src/server/agent/providers/claude/agent.ts

@@ -2250,7 +2250,7 @@ class ClaudeAgentSession implements AgentSession {
   private readonly sidechainTracker = new ClaudeSidechainTracker({
     getToolInput: (toolUseId) =>
       this.toolUseCache.get(toolUseId)?.input ??
-      this.settledSubagentToolCalls.get(toolUseId)?.input ??
+      this.settledSubagentToolCallInCurrentTurn(toolUseId)?.input ??
       null,
     // Releases that predate the task protocol announce nothing, so the tracker keeps deriving
     // identity and status from frames for them. Detecting the capability beats comparing version
@@ -2258,11 +2258,13 @@ class ClaudeAgentSession implements AgentSession {
     isDescriptorOwnedElsewhere: () => this.taskProtocolSource.isActive,
     // A background child streams its frames after Claude has already answered the call, so its
     // card is rebuilt from the settled call: a running one would replace the settled, labeled card.
-    // Late card updates retain the turn that answered the call.
+    // A card belongs to the turn that answered the call, so frames from a later turn leave it be.
     needsSyntheticParentToolCard: (toolUseId) =>
-      (this.toolUseCache.has(toolUseId) || this.settledSubagentToolCalls.has(toolUseId)) &&
+      (this.toolUseCache.has(toolUseId) ||
+        this.settledSubagentToolCallInCurrentTurn(toolUseId) !== undefined) &&
       this.taskProtocolSource.needsSyntheticParentToolCard(toolUseId),
-    getSettledParentToolCall: (toolUseId) => this.settledSubagentToolCalls.get(toolUseId)?.item,
+    getSettledParentToolCall: (toolUseId) =>
+      this.settledSubagentToolCallInCurrentTurn(toolUseId)?.item,
   });
   private persistedHistory: PersistedTimelineEntry[] = [];
   private persistedProviderSubagentEvents: Extract<
@@ -4488,12 +4490,7 @@ class ClaudeAgentSession implements AgentSession {
       ),
     ).map((event): AgentStreamEvent => ({ type: "provider_subagent", provider: "claude", event }));
     const routedId = canonicalSubagentId ?? parentToolUseId;
-    const settled = this.settledSubagentToolCalls.get(routedId);
-    const sidechainEvents = this.sidechainTracker.handleMessage(message, routedId).map((event) => {
-      if (event.type === "timeline" && settled?.turnId) event.turnId = settled.turnId;
-      return event;
-    });
-    return [...runtimeEvents, ...sidechainEvents];
+    return [...runtimeEvents, ...this.sidechainTracker.handleMessage(message, routedId)];
   }
 
   /**
@@ -5148,8 +5145,7 @@ class ClaudeAgentSession implements AgentSession {
   }
 
   private notifySubscribers(event: AgentStreamEvent): void {
-    const turnId =
-      getAgentStreamEventTurnId(event) ?? this.activeForegroundTurnId ?? this.autonomousTurn?.id;
+    const turnId = this.activeForegroundTurnId ?? this.autonomousTurn?.id;
     const tagged = turnId ? { ...event, turnId } : event;
     this.logger.trace(
       {
@@ -5625,12 +5621,17 @@ class ClaudeAgentSession implements AgentSession {
     });
   }
 
+  private settledSubagentToolCallInCurrentTurn(subagentId: string) {
+    const settled = this.settledSubagentToolCalls.get(subagentId);
+    const currentTurnId = this.activeForegroundTurnId ?? this.autonomousTurn?.id ?? null;
+    return settled && settled.turnId === currentTurnId ? settled : undefined;
+  }
+
   /** A finished child streams no more frames, so its settled call has nothing left to update. */
   private releaseFinishedSubagentToolCalls(observations: SubagentObservation[]): void {
     for (const observation of observations) {
       if (observation.kind === "status" && observation.status !== "running") {
         this.settledSubagentToolCalls.delete(observation.id);
-        this.sidechainTracker.delete(observation.id);
       }
     }
   }

packages/server/src/server/agent/providers/claude/sidechain-tracker.test.ts

@@ -4,40 +4,6 @@ import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 import { ClaudeSidechainTracker } from "./sidechain-tracker.js";
 
 describe("ClaudeSidechainTracker", () => {
-  it("retains a background child's actions across the parent finishing", () => {
-    const tracker = new ClaudeSidechainTracker({
-      getToolInput: () => ({ subagent_type: "general-purpose", description: "List files" }),
-      isDescriptorOwnedElsewhere: () => true,
-    });
-    const action = (id: string, command: string) =>
-      ({
-        type: "assistant",
-        parent_tool_use_id: "task-1",
-        message: { content: [{ type: "tool_use", id, name: "Bash", input: { command } }] },
-      }) as unknown as SDKMessage;
-    tracker.handleMessage(action("ls", "ls -1"), "task-1");
-    expect(tracker.finishAll("completed")).toEqual([]);
-    const events = tracker.handleMessage(action("pwd", "pwd"), "task-1");
-    expect(events).toContainEqual(
-      expect.objectContaining({
-        type: "timeline",
-        item: expect.objectContaining({
-          detail: expect.objectContaining({ log: "[Bash] ls -1\n[Bash] pwd" }),
-        }),
-      }),
-    );
-    tracker.delete("task-1");
-    const next = tracker.handleMessage(action("next", "ls"), "task-1");
-    expect(next).toContainEqual(
-      expect.objectContaining({
-        type: "timeline",
-        item: expect.objectContaining({
-          detail: expect.objectContaining({ log: "[Bash] ls" }),
-        }),
-      }),
-    );
-  });
-
   it("uses Claude's native agent name for the provider subagent title", () => {
     const tracker = new ClaudeSidechainTracker({
       getToolInput: () => ({

packages/server/src/server/agent/providers/claude/sidechain-tracker.ts

@@ -199,7 +199,7 @@ export class ClaudeSidechainTracker {
   finishAll(status: "completed" | "failed" | "canceled"): AgentStreamEvent[] {
     const events: AgentStreamEvent[] = [];
     if (this.isDescriptorOwnedElsewhere()) {
-      // The task protocol owns child completion; the parent finishing does not end its children.
+      this.activeSidechains.clear();
       return events;
     }
     for (const [id, state] of this.activeSidechains) {

packages/server/src/server/daemon-e2e/background-subagent-action-log.real.e2e.test.ts

@@ -1,105 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { fileURLToPath } from "node:url";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import pino from "pino";
-import { expect, test } from "vitest";
-import { ClaudeAgentClient } from "../agent/providers/claude/agent.js";
-import { createTestPaseoDaemon } from "../test-utils/paseo-daemon.js";
-import { DaemonClient } from "../test-utils/daemon-client.js";
-
-test("background cards retain child actions after the parent finishes (#6253)", async () => {
-  const cwd = mkdtempSync(path.join(tmpdir(), "paseo-background-card-"));
-  const logger = pino({ level: "silent" });
-  const daemon = await createTestPaseoDaemon({
-    logger,
-    agentClients: { claude: new ClaudeAgentClient({ logger }) },
-  });
-  const client = new DaemonClient({ url: `ws://127.0.0.1:${daemon.port}/ws` });
-  try {
-    await client.connect();
-    await client.fetchAgents({ subscribe: {} });
-    const agent = await client.createAgent({
-      provider: "claude",
-      model: "haiku",
-      modeId: "bypassPermissions",
-      cwd,
-      title: "Background action log reproduction",
-    });
-    await client.sendMessage(
-      agent.id,
-      'In one message, call Agent twice with run_in_background true: first with subagent_type "general-purpose", description "List files", prompt "Run ls -1, then run sleep 20, then reply with the number of entries."; second with subagent_type "general-purpose", description "Print cwd", prompt "Run pwd, then run sleep 20, then reply with the path." After launching both, reply "launched" and end your turn immediately without waiting.',
-    );
-    await client.waitForFinish(agent.id, 180_000);
-    const atFinish = await client.fetchAgentTimeline(agent.id, {
-      direction: "tail",
-      limit: 0,
-      projection: "projected",
-    });
-    await expect
-      .poll(
-        async () => {
-          const { subagents } = await client.listProviderSubagents(agent.id);
-          return subagents.length === 2 && subagents.every((child) => child.status === "completed");
-        },
-        { timeout: 180_000, interval: 1000 },
-      )
-      .toBe(true);
-    const { subagents } = await client.listProviderSubagents(agent.id);
-    const children = await Promise.all(
-      subagents.map(async (child) => ({
-        description: child.description,
-        timeline: await client.fetchProviderSubagentTimeline(agent.id, child.id, {
-          direction: "tail",
-          limit: 0,
-        }),
-      })),
-    );
-    const final = await client.fetchAgentTimeline(agent.id, {
-      direction: "tail",
-      limit: 0,
-      projection: "projected",
-    });
-    const { stdout } = await promisify(execFile)(
-      process.execPath,
-      [
-        "--conditions=source",
-        "--import",
-        "tsx",
-        fileURLToPath(new URL("../../../../cli/src/index.ts", import.meta.url)),
-        "--host",
-        `127.0.0.1:${daemon.port}`,
-        "logs",
-        agent.id,
-      ],
-      { env: { ...process.env, PASEO_HOME: daemon.paseoHome }, timeout: 30_000 },
-    );
-    expect(stdout).toContain("[Bash] ls -1");
-    expect(stdout).toContain("[Bash] pwd");
-    expect(
-      atFinish.entries.filter(
-        (row) => row.item.type === "tool_call" && row.item.detail?.type === "sub_agent",
-      ),
-    ).toHaveLength(2);
-    const cards = final.entries
-      .map((row) => row.item)
-      .filter((item) => item.type === "tool_call" && item.detail?.type === "sub_agent");
-    expect(cards).toHaveLength(2);
-    for (const child of children) {
-      expect(
-        child.timeline.rows.some(
-          (row) => row.item.type === "tool_call" && row.item.name === "Bash",
-        ),
-      ).toBe(true);
-    }
-    for (const card of cards) {
-      expect(card.detail?.type === "sub_agent" ? card.detail.log : "").toContain("[Bash]");
-    }
-  } finally {
-    await client.close();
-    await daemon.close();
-    rmSync(cwd, { recursive: true, force: true });
-  }
-}, 420_000);

packages/server/vitest.config.ts

@@ -19,6 +19,9 @@ export default defineConfig({
     setupFiles: [path.resolve(__dirname, "./src/test-utils/vitest-setup.ts")],
     pool: "forks",
     fileParallelism: false,
+    // Even two concurrent Git-heavy suites can exhaust Windows test deadlines.
+    // Run files serially so their subprocesses do not compete across suites.
+    maxWorkers: process.platform === "win32" ? 1 : undefined,
     exclude: ["**/node_modules/**", "**/dist/**", "**/.claude/**", "**/.dev/**"],
   },
 });