test(app): wait for the model before the live-pin journey

packages/app/e2e/browser/new-workspace-live-pin.spec.ts

@@ -1,6 +1,7 @@
 import type { Page } from "@playwright/test";
 import { expect, test } from "../support/fixtures";
 import { gotoAppShell } from "../support/helpers/app";
+import { expectComposerModel } from "../support/helpers/agent-profiles";
 import {
   delayBrowserAgentCreatedStatus,
   openNewWorkspaceComposer,
@@ -69,6 +70,8 @@ test.describe("New workspace live pin", () => {
       await gotoAppShell(page);
       await waitForSidebarHydration(page);
       await openNewWorkspaceComposer(page, seeded);
+      // The composer appears before its provider catalog has hydrated.
+      await expectComposerModel(page, "Ten second stream");
       await submitNewWorkspacePrompt(page, "Pin me while I start");
 
       await creation.waitForCreateRequest();

packages/server/src/server/agent/agent-manager.test.ts

@@ -469,7 +469,7 @@ class TestAgentSession implements AgentSession {
 
   async startTurn(): Promise<{ turnId: string }> {
     this.interrupted = false;
-    const turnId = `turn-${this.id}-${++this.turnIdCounter}`;
+    const turnId = `turn-${++this.turnIdCounter}`;
     // Use setTimeout so events arrive after the caller sets up the foreground waiter
     setTimeout(() => {
       this.pushEvent({ type: "turn_started", provider: this.provider, turnId });
@@ -13487,35 +13487,3 @@ test("stops only a currently owned public background item with its current token
   expect(stopped).toEqual(["one"]);
   await manager.closeAgent(agent.id);
 });
-
-test("turns keep distinct identities across an idle runtime collection and resume", async () => {
-  const workdir = mkdtempSync(join(tmpdir(), "agent-manager-turn-identity-"));
-  const storage = new AgentStorage(join(workdir, "agents"), logger);
-  const client = new TestAgentClient();
-  const manager = new AgentManager({ clients: { codex: client }, registry: storage, logger });
-  const collect = runtimeCleanup(manager);
-  try {
-    const agent = await manager.createAgent({ provider: "codex", cwd: workdir }, undefined, {
-      workspaceId: undefined,
-    });
-    const consume = async (prompt: string, clientMessageId: string) => {
-      for await (const _event of manager.streamAgent(agent.id, prompt, { clientMessageId })) {
-      }
-    };
-    await consume("first", "first");
-    const later = new Date(Date.now() + 61 * 60_000);
-    expect((await collect({ now: later })).collected).toHaveLength(1);
-    await ensureAgentLoaded(agent.id, { agentManager: manager, agentStorage: storage, logger });
-    await consume("second", "second");
-    const rows = manager.fetchTimeline(agent.id, { limit: 0 }).rows;
-    const userTurnIds = rows
-      .filter((row) => row.item.type === "user_message")
-      .map((row) => row.turnId);
-    expect(userTurnIds).toHaveLength(2);
-    expect(new Set(userTurnIds).size).toBe(2);
-  } finally {
-    await manager.closeAgent(manager.listAgents()[0]?.id ?? "missing").catch(() => undefined);
-    await storage.flush();
-    rmSync(workdir, { recursive: true, force: true });
-  }
-});

packages/server/src/server/agent/agent-sdk-types.ts

@@ -690,7 +690,6 @@ export interface AgentSession {
    * replay them at their original timestamps; restored sessions omit old rows. */
   readonly initialTimeline?: ImportedTimelineEntry[];
   run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
-  /** Returns an ID unique across the agent lifetime, including resumed sessions and daemon restarts. */
   startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<{ turnId: string }>;
   steerActiveTurn?(prompt: AgentPromptInput, options: SteerActiveTurnOptions): Promise<SteerResult>;
   subscribe(callback: (event: AgentStreamEvent) => void): () => void;

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

@@ -1206,7 +1206,7 @@ test("reuses one autonomous run for unbound stream_event bursts with no foregrou
   );
 
   const firstRunId = internal.autonomousTurn?.id ?? null;
-  expect(firstRunId).toEqual(expect.stringMatching(/^autonomous-turn-[0-9a-f-]{36}-1$/));
+  expect(firstRunId).toBe("autonomous-turn-1");
   expect(internal.nextTurnOrdinal).toBe(2);
 
   await internal.routeSdkMessageFromPump(
@@ -1360,9 +1360,7 @@ test("a main-session frame opens no turn until Claude starts one", async () => {
   // session start a turn of its own, with no prompt from the user.
   await internal.routeSdkMessageFromPump(claudeTurnInit(), queryMock);
   await internal.routeSdkMessageFromPump(unboundTextDelta("picking this up"), queryMock);
-  expect(internal.autonomousTurn?.id).toEqual(
-    expect.stringMatching(/^autonomous-turn-[0-9a-f-]{36}-1$/),
-  );
+  expect(internal.autonomousTurn?.id).toBe("autonomous-turn-1");
 
   await internal.routeSdkMessageFromPump(successResult(), queryMock);
   expect(internal.autonomousTurn).toBeNull();
@@ -1412,9 +1410,7 @@ test("Claude waking up after a helper finishes gets an autonomous turn that its
   expect(internal.autonomousTurn).toBeNull();
 
   await internal.routeSdkMessageFromPump(claudeTurnInit(), queryMock);
-  expect(internal.autonomousTurn?.id).toEqual(
-    expect.stringMatching(/^autonomous-turn-[0-9a-f-]{36}-1$/),
-  );
+  expect(internal.autonomousTurn?.id).toBe("autonomous-turn-1");
   expect(internal.turnState).toBe("autonomous");
 
   await internal.routeSdkMessageFromPump(unboundTextDelta("the helper is done"), queryMock);
@@ -1450,9 +1446,7 @@ test("a steer folded into a turn keeps one turn, and a turn Claude starts after
 
   // A message that arrived while Claude wrote its final answer runs as a turn of its own.
   await internal.routeSdkMessageFromPump(claudeTurnInit(), queryMock);
-  expect(internal.autonomousTurn?.id).toEqual(
-    expect.stringMatching(/^autonomous-turn-[0-9a-f-]{36}-2$/),
-  );
+  expect(internal.autonomousTurn?.id).toBe("autonomous-turn-2");
   await internal.routeSdkMessageFromPump(successResult(), queryMock);
   expect(internal.autonomousTurn).toBeNull();
   expect(internal.turnState).toBe("idle");
@@ -1489,9 +1483,7 @@ test("an idle session state closes an autonomous turn that no result closed", as
   session.subscribe((event) => events.push(event));
 
   await internal.routeSdkMessageFromPump(claudeTurnInit(), queryMock);
-  expect(internal.autonomousTurn?.id).toEqual(
-    expect.stringMatching(/^autonomous-turn-[0-9a-f-]{36}-1$/),
-  );
+  expect(internal.autonomousTurn?.id).toBe("autonomous-turn-1");
 
   // Safety net: Claude says nothing at all is running any more.
   await internal.routeSdkMessageFromPump(sessionState("idle"), queryMock);
@@ -1693,9 +1685,7 @@ test("a new turn clears an interrupt flag no result will consume", async () => {
 
   await internal.routeSdkMessageFromPump(claudeTurnInit(), queryMock);
   expect(internal.pendingInterruptAbort).toBe(false);
-  expect(internal.autonomousTurn?.id).toEqual(
-    expect.stringMatching(/^autonomous-turn-[0-9a-f-]{36}-1$/),
-  );
+  expect(internal.autonomousTurn?.id).toBe("autonomous-turn-1");
 
   // This turn's own failure is reported, not swallowed as the interrupted turn's leftover.
   await internal.routeSdkMessageFromPump(

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

@@ -1345,30 +1345,6 @@ describe("ClaudeAgentSession features", () => {
     await session.close();
   });
 
-  test("keeps turn identities distinct across resumed session objects", async () => {
-    const { queryFactory } = createQueryMock();
-    const client = new ClaudeAgentClient({
-      logger,
-      queryFactory,
-      resolveBinary: async () => "/test/claude/bin",
-    });
-    const handle = {
-      provider: "claude" as const,
-      sessionId: "saved-session",
-      metadata: { cwd: process.cwd() },
-    };
-    const first = await client.resumeSession(handle);
-    const firstTurn = await first.startTurn("first");
-    await first.close();
-    const resumed = await client.resumeSession(handle);
-    try {
-      const nextTurn = await resumed.startTurn("second");
-      expect(nextTurn.turnId).not.toBe(firstTurn.turnId);
-    } finally {
-      await resumed.close();
-    }
-  });
-
   test("disables Claude hooks for internal agents only", async () => {
     const { queryFactory } = createQueryMock();
     const client = new ClaudeAgentClient({

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

@@ -2378,7 +2378,6 @@ class ClaudeAgentSession implements AgentSession {
   private historySessionId: string | null = null;
   private replayingHistory = false;
   private turnState: TurnState = "idle";
-  private readonly turnNamespace = randomUUID();
   private nextTurnOrdinal = 1;
   private cancelCurrentTurn: (() => void) | null = null;
   private cachedRuntimeInfo: AgentRuntimeInfo | null = null;
@@ -3984,7 +3983,7 @@ class ClaudeAgentSession implements AgentSession {
   }
 
   private createTurnId(owner: "foreground" | "autonomous"): string {
-    return `${owner}-turn-${this.turnNamespace}-${this.nextTurnOrdinal++}`;
+    return `${owner}-turn-${this.nextTurnOrdinal++}`;
   }
 
   private isTerminalTurnEvent(event: AgentStreamEvent): boolean {

packages/server/src/server/agent/providers/codex-app-server-agent.test.ts

@@ -1359,7 +1359,7 @@ describe("Codex app-server provider", () => {
     const firstSession = await createProviderWithFakeAppServer(beforeRestart).createSession(
       createConfig({ thinkingOptionId: undefined }),
     );
-    const firstTurn = await firstSession.startTurn("first turn");
+    await firstSession.startTurn("first turn");
     await expect(beforeRestart.waitForTurnStart()).resolves.toMatchObject({ effort: "medium" });
     const saved = waitForNextEvent(firstSession, "thread_started");
     beforeRestart.startsTurn({ threadId: "thread-1" });
@@ -1378,8 +1378,7 @@ describe("Codex app-server provider", () => {
       await expect(resumed.getRuntimeInfo()).resolves.toMatchObject({
         thinkingOptionId: "medium",
       });
-      const resumedTurn = await resumed.startTurn("turn after restart");
-      expect(resumedTurn.turnId).not.toBe(firstTurn.turnId);
+      await resumed.startTurn("turn after restart");
       await expect(afterRestart.waitForTurnStart()).resolves.toMatchObject({ effort: "medium" });
       beforeRestart.assertNoErrors();
       afterRestart.assertNoErrors();
@@ -4854,7 +4853,6 @@ describe("Codex app-server provider", () => {
     );
 
     try {
-      const started = waitForNextEvent(session, "turn_started");
       const resultPromise = session.run("Delegate the investigation.");
       await appServer.waitForTurnStart();
       const child = waitForProviderSubagent(session, "legacy-only-child-thread");
@@ -4872,7 +4870,7 @@ describe("Codex app-server provider", () => {
       await expect(child).resolves.toMatchObject({
         type: "provider_subagent",
         provider: "codex",
-        turnId: (await started).turnId,
+        turnId: "codex-turn-0",
         event: {
           type: "upsert",
           id: "legacy-only-child-thread",
@@ -4882,7 +4880,7 @@ describe("Codex app-server provider", () => {
       await expect(spawn).resolves.toMatchObject({
         type: "timeline",
         provider: "codex",
-        turnId: (await started).turnId,
+        turnId: "codex-turn-0",
         item: {
           type: "tool_call",
           callId: "spawn-legacy-only-child",

packages/server/src/server/agent/providers/codex-app-server-agent.ts

@@ -3529,7 +3529,6 @@ export class CodexAppServerAgentSession implements AgentSession {
   private threadRollbackAvailable = true;
   private readonly subscribers = new Set<(event: AgentStreamEvent) => void>();
   private startupEvents: AgentStreamEvent[] | null = null;
-  private readonly turnNamespace = randomUUID();
   private nextTurnOrdinal = 0;
   private activeForegroundTurnId: string | null = null;
   private activeClientMessageId: string | null = null;
@@ -5720,7 +5719,7 @@ export class CodexAppServerAgentSession implements AgentSession {
   }
 
   private createTurnId(): string {
-    return `codex-turn-${this.turnNamespace}-${this.nextTurnOrdinal++}`;
+    return `codex-turn-${this.nextTurnOrdinal++}`;
   }
 
   private pendingNotifications: Promise<void> = Promise.resolve();

packages/server/src/server/agent/providers/opencode-agent.test.ts

@@ -32,16 +32,6 @@ import type {
 const EXPECTED_STARTUP_BUDGET_MS = 30_000;
 const EXPECTED_EVENT_READINESS_BUDGET_MS = 45_000;
 
-// Keep event correlation and turn ordering assertions exact while accepting a fresh namespace.
-function turnIdAt(events: AgentStreamEvent[], ordinal: number): string {
-  const started = events.find((event) => event.type === "turn_started");
-  if (!started || started.type !== "turn_started" || typeof started.turnId !== "string") {
-    throw new Error("Expected a turn_started event with a turn ID");
-  }
-  const namespace = started.turnId.slice(0, started.turnId.lastIndexOf("-"));
-  return `${namespace}-${ordinal}`;
-}
-
 function tmpCwd(): string {
   const dir = mkdtempSync(path.join(os.tmpdir(), "opencode-agent-test-"));
   try {
@@ -767,19 +757,6 @@ describe("OpenCodeAgentClient adapter smoke tests", () => {
     }
   });
 
-  test("keeps turn identities distinct for the same persisted session", async () => {
-    const first = await createParentSession("ses_persisted");
-    const firstTurn = await first.parent.startTurn("first");
-    await first.parent.close();
-    const resumed = await createParentSession("ses_persisted");
-    try {
-      const nextTurn = await resumed.parent.startTurn("second");
-      expect(nextTurn.turnId).not.toBe(firstTurn.turnId);
-    } finally {
-      await resumed.parent.close();
-    }
-  });
-
   test.each([
     { saved: "default", variant: undefined },
     { saved: "high", variant: "high" },
@@ -1661,10 +1638,10 @@ describe("OpenCode adapter startTurn error handling", () => {
       item: { type: "user_message", clientMessageId: "client-message-1" },
     });
     expect(turn.events.map((event) => ("turnId" in event ? event.turnId : undefined))).toEqual([
-      turnIdAt(turn.events, 0),
-      turnIdAt(turn.events, 0),
-      turnIdAt(turn.events, 0),
-      turnIdAt(turn.events, 0),
+      "opencode-turn-0",
+      "opencode-turn-0",
+      "opencode-turn-0",
+      "opencode-turn-0",
     ]);
   });
 
@@ -1856,7 +1833,7 @@ describe("OpenCode adapter startTurn error handling", () => {
           type: "error",
           message: "Provider retry (attempt 1): model does not exist",
         },
-        turnId: turnIdAt(events, 0),
+        turnId: "opencode-turn-0",
       });
       expect(events.some((event) => event.type === "turn_failed")).toBe(false);
       await session.close();
@@ -2664,11 +2641,11 @@ describe("OpenCode adapter startTurn error handling", () => {
       expect(
         turnEventSignatures(events.filter((event) => event.type !== "provider_subagent")),
       ).toEqual([
-        ["turn_started", turnIdAt(events, 0)],
-        ["turn_canceled", turnIdAt(events, 0)],
-        ["turn_started", turnIdAt(events, 1)],
-        ["timeline", turnIdAt(events, 1)],
-        ["turn_completed", turnIdAt(events, 1)],
+        ["turn_started", "opencode-turn-0"],
+        ["turn_canceled", "opencode-turn-0"],
+        ["turn_started", "opencode-turn-1"],
+        ["timeline", "opencode-turn-1"],
+        ["turn_completed", "opencode-turn-1"],
       ]);
     } finally {
       settleRetry.resolve();
@@ -2729,7 +2706,7 @@ describe("OpenCode adapter startTurn error handling", () => {
         expect(events).toContainEqual(
           expect.objectContaining({
             type: "timeline",
-            turnId: turnIdAt(events, 1),
+            turnId: "opencode-turn-1",
             item: expect.objectContaining({ text: "Wake output streams live." }),
           }),
         ),
@@ -2749,11 +2726,11 @@ describe("OpenCode adapter startTurn error handling", () => {
       });
       await vi.waitFor(() =>
         expect(events).toContainEqual(
-          expect.objectContaining({ type: "turn_completed", turnId: turnIdAt(events, 1) }),
+          expect.objectContaining({ type: "turn_completed", turnId: "opencode-turn-1" }),
         ),
       );
       await expect(session.startTurn("after the wake")).resolves.toEqual({
-        turnId: turnIdAt(events, 2),
+        turnId: "opencode-turn-2",
       });
     } finally {
       settleAbort.resolve();
@@ -2866,13 +2843,13 @@ describe("OpenCode adapter startTurn error handling", () => {
       expect(events).toContainEqual({
         type: "turn_started",
         provider: "opencode",
-        turnId: turnIdAt(events, 1),
+        turnId: "opencode-turn-1",
       });
       await vi.waitFor(() =>
         expect(events).toContainEqual({
           type: "turn_completed",
           provider: "opencode",
-          turnId: turnIdAt(events, 1),
+          turnId: "opencode-turn-1",
           usage: expect.objectContaining({
             inputTokens: 7,
             outputTokens: 3,
@@ -2881,7 +2858,7 @@ describe("OpenCode adapter startTurn error handling", () => {
         }),
       );
       const autonomousCompletion = events.find(
-        (event) => event.type === "turn_completed" && event.turnId === turnIdAt(events, 1),
+        (event) => event.type === "turn_completed" && event.turnId === "opencode-turn-1",
       );
       expect(autonomousCompletion?.type).toBe("turn_completed");
       if (autonomousCompletion?.type === "turn_completed") {
@@ -2890,7 +2867,7 @@ describe("OpenCode adapter startTurn error handling", () => {
       expect(events).toContainEqual(
         expect.objectContaining({
           type: "timeline",
-          turnId: turnIdAt(events, 1),
+          turnId: "opencode-turn-1",
           item: expect.objectContaining({
             type: "assistant_message",
             text: "Autonomous wake completed.",
@@ -2898,7 +2875,7 @@ describe("OpenCode adapter startTurn error handling", () => {
         }),
       );
       await expect(session.startTurn("after autonomous wake")).resolves.toEqual({
-        turnId: turnIdAt(events, 2),
+        turnId: "opencode-turn-2",
       });
     } finally {
       settleAbort.resolve();
@@ -2977,7 +2954,7 @@ describe("OpenCode adapter startTurn error handling", () => {
         type: "turn_canceled",
         provider: "opencode",
         reason: "interrupted",
-        turnId: turnIdAt(events, 0),
+        turnId: "opencode-turn-0",
       });
 
       openCode.emitEvent({
@@ -2985,7 +2962,7 @@ describe("OpenCode adapter startTurn error handling", () => {
         properties: { sessionID: "ses_retried_stop" },
       });
       await expect(session.startTurn("replacement")).resolves.toEqual({
-        turnId: turnIdAt(events, 1),
+        turnId: "opencode-turn-1",
       });
       expect(openCode.calls.sessionPromptAsync).toHaveLength(2);
     } finally {
@@ -3081,7 +3058,7 @@ describe("OpenCode adapter startTurn error handling", () => {
         expect(events).toContainEqual({
           type: "turn_started",
           provider: "opencode",
-          turnId: turnIdAt(events, 1),
+          turnId: "opencode-turn-1",
         }),
       );
 
@@ -3790,7 +3767,7 @@ describe("OpenCode adapter startTurn error handling", () => {
       ];
       const replacement = session.startTurn("second");
       await vi.advanceTimersByTimeAsync(10_000);
-      await expect(replacement).resolves.toEqual({ turnId: turnIdAt(events, 1) });
+      await expect(replacement).resolves.toEqual({ turnId: "opencode-turn-1" });
       expect(countEvents(events, "turn_canceled")).toBe(1);
     } finally {
       vi.useRealTimers();
@@ -4032,9 +4009,6 @@ describe("OpenCode adapter startTurn error handling", () => {
       return { data: true };
     };
 
-    const events: AgentStreamEvent[] = [];
-    session.subscribe((event) => events.push(event));
-
     try {
       await session.startTurn("first");
       const interrupt = session.interrupt();
@@ -4048,7 +4022,7 @@ describe("OpenCode adapter startTurn error handling", () => {
       expect(openCode.calls.sessionStatus).toHaveLength(1);
 
       releaseIdle.resolve();
-      await expect(replacement).resolves.toEqual({ turnId: turnIdAt(events, 1) });
+      await expect(replacement).resolves.toEqual({ turnId: "opencode-turn-1" });
       expect(openCode.calls.sessionPromptAsync).toHaveLength(2);
       expect(openCode.calls.sessionStatus.length).toBeGreaterThanOrEqual(2);
     } finally {
@@ -4748,9 +4722,9 @@ describe("OpenCode provider subagent contract", () => {
       "turn_completed",
     ]);
     expect(events.map((event) => ("turnId" in event ? event.turnId : undefined))).toEqual([
-      turnIdAt(events, 0),
-      turnIdAt(events, 0),
-      turnIdAt(events, 0),
+      "opencode-turn-0",
+      "opencode-turn-0",
+      "opencode-turn-0",
     ]);
     expect(events).toContainEqual(
       expect.objectContaining({
@@ -4786,7 +4760,7 @@ describe("OpenCode provider subagent contract", () => {
           expect(events).toContainEqual({
             type: "turn_started",
             provider: "opencode",
-            turnId: turnIdAt(events, 0),
+            turnId: "opencode-turn-0",
           });
         });
         for (const event of assistantTurnEvents({
@@ -4800,9 +4774,9 @@ describe("OpenCode provider subagent contract", () => {
 
         expect(childClient.calls.sessionStatus).toEqual([{ directory: "/workspace/repo" }]);
         expect(turnEventSignatures(events)).toEqual([
-          ["turn_started", turnIdAt(events, 0)],
-          ["timeline", turnIdAt(events, 0)],
-          ["turn_completed", turnIdAt(events, 0)],
+          ["turn_started", "opencode-turn-0"],
+          ["timeline", "opencode-turn-0"],
+          ["turn_completed", "opencode-turn-0"],
         ]);
         expect(events).toContainEqual(
           expect.objectContaining({
@@ -4907,9 +4881,9 @@ describe("OpenCode provider subagent contract", () => {
 
       await vi.waitFor(() => {
         expect(turnEventSignatures(events)).toEqual([
-          ["turn_started", turnIdAt(events, 0)],
-          ["timeline", turnIdAt(events, 0)],
-          ["turn_completed", turnIdAt(events, 0)],
+          ["turn_started", "opencode-turn-0"],
+          ["timeline", "opencode-turn-0"],
+          ["turn_completed", "opencode-turn-0"],
         ]);
       });
       expect(events).toContainEqual(
@@ -4953,9 +4927,9 @@ describe("OpenCode provider subagent contract", () => {
 
       await vi.waitFor(() => {
         expect(turnEventSignatures(events)).toEqual([
-          ["turn_started", turnIdAt(events, 0)],
-          ["timeline", turnIdAt(events, 0)],
-          ["turn_completed", turnIdAt(events, 0)],
+          ["turn_started", "opencode-turn-0"],
+          ["timeline", "opencode-turn-0"],
+          ["turn_completed", "opencode-turn-0"],
         ]);
       });
     } finally {
@@ -5029,7 +5003,7 @@ describe("OpenCode provider subagent contract", () => {
       });
       await vi.waitFor(() => {
         expect(events).toEqual([
-          { type: "turn_started", provider: "opencode", turnId: turnIdAt(events, 0) },
+          { type: "turn_started", provider: "opencode", turnId: "opencode-turn-0" },
         ]);
       });
 
@@ -5144,12 +5118,12 @@ describe("OpenCode provider subagent contract", () => {
 
       await streamDrained.promise;
       expect(events.filter((event) => event.type !== "provider_subagent")).toEqual([
-        { type: "turn_started", provider: "opencode", turnId: turnIdAt(events, 0) },
+        { type: "turn_started", provider: "opencode", turnId: "opencode-turn-0" },
         {
           type: "turn_canceled",
           provider: "opencode",
           reason: "interrupted",
-          turnId: turnIdAt(events, 0),
+          turnId: "opencode-turn-0",
         },
       ]);
     } finally {
@@ -5200,7 +5174,7 @@ describe("OpenCode provider subagent contract", () => {
       expect.objectContaining({
         type: "permission_requested",
         request: expect.objectContaining({ id: "perm_child_external" }),
-        turnId: turnIdAt(events, 0),
+        turnId: "opencode-turn-0",
       }),
     );
   });

packages/server/src/server/agent/providers/opencode-agent.ts

@@ -3409,7 +3409,6 @@ class OpenCodeAgentSession implements AgentSession {
   private partTypes = new Map<string, string>();
   private availableModesCache: AgentMode[] | null = null;
   private readonly subscribers = new Set<(event: AgentStreamEvent) => void>();
-  private readonly turnNamespace = randomUUID();
   private nextTurnOrdinal = 0;
   private turnState: OpenCodeTurnState = { status: "idle" };
   /**
@@ -4887,7 +4886,7 @@ class OpenCodeAgentSession implements AgentSession {
 
   private createTurnId(): string {
     this.gapRepairRevision += 1;
-    return `opencode-turn-${this.turnNamespace}-${this.nextTurnOrdinal++}`;
+    return `opencode-turn-${this.nextTurnOrdinal++}`;
   }
 
   private traceOpenCode(msg: OpenCodeTraceMessage, data: OpenCodeTraceData = {}): void {

public-docs/plugins/hooks.md

@@ -94,7 +94,7 @@ type PluginTurnOutcome =
 
 | Field        | Shape / meaning                                                                        |
 | ------------ | -------------------------------------------------------------------------------------- |
-| `turnId`     | Provider-reported `string` or `null`; unique across resumed sessions                   |
+| `turnId`     | Provider-reported `string` or `null`; can repeat after a session reopens               |
 | `timeline`   | Deprecated, always `[]`; fetch history with the SDK.                                   |
 | `request`    | SDK `AgentPermissionRequest`; `kind` is `tool`, `plan`, `question`, `mode`, or `other` |
 | `resolution` | SDK `AgentPermissionResponse`                                                          |

public-docs/plugins/hooks.zh-CN.md

@@ -92,7 +92,7 @@ type PluginTurnOutcome =
 
 | 字段         | 结构 / 含义                                                                              |
 | ------------ | ---------------------------------------------------------------------------------------- |
-| `turnId`     | Provider 报告的 `string` 或 `null`；在会话恢复后仍保持唯一                               |
+| `turnId`     | Provider 报告的 `string` 或 `null`；会话重新打开后可能重复                               |
 | `timeline`   | 已弃用，始终为 `[]`；通过 SDK 获取历史。                                                 |
 | `request`    | SDK 的 `AgentPermissionRequest`；`kind` 为 `tool`、`plan`、`question`、`mode` 或 `other` |
 | `resolution` | SDK 的 `AgentPermissionResponse`                                                         |