@@ -1676,8 +1676,22 @@ 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.
+					try {
+						await provider.handleModeSwitch(mode, this)
+					} catch (error) {
+						console.error(
+							`[Task#submitUserMessage] Mode switch to ${mode} failed (taskId=${this.taskId}):`,
+							error,
+						)
+					}
 				}
 
 				if (providerProfile) {
 
@@ -41,6 +41,9 @@ type TaskTestAccess = {
 	saveClineMessages: () => Promise<boolean>
 	safeEnsureModelFetched: () => Promise<void>
 	addToApiConversationHistory: (message: unknown, reasoning?: string) => Promise<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"]>>
@@ -1411,6 +1414,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),
@@ -1966,7 +1970,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,
@@ -1975,6 +1985,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* () {
@@ -1987,10 +2001,34 @@ 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("stores a provider profile selected through submitUserMessage", async () => {
 				const selectedConfiguration: ProviderSettings = {
 					...mockApiConfig,
 
@@ -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 ${
 
@@ -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.",
 		)