fix(api): give startNewTask(newTab) a fresh tab panel instead of reusing the tracked one

The F0 single-tab reuse in openClineInNewTab made the 2nd/3rd
startNewTask({newTab:true}) return the first tab's provider, so its
evictCurrentTask() aborted the live task that tab was serving (TaskUnfocused
-> removeRegisteredTask, breaking follow-up suggestion delivery) and
re-registering listeners on the reused provider stacked duplicate task
handlers (Nth task events re-emitted N times).

Extract the creation body as createClineTabPanel (always creates a fresh
panel + provider), point API.startNewTask at it, keep the UI button path on
openClineInNewTab's reuse behavior, guard registerListeners with a
per-provider set, and only clear the tracked tab ref on dispose when it
still points at the disposed panel.

Restores the 3-panel follow-up coordination contract; the e2e 3-panel
coordinated-rounds test that failed 6/6 now passes locally.

Author: easonliang28

src/activate/__tests__/registerCommands.spec.ts

@@ -4,7 +4,13 @@ import { TelemetryService } from "@roo-code/telemetry"
 
 import { ClineProvider } from "../../core/webview/ClineProvider"
 
-import { getVisibleProviderOrLog, openClineInNewTab, registerCommands, setPanel } from "../registerCommands"
+import {
+	createClineTabPanel,
+	getVisibleProviderOrLog,
+	openClineInNewTab,
+	registerCommands,
+	setPanel,
+} from "../registerCommands"
 
 vi.mock("execa", () => ({
 	execa: vi.fn(),
@@ -640,3 +646,55 @@ describe("openClineInNewTab", () => {
 		expect(vscode.window.createWebviewPanel).toHaveBeenCalledTimes(1)
 	})
 })
+
+describe("createClineTabPanel", () => {
+	let mockOutputChannel: vscode.OutputChannel
+	let mockContext: vscode.ExtensionContext
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+
+		mockOutputChannel = {
+			appendLine: vi.fn(),
+			append: vi.fn(),
+			clear: vi.fn(),
+			hide: vi.fn(),
+			name: "mock",
+			replace: vi.fn(),
+			show: vi.fn(),
+			dispose: vi.fn(),
+		}
+
+		mockContext = {
+			subscriptions: [],
+			extensionUri: { path: "/mock/ext" },
+		} as unknown as vscode.ExtensionContext
+
+		const mockPanel = {
+			webview: { postMessage: vi.fn() },
+			onDidChangeViewState: vi.fn(),
+			onDidDispose: vi.fn(),
+		}
+		;(vscode.window.createWebviewPanel as Mock).mockReturnValue(mockPanel)
+
+		// Reset module-level panel state.
+		setPanel(undefined, "sidebar")
+		setPanel(undefined, "tab")
+	})
+
+	it("always creates a fresh panel even when a tab is already tracked", async () => {
+		const mockTrackedPanel = {
+			webview: { postMessage: vi.fn() },
+			onDidChangeViewState: vi.fn(),
+			onDidDispose: vi.fn(),
+			reveal: vi.fn().mockResolvedValue(undefined),
+		} as unknown as vscode.WebviewPanel
+		setPanel(mockTrackedPanel, "tab")
+		;(ClineProvider.getInstanceForView as Mock).mockReturnValue({ postMessageToWebview: vi.fn() })
+
+		await createClineTabPanel({ context: mockContext, outputChannel: mockOutputChannel })
+
+		expect(mockTrackedPanel.reveal).not.toHaveBeenCalled()
+		expect(vscode.window.createWebviewPanel).toHaveBeenCalledTimes(1)
+	})
+})

src/activate/registerCommands.ts

@@ -282,18 +282,16 @@ const getCommandsMap = ({
 	},
 })
 
