fix(delegation): isolate parent/child provider state during fan-out

Author: edelauna

apps/vscode-e2e/src/fixtures/subtasks.ts

@@ -16,6 +16,8 @@ const SUBTASK_XPROFILE_SAME_CHILD_MARKER = "SUBTASK_CHILD_SAME_PROFILE"
 const SUBTASK_XPROFILE_DIFFERENT_CHILD_MARKER = "SUBTASK_CHILD_DIFFERENT_PROFILE"
 const SUBTASK_FANOUT_PARENT_MARKER = "SUBTASK_PARENT_FANOUT_CONCURRENT"
 const SUBTASK_FANOUT_CHILD_MARKER = "SUBTASK_CHILD_FANOUT_CONCURRENT"
+const SUBTASK_FANOUT_XPROFILE_PARENT_MARKER = "SUBTASK_PARENT_FANOUT_CROSS_PROFILE"
+const SUBTASK_FANOUT_XPROFILE_CHILD_MARKER = "SUBTASK_CHILD_FANOUT_CROSS_PROFILE"
 
 const SUBTASK_CHILD_PROMPT = `${SUBTASK_CHILD_MARKER}: Ask the user exactly this follow-up question: What is the square root of 81? After the user answers, complete with only the answer.`
 export const SUBTASK_PARENT_PROMPT = `${SUBTASK_PARENT_MARKER}: Use the new_task tool exactly once. Create an ask-mode subtask with this exact message: "${SUBTASK_CHILD_PROMPT}" Do not answer directly.`
@@ -27,6 +29,12 @@ export const SUBTASK_FANOUT_PARENT_FOLLOWUP = "Parent fan-out is still active?"
 export const SUBTASK_FANOUT_CHILD_RESULT = "Fan-out child completed"
 const SUBTASK_FANOUT_CHILD_PROMPT = `${SUBTASK_FANOUT_CHILD_MARKER}: Complete with the exact result "${SUBTASK_FANOUT_CHILD_RESULT}".`
 export const SUBTASK_FANOUT_PARENT_PROMPT = `${SUBTASK_FANOUT_PARENT_MARKER}: Use the new_task tool exactly once. Create an ask-mode subtask with this exact message: "${SUBTASK_FANOUT_CHILD_PROMPT}" After delegation, ask the user exactly this follow-up question: ${SUBTASK_FANOUT_PARENT_FOLLOWUP}`
+export const SUBTASK_FANOUT_XPROFILE_PARENT_MODEL = "openai/gpt-4.1"
+export const SUBTASK_FANOUT_XPROFILE_CHILD_MODEL = "openai/gpt-4.1-mini"
+export const SUBTASK_FANOUT_XPROFILE_PARENT_FOLLOWUP = "Parent cross-profile fan-out is still isolated?"
+export const SUBTASK_FANOUT_XPROFILE_CHILD_RESULT = "Fan-out cross-profile child completed"
+const SUBTASK_FANOUT_XPROFILE_CHILD_PROMPT = `${SUBTASK_FANOUT_XPROFILE_CHILD_MARKER}: Complete with the exact result "${SUBTASK_FANOUT_XPROFILE_CHILD_RESULT}".`
+export const SUBTASK_FANOUT_XPROFILE_PARENT_PROMPT = `${SUBTASK_FANOUT_XPROFILE_PARENT_MARKER}: Use the new_task tool exactly once. Create an ask-mode subtask with this exact message: "${SUBTASK_FANOUT_XPROFILE_CHILD_PROMPT}" After delegation, ask the user exactly this follow-up question: ${SUBTASK_FANOUT_XPROFILE_PARENT_FOLLOWUP}`
 
 const SUBTASK_INTERRUPT_CHILD_PROMPT = `${SUBTASK_INTERRUPT_CHILD_MARKER}: Ask the user exactly this follow-up question: What is the square root of 81? After the user answers, complete with only the answer.`
 export const SUBTASK_INTERRUPT_PARENT_PROMPT = `${SUBTASK_INTERRUPT_PARENT_MARKER}: Use the new_task tool exactly once. Create an ask-mode subtask with this exact message: "${SUBTASK_INTERRUPT_CHILD_PROMPT}" Do not answer directly. When the subtask returns, complete with the exact result "Interrupted parent resumed".`
