Fix task-scoped stop state

Co-Authored-By: Oz <oz-agent@warp.dev>

Author: allquixotic

packages/types/src/task.ts

@@ -22,7 +22,7 @@ export interface TaskProviderLike extends EventEmitter<TaskProviderEvents> {
 		options?: CreateTaskOptions,
 		configuration?: RooCodeSettings,
 	): Promise<TaskLike>
-	cancelTask(): Promise<void>
+	cancelTask(taskId?: string): Promise<void>
 	clearTask(): Promise<void>
 	resumeTask(taskId: string): void
 
@@ -37,7 +37,6 @@ export interface TaskProviderLike extends EventEmitter<TaskProviderEvents> {
 	setProviderProfile(providerProfile: string): Promise<void>
 	readonly cwd: string
 
-
 	// @TODO: Find a better way to do this.
 	postStateToWebview(): Promise<void>
 }

src/core/webview/ClineProvider.ts

@@ -3393,14 +3393,15 @@ export class ClineProvider
 		return task
 	}
 
-	public async cancelTask(): Promise<void> {
-		const task = this.getCurrentTask()
+	public async cancelTask(taskId?: string): Promise<void> {
+		const task = this.resolveMessageTask(taskId)
 
 		if (!task) {
 			return
 		}
 
 		console.log(`[cancelTask] cancelling task ${task.taskId}.${task.instanceId}`)
+		const wasVisible = this.isTaskVisible(task.taskId)
 		const preservedQueuedMessages = task.messageQueueService.messages.map((message) => ({
 			...message,
 			images: message.images ? [...message.images] : undefined,
@@ -3453,7 +3454,7 @@ export class ClineProvider
 		}
 		const replacementTask = await this.createTaskWithHistoryItem(
 			{ ...historyItem, rootTask, parentTask },
-			{ replaceExistingTask: true },
+			{ replaceExistingTask: true, focus: wasVisible },
 		)
 
 		if (replacementTask && preservedQueuedMessages.length > 0) {

src/core/webview/__tests__/ClineProvider.flicker-free-cancel.spec.ts

@@ -350,6 +350,7 @@ describe("ClineProvider flicker-free cancel", () => {
 		mockTask1.rootTask = { taskId: "root-task" }
 		mockTask1.parentTask = { taskId: "parent-task" }
 		;(provider as any).clineStack = [mockTask1]
+		;(provider as any).visibleTaskId = "task-1"
 
 		const createTaskWithHistoryItemSpy = vi
 			.spyOn(provider, "createTaskWithHistoryItem")
@@ -371,7 +372,7 @@ describe("ClineProvider flicker-free cancel", () => {
 				rootTask: mockTask1.rootTask,
 				parentTask: mockTask1.parentTask,
 			}),
-			{ replaceExistingTask: true },
+			{ replaceExistingTask: true, focus: true },
 		)
 		expect(replacementTask.messageQueueService.restoreMessages).toHaveBeenCalledWith([
 			{
@@ -384,4 +385,53 @@ describe("ClineProvider flicker-free cancel", () => {
 		expect(replacementTask.setDeferQueuedMessageDrainUntilResume).toHaveBeenCalledWith(true)
 		expect(removeClineFromStackSpy).not.toHaveBeenCalled()
 	})
+
+	it("hard-stops the requested task without cancelling the visible task", async () => {
+		const visibleTask = {
+			taskId: "task-2",
+			instanceId: "instance-2",
+			emit: vi.fn(),
+			abortTask: vi.fn().mockResolvedValue(undefined),
+			cancelCurrentRequest: vi.fn(),
+			cancelAutoApprovalTimeout: vi.fn(),
+			supersedePendingAsk: vi.fn(),
+			messageQueueService: { messages: [] },
+			terminalProcess: { abort: vi.fn() },
+			rootTask: undefined,
+			parentTask: undefined,
+			abandoned: false,
+			abort: false,
+			on: vi.fn(),
+			off: vi.fn(),
+		}
+		const replacementTask = {
+			messageQueueService: {
+				restoreMessages: vi.fn(),
+			},
+			setDeferQueuedMessageDrainUntilResume: vi.fn(),
+		}
+
+		;(provider as any).clineStack = [mockTask1, visibleTask]
+		;(provider as any).visibleTaskId = "task-2"
+
+		const createTaskWithHistoryItemSpy = vi
+			.spyOn(provider, "createTaskWithHistoryItem")
+			.mockResolvedValue(replacementTask as any)
+
+		await provider.cancelTask("task-1")
+
+		expect(mockTask1.abortReason).toBe("user_cancelled")
+		expect(mockTask1.cancelCurrentRequest).toHaveBeenCalledTimes(1)
+		expect(mockTask1.cancelAutoApprovalTimeout).toHaveBeenCalledTimes(1)
+		expect(mockTask1.supersedePendingAsk).toHaveBeenCalledTimes(1)
+		expect(mockTask1.abortTask).toHaveBeenCalledWith(true)
+		expect(visibleTask.cancelCurrentRequest).not.toHaveBeenCalled()
+		expect(visibleTask.cancelAutoApprovalTimeout).not.toHaveBeenCalled()
+		expect(visibleTask.supersedePendingAsk).not.toHaveBeenCalled()
+		expect(visibleTask.abortTask).not.toHaveBeenCalled()
+		expect(createTaskWithHistoryItemSpy).toHaveBeenCalledWith(expect.objectContaining({ id: "task-1" }), {
+			replaceExistingTask: true,
+			focus: false,
+		})
+	})
 })

src/core/webview/webviewMessageHandler.ts

@@ -1388,7 +1388,7 @@ export const webviewMessageHandler = async (
 			break
 		}
 		case "cancelTask":
-			await provider.cancelTask()
+			await provider.cancelTask(message.taskId)
 			break
 		case "cancelAutoApproval":
 			// Cancel any pending auto-approval timeout for the target task

src/package.json

@@ -3,7 +3,7 @@
 	"displayName": "%extension.displayName%",
 	"description": "%extension.description%",
 	"publisher": "allquixotic",
-	"version": "3.53.16",
+	"version": "3.53.17",
 	"icon": "assets/icons/icon.png",
 	"galleryBanner": {
 		"color": "#617A91",

webview-ui/src/components/chat/ChatView.tsx

@@ -651,6 +651,23 @@ const ChatViewComponent: React.ForwardRefRenderFunction<ChatViewRef, ChatViewPro
 		return false
 	}, [modifiedMessages, clineAsk, enableButtons, primaryButtonText])
 
+	useEffect(() => {
+		// Button/ask state is local React state, while messages are task-scoped.
+		// When switching from a paused task to a running task whose last message is
+		// not an ask, clear the previous task's Continue/approval buttons instead
+		// of carrying them onto the newly selected task.
+		if (lastMessage?.type === "ask") {
+			return
+		}
+
+		setClineAsk(undefined)
+		setEnableButtons(false)
+		setPrimaryButtonText(undefined)
+		setSecondaryButtonText(undefined)
+		setSendingDisabled(isStreaming)
+		setDidClickCancel(false)
+	}, [currentTaskId, isStreaming, lastMessage?.type, taskTs])
+
 	const markFollowUpAsAnswered = useCallback(() => {
 		const lastFollowUpMessage = messagesRef.current.findLast((msg: ClineMessage) => msg.ask === "followup")
 		if (lastFollowUpMessage) {
@@ -915,9 +932,9 @@ const ChatViewComponent: React.ForwardRefRenderFunction<ChatViewRef, ChatViewPro
 
 	// Handle stop button click from textarea
 	const handleStopTask = useCallback(() => {
-		vscode.postMessage({ type: "cancelTask" })
+		vscode.postMessage({ type: "cancelTask", taskId: currentTaskId })
 		setDidClickCancel(true)
-	}, [setDidClickCancel])
+	}, [currentTaskId, setDidClickCancel])
 
 	// This logic depends on the useEffect[messages] above to set clineAsk,
 	// after which buttons are shown and we then send an askResponse to the
@@ -1019,7 +1036,7 @@ const ChatViewComponent: React.ForwardRefRenderFunction<ChatViewRef, ChatViewPro
 			const trimmedInput = text?.trim()
 
 			if (isStreaming) {
-				vscode.postMessage({ type: "cancelTask" })
+				vscode.postMessage({ type: "cancelTask", taskId: currentTaskId })
 				setDidClickCancel(true)
 				return
 			}

webview-ui/src/components/chat/__tests__/ChatView.spec.tsx

@@ -14,6 +14,7 @@ interface ClineMessage {
 	type: "say" | "ask"
 	say?: string
 	ask?: string
+	task?: string
 	ts: number
 	text?: string
 	partial?: boolean
@@ -153,6 +154,8 @@ interface ChatTextAreaProps {
 	placeholderText?: string
 	selectedImages?: string[]
 	shouldDisableImages?: boolean
+	isStreaming?: boolean
+	onStop?: () => void
 }
 
 const mockInputRef = React.createRef<HTMLInputElement>()
@@ -195,6 +198,11 @@ vi.mock("../ChatTextArea", () => {
 					}}
 					data-sending-disabled={props.sendingDisabled}
 				/>
+				{props.isStreaming && props.onStop && (
+					<button type="button" onClick={props.onStop}>
+						Stop
+					</button>
+				)}
 			</div>
 		)
 	})
@@ -1017,6 +1025,123 @@ describe("ChatView - Message Queueing Tests", () => {
 	})
 })
 
+describe("ChatView - Task-local Stop and Continue state", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+		vi.mocked(vscode.postMessage).mockClear()
+	})
+
+	it("clears a paused task's Continue button when switching to a running task", async () => {
+		const { getByText, queryByText, getByTestId } = renderChatView()
+
+		const activeConversations = [
+			{
+				rootTaskId: "task-a",
+				activeTaskId: "task-a",
+				rootTask: "Paused task",
+				activeTask: "Paused task",
+				ts: 1000,
+				status: "resumable",
+				queuedMessageCount: 0,
+				steerMessageCount: 0,
+			},
+			{
+				rootTaskId: "task-b",
+				activeTaskId: "task-b",
+				rootTask: "Running task",
+				activeTask: "Running task",
+				ts: 2000,
+				status: "running",
+				queuedMessageCount: 0,
+				steerMessageCount: 0,
+			},
+		]
+
+		mockPostMessage({
+			currentTaskId: "task-a",
+			currentTaskItem: { id: "task-a" },
+			activeConversations,
+			clineMessages: [
+				{
+					type: "say",
+					say: "task",
+					ts: 100,
+					text: "Paused task",
+				},
+				{
+					type: "ask",
+					ask: "resume_task",
+					ts: 101,
+					text: "",
+					partial: false,
+				},
+			],
+		})
+
+		await waitFor(() => {
+			expect(getByText("chat:resumeTask.title")).toBeInTheDocument()
+		})
+
+		mockPostMessage({
+			currentTaskId: "task-b",
+			currentTaskItem: { id: "task-b" },
+			activeConversations,
+			clineMessages: [
+				{
+					type: "say",
+					say: "task",
+					ts: 200,
+					text: "Running task",
+				},
+				{
+					type: "say",
+					say: "text",
+					ts: 201,
+					text: "Still running",
+				},
+			],
+		})
+
+		await waitFor(() => {
+			expect(getByTestId("chat-textarea")).toBeInTheDocument()
+			expect(queryByText("chat:resumeTask.title")).not.toBeInTheDocument()
+			expect(queryByText("chat:terminate.title")).not.toBeInTheDocument()
+		})
+	})
+
+	it("includes the current task id when stopping a streaming task", async () => {
+		const { getByText } = renderChatView()
+
+		mockPostMessage({
+			currentTaskId: "task-1",
+			currentTaskItem: { id: "task-1" },
+			clineMessages: [
+				{
+					type: "say",
+					say: "task",
+					ts: 100,
+					text: "Streaming task",
+				},
+				{
+					type: "say",
+					say: "api_req_started",
+					ts: 101,
+					text: JSON.stringify({ apiProtocol: "anthropic" }),
+				},
+			],
+		})
+
+		await waitFor(() => {
+			expect(getByText("Stop")).toBeInTheDocument()
+		})
+
+		vi.mocked(vscode.postMessage).mockClear()
+		fireEvent.click(getByText("Stop"))
+
+		expect(vscode.postMessage).toHaveBeenCalledWith({ type: "cancelTask", taskId: "task-1" })
+	})
+})
+
 describe("ChatView - Context Condensing Indicator Tests", () => {
 	beforeEach(() => {
 		vi.clearAllMocks()