fix: isolate fan-out task state during delegation

Author: edelauna

apps/vscode-e2e/src/suite/subtasks.test.ts

@@ -254,11 +254,13 @@ suite("Roo Code Subtasks", function () {
 		const priorModeApiConfigs = api.getConfiguration().modeApiConfigs ?? {}
 		const parentProfileId = await api.upsertProfile("subtask-fanout-parent-profile", parentProfile, true)
 		const childProfileId = await api.upsertProfile("subtask-fanout-child-profile", childProfile, false)
+		assert.ok(parentProfileId, "Failed to create parent profile")
+		assert.ok(childProfileId, "Failed to create child profile")
 		await api.setConfiguration({
 			modeApiConfigs: {
 				...priorModeApiConfigs,
-				code: parentProfileId!,
-				ask: childProfileId!,
+				code: parentProfileId,
+				ask: childProfileId,
 			},
 		})
 

src/__tests__/helpers/provider-stub.ts

@@ -23,6 +23,12 @@ type PrivateProviderMethods = {
 	restoreParentOrReleasePermit: (this: unknown, ...args: unknown[]) => unknown
 }
 
+export function bindRestoreParentOrReleasePermit(provider: ClineProvider): void {
+	const s = provider as unknown as ProviderStubFields
+	const proto = ClineProvider.prototype as unknown as PrivateProviderMethods
+	s.restoreParentOrReleasePermit = proto.restoreParentOrReleasePermit.bind(s)
+}
+
 /**
  * Augments a plain stub object with the instance fields and bound methods that
  * ClineProvider methods read from `this` (runDelegationTransition,
@@ -53,6 +59,8 @@ export function makeProviderStub<T extends object>(stub: T): ClineProvider {
 	s.runDelegationTransition ??= proto.runDelegationTransition.bind(s)
 	s.removeClineFromStack ??= proto.removeClineFromStack.bind(s)
 	s.evictCurrentTask ??= proto.evictCurrentTask.bind(s)
-	s.restoreParentOrReleasePermit ??= proto.restoreParentOrReleasePermit.bind(s)
+	if (!s.restoreParentOrReleasePermit) {
+		bindRestoreParentOrReleasePermit(s as unknown as ClineProvider)
+	}
 	return s as unknown as ClineProvider
 }

src/__tests__/provider-delegation.spec.ts

@@ -5,24 +5,7 @@ import type { HistoryItem } from "@roo-code/types"
 import { RooCodeEventName } from "@roo-code/types"
 import { ClineProvider } from "../core/webview/ClineProvider"
 import { TaskScheduler } from "../core/task/TaskScheduler"
-
-/**
- * restoreParentOrReleasePermit is a private prototype method that plain
- * object-literal provider stubs don't have unless bound explicitly (same
- * reason removeClineFromStack/evictCurrentTask need binding in provider-stub.ts).
- */
-function bindRestoreParentOrReleasePermit(provider: ClineProvider): void {
-	type WithRestore = {
-		restoreParentOrReleasePermit: (
-			parentTaskId: string,
-			fanOut: boolean,
-			childReservedRelease: (() => void) | undefined,
-		) => Promise<void>
-	}
-	;(provider as unknown as WithRestore).restoreParentOrReleasePermit = (
-		ClineProvider.prototype as unknown as WithRestore
-	).restoreParentOrReleasePermit.bind(provider)
-}
+import { bindRestoreParentOrReleasePermit } from "./helpers/provider-stub"
 
 const parentHistoryItem: HistoryItem = {
 	id: "parent-1",

src/core/task/Task.ts

@@ -4021,14 +4021,16 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		const state = await this.providerRef.deref()?.getState()
 
 		const {
-			apiConfiguration,
 			autoApprovalEnabled,
 			requestDelaySeconds,
-			mode,
 			autoCondenseContext = true,
 			autoCondenseContextPercent = 100,
 			profileThresholds = {},
 		} = state ?? {}
+		// mode/apiConfiguration come from this task's own fields, not shared
+		// provider state — see getSystemPrompt() for why.
+		const mode = await this.getTaskMode()
+		const apiConfiguration = this.apiConfiguration
 
 		// Get condensing configuration for automatic triggers.
 		const customCondensingPrompt = state?.customSupportPrompts?.CONDENSE

src/core/task/__tests__/Task.spec.ts

@@ -599,6 +599,57 @@ describe("Cline", () => {
 				expect(Object.keys(cleanConversationHistory[0]!)).toEqual(["role", "content"])
 			})
 
+			it("uses task-local mode and apiConfiguration in request metadata when provider state diverges", async () => {
+				const taskApiConfiguration = {
+					...mockApiConfig,
+					apiProvider: providerIdentifiers.gemini,
+				} as ProviderSettings
+
+				vi.spyOn(mockProvider, "getState").mockResolvedValue({
+					mode: "ask",
+					apiConfiguration: taskApiConfiguration,
+					autoApprovalEnabled: true,
+					requestDelaySeconds: 0,
+				})
+
+				const cline = new Task({
+					provider: mockProvider,
+					apiConfiguration: taskApiConfiguration,
+					task: "test task",
+					startTask: false,
+				})
+				await cline.getTaskMode()
+				vi.spyOn(getTaskTestAccess(cline), "getSystemPrompt").mockResolvedValue("mock system prompt")
+				vi.spyOn(cline.api, "getModel").mockReturnValue({
+					id: requireDefined(mockApiConfig.apiModelId),
+					info: { contextWindow: 200000, maxTokens: 4096 } as ModelInfo,
+				})
+
+				vi.spyOn(mockProvider, "getState").mockResolvedValue({
+					mode: "code",
+					apiConfiguration: {
+						...mockApiConfig,
+						apiProvider: providerIdentifiers.anthropic,
+					},
+					autoApprovalEnabled: true,
+					requestDelaySeconds: 0,
+				})
+
+				const mockStream = (async function* () {
+					yield { type: "text", text: "response" } as ApiStreamChunk
+				})()
+				const createMessageSpy = vi.spyOn(cline.api, "createMessage").mockReturnValue(mockStream)
+				cline.apiConversationHistory = [
+					{ role: "user", content: [{ type: "text", text: "test message" }], ts: Date.now() },
+				]
+
+				await cline.attemptApiRequest(0).next()
+
+				const [, , metadata] = requireDefined(createMessageSpy.mock.calls[0])
+				expect(metadata?.mode).toBe("ask")
+				expect(metadata?.allowedFunctionNames).toBeDefined()
+			})
+
 			it("should shape image blocks for API compatibility before request construction", async () => {
 				const conversationHistory = [
 					{

src/core/task/__tests__/delegation-concurrent.spec.ts

@@ -147,7 +147,7 @@ describe("delegateParentAndOpenChild — fan-out (Story 3.2b)", () => {
 		void scheduler.schedule(makeParent({ taskId: "occupant-2" }), () => new Promise<void>(() => {}))
 		// Poll the deterministic signal instead of assuming a fixed microtask
 		// depth for sem.acquire() to settle.
-		while (scheduler.available > 0) {
+		for (let i = 0; i < 10 && scheduler.available > 0; i++) {
 			await Promise.resolve()
 		}
 
@@ -263,12 +263,16 @@ describe("delegateParentAndOpenChild — fan-out (Story 3.2b)", () => {
 			createTaskWithHistoryItem,
 		})
 
-		await expect(callDelegate(provider)).rejects.toThrow(createTaskError)
+		try {
+			await expect(callDelegate(provider)).rejects.toThrow(createTaskError)
 
-		expect(createTaskWithHistoryItem).toHaveBeenCalledTimes(2)
-		expect(showErrorMessage).toHaveBeenCalledWith(
-			"Failed to restore the parent task after subtask creation failed. Reopen the task from history to continue.",
-		)
+			expect(createTaskWithHistoryItem).toHaveBeenCalledTimes(2)
+			expect(showErrorMessage).toHaveBeenCalledWith(
+				"Failed to restore the parent task after subtask creation failed. Reopen the task from history to continue.",
+			)
+		} finally {
+			showErrorMessage.mockRestore()
+		}
 	})
 
 	it("fan-out path: both parent and child are tracked in the registry with no shared clineMessages reference", async () => {
@@ -313,7 +317,7 @@ describe("delegateParentAndOpenChild — fan-out (Story 3.2b)", () => {
 		// Occupy one permit with the "parent's own request loop" so only one
 		// permit remains — exactly the scenario fan-out is meant to handle.
 		void scheduler.schedule(parent, parentRun)
-		while (scheduler.available > 1) {
+		for (let i = 0; i < 10 && scheduler.available > 1; i++) {
 			await Promise.resolve()
 		}
 

src/core/webview/__tests__/ClineProvider.lockApiConfig.spec.ts

@@ -374,14 +374,15 @@ describe("ClineProvider - Lock API Config Across Modes", () => {
 				apiProvider: "anthropic",
 			})
 
-			const activateProviderProfileSpy = vi
-				.spyOn(provider, "activateProviderProfile")
-				.mockResolvedValue(undefined)
+			const activateProfileSpy = vi.spyOn(provider.providerSettingsManager, "activateProfile").mockResolvedValue({
+				name: "architect-profile",
+				apiProvider: "anthropic",
+			})
 
 			await provider.handleModeSwitch("architect")
 
 			expect(getModeConfigIdSpy).toHaveBeenCalledWith("architect")
-			expect(activateProviderProfileSpy).toHaveBeenCalledWith({ name: "architect-profile" })
+			expect(activateProfileSpy).toHaveBeenCalledWith({ name: "architect-profile" })
 		})
 	})
 })