@@ -198,6 +206,63 @@ export function addSubtaskFixtures(mock: InstanceType<typeof LLMock>) {
 		},
 	})
 
+	mock.addFixture({
+		match: {
+			userMessage: new RegExp(SUBTASK_FANOUT_XPROFILE_PARENT_MARKER),
+			sequenceIndex: 0,
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "new_task",
+					arguments: JSON.stringify({
+						mode: "ask",
+						message: SUBTASK_FANOUT_XPROFILE_CHILD_PROMPT,
+					}),
+					id: "call_subtasks_fanout_xprofile_parent_new_task_001",
+				},
+			],
+		},
+	})
+
+	mock.addFixture({
+		match: {
+			predicate: (req: ChatCompletionRequest) =>
+				lastUserMessageContains(req, SUBTASK_FANOUT_XPROFILE_CHILD_MARKER) &&
+				!requestContains(req, [SUBTASK_FANOUT_XPROFILE_PARENT_MARKER]),
+		},
+		latency: 15_000,
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: SUBTASK_FANOUT_XPROFILE_CHILD_RESULT }),
+					id: "call_subtasks_fanout_xprofile_child_completion_002",
+				},
+			],
+		},
+	})
+
+	mock.addFixture({
+		match: {
+			predicate: (req: ChatCompletionRequest) =>
+				requestContains(req, [SUBTASK_FANOUT_XPROFILE_PARENT_MARKER, "Delegated to child task"]) &&
+				!requestContains(req, [SUBTASK_RESULT_INJECTION]),
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "ask_followup_question",
+					arguments: JSON.stringify({
+						question: SUBTASK_FANOUT_XPROFILE_PARENT_FOLLOWUP,
+						follow_up: [{ text: "continue" }],
+					}),
+					id: "call_subtasks_fanout_xprofile_parent_followup_003",
+				},
+			],
+		},
+	})
+
 	// The parent prompt embeds SUBTASK_FAST_CHILD_MARKER verbatim, so parent-resume turns
 	// can also match a bare substring check (same collision class as #561). Exclude the
 	// parent marker so those turns fall through to the parent-resume fixture below.

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

