fix(webview): isolate parallel mode and provider profile writes

Port vps2 F3 (mode/profile writes) from upstream 978, hunk-by-hunk against
the F1c..CS residual:

- ClineProvider: add repointPersistedViewStates() to re-point
  currentApiConfigName across per-view entries when a profile is renamed
  or replaced, and prune orphaned entries; validate handleModeSwitch slugs
  against the custom-modes manager and no-op with a log on unknown modes;
  drop the as-any cast in delegateParentAndOpenChild.
- Task: route mode switches through provider.handleModeSwitch(task) and
  keep the submitted message on failure instead of setMode().
- SwitchModeTool and specs: durable per-view mode writes.
- webviewMessageHandler: no change vs base - the kimi-code OAuth hunk in
  the residual is CS-only divergence (not-ported register item 1), not
  part of #978/#979.
- webviewMessageHandler.spec: ported only #979's 4 mock fields +
  defaultModeSlug import; the stack-side legacy-repair test, Key-aware
  getValue mock and em-dash comment are retained (register item 4).
  #979's mode-routing WMH.spec describe ("routes mode messages through
  handleModeSwitch instead of writing ContextProxy directly") exists in
  neither CS nor the stack and is ported by no unit (open question,
  logged).
- Tests: H3/H4 durable handleModeSwitch writes in ClineProvider.spec.ts;
  profile-mutation, profile-activation and handleModeSwitch-integration
  describes (incl. A4 non-focused-target regression and new
  mutation-killing tests) in ClineProvider.parallelMode.spec.ts;
  sticky-mode and webviewMessageHandler spec updates; retain the
  setViewStateId __proto__ guard + spec test - shipped F1a hardening;
  the residual's guard removal is lineage divergence, not F3 content.
- eslint-suppressions.json: no-explicit-any counts decrease for
  core/webview/ClineProvider.ts (12 -> 11) and
  core/webview/__tests__/ClineProvider.sticky-mode.spec.ts (36 -> 33).

Upstream: #978 (vps2 F3) - issue #978; content ported
hunk-by-hunk from the F1c..CS residual, cross-checked against upstream PR

Author: easonliang28

src/core/task/Task.ts

