fix: fix the mode switch when continue with the parent task

Author: catrielmuller

src/core/task/Task.ts

@@ -372,11 +372,13 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		if (historyItem) {
 			this._taskMode = historyItem.mode || defaultModeSlug
 			this.taskModeReady = Promise.resolve()
+			provider.log(`[Task#${this.taskId}] Initialized from history with mode: ${this._taskMode}`)
 			TelemetryService.instance.captureTaskRestarted(this.taskId)
 		} else {
 			// For new tasks, don't set the mode yet - wait for async initialization.
 			this._taskMode = undefined
 			this.taskModeReady = this.initializeTaskMode(provider)
+			provider.log(`[Task#${this.taskId}] New task - will initialize mode asynchronously`)
 			TelemetryService.instance.captureTaskCreated(this.taskId)
 		}
 
@@ -455,12 +457,14 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		try {
 			const state = await provider.getState()
 			this._taskMode = state?.mode || defaultModeSlug
+			provider.log(`[Task#${this.taskId}] Initialized mode from provider state: ${this._taskMode}`)
 		} catch (error) {
 			// If there's an error getting state, use the default mode
 			this._taskMode = defaultModeSlug
 			// Use the provider's log method for better error visibility
 			const errorMessage = `Failed to initialize task mode: ${error instanceof Error ? error.message : String(error)}`
 			provider.log(errorMessage)
+			provider.log(`[Task#${this.taskId}] Fell back to default mode: ${this._taskMode}`)
 		}
 	}
 
@@ -1607,6 +1611,13 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		const newTask = await provider.createTask(message, undefined, this, { initialTodos })
 
 		if (newTask) {
+			// Store the current task's mode before pausing
+			const currentTaskMode = await this.getTaskMode()
+			this.pausedModeSlug = currentTaskMode
+			provider.log(
+				`[startSubtask] Storing parent task mode '${currentTaskMode}' in pausedModeSlug before pausing`,
+			)
+
 			this.isPaused = true // Pause parent.
 			this.childTaskId = newTask.taskId
 
@@ -1756,6 +1767,9 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 
 				if (currentMode !== this.pausedModeSlug) {
 					// The mode has changed, we need to switch back to the paused mode.
+					provider.log(
+						`[subtasks] task ${this.taskId}.${this.instanceId} switching back to paused mode '${this.pausedModeSlug}' from current mode '${currentMode}'`,
+					)
 					await provider.handleModeSwitch(this.pausedModeSlug)
 
 					// Delay to allow mode change to take effect before next tool is executed.
@@ -1764,6 +1778,8 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 					provider.log(
 						`[subtasks] task ${this.taskId}.${this.instanceId} has switched back to '${this.pausedModeSlug}' from '${currentMode}'`,
 					)
+				} else {
+					provider.log(`[subtasks] task ${this.taskId}.${this.instanceId} mode unchanged: '${currentMode}'`)
 				}
 			}
 

src/core/webview/ClineProvider.ts

@@ -1553,7 +1553,34 @@ export class ClineProvider
 			this.log(`[continueParentTask] Found parent task ${parentTask.taskId}, isPaused: ${parentTask.isPaused}`)
 			this.log(`[continueParentTask] Parent task isInitialized: ${parentTask.isInitialized}`)
 
+			// Log mode information for debugging
+			const currentProviderMode = (await this.getState()).mode
+			const parentTaskMode =
+				typeof parentTask.getTaskMode === "function"
+					? await parentTask.getTaskMode()
+					: (parentTask as any)._taskMode || parentTask.pausedModeSlug || "unknown"
+			this.log(`[continueParentTask] Current provider mode: ${currentProviderMode}`)
+			this.log(`[continueParentTask] Parent task mode: ${parentTaskMode}`)
+			this.log(`[continueParentTask] Parent task pausedModeSlug: ${parentTask.pausedModeSlug}`)
+
 			try {
+				// Switch provider mode to match parent task's mode if they differ
+				if (currentProviderMode !== parentTaskMode && parentTaskMode !== "unknown") {
+					this.log(
+						`[continueParentTask] Provider mode (${currentProviderMode}) differs from parent task mode (${parentTaskMode})`,
+					)
+					this.log(`[continueParentTask] Switching provider mode to match parent task: ${parentTaskMode}`)
+
+					try {
+						await this.handleModeSwitch(parentTaskMode as any)
+						this.log(`[continueParentTask] Successfully switched provider mode to: ${parentTaskMode}`)
+					} catch (error) {
+						this.log(
+							`[continueParentTask] Failed to switch provider mode: ${error instanceof Error ? error.message : String(error)}`,
+						)
+					}
+				}
+
 				// If the parent task is not initialized, we need to initialize it properly
 				if (!parentTask.isInitialized) {
 					this.log(`[continueParentTask] Initializing parent task from history`)
@@ -1679,6 +1706,35 @@ export class ClineProvider
 			}
 
 			this.log(`[reconstructTaskStack] Successfully reconstructed stack with ${createdTasks.length} tasks`)
+
+			// Log final mode state after reconstruction
+			const finalProviderMode = (await this.getState()).mode
+			const targetTask = createdTasks[createdTasks.length - 1]
+			// Safety check for getTaskMode method (may not exist in tests)
+			const targetTaskMode =
+				typeof targetTask.getTaskMode === "function"
+					? await targetTask.getTaskMode()
+					: (targetTask as any)._taskMode || "unknown"
+			this.log(`[reconstructTaskStack] Final provider mode after reconstruction: ${finalProviderMode}`)
+			this.log(`[reconstructTaskStack] Target task final mode: ${targetTaskMode}`)
+
+			// Check if provider mode matches target task mode
+			if (finalProviderMode !== targetTaskMode) {
+				this.log(
+					`[reconstructTaskStack] WARNING: Provider mode (${finalProviderMode}) does not match target task mode (${targetTaskMode})`,
+				)
+				this.log(`[reconstructTaskStack] Switching provider mode to match target task mode: ${targetTaskMode}`)
+
+				// Switch provider mode to match the target task's mode
+				try {
+					await this.handleModeSwitch(targetTaskMode as any)
+					this.log(`[reconstructTaskStack] Successfully switched provider mode to: ${targetTaskMode}`)
+				} catch (error) {
+					this.log(
+						`[reconstructTaskStack] Failed to switch provider mode: ${error instanceof Error ? error.message : String(error)}`,
+					)
+				}
+			}
 		} catch (error) {
 			this.log(
 				`[reconstructTaskStack] ERROR during reconstruction: ${error instanceof Error ? error.message : String(error)}`,