-export const openClineInNewTab = async ({ context, outputChannel }: Omit<RegisterCommandOptions, "provider">) => {
-	// Reuse the tracked tab instead of opening a second one: a repeated
-	// "Open in editor" click reveals the existing tab's panel.
-	if (tabPanel) {
-		const existingProvider = ClineProvider.getInstanceForView(tabPanel)
-		if (existingProvider) {
-			await tabPanel.reveal()
-			await existingProvider.postMessageToWebview({ type: "action", action: "didBecomeVisible" })
-			return existingProvider
-		}
-	}
-
+/**
+ * Create a fresh "Zoo Code" tab panel and provider.
+ *
+ * Unlike `openClineInNewTab`, this never reuses the tracked tab: callers that
+ * must not evict the task an existing tab is already serving (such as
+ * `API.startNewTask({ newTab: true })`) get a new surface here so concurrent
+ * tab tasks stay independent. The UI "Open in editor" button keeps the
+ * single-tab reuse behavior.
+ */
+export const createClineTabPanel = async ({ context, outputChannel }: Omit<RegisterCommandOptions, "provider">) => {
 	// (This example uses webviewProvider activation event which is necessary to
 	// deserialize cached webview, but since we use retainContextWhenHidden, we
 	// don't need to use that event).
@@ -356,7 +354,11 @@ export const openClineInNewTab = async ({ context, outputChannel }: Omit<Registe
 	// Handle panel closing events.
 	newPanel.onDidDispose(
 		() => {
-			setPanel(undefined, "tab")
+			// Only clear the tracked ref when it still points to this panel, so
+			// closing an older concurrent tab never wipes the newer tab's ref.
+			if (tabPanel === newPanel) {
+				setPanel(undefined, "tab")
+			}
 		},
 		null,
 		context.subscriptions, // Also register dispose listener
@@ -368,3 +370,18 @@ export const openClineInNewTab = async ({ context, outputChannel }: Omit<Registe
 
 	return tabProvider
 }
+
+export const openClineInNewTab = async ({ context, outputChannel }: Omit<RegisterCommandOptions, "provider">) => {
+	// Reuse the tracked tab instead of opening a second one: a repeated
+	// "Open in editor" click reveals the existing tab's panel.
+	if (tabPanel) {
+		const existingProvider = ClineProvider.getInstanceForView(tabPanel)
+		if (existingProvider) {
+			await tabPanel.reveal()
+			await existingProvider.postMessageToWebview({ type: "action", action: "didBecomeVisible" })
+			return existingProvider
+		}
+	}
+
+	return createClineTabPanel({ context, outputChannel })
+}

src/extension/__tests__/api-task-control.spec.ts

@@ -8,8 +8,8 @@ import { RooCodeEventName, type ModeConfig, type RooCodeSettings } from "@roo-co
 import { API } from "../api"
 import { ClineProvider } from "../../core/webview/ClineProvider"
 
-const { openClineInNewTabMock } = vi.hoisted(() => ({
-	openClineInNewTabMock: vi.fn(),
+const { createClineTabPanelMock } = vi.hoisted(() => ({
+	createClineTabPanelMock: vi.fn(),
 }))
 
 vi.mock("vscode", () => ({
@@ -23,7 +23,7 @@ vi.mock("@roo-code/ipc", () => ({
 }))
 
 vi.mock("../../activate/registerCommands", () => ({
-	openClineInNewTab: openClineInNewTabMock,
+	createClineTabPanel: createClineTabPanelMock,
 }))
 
 vi.mock("../../integrations/terminal/Terminal", () => ({
@@ -108,14 +108,14 @@ describe("API task controls", () => {
 	describe("startNewTask", () => {
 		it("reverts and closes existing editors before opening a new tab unless preserveOpenTabs is true", async () => {
 			const newTabProvider = createProvider("new-tab-task")
-			openClineInNewTabMock.mockResolvedValue(newTabProvider)
+			createClineTabPanelMock.mockResolvedValue(newTabProvider)
 
 			const taskId = await api.startNewTask({ configuration, text: "new task", newTab: true })
 
 			expect(taskId).toBe("new-tab-task")
 			expect(vscode.commands.executeCommand).toHaveBeenNthCalledWith(1, "workbench.action.files.revert")
 			expect(vscode.commands.executeCommand).toHaveBeenNthCalledWith(2, "workbench.action.closeAllEditors")
-			expect(openClineInNewTabMock).toHaveBeenCalledWith({
+			expect(createClineTabPanelMock).toHaveBeenCalledWith({
 				context: sidebarProvider.context,
 				outputChannel,
 			})
@@ -131,7 +131,7 @@ describe("API task controls", () => {
 
 		it("opens a new tab without revert or close commands when preserveOpenTabs is true", async () => {
 			const newTabProvider = createProvider("preserved-tab-task")
-			openClineInNewTabMock.mockResolvedValue(newTabProvider)
+			createClineTabPanelMock.mockResolvedValue(newTabProvider)
 
 			const taskId = await api.startNewTask({
 				configuration,
@@ -142,7 +142,7 @@ describe("API task controls", () => {
 
 			expect(taskId).toBe("preserved-tab-task")
 			expect(vscode.commands.executeCommand).not.toHaveBeenCalled()
-			expect(openClineInNewTabMock).toHaveBeenCalledWith({
+			expect(createClineTabPanelMock).toHaveBeenCalledWith({
 				context: sidebarProvider.context,
 				outputChannel,
 			})

src/extension/api.ts

@@ -31,7 +31,7 @@ import { ClineProvider } from "../core/webview/ClineProvider"
 import type { Task } from "../core/task/Task"
 import { Terminal } from "../integrations/terminal/Terminal"
 import { TerminalRegistry } from "../integrations/terminal/TerminalRegistry"
-import { openClineInNewTab } from "../activate/registerCommands"
+import { createClineTabPanel } from "../activate/registerCommands"
 import { getCommands } from "../services/command/commands"
 import { getModels } from "../api/providers/fetchers/modelCache"
 
@@ -51,6 +51,7 @@ export class API extends EventEmitter<RooCodeEvents> implements RooCodeAPI {
 	private readonly context: vscode.ExtensionContext
 	private readonly ipc?: IpcServer
 	private readonly tasksById = new Map<string, RegisteredTask>()
+	private readonly listenersRegisteredFor = new Set<ClineProvider>()
 	private readonly log: (...args: unknown[]) => void
 	private logfile?: string
 
@@ -204,7 +205,8 @@ export class API extends EventEmitter<RooCodeEvents> implements RooCodeAPI {
 				await vscode.commands.executeCommand("workbench.action.closeAllEditors")
 			}
 
-			provider = await openClineInNewTab({ context: this.context, outputChannel: this.outputChannel })
+			// A fresh tab: reusing the tracked tab would evict the task it is already serving.
+			provider = await createClineTabPanel({ context: this.context, outputChannel: this.outputChannel })
 			this.registerListeners(provider)
 		} else {
 			await vscode.commands.executeCommand(`${Package.name}.SidebarProvider.focus`)
@@ -434,6 +436,13 @@ export class API extends EventEmitter<RooCodeEvents> implements RooCodeAPI {
 	}
 
 	private registerListeners(provider: ClineProvider) {
+		// A duplicated registration would re-emit every task event once per copy of the
+		// handler, so each provider is wired exactly once.
+		if (this.listenersRegisteredFor.has(provider)) {
+			return
+		}
+		this.listenersRegisteredFor.add(provider)
+
 		provider.on(RooCodeEventName.TaskCreated, (task) => {
 			this.tasksById.set(task.taskId, { task: task as unknown as TaskAskController, provider })