test(e2e): interrupted child resumes and reports back to parent

Author: edelauna

apps/cli/src/ui/components/autocomplete/triggers/HistoryTrigger.tsx

@@ -21,7 +21,7 @@ export interface HistoryResult extends AutocompleteItem {
 	/** Mode the task was run in */
 	mode?: string
 	/** Task status */
-	status?: "active" | "completed" | "delegated"
+	status?: "active" | "completed" | "delegated" | "interrupted"
 }
 
 /**
@@ -133,8 +133,22 @@ export function createHistoryTrigger(config: HistoryTriggerConfig): Autocomplete
 
 		renderItem: (item: HistoryResult, isSelected: boolean) => {
 			// Status indicator
-			const statusIcon = item.status === "completed" ? "✓" : item.status === "active" ? "●" : "○"
-			const statusColor = item.status === "completed" ? "green" : item.status === "active" ? "yellow" : "gray"
+			const statusIcon =
+				item.status === "completed"
+					? "✓"
+					: item.status === "active"
+						? "●"
+						: item.status === "interrupted"
+							? "⏸"
+							: "○"
+			const statusColor =
+				item.status === "completed"
+					? "green"
+					: item.status === "active"
+						? "yellow"
+						: item.status === "interrupted"
+							? "cyan"
+							: "gray"
 
 			// Mode indicator (if available)
 			const modeText = item.mode ? ` [${item.mode}]` : ""
@@ -178,7 +192,7 @@ export function toHistoryResult(item: {
 	totalCost?: number
 	workspace?: string
 	mode?: string
-	status?: "active" | "completed" | "delegated"
+	status?: "active" | "completed" | "delegated" | "interrupted"
 }): HistoryResult {
 	return {
 		key: item.id, // Use task ID as the unique key

apps/cli/src/ui/components/autocomplete/triggers/__tests__/HistoryTrigger.test.tsx

@@ -188,6 +188,24 @@ describe("HistoryTrigger", () => {
 			expect(output).toContain("○")
 		})
 
+		it("should render interrupted status with correct indicator", () => {
+			const trigger = createHistoryTrigger({ getHistory: () => mockHistoryItems })
+
+			const interruptedItem: HistoryResult = {
+				key: "task-interrupted",
+				id: "task-interrupted",
+				task: "Interrupted subtask waiting to resume",
+				ts: Date.now() - 1000 * 60 * 5,
+				mode: "ask",
+				status: "interrupted",
+			}
+			const { lastFrame } = render(trigger.renderItem(interruptedItem, false) as React.ReactElement)
+
+			const output = lastFrame()
+			// Should contain the interrupted status indicator (⏸)
+			expect(output).toContain("⏸")
+		})
+
 		it("should render selected items with different styling", () => {
 			const trigger = createHistoryTrigger({ getHistory: () => mockHistoryItems })
 

apps/cli/src/ui/types.ts

@@ -109,7 +109,7 @@ export interface TaskHistoryItem {
 	totalCost?: number
 	workspace?: string
 	mode?: string
-	status?: "active" | "completed" | "delegated"
+	status?: "active" | "completed" | "delegated" | "interrupted"
 	tokensIn?: number
 	tokensOut?: number
 }

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

@@ -5,6 +5,8 @@ import { toolResultContains } from "./tool-result"
 
 const SUBTASK_PARENT_MARKER = "SUBTASK_PARENT_CANCELLATION_SMOKE"
 const SUBTASK_CHILD_MARKER = "SUBTASK_CHILD_CALCULATOR_SMOKE"
+const SUBTASK_INTERRUPT_PARENT_MARKER = "SUBTASK_PARENT_INTERRUPT_RESUME"
+const SUBTASK_INTERRUPT_CHILD_MARKER = "SUBTASK_CHILD_INTERRUPT_RESUME"
 const SUBTASK_FAST_PARENT_MARKER = "SUBTASK_PARENT_IMMEDIATE_COMPLETION"
 const SUBTASK_FAST_CHILD_MARKER = "SUBTASK_CHILD_IMMEDIATE_COMPLETION"
 const SUBTASK_XPROFILE_PARENT_MARKER = "SUBTASK_PARENT_CROSS_PROFILE"
@@ -17,6 +19,11 @@ export const SUBTASK_CHILD_FOLLOWUP_ANSWER = "9"
 const SUBTASK_FAST_CHILD_PROMPT = `${SUBTASK_FAST_CHILD_MARKER}: Complete immediately with the exact result "Fast child completed".`
 export const SUBTASK_FAST_PARENT_PROMPT = `${SUBTASK_FAST_PARENT_MARKER}: Use the new_task tool exactly once. Create an ask-mode subtask with this exact message: "${SUBTASK_FAST_CHILD_PROMPT}" Do not answer directly.`
 
+const SUBTASK_INTERRUPT_CHILD_PROMPT = `${SUBTASK_INTERRUPT_CHILD_MARKER}: Ask the user exactly this follow-up question: What is the square root of 81? After the user answers, complete with only the answer.`
+export const SUBTASK_INTERRUPT_PARENT_PROMPT = `${SUBTASK_INTERRUPT_PARENT_MARKER}: Use the new_task tool exactly once. Create an ask-mode subtask with this exact message: "${SUBTASK_INTERRUPT_CHILD_PROMPT}" Do not answer directly. When the subtask returns, complete with the exact result "Interrupted parent resumed".`
+export const SUBTASK_INTERRUPT_CHILD_FOLLOWUP_ANSWER = "9"
+export const SUBTASK_INTERRUPT_PARENT_RESULT = "Interrupted parent resumed"
+
 const SUBTASK_XPROFILE_SAME_CHILD_PROMPT = `${SUBTASK_XPROFILE_SAME_CHILD_MARKER}: Complete immediately with the exact result "Same-profile child completed".`
 const SUBTASK_XPROFILE_DIFFERENT_CHILD_PROMPT = `${SUBTASK_XPROFILE_DIFFERENT_CHILD_MARKER}: Complete immediately with the exact result "Different-profile child completed".`
 export const SUBTASK_XPROFILE_PARENT_PROMPT = `${SUBTASK_XPROFILE_PARENT_MARKER}: First use new_task to create a code-mode subtask with this exact message: "${SUBTASK_XPROFILE_SAME_CHILD_PROMPT}" After it returns, create an ask-mode subtask with the next instructions you receive.`
@@ -252,4 +259,87 @@ export function addSubtaskFixtures(mock: InstanceType<typeof LLMock>) {
 			],
 		},
 	})
+
+	// Interrupted-child-resumes-and-reports-back scenario (#560)
+	mock.addFixture({
+		match: {
+			userMessage: new RegExp(SUBTASK_INTERRUPT_PARENT_MARKER),
+			sequenceIndex: 0,
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "new_task",
+					arguments: JSON.stringify({
+						mode: "ask",
+						message: SUBTASK_INTERRUPT_CHILD_PROMPT,
+					}),
+					id: "call_interrupt_parent_new_task_001",
+				},
+			],
+		},
+	})
+
+	// The parent prompt embeds SUBTASK_INTERRUPT_CHILD_MARKER verbatim, so parent-resume turns
+	// also match a bare substring check. Exclude the parent marker so they fall through.
+	mock.addFixture({
+		match: {
+			predicate: (req: ChatCompletionRequest) =>
+				requestContains(req, [SUBTASK_INTERRUPT_CHILD_MARKER]) &&
+				!requestContains(req, [SUBTASK_INTERRUPT_PARENT_MARKER]),
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "ask_followup_question",
+					arguments: JSON.stringify({
+						question: "What is the square root of 81?",
+						follow_up: [{ text: SUBTASK_INTERRUPT_CHILD_FOLLOWUP_ANSWER }],
+					}),
+					id: "call_interrupt_child_followup_001",
+				},
+			],
+		},
+	})
+
+	mock.addFixture({
+		match: {
+			predicate: (req: ChatCompletionRequest) =>
+				// Preferred: structured tool-result message carries the followup answer.
+				toolResultContains(req, "call_interrupt_child_followup_001", [
+					SUBTASK_INTERRUPT_CHILD_FOLLOWUP_ANSWER,
+				]) ||
+				// Fallback 1: answer present alongside the tool-call ID.
+				requestContains(req, ["call_interrupt_child_followup_001", SUBTASK_INTERRUPT_CHILD_FOLLOWUP_ANSWER]) ||
+				// Fallback 2: answer arrives as a bare user message after task resume.
+				requestContains(req, [
+					SUBTASK_INTERRUPT_CHILD_MARKER,
+					`<user_message>\\n${SUBTASK_INTERRUPT_CHILD_FOLLOWUP_ANSWER}\\n</user_message>`,
+				]),
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: "9" }),
+					id: "call_interrupt_child_completion_002",
+				},
+			],
+		},
+	})
+
+	mock.addFixture({
+		match: {
+			toolCallId: "call_interrupt_parent_new_task_001",
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: "Interrupted parent resumed" }),
+					id: "call_interrupt_parent_completion_003",
+				},
+			],
+		},
+	})
 }

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

@@ -7,6 +7,9 @@ import { waitFor, waitUntilCompleted } from "./utils"
 import {
 	SUBTASK_CHILD_FOLLOWUP_ANSWER,
 	SUBTASK_FAST_PARENT_PROMPT,
+	SUBTASK_INTERRUPT_CHILD_FOLLOWUP_ANSWER,
+	SUBTASK_INTERRUPT_PARENT_PROMPT,
+	SUBTASK_INTERRUPT_PARENT_RESULT,
 	SUBTASK_PARENT_PROMPT,
 	SUBTASK_XPROFILE_DIFFERENT_CHILD_RESULT,
 	SUBTASK_XPROFILE_PARENT_PROMPT,
@@ -439,4 +442,102 @@ suite("Roo Code Subtasks", function () {
 			}
 		}
 	})
+
+	// Issue #560: interrupted child resumes and reports back to parent.
+	// Before the fix, cancelTask() severed the parent link, so the resumed child
+	// fell through to "Start New Task" instead of delegating back to the parent.
+	test("interrupted child resumes and reports back to parent", 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 {
+			const parentTaskId = await api.startNewTask({
+				configuration: {
+					mode: "ask",
+					alwaysAllowModeSwitch: true,
+					alwaysAllowSubtasks: true,
+					autoApprovalEnabled: true,
+					enableCheckpoints: false,
+				},
+				text: SUBTASK_INTERRUPT_PARENT_PROMPT,
+			})
+
+			// Wait for child to spawn
+			let childTaskId: string | undefined
+			await waitFor(() => {
+				const stack = api.getCurrentTaskStack()
+				const current = stack[stack.length - 1]
+				if (current && current !== parentTaskId) {
+					childTaskId = current
+					return true
+				}
+				return false
+			})
+
+			// Wait for the child's followup question
+			await waitFor(() => asks[childTaskId!]?.some(({ ask }) => ask === "followup") ?? false)
+
+			// Cancel the child — it should be marked "interrupted", parent stays "delegated"
+			await api.cancelCurrentTask()
+
+			// Child should be back on the stack (rehydrated as interrupted)
+			await waitFor(() => api.getCurrentTaskStack().at(-1) === childTaskId)
+			await waitFor(
+				() => asks[childTaskId!]?.some(({ type, ask }) => type === "ask" && ask === "resume_task") ?? false,
+			)
+
+			// Parent must not have resumed yet
+			assert.strictEqual(
+				says[parentTaskId]?.find(({ say }) => say === "completion_result"),
+				undefined,
+				"Parent must not have resumed while child is interrupted",
+			)
+
+			// Resume the child and answer the followup — child should complete and reopen parent
+			const completedParentTaskId = await waitUntilCompleted({
+				api,
+				start: async () => {
+					await api.sendMessage(SUBTASK_INTERRUPT_CHILD_FOLLOWUP_ANSWER)
+					return parentTaskId
+				},
+			})
+
+			assert.strictEqual(
+				completedParentTaskId,
+				parentTaskId,
+				"Parent task should be the one that completes after interrupted child reports back",
+			)
+
+			const parentCompletionText = says[parentTaskId]
+				?.filter(({ say }) => say === "completion_result")
+				.map(({ text }) => text?.trim())
+				.find((t): t is string => !!t)
+
+			assert.strictEqual(
+				parentCompletionText,
+				SUBTASK_INTERRUPT_PARENT_RESULT,
+				"Parent should complete with expected result after interrupted child reports back",
+			)
+		} finally {
+			api.off(RooCodeEventName.Message, messageHandler)
+			while (api.getCurrentTaskStack().length > 0) {
+				await api.clearCurrentTask()
+			}
+			await waitFor(() => api.getCurrentTaskStack().length === 0).catch(() => {})
+		}
+	})
 })