@@ -21,6 +21,11 @@ import {
 	SUBTASK_FAST_CHILD_RESULT,
 	SUBTASK_FANOUT_PARENT_FOLLOWUP,
 	SUBTASK_FANOUT_PARENT_PROMPT,
+	SUBTASK_FANOUT_XPROFILE_CHILD_MODEL,
+	SUBTASK_FANOUT_XPROFILE_CHILD_RESULT,
+	SUBTASK_FANOUT_XPROFILE_PARENT_FOLLOWUP,
+	SUBTASK_FANOUT_XPROFILE_PARENT_MODEL,
+	SUBTASK_FANOUT_XPROFILE_PARENT_PROMPT,
 	SUBTASK_FAST_PARENT_PROMPT,
 	SUBTASK_INTERRUPT_CHILD_FOLLOWUP_ANSWER,
 	SUBTASK_INTERRUPT_PARENT_PROMPT,
@@ -36,6 +41,7 @@ type AimockMessageContent = string | Array<{ type?: string; text?: string }>
 
 type AimockJournalEntry = {
 	body?: {
+		model?: string
 		messages?: Array<{
 			role?: string
 			content?: AimockMessageContent
@@ -51,24 +57,55 @@ const messageContentText = (content?: AimockMessageContent) => {
 	return content?.map((part) => part.text ?? "").join("") ?? ""
 }
 
+const requestUserText = (entry: AimockJournalEntry) =>
+	(entry.body?.messages ?? [])
+		.filter((message) => message.role === "user")
+		.map((message) => messageContentText(message.content))
+		.join("")
+
 const waitForAimockRequestContaining = async (expectedText: string, excludeText?: string) => {
+	await waitForAimockRequest((entry) => {
+		const messages = entry.body?.messages
+		if (!messages) return false
+		const entryText = messages.map((m) => messageContentText(m.content)).join("")
+		if (excludeText && entryText.includes(excludeText)) return false
+		return messages.some(
+			(message) => message.role === "user" && messageContentText(message.content).includes(expectedText),
+		)
+	})
+}
+
+const waitForAimockRequest = async (matches: (entry: AimockJournalEntry) => boolean) => {
+	let latestEntries: AimockJournalEntry[] = []
+
+	try {
+		await waitFor(async () => {
+			latestEntries = await readAimockJournal()
+			return latestEntries.some(matches)
+		})
+	} catch {
+		assertAimockRequest(latestEntries, matches)
+	}
+}
+
+const readAimockJournal = async () => {
 	const aimockUrl = process.env.AIMOCK_URL
 	assert.ok(aimockUrl, "AIMOCK_URL must be set for aimock journal assertions")
 
-	await waitFor(async () => {
-		const response = await fetch(`${aimockUrl}/__aimock/journal`)
-		const entries = (await response.json()) as AimockJournalEntry[]
-
-		return entries.some((entry) => {
-			const messages = entry.body?.messages
-			if (!messages) return false
-			const entryText = messages.map((m) => messageContentText(m.content)).join("")
-			if (excludeText && entryText.includes(excludeText)) return false
-			return messages.some(
-				(message) => message.role === "user" && messageContentText(message.content).includes(expectedText),
-			)
-		})
-	})
+	const response = await fetch(`${aimockUrl}/__aimock/journal`)
+	return (await response.json()) as AimockJournalEntry[]
+}
+
+const assertAimockRequest = (entries: AimockJournalEntry[], matches: (entry: AimockJournalEntry) => boolean) => {
+	if (entries.some(matches)) return
+
+	const summary = entries.map((entry) => ({
+		model: entry.body?.model,
+		userText: entry.body?.messages
+			?.filter((message) => message.role === "user")
+			.map((message) => messageContentText(message.content).slice(0, 180)),
+	}))
+	assert.fail(`Expected aimock request was not found. Requests: ${JSON.stringify(summary, null, 2)}`)
 }
 
 suite("Roo Code Subtasks", function () {
@@ -189,6 +226,118 @@ suite("Roo Code Subtasks", function () {
 		}
 	})
 
+	test("fan-out keeps parent API config isolated when child switches to a different saved profile", async () => {
+		const api = globalThis.api
+		const asks: Record<string, ClineMessage[]> = {}
+
+		const messageHandler = ({ taskId, message }: { taskId: string; message: ClineMessage }) => {
+			if (message.type === "ask") {
+				asks[taskId] = asks[taskId] || []
+				asks[taskId].push(message)
+			}
+		}
+
+		api.on(RooCodeEventName.Message, messageHandler)
+
+		const aimockUrl = process.env.AIMOCK_URL
+		const parentProfile = {
+			apiProvider: "openrouter" as const,
+			openRouterApiKey: "mock-key",
+			openRouterModelId: SUBTASK_FANOUT_XPROFILE_PARENT_MODEL,
+			rateLimitSeconds: 0,
+			...(aimockUrl && { openRouterBaseUrl: `${aimockUrl}/v1` }),
+		}
+		const childProfile = {
+			...parentProfile,
+			openRouterModelId: SUBTASK_FANOUT_XPROFILE_CHILD_MODEL,
+		}
+		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)
+		await api.setConfiguration({
+			modeApiConfigs: {
+				...priorModeApiConfigs,
+				code: parentProfileId!,
+				ask: childProfileId!,
+			},
+		})
+
+		try {
+			api.setTaskSchedulerMaxConcurrency(2)
+
+			const parentTaskId = await api.startNewTask({
+				configuration: {
+					mode: "code",
+					alwaysAllowModeSwitch: true,
+					alwaysAllowSubtasks: true,
+					autoApprovalEnabled: true,
+					enableCheckpoints: false,
+				},
+				text: SUBTASK_FANOUT_XPROFILE_PARENT_PROMPT,
+			})
+
+			let childTaskId: string | undefined
+			await waitFor(() => {
+				const stack = api.getCurrentTaskStack()
+				const current = stack.at(-1)
+				if (current && current !== parentTaskId) {
+					childTaskId = current
+					return stack.includes(parentTaskId)
+				}
+				return false
+			})
+
+			await waitFor(() =>
+				(asks[parentTaskId] ?? []).some(
+					({ ask, text }) => ask === "followup" && text?.includes(SUBTASK_FANOUT_XPROFILE_PARENT_FOLLOWUP),
+				),
+			)
+
+			assert.ok(
+				(asks[parentTaskId] ?? []).some(
+					({ ask, text }) => ask === "followup" && text?.includes(SUBTASK_FANOUT_XPROFILE_PARENT_FOLLOWUP),
+				),
+				"Parent should keep running and ask its follow-up using its own profile",
+			)
+
+			const stack = api.getCurrentTaskStack()
+			assert.ok(stack.includes(parentTaskId), "Fan-out parent should remain in the live task stack")
+			assert.ok(stack.includes(childTaskId!), "Fan-out child should remain in the live task stack")
+			assert.strictEqual(stack.at(-1), childTaskId, "Child should remain the focused task while parent runs")
+
+			await waitForAimockRequest((entry) => {
+				const text = requestUserText(entry)
+				const userMessageCount = (entry.body?.messages ?? []).filter(
+					(message) => message.role === "user",
+				).length
+				return (
+					entry.body?.model === SUBTASK_FANOUT_XPROFILE_PARENT_MODEL &&
+					text.includes(SUBTASK_FANOUT_XPROFILE_PARENT_PROMPT) &&
+					userMessageCount > 1
+				)
+			})
+			await waitForAimockRequest(
+				(entry) =>
+					entry.body?.model === SUBTASK_FANOUT_XPROFILE_CHILD_MODEL &&
+					(entry.body.messages ?? []).some(
+						(message) =>
+							message.role === "user" &&
+							messageContentText(message.content).includes(SUBTASK_FANOUT_XPROFILE_CHILD_RESULT),
+					),
+			)
+		} finally {
+			api.off(RooCodeEventName.Message, messageHandler)
+			while (api.getCurrentTaskStack().length > 0) {
+				await api.clearCurrentTask()
+			}
+			api.setTaskSchedulerMaxConcurrency(1)
+			await waitFor(() => api.getCurrentTaskStack().length === 0).catch(() => {})
+			await api.setConfiguration({ modeApiConfigs: priorModeApiConfigs })
+			await api.deleteProfile("subtask-fanout-child-profile").catch(() => {})
+			await api.deleteProfile("subtask-fanout-parent-profile").catch(() => {})
+		}
+	})
+
 	// Smoke: child completing normally must resume the parent task.
 	test("child task returns to parent after normal completion", async () => {
 		const api = globalThis.api

src/__tests__/helpers/provider-stub.ts

@@ -13,12 +13,14 @@ type ProviderStubFields = {
 	runDelegationTransition?: unknown
 	removeClineFromStack?: unknown
 	evictCurrentTask?: unknown
+	restoreParentOrReleasePermit?: unknown
 }
 
 type PrivateProviderMethods = {
 	runDelegationTransition: (this: unknown, ...args: unknown[]) => unknown
 	removeClineFromStack: (this: unknown, ...args: unknown[]) => unknown
 	evictCurrentTask: (this: unknown, ...args: unknown[]) => unknown
+	restoreParentOrReleasePermit: (this: unknown, ...args: unknown[]) => unknown
 }
 
 /**
@@ -51,5 +53,6 @@ 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)
 	return s as unknown as ClineProvider
 }

src/__tests__/provider-delegation.spec.ts

@@ -6,6 +6,24 @@ 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)
+}
+
 const parentHistoryItem: HistoryItem = {
 	id: "parent-1",
 	task: "Parent",
@@ -318,6 +336,7 @@ describe("ClineProvider.delegateParentAndOpenChild()", () => {
 			recentTasksCache: undefined,
 			taskHistoryStore,
 		} as unknown as ClineProvider
+		bindRestoreParentOrReleasePermit(provider)
 
 		await expect(
 			(ClineProvider.prototype as any).delegateParentAndOpenChild.call(provider, {
@@ -373,6 +392,7 @@ describe("ClineProvider.delegateParentAndOpenChild()", () => {
 			// still needs evicting, independent of current focus.
 			taskRegistry: { getById: vi.fn((id: string) => (id === "child-1" ? child : undefined)) },
 		} as unknown as ClineProvider
+		bindRestoreParentOrReleasePermit(provider)
 
 		await expect(
 			(ClineProvider.prototype as any).delegateParentAndOpenChild.call(provider, {