@@ -1790,8 +1790,26 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 
 			if (provider) {
 				if (mode) {
-					await provider.setMode(mode)
-					this._taskMode = mode
+					// Route through the shared mode-switch handler so the switch is
+					// validated and recorded like any other mode change (task history,
+					// TaskModeSwitched, and — when this is the focused task — the view's
+					// durable mode pin + ModeChanged broadcast). The handler writes this
+					// task's mode only after validation and persistence, so an unknown
+					// slug leaves the task mode untouched instead of recording a bad one.
+					// A mode-switch failure (e.g. a task-history write failure) must not
+					// swallow the submitted message: log it locally and continue delivery.
+					// Let the constructor-started mode initialization settle first: its
+					// deferred provider-state read would otherwise resolve after the switch
+					// and clobber the explicitly selected mode with the pre-switch value.
+					try {
+						await this.waitForModeInitialization()
+						await provider.handleModeSwitch(mode, this)
+					} catch (error) {
+						console.error(
+							`[Task#submitUserMessage] Mode switch to ${mode} failed (taskId=${this.taskId}):`,
+							error,
+						)
+					}
 				}
 
 				if (providerProfile) {

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

@@ -42,6 +42,9 @@ type TaskTestAccess = {
 	safeEnsureModelFetched: () => Promise<void>
 	addToApiConversationHistory: (message: unknown, reasoning?: string) => Promise<void>
 	resetAssistantMessagePersistence: () => void
+	// Private on Task; the provider-owned mode write (ClineProvider.handleModeSwitch)
+	// sets it, and tests mirror that write through this helper.
+	_taskMode: string | undefined
 }
 
 type TaskAskResult = Awaited<ReturnType<Task["ask"]>>
@@ -1412,6 +1415,7 @@ describe("Cline", () => {
 					getMcpHub: vi.fn().mockReturnValue(undefined),
 					getSkillsManager: vi.fn().mockReturnValue(undefined),
 					say: vi.fn(),
+					handleModeSwitch: vi.fn().mockResolvedValue(undefined),
 					postStateToWebview: vi.fn().mockResolvedValue(undefined),
 					postStateToWebviewWithoutTaskHistory: vi.fn().mockResolvedValue(undefined),
 					postStateToWebviewThrottled: vi.fn().mockResolvedValue(undefined),
@@ -1967,7 +1971,13 @@ describe("Cline", () => {
 					mode: "ask",
 					mcpEnabled: false,
 				} as unknown as ProviderState)
-				vi.spyOn(mockProvider, "setMode").mockResolvedValue(undefined)
+				vi.spyOn(mockProvider, "handleModeSwitch").mockImplementation(async (mode, targetTask) => {
+					// Mirror ClineProvider.handleModeSwitch: after validation and persistence
+					// the provider owns the task's mode write.
+					if (targetTask) {
+						getTaskTestAccess(targetTask)._taskMode = mode
+					}
+				})
 				const task = new Task({
 					provider: mockProvider,
 					apiConfiguration: mockApiConfig,
@@ -1976,6 +1986,10 @@ describe("Cline", () => {
 				})
 				vi.spyOn(task, "handleWebviewAskResponse").mockImplementation(() => {})
 
+				// Let the task's initial mode ("ask", from provider state) settle first, so the
+				// mode selected with the user message is the task's final mode write.
+				await task.getTaskMode()
+
 				await task.submitUserMessage("switch modes", undefined, "code")
 				vi.spyOn(getTaskTestAccess(task), "getSystemPrompt").mockResolvedValue("mock system prompt")
 				const stream = (async function* () {
@@ -1988,10 +2002,74 @@ describe("Cline", () => {
 
 				await task.attemptApiRequest().next()
 
-				expect(mockProvider.setMode).toHaveBeenCalledWith("code")
+				expect(mockProvider.handleModeSwitch).toHaveBeenCalledWith("code", task)
 				expect(requireDefined(createMessage.mock.calls[0])[2]?.mode).toBe("code")
 			})
 
+			it("still delivers the user message when the mode switch fails", async () => {
+				const task = new Task({
+					provider: mockProvider,
+					apiConfiguration: mockApiConfig,
+					task: "initial task",
+					startTask: false,
+				})
+				const switchError = new Error("task history write failed")
+				vi.spyOn(mockProvider, "handleModeSwitch").mockRejectedValue(switchError)
+				const handleResponseSpy = vi.spyOn(task, "handleWebviewAskResponse").mockImplementation(() => {})
+				const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+
+				await task.submitUserMessage("still delivered", undefined, "code")
+
+				// The mode-switch rejection is caught and logged locally...
+				expect(consoleErrorSpy).toHaveBeenCalledWith(
+					`[Task#submitUserMessage] Mode switch to code failed (taskId=${task.taskId}):`,
+					switchError,
+				)
+				// ...and the pending ask is still answered, so the submitted text is not lost.
+				expect(handleResponseSpy).toHaveBeenCalledWith("messageResponse", "still delivered", [])
+				consoleErrorSpy.mockRestore()
+			})
+
+			it("keeps the selected mode when the deferred mode initialization settles after the submission", async () => {
+				// The constructor-started initializeTaskMode() is still awaiting the
+				// provider state. submitUserMessage must let that initialization settle
+				// before switching: without the await, the deferred read resolves after
+				// the switch and clobbers the selected mode with the pre-switch value.
+				// One shared pending promise: both the mode and api-config initializers
+				// await provider.getState(), and a per-call promise would leave the mode
+				// initializer's own read pending forever.
+				let releaseState: (state: ProviderState) => void = () => {}
+				const deferredState = new Promise<ProviderState>((resolve) => {
+					releaseState = resolve
+				})
+				vi.spyOn(mockProvider, "getState").mockImplementation(() => deferredState)
+				vi.spyOn(mockProvider, "handleModeSwitch").mockImplementation(async (mode, targetTask) => {
+					if (targetTask) {
+						getTaskTestAccess(targetTask)._taskMode = mode
+					}
+				})
+				const task = new Task({
+					provider: mockProvider,
+					apiConfiguration: mockApiConfig,
+					task: "initial task",
+					startTask: false,
+				})
+				vi.spyOn(task, "handleWebviewAskResponse").mockImplementation(() => {})
+
+				const submitted = task.submitUserMessage("select while initializing", undefined, "architect")
+
+				// Resolve the pending provider state only after the submission has started,
+				// carrying the provider's pre-switch mode.
+				releaseState({ mode: "ask" } as unknown as ProviderState)
+
+				await submitted
+
+				expect(mockProvider.handleModeSwitch).toHaveBeenCalledWith("architect", task)
+				// The explicit selection survives: the deferred initialization ran before,
+				// not after, the mode write.
+				expect(await task.getTaskMode()).toBe("architect")
+			})
+
 			it("stores a provider profile selected through submitUserMessage", async () => {
 				const selectedConfiguration: ProviderSettings = {
 					...mockApiConfig,

src/core/tools/SwitchModeTool.ts

@@ -2,7 +2,7 @@ import delay from "delay"
 
 import { Task } from "../task/Task"
 import { formatResponse } from "../prompts/responses"
-import { defaultModeSlug, getModeBySlug } from "../../shared/modes"
+import { getModeBySlug } from "../../shared/modes"
 import { BaseTool, ToolCallbacks } from "./BaseTool"
 import type { ToolUse } from "../../shared/tools"
 
@@ -39,7 +39,9 @@ export class SwitchModeTool extends BaseTool<"switch_mode"> {
 			}
 
 			// Check if already in requested mode
-			const currentMode = (await task.providerRef.deref()?.getState())?.mode ?? defaultModeSlug
+			// the task's own mode (awaits taskModeReady and applies the default slug) instead of the provider
+			// state, which may be stale or focused on another task.
+			const currentMode = await task.getTaskMode()
 
 			if (currentMode === mode_slug) {
 				task.recordToolError("switch_mode")
@@ -55,8 +57,9 @@ export class SwitchModeTool extends BaseTool<"switch_mode"> {
 				return
 			}
 
-			// Switch the mode using shared handler
-			await task.providerRef.deref()?.handleModeSwitch(mode_slug)
+			// Switch the mode using shared handler. Pass this task explicitly so the
+			// switch is scoped to it rather than the provider's currently focused task.
+			await task.providerRef.deref()?.handleModeSwitch(mode_slug, task)
 
 			pushToolResult(
 				`Successfully switched from ${getModeBySlug(currentMode)?.name ?? currentMode} mode to ${

src/core/tools/__tests__/switchModeTool.spec.ts

@@ -33,19 +33,22 @@ describe("SwitchModeTool", () => {
 	let mockCallbacks: ToolCallbacks
 	let mockHandleModeSwitch: ReturnType<typeof vi.fn>
 	let mockGetState: ReturnType<typeof vi.fn>
+	let mockGetTaskMode: ReturnType<typeof vi.fn>
 
 	beforeEach(() => {
 		vi.clearAllMocks()
 
 		mockHandleModeSwitch = vi.fn().mockResolvedValue(undefined)
 		mockGetState = vi.fn().mockResolvedValue({ mode: "code", customModes: [] })
+		mockGetTaskMode = vi.fn().mockResolvedValue("code")
 
 		mockTask = {
 			consecutiveMistakeCount: 0,
 			recordToolError: vi.fn(),
 			didToolFailInCurrentTurn: false,
 			sayAndCreateMissingParamError: vi.fn().mockResolvedValue("Missing parameter error"),
 			ask: vi.fn().mockResolvedValue({}),
+			getTaskMode: mockGetTaskMode,
 			providerRef: {
 				deref: vi.fn().mockReturnValue({
 					getState: mockGetState,
@@ -165,8 +168,8 @@ describe("SwitchModeTool", () => {
 			}),
 		)
 
-		// Should have called handleModeSwitch with the target slug
-		expect(mockHandleModeSwitch).toHaveBeenCalledWith("architect")
+		// Should have called handleModeSwitch with the target slug and the task
+		expect(mockHandleModeSwitch).toHaveBeenCalledWith("architect", mockTask)
 
 		// Should have pushed success result
 		expect(mockCallbacks.pushToolResult).toHaveBeenCalledWith(
@@ -184,7 +187,7 @@ describe("SwitchModeTool", () => {
 			JSON.stringify({ tool: "switchMode", mode: "ask", reason: "" }),
 		)
 
-		expect(mockHandleModeSwitch).toHaveBeenCalledWith("ask")
+		expect(mockHandleModeSwitch).toHaveBeenCalledWith("ask", mockTask)
 
 		expect(mockCallbacks.pushToolResult).toHaveBeenCalledWith("Successfully switched from Code mode to Ask mode.")
 	})
@@ -244,7 +247,7 @@ describe("SwitchModeTool", () => {
 		// Should have asked for approval first
 		expect(mockCallbacks.askApproval).toHaveBeenCalled()
 		// Should have called handleModeSwitch (which throws)
-		expect(mockHandleModeSwitch).toHaveBeenCalledWith("architect")
+		expect(mockHandleModeSwitch).toHaveBeenCalledWith("architect", mockTask)
 		// Error should be caught and reported
 		expect(mockCallbacks.handleError).toHaveBeenCalledWith("switching mode", switchError)
 	})
@@ -303,7 +306,7 @@ describe("SwitchModeTool", () => {
 		await switchModeTool.handle(mockTask, block, mockCallbacks)
 
 		expect(mockCallbacks.askApproval).toHaveBeenCalled()
-		expect(mockHandleModeSwitch).toHaveBeenCalledWith("custom-mode")
+		expect(mockHandleModeSwitch).toHaveBeenCalledWith("custom-mode", mockTask)
 		expect(mockCallbacks.pushToolResult).toHaveBeenCalledWith(
 			"Successfully switched from Code mode to Custom Mode mode because: testing custom modes.",
 		)
@@ -325,31 +328,36 @@ describe("SwitchModeTool", () => {
 		expect(mockCallbacks.askApproval).toHaveBeenCalledWith("tool", expectedMessage)
 	})
 
-	// ===== getState with custom modes =====
+	// ===== current mode source =====
 
-	it("should read current mode from providerRef state", async () => {
-		// Set current mode to "architect"
-		mockGetState.mockResolvedValue({ mode: "architect", customModes: [] })
+	it("should read the current mode from task.getTaskMode, not provider state", async () => {
+		// The provider state still reports the stale "code" mode while the task is actually in
+		// "architect". The switch report must use the task's own mode.
+		mockGetState.mockResolvedValue({ mode: "code", customModes: [] })
+		mockGetTaskMode.mockResolvedValue("architect")
 
 		const block = createBlock({ mode_slug: "code", reason: "switching back" })
 
 		await switchModeTool.handle(mockTask, block, mockCallbacks)
 
-		expect(mockHandleModeSwitch).toHaveBeenCalledWith("code")
+		expect(mockGetTaskMode).toHaveBeenCalledTimes(1)
+		expect(mockHandleModeSwitch).toHaveBeenCalledWith("code", mockTask)
 		expect(mockCallbacks.pushToolResult).toHaveBeenCalledWith(
 			"Successfully switched from Architect mode to Code mode because: switching back.",
 		)
 	})
 
-	it("should use defaultModeSlug when getState returns no mode", async () => {
-		mockGetState.mockResolvedValue({})
+	it("should use the default slug reported by task.getTaskMode when no mode is active", async () => {
+		// task.getTaskMode applies the default slug when the task has no explicit mode, so the
+		// tool reports switching from the default (Code) mode.
+		mockGetState.mockResolvedValue({ customModes: [] })
+		mockGetTaskMode.mockResolvedValue("code")
 
 		const block = createBlock({ mode_slug: "ask", reason: "test" })
 
 		await switchModeTool.handle(mockTask, block, mockCallbacks)
 
-		// defaultModeSlug is "code" (from mock)
-		// Should report switching from Code mode
+		expect(mockGetTaskMode).toHaveBeenCalledTimes(1)
 		expect(mockCallbacks.pushToolResult).toHaveBeenCalledWith(
 			"Successfully switched from Code mode to Ask mode because: test.",
 		)