fix(orchestrator): always restore parent mode after subtask completion

Previously, when an orchestrated workflow dispatched a subtask (e.g., in code or architect mode) and the subtask completed, the parent orchestrator task would resume execution but remain in the child mode instead of reverting to orchestrator mode. This caused confusion and improper workflows, as documented in issues #4896, #5478, and #5747.

The fix ensures that, upon subtask completion (including cancellations or API aborts), the parent task's mode is explicitly restored to the `pausedModeSlug` saved before launching the subtask. All possible subtask completion and stack handling code paths are covered, making regressions unlikely.

Also adds a focused test to verify mode restoration logic.

Rationale: Correct orchestrator handoff is critical to multi-mode workflows. This change ensures state isn't leaked between parent/child, and is robust against all completion/cancellation scenarios.

Author: victoraranda

src/core/task/Task.ts

@@ -1623,6 +1623,11 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		this.isPaused = false
 		this.childTaskId = undefined
 
+		const provider = this.providerRef.deref()
+		if (provider) {
+			await provider.handleModeSwitch(this.pausedModeSlug)
+		}
+
 		this.emit(RooCodeEventName.TaskUnpaused, this.taskId)
 
 		// Fake an answer from the subtask that it has completed running and

src/core/task/__tests__/Task.subtask-mode-restore.spec.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect, vi, beforeEach } from "vitest"
+import { Task } from "../Task"
+import { ClineProvider } from "../../webview/ClineProvider"
+import { TodoItem } from "@roo-code/types"
+
+describe("Task subtask mode restoration", () => {
+	let parentTask: Task
+	let mockProvider: any
+
+	beforeEach(() => {
+		mockProvider = {
+			handleModeSwitch: vi.fn().mockResolvedValue(undefined),
+			log: vi.fn(),
+			deref: vi.fn().mockReturnValue({
+				handleModeSwitch: vi.fn().mockResolvedValue(undefined),
+			}),
+		}
+	})
+
+	it("should restore parent task mode when subtask completes", async () => {
+		// Create parent task with orchestrator mode
+		parentTask = new Task({
+			provider: mockProvider as any,
+			apiConfiguration: {} as any,
+			task: "Parent task",
+		})
+		
+		// Set parent task to orchestrator mode
+		parentTask.pausedModeSlug = "orchestrator"
+		
+		// Mock the provider reference
+		parentTask.providerRef = {
+			deref: () => mockProvider.deref(),
+		} as any
+
+		// Complete the subtask
+		await parentTask.completeSubtask("Subtask completed")
+
+		// Verify handleModeSwitch was called with the pausedModeSlug
+		expect(mockProvider.deref().handleModeSwitch).toHaveBeenCalledWith("orchestrator")
+		
+		// Verify task is unpaused
+		expect(parentTask.isPaused).toBe(false)
+		
+		// Verify childTaskId is cleared
+		expect(parentTask.childTaskId).toBeUndefined()
+	})
+
+	it("should handle missing provider gracefully", async () => {
+		// Create parent task
+		parentTask = new Task({
+			provider: mockProvider as any,
+			apiConfiguration: {} as any,
+			task: "Parent task",
+		})
+		
+		// Set parent task to orchestrator mode
+		parentTask.pausedModeSlug = "orchestrator"
+		
+		// Mock provider as unavailable
+		parentTask.providerRef = {
+			deref: () => undefined,
+		} as any
+
+		// Complete the subtask - should not throw
+		await expect(parentTask.completeSubtask("Subtask completed")).resolves.not.toThrow()
+		
+		// Verify task is still unpaused
+		expect(parentTask.isPaused).toBe(false)
+	})
+})