test(e2e): add scheduler regression tests for task resume paths

Author: edelauna

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

@@ -48,6 +48,15 @@ export const SUBTASK_XPROFILE_SAME_CHILD_RESULT = "Same-profile child completed"
 export const SUBTASK_XPROFILE_DIFFERENT_CHILD_RESULT = "Different-profile child completed"
 export const SUBTASK_XPROFILE_PARENT_RESULT = "Sequential cross-profile parent resumed"
 
+// Scheduler regression tests — exercises TaskScheduler + run() dispatch post-CodeRabbit fix.
+// Separate markers to avoid collisions with the other subtask fixtures.
+const SCHED_STANDALONE_MARKER = "SCHED_STANDALONE_INTERRUPT_RESUME"
+const SCHED_COMPLETED_MARKER = "SCHED_COMPLETED_REOPEN"
+export const SCHED_STANDALONE_PROMPT = `${SCHED_STANDALONE_MARKER}: Ask the user exactly this follow-up question: What is the square root of 64? After the user answers, complete with only the answer.`
+export const SCHED_STANDALONE_FOLLOWUP_ANSWER = "8"
+export const SCHED_COMPLETED_PROMPT = `${SCHED_COMPLETED_MARKER}: Complete immediately with the exact result "Scheduler completed task".`
+export const SCHED_COMPLETED_RESULT = "Scheduler completed task"
+
 const apiHangChildMatch = new RegExp(SUBTASK_API_HANG_CHILD_MARKER)
 
 const requestContains = (req: ChatCompletionRequest, expected: string[]) => {
@@ -396,6 +405,62 @@ export function addSubtaskFixtures(mock: InstanceType<typeof LLMock>) {
 		},
 	})
 
