test(claude): split the thinking-restart regression into two tests

Each case now states its own setup instead of branching inside one test body.

packages/server/src/server/agent/providers/claude/agent.interrupt-restart-regression.test.ts

@@ -278,45 +278,63 @@ afterEach(() => {
   queryFactory.mockReset();
 });
 
-test.each([false, true])(
+async function createThinkingRestartSession() {
-  "submits after a thinking change with no live query (previous query ended: %s)",
+  const queries: ScriptedQuery[] = [];
-  async (previousQueryEnded) => {
+  queryFactory.mockImplementation(({ prompt }: { prompt: AsyncIterable<unknown> }) => {
-    const queries: ScriptedQuery[] = [];
+    const scriptedQuery = createScriptedQuery({
-    queryFactory.mockImplementation(({ prompt }: { prompt: AsyncIterable<unknown> }) => {
+      prompt,
-      const scriptedQuery = createScriptedQuery({
+      sessionId: "thinking-restart-session",
-        prompt,
+      handlePrompt: ({ query }) => query.emit(buildSuccessResult("thinking-restart-session")),
-        sessionId: "thinking-restart-session",
-        handlePrompt: ({ query }) => query.emit(buildSuccessResult("thinking-restart-session")),
-      });
-      queries.push(scriptedQuery);
-      return scriptedQuery;
     });
-    const session = await new ClaudeAgentClient({
+    queries.push(scriptedQuery);
-      logger: createTestLogger(),
+    return scriptedQuery;
-      queryFactory,
+  });
-      resolveBinary: async () => "/test/claude/bin",
+  const session = await new ClaudeAgentClient({
-    }).createSession({ provider: "claude", cwd: process.cwd() });
+    logger: createTestLogger(),
+    queryFactory,
+    resolveBinary: async () => "/test/claude/bin",
+  }).createSession({ provider: "claude", cwd: process.cwd() });
+  return { session, queries };
+}
 
-    try {
+test("submits after a thinking change before the first turn", async () => {
-      if (previousQueryEnded) {
+  const { session, queries } = await createThinkingRestartSession();
-        await collectUntilTerminal(streamSession(session, "first prompt"));
+
-        queries[0].end();
+  try {
-        // Let the pump retire the old query before changing thinking.
+    await session.setThinkingOption!("medium");
-        await new Promise((resolve) => setTimeout(resolve, 0));
+    const events = await collectUntilTerminal(
-      }
+      streamSession(session, "continue", { clientMessageId: "client-continue" }),
-      await session.setThinkingOption!("medium");
+    );
-      const events = await collectUntilTerminal(
+    expect(events.filter((event) => event.type === "turn_failed")).toEqual([]);
-        streamSession(session, "continue", { clientMessageId: "client-continue" }),
+    expect(events.at(-1)?.type).toBe("turn_completed");
-      );
+    expect(queryFactory).toHaveBeenCalledTimes(1);
-      expect(events.filter((event) => event.type === "turn_failed")).toEqual([]);
+    expect(queries[0].prompts.map((prompt) => prompt.text)).toEqual(["continue"]);
-      expect(events.at(-1)?.type).toBe("turn_completed");
+  } finally {
-      expect(queryFactory).toHaveBeenCalledTimes(previousQueryEnded ? 2 : 1);
+    await session.close();
-      expect(queries.at(-1)?.prompts.map((prompt) => prompt.text)).toEqual(["continue"]);
+  }
-    } finally {
+});
-      await session.close();
+
-    }
+test("submits after a thinking change once the previous query ended", async () => {
-  },
+  const { session, queries } = await createThinkingRestartSession();
-);
+
+  try {
+    await collectUntilTerminal(streamSession(session, "first prompt"));
+    queries[0].end();
+    // Let the pump retire the old query before changing thinking.
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    await session.setThinkingOption!("medium");
+    const events = await collectUntilTerminal(
+      streamSession(session, "continue", { clientMessageId: "client-continue" }),
+    );
+    expect(events.filter((event) => event.type === "turn_failed")).toEqual([]);
+    expect(events.at(-1)?.type).toBe("turn_completed");
+    expect(queryFactory).toHaveBeenCalledTimes(2);
+    expect(queries[1].prompts.map((prompt) => prompt.text)).toEqual(["continue"]);
+  } finally {
+    await session.close();
+  }
+});
 
 test("interrupt only calls query.interrupt and leaves the query open", async () => {
   const logger = createTestLogger();