+	// Scheduler regression fixtures: standalone interrupted task resume and completed task reopen.
+	mock.addFixture({
+		match: {
+			predicate: (req: ChatCompletionRequest) =>
+				requestContains(req, [SCHED_STANDALONE_MARKER]) &&
+				!requestContains(req, ["call_sched_standalone_followup_001"]) &&
+				!requestContains(req, [`<user_message>\\n${SCHED_STANDALONE_FOLLOWUP_ANSWER}\\n</user_message>`]),
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "ask_followup_question",
+					arguments: JSON.stringify({
+						question: "What is the square root of 64?",
+						follow_up: [{ text: SCHED_STANDALONE_FOLLOWUP_ANSWER }],
+					}),
+					id: "call_sched_standalone_followup_001",
+				},
+			],
+		},
+	})
+
+	mock.addFixture({
+		match: {
+			predicate: (req: ChatCompletionRequest) =>
+				toolResultContains(req, "call_sched_standalone_followup_001", [SCHED_STANDALONE_FOLLOWUP_ANSWER]) ||
+				requestContains(req, ["call_sched_standalone_followup_001", SCHED_STANDALONE_FOLLOWUP_ANSWER]) ||
+				requestContains(req, [
+					SCHED_STANDALONE_MARKER,
+					`<user_message>\\n${SCHED_STANDALONE_FOLLOWUP_ANSWER}\\n</user_message>`,
+				]),
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: SCHED_STANDALONE_FOLLOWUP_ANSWER }),
+					id: "call_sched_standalone_completion_002",
+				},
+			],
+		},
+	})
+
+	mock.addFixture({
+		match: { userMessage: new RegExp(SCHED_COMPLETED_MARKER) },
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: SCHED_COMPLETED_RESULT }),
+					id: "call_sched_completed_completion_001",
+				},
+			],
+		},
+	})
+
 	// Interrupted-child-resumes-and-reports-back scenario (#560)
 	mock.addFixture({
 		match: {

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

@@ -5,6 +5,10 @@ import { RooCodeEventName, type ClineMessage } from "@roo-code/types"
 import { setDefaultSuiteTimeout } from "./test-utils"
 import { sleep, waitFor, waitUntilCompleted } from "./utils"
 import {
+	SCHED_COMPLETED_PROMPT,
+	SCHED_COMPLETED_RESULT,
+	SCHED_STANDALONE_FOLLOWUP_ANSWER,
+	SCHED_STANDALONE_PROMPT,
 	SUBTASK_ABANDON_CHILD_FOLLOWUP_ANSWER,
 	SUBTASK_ABANDON_PARENT_PROMPT,
 	SUBTASK_API_HANG_CHILD_MARKER,
@@ -945,4 +949,139 @@ suite("Roo Code Subtasks", function () {
 			await waitFor(() => api.getCurrentTaskStack().length === 0).catch(() => {})
 		}
 	})
+
+	// TaskScheduler regression: resumeTask on a completed task must show resume_completed_task ask.
+	// Before the CodeRabbit fix, createTaskWithHistoryItem bypassed the scheduler and called
+	// Task.run() via the constructor's startTask: true default, causing run() to call startTask()
+	// (clearing history) instead of resumeTaskFromHistory().
+	test("resumeTask on a completed task presents resume_completed_task ask", async () => {
+		const api = globalThis.api
+		const asks: Record<string, ClineMessage[]> = {}
+		const says: Record<string, ClineMessage[]> = {}
+
+		const messageHandler = ({ taskId, message }: { taskId: string; message: ClineMessage }) => {
+			if (message.type === "ask") {
+				asks[taskId] = asks[taskId] || []
+				asks[taskId].push(message)
+			}
+			if (message.type === "say" && message.partial === false) {
+				says[taskId] = says[taskId] || []
+				says[taskId].push(message)
+			}
+		}
+
+		api.on(RooCodeEventName.Message, messageHandler)
+
+		try {
+			// Run a task to completion.
+			const taskId = await waitUntilCompleted({
+				api,
+				start: () =>
+					api.startNewTask({
+						configuration: {
+							mode: "ask",
+							autoApprovalEnabled: true,
+							enableCheckpoints: false,
+						},
+						text: SCHED_COMPLETED_PROMPT,
+					}),
+			})
+
+			assert.strictEqual(
+				says[taskId]?.find(({ say }) => say === "completion_result")?.text?.trim(),
+				SCHED_COMPLETED_RESULT,
+				"Task should complete with expected result",
+			)
+
+			// Re-open it via resumeTask — should hit resumeTaskFromHistory(), showing resume_completed_task.
+			await api.resumeTask(taskId)
+
+			await waitFor(
+				() => asks[taskId]?.some(({ type, ask }) => type === "ask" && ask === "resume_completed_task") ?? false,
+			)
+		} finally {
+			api.off(RooCodeEventName.Message, messageHandler)
+			while (api.getCurrentTaskStack().length > 0) {
+				await api.clearCurrentTask()
+			}
+			await sleep(500)
+		}
+	})
+
+	// TaskScheduler regression: resumeTask on an interrupted standalone task must show resume_task
+	// ask and allow the task to complete normally via the scheduler slot.
+	test("resumeTask on an interrupted standalone task presents resume_task ask and completes", async () => {
+		const api = globalThis.api
+		const asks: Record<string, ClineMessage[]> = {}
+		const says: Record<string, ClineMessage[]> = {}
+
+		const messageHandler = ({ taskId, message }: { taskId: string; message: ClineMessage }) => {
+			if (message.type === "ask") {
+				asks[taskId] = asks[taskId] || []
+				asks[taskId].push(message)
+			}
+			if (message.type === "say" && message.partial === false) {
+				says[taskId] = says[taskId] || []
+				says[taskId].push(message)
+			}
+		}
+
+		api.on(RooCodeEventName.Message, messageHandler)
+
+		let taskId: string | undefined
+
+		try {
+			taskId = await api.startNewTask({
+				configuration: {
+					mode: "ask",
+					autoApprovalEnabled: true,
+					enableCheckpoints: false,
+				},
+				text: SCHED_STANDALONE_PROMPT,
+			})
+
+			// Wait until the task pauses at the follow-up question.
+			await waitFor(() => asks[taskId!]?.some(({ type, ask }) => type === "ask" && ask === "followup") ?? false)
+
+			// Cancel it — the task becomes interrupted.
+			await api.cancelCurrentTask()
+
+			await waitFor(
+				() => asks[taskId!]?.some(({ type, ask }) => type === "ask" && ask === "resume_task") ?? false,
+			)
+
+			// Resume via scheduler path (createTaskWithHistoryItem).
+			const askCountBeforeResume = asks[taskId!]?.length ?? 0
+			await api.resumeTask(taskId!)
+
+			await waitFor(() =>
+				(asks[taskId!] ?? [])
+					.slice(askCountBeforeResume)
+					.some(({ type, ask }) => type === "ask" && ask === "resume_task"),
+			)
+
+			// Sending the answer both acknowledges the resume_task ask and answers the pending
+			// follow-up question from the original task, completing the task.
+			const completedTaskId = await waitUntilCompleted({
+				api,
+				start: async () => {
+					await api.sendMessage(SCHED_STANDALONE_FOLLOWUP_ANSWER)
+					return taskId!
+				},
+			})
+
+			assert.strictEqual(completedTaskId, taskId, "The resumed standalone task should complete")
+			assert.strictEqual(
+				says[taskId!]?.find(({ say }) => say === "completion_result")?.text?.trim(),
+				SCHED_STANDALONE_FOLLOWUP_ANSWER,
+				"Task should complete with the follow-up answer as result",
+			)
+		} finally {
+			api.off(RooCodeEventName.Message, messageHandler)
+			while (api.getCurrentTaskStack().length > 0) {
+				await api.clearCurrentTask()
+			}
+			await sleep(500)
+		}
+	})
 })

src/__tests__/single-open-invariant.spec.ts

@@ -67,13 +67,14 @@ describe("Single-open-task invariant", () => {
 
 		const removeClineFromStack = vi.fn().mockResolvedValue(undefined)
 		const addClineToStack = vi.fn().mockResolvedValue(undefined)
+		const schedulespy = vi.fn().mockResolvedValue(undefined)
 
 		const existingTask = { taskId: "existing-1", abort: false, abandoned: false }
 		const registry = new TaskRegistry()
 		registry.push(existingTask as unknown as Task)
 		const provider = {
 			taskRegistry: registry,
-			taskScheduler: new TaskScheduler(),
+			taskScheduler: { schedule: schedulespy },
 			getCurrentTask: vi.fn(() => existingTask),
 			taskHistoryStore: { get: vi.fn(() => undefined) },
 			markDelegatedChildInterrupted: vi.fn().mockResolvedValue(undefined),
@@ -109,6 +110,7 @@ describe("Single-open-task invariant", () => {
 
 		expect(removeClineFromStack).toHaveBeenCalledTimes(1)
 		expect(addClineToStack).toHaveBeenCalledTimes(1)
+		expect(schedulespy).toHaveBeenCalledTimes(1)
 	})
 
 	it("Subtask create: keeps existing task open when parentTask is provided", async () => {
@@ -158,6 +160,7 @@ describe("Single-open-task invariant", () => {
 		const removeClineFromStack = vi.fn().mockResolvedValue(undefined)
 		const addClineToStack = vi.fn().mockResolvedValue(undefined)
 		const updateGlobalState = vi.fn().mockResolvedValue(undefined)
+		const schedulespy = vi.fn().mockResolvedValue(undefined)
 
 		const provider = {
 			getCurrentTask: vi.fn(() => undefined), // ensure not rehydrating
@@ -186,7 +189,7 @@ describe("Single-open-task invariant", () => {
 			// Methods used by createTaskWithHistoryItem for pending edit cleanup
 			getPendingEditOperation: vi.fn().mockReturnValue(undefined),
 			clearPendingEditOperation: vi.fn(),
-			taskScheduler: { schedule: vi.fn().mockResolvedValue(undefined) },
+			taskScheduler: { schedule: schedulespy },
 			context: { extension: { packageJSON: {} }, globalStorageUri: { fsPath: "/tmp" } },
 			contextProxy: {
 				extensionUri: {},
@@ -213,6 +216,82 @@ describe("Single-open-task invariant", () => {
 		expect(task).toBeTruthy()
 		expect(removeClineFromStack).toHaveBeenCalledTimes(1)
 		expect(addClineToStack).toHaveBeenCalledTimes(1)
+		expect(schedulespy).toHaveBeenCalledTimes(1)
+	})
+
+	it("History resume path wires scheduler in rehydrating (in-place) case", async () => {
+		const schedulespy = vi.fn().mockResolvedValue(undefined)
+		const removeClineFromStack = vi.fn().mockResolvedValue(undefined)
+		const historyId = "hist-rehydrate-1"
+
+		const existingTask = {
+			taskId: historyId,
+			instanceId: "old-inst",
+			abort: false,
+			abandoned: false,
+			abortTask: vi.fn().mockResolvedValue(undefined),
+			emit: vi.fn(),
+		}
+
+		const registry = new TaskRegistry()
+		registry.push(existingTask as unknown as Task)
+
+		const provider = {
+			getCurrentTask: vi.fn(() => existingTask),
+			taskRegistry: registry,
+			taskHistoryStore: { get: vi.fn(() => undefined) },
+			markDelegatedChildInterrupted: vi.fn().mockResolvedValue(undefined),
+			get evictCurrentTask() {
+				return privateClineProvider.evictCurrentTask.bind(this)
+			},
+			removeClineFromStack,
+			addClineToStack: vi.fn().mockResolvedValue(undefined),
+			log: vi.fn(),
+			customModesManager: { getCustomModes: vi.fn().mockResolvedValue([]) },
+			providerSettingsManager: {
+				getModeConfigId: vi.fn().mockResolvedValue(undefined),
+				listConfig: vi.fn().mockResolvedValue([]),
+			},
+			getState: vi.fn().mockResolvedValue({
+				apiConfiguration: { apiProvider: "anthropic", consecutiveMistakeLimit: 0 },
+				enableCheckpoints: true,
+				checkpointTimeout: 60,
+				experiments: {},
+				cloudUserInfo: null,
+				taskSyncEnabled: false,
+			}),
+			getPendingEditOperation: vi.fn().mockReturnValue(undefined),
+			clearPendingEditOperation: vi.fn(),
+			taskScheduler: { schedule: schedulespy },
+			taskEventListeners: new WeakMap(),
+			performPreparationTasks: vi.fn().mockResolvedValue(undefined),
+			context: { extension: { packageJSON: {} }, globalStorageUri: { fsPath: "/tmp" } },
+			contextProxy: {
+				extensionUri: {},
+				getValue: vi.fn(),
+				setValue: vi.fn(),
+				setProviderSettings: vi.fn(),
+				getProviderSettings: vi.fn(() => ({})),
+			},
+			postStateToWebview: vi.fn(),
+		} as unknown as ClineProvider
+
+		const historyItem = {
+			id: historyId,
+			number: 1,
+			ts: Date.now(),
+			task: "Task",
+			tokensIn: 0,
+			tokensOut: 0,
+			totalCost: 0,
+			workspace: "/tmp",
+		}
+
+		await privateClineProvider.createTaskWithHistoryItem.call(provider, historyItem)
+
+		expect(schedulespy).toHaveBeenCalledTimes(1)
+		// evictCurrentTask must NOT have been called — in-place replace, no stack pop
+		expect(removeClineFromStack).not.toHaveBeenCalled()
 	})
 
 	it("IPC StartNewTask path closes current before new task", async () => {