From 928b0207aa2e73f39951fb9587c290d1775c557f Mon Sep 17 00:00:00 2001 From: Roomote Date: Fri, 21 Aug 2026 03:12:45 +0000 Subject: [PATCH 1/8] fix(task): preserve queued input as feedback --- apps/vscode-e2e/src/fixtures/subtasks.ts | 85 +++++++++++++++++++ apps/vscode-e2e/src/suite/subtasks.test.ts | 72 ++++++++++++++++ .../ask-queued-message-drain.spec.ts | 8 +- 3 files changed, 161 insertions(+), 4 deletions(-) diff --git a/apps/vscode-e2e/src/fixtures/subtasks.ts b/apps/vscode-e2e/src/fixtures/subtasks.ts index ebfd94324e..7ce8122185 100644 --- a/apps/vscode-e2e/src/fixtures/subtasks.ts +++ b/apps/vscode-e2e/src/fixtures/subtasks.ts @@ -16,6 +16,8 @@ const SUBTASK_APPROVAL_RESTORE_CHILD_MARKER = "SUBTASK_CHILD_APPROVAL_RESTORE" const SUBTASK_XPROFILE_PARENT_MARKER = "SUBTASK_PARENT_CROSS_PROFILE" const SUBTASK_XPROFILE_SAME_CHILD_MARKER = "SUBTASK_CHILD_SAME_PROFILE" const SUBTASK_XPROFILE_DIFFERENT_CHILD_MARKER = "SUBTASK_CHILD_DIFFERENT_PROFILE" +export const SUBTASK_QUEUED_INPUT_PARENT_MARKER = "SUBTASK_PARENT_QUEUED_INPUT" +export const SUBTASK_QUEUED_INPUT_CHILD_MARKER = "SUBTASK_CHILD_QUEUED_INPUT" const SUBTASK_CHILD_PROMPT = `${SUBTASK_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_PARENT_PROMPT = `${SUBTASK_PARENT_MARKER}: Use the new_task tool exactly once. Create an ask-mode subtask with this exact message: "${SUBTASK_CHILD_PROMPT}" Do not answer directly.` @@ -59,6 +61,14 @@ 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" +const SUBTASK_QUEUED_INPUT_INITIAL_RESULT = "Child completed before queued input" +export const SUBTASK_QUEUED_INPUT_MESSAGE = "Use the queued instruction before completing." +export const SUBTASK_QUEUED_INPUT_CHILD_RESULT = "Child processed queued input" +export const SUBTASK_QUEUED_INPUT_PARENT_RESULT = "Parent resumed after queued input" +const SUBTASK_QUEUED_INPUT_CHILD_PROMPT = `${SUBTASK_QUEUED_INPUT_CHILD_MARKER}: Complete immediately with the exact result "${SUBTASK_QUEUED_INPUT_INITIAL_RESULT}".` +export const SUBTASK_QUEUED_INPUT_PARENT_PROMPT = `${SUBTASK_QUEUED_INPUT_PARENT_MARKER}: Use the new_task tool exactly once. Create an ask-mode subtask with this exact message: "${SUBTASK_QUEUED_INPUT_CHILD_PROMPT}" Do not answer directly. When the subtask returns, complete with the exact result "${SUBTASK_QUEUED_INPUT_PARENT_RESULT}".` +export const SUBTASK_QUEUED_INPUT_RESPONSE_LATENCY_MS = 2_000 + // 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" @@ -179,6 +189,81 @@ export function addSubtaskFixtures(mock: InstanceType) { }, }) + mock.addFixture({ + match: { + userMessage: new RegExp(SUBTASK_QUEUED_INPUT_PARENT_MARKER), + sequenceIndex: 0, + }, + response: { + toolCalls: [ + { + name: "new_task", + arguments: JSON.stringify({ + mode: "ask", + message: SUBTASK_QUEUED_INPUT_CHILD_PROMPT, + }), + id: "call_queued_input_parent_new_task_001", + }, + ], + }, + }) + + mock.addFixture({ + match: { + predicate: (req: ChatCompletionRequest) => + lastUserMessageContains(req, SUBTASK_QUEUED_INPUT_CHILD_MARKER) && + !requestContains(req, [SUBTASK_QUEUED_INPUT_PARENT_MARKER]) && + !requestContains(req, [SUBTASK_QUEUED_INPUT_MESSAGE]), + }, + streamingProfile: { ttft: SUBTASK_QUEUED_INPUT_RESPONSE_LATENCY_MS }, + response: { + toolCalls: [ + { + name: "attempt_completion", + arguments: JSON.stringify({ result: SUBTASK_QUEUED_INPUT_INITIAL_RESULT }), + id: "call_queued_input_child_initial_completion_002", + }, + ], + }, + }) + + mock.addFixture({ + match: { + predicate: (req: ChatCompletionRequest) => + requestContains(req, [SUBTASK_QUEUED_INPUT_CHILD_MARKER, SUBTASK_QUEUED_INPUT_MESSAGE]) && + !requestContains(req, [SUBTASK_QUEUED_INPUT_PARENT_MARKER]), + }, + response: { + toolCalls: [ + { + name: "attempt_completion", + arguments: JSON.stringify({ result: SUBTASK_QUEUED_INPUT_CHILD_RESULT }), + id: "call_queued_input_child_revised_completion_003", + }, + ], + }, + }) + + mock.addFixture({ + match: { + predicate: (req: ChatCompletionRequest) => + requestContains(req, [ + SUBTASK_QUEUED_INPUT_PARENT_MARKER, + SUBTASK_RESULT_INJECTION, + SUBTASK_QUEUED_INPUT_CHILD_RESULT, + ]), + }, + response: { + toolCalls: [ + { + name: "attempt_completion", + arguments: JSON.stringify({ result: SUBTASK_QUEUED_INPUT_PARENT_RESULT }), + id: "call_queued_input_parent_completion_004", + }, + ], + }, + }) + mock.addFixture({ match: { userMessage: new RegExp(SUBTASK_FAST_PARENT_MARKER), diff --git a/apps/vscode-e2e/src/suite/subtasks.test.ts b/apps/vscode-e2e/src/suite/subtasks.test.ts index 857c8accc5..1116ebf89c 100644 --- a/apps/vscode-e2e/src/suite/subtasks.test.ts +++ b/apps/vscode-e2e/src/suite/subtasks.test.ts @@ -27,6 +27,11 @@ import { SUBTASK_INTERRUPT_PARENT_PROMPT, SUBTASK_INTERRUPT_PARENT_RESULT, SUBTASK_PARENT_PROMPT, + SUBTASK_QUEUED_INPUT_CHILD_MARKER, + SUBTASK_QUEUED_INPUT_CHILD_RESULT, + SUBTASK_QUEUED_INPUT_MESSAGE, + SUBTASK_QUEUED_INPUT_PARENT_PROMPT, + SUBTASK_QUEUED_INPUT_PARENT_RESULT, SUBTASK_XPROFILE_DIFFERENT_CHILD_RESULT, SUBTASK_XPROFILE_PARENT_PROMPT, SUBTASK_XPROFILE_PARENT_RESULT, @@ -260,6 +265,73 @@ suite("Roo Code Subtasks", function () { } }) + test("queued input interrupts child completion before the parent resumes", async () => { + const api = globalThis.api + const says: Record = {} + + const messageHandler = ({ taskId, message }: { taskId: string; message: ClineMessage }) => { + 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_QUEUED_INPUT_PARENT_PROMPT, + }) + + let childTaskId: string | undefined + await waitFor(() => { + const current = api.getCurrentTaskStack().at(-1) + if (current && current !== parentTaskId) { + childTaskId = current + return true + } + return false + }) + + await waitForAimockRequestContaining(SUBTASK_QUEUED_INPUT_CHILD_MARKER) + + const completedParentTaskId = await waitUntilCompleted({ + api, + start: async () => { + await api.sendMessage(SUBTASK_QUEUED_INPUT_MESSAGE) + return parentTaskId + }, + }) + + assert.strictEqual(completedParentTaskId, parentTaskId) + assert.ok( + says[childTaskId!]?.some( + ({ say, text }) => + say === "completion_result" && text?.trim() === SUBTASK_QUEUED_INPUT_CHILD_RESULT, + ), + "Child should process the queued instruction before returning to its parent", + ) + assert.strictEqual( + says[parentTaskId]?.find(({ say }) => say === "completion_result")?.text?.trim(), + SUBTASK_QUEUED_INPUT_PARENT_RESULT, + "Parent should resume only after the child processes the queued instruction", + ) + } finally { + api.off(RooCodeEventName.Message, messageHandler) + while (api.getCurrentTaskStack().length > 0) { + await api.clearCurrentTask() + } + await waitFor(() => api.getCurrentTaskStack().length === 0).catch(() => {}) + } + }) + // Smoke: child completing normally must resume the parent task. test("child task returns to parent after normal completion", async () => { const api = globalThis.api diff --git a/src/core/task/__tests__/ask-queued-message-drain.spec.ts b/src/core/task/__tests__/ask-queued-message-drain.spec.ts index b137130174..44cbe6d06e 100644 --- a/src/core/task/__tests__/ask-queued-message-drain.spec.ts +++ b/src/core/task/__tests__/ask-queued-message-drain.spec.ts @@ -41,7 +41,7 @@ describe("Task.ask queued message drain", () => { const askPromise = task.ask("followup", "Q?", false) // Simulate webview queuing the user's selection text while the ask is pending. - ;(task as any).messageQueueService.addMessage("picked answer") + task.messageQueueService.addMessage("picked answer") const result = await askPromise expect(result.response).toBe("messageResponse") @@ -52,7 +52,7 @@ describe("Task.ask queued message drain", () => { const task = await createTask() const askPromise = task.ask("command_output", "command is still running...", false) - ;(task as any).messageQueueService.addMessage("1+1=?") + task.messageQueueService.addMessage("1+1=?") setTimeout(() => { task.approveAsk() @@ -62,8 +62,8 @@ describe("Task.ask queued message drain", () => { expect(result.response).toBe("yesButtonClicked") expect(result.text).toBeUndefined() - expect((task as any).messageQueueService.isEmpty()).toBe(false) - expect((task as any).messageQueueService.messages[0]?.text).toBe("1+1=?") + expect(task.messageQueueService.isEmpty()).toBe(false) + expect(task.messageQueueService.messages[0]?.text).toBe("1+1=?") }) it("does not consume a message already queued before a command_output ask", async () => { From 3772cd3eecfea5c8dd1657b66e4b8de78b13ab54 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 26 Aug 2026 02:43:57 +0000 Subject: [PATCH 2/8] fix(task): safely drain queued messages into pending asks --- src/core/task/Task.ts | 13 +++++++ .../ask-queued-message-drain.spec.ts | 1 - src/core/tools/ReadFileTool.ts | 8 ++-- src/core/tools/__tests__/readFileTool.spec.ts | 38 +++++++++++++++++++ 4 files changed, 56 insertions(+), 4 deletions(-) diff --git a/src/core/task/Task.ts b/src/core/task/Task.ts index 37281a9010..a04b199768 100644 --- a/src/core/task/Task.ts +++ b/src/core/task/Task.ts @@ -1264,6 +1264,19 @@ export class Task extends EventEmitter implements TaskLike { return undefined } + private drainQueuedMessageIntoAskResponse(): void { + // A synchronous auto-approval may already have resolved the ask before the + // entry queue snapshot is acted on. Never replace that resolved response. + if (this.askResponse !== undefined) { + return + } + + const message = this.messageQueueService.dequeueMessage() + if (message) { + this.handleWebviewAskResponse("messageResponse", message.text, message.images) + } + } + // Note that `partial` has three valid states true (partial message), // false (completion of partial message), undefined (individual complete // message). diff --git a/src/core/task/__tests__/ask-queued-message-drain.spec.ts b/src/core/task/__tests__/ask-queued-message-drain.spec.ts index 44cbe6d06e..4a25c790c6 100644 --- a/src/core/task/__tests__/ask-queued-message-drain.spec.ts +++ b/src/core/task/__tests__/ask-queued-message-drain.spec.ts @@ -52,7 +52,6 @@ describe("Task.ask queued message drain", () => { const task = await createTask() const askPromise = task.ask("command_output", "command is still running...", false) - task.messageQueueService.addMessage("1+1=?") setTimeout(() => { task.approveAsk() diff --git a/src/core/tools/ReadFileTool.ts b/src/core/tools/ReadFileTool.ts index 2107cfe21b..fa26e32630 100644 --- a/src/core/tools/ReadFileTool.ts +++ b/src/core/tools/ReadFileTool.ts @@ -292,7 +292,7 @@ export class ReadFileTool extends BaseTool<"read_file"> { output = `IMPORTANT: File content truncated. Status: Showing lines ${start}-${end} of ${result.totalLines} total lines. To read more: Use the read_file tool with offset=${nextOffset} and limit=${effectiveLimit}. - + ${result.content}` } else if (result.includedRanges.length > 0) { const rangeStr = result.includedRanges.map(([s, e]) => `${s}-${e}`).join(", ") @@ -320,7 +320,7 @@ export class ReadFileTool extends BaseTool<"read_file"> { output = `IMPORTANT: File content truncated. Status: Showing lines ${startLine}-${endLine} of ${result.totalLines} total lines. To read more: Use the read_file tool with offset=${nextOffset} and limit=${limit}. - + ${result.content}` } else if (result.returnedLines === 0) { output = "Note: File is empty" @@ -453,7 +453,9 @@ export class ReadFileTool extends BaseTool<"read_file"> { filesToApprove.forEach((fr) => { updateFileResult(fr.path, { status: "approved", feedbackText: text, feedbackImages: images }) }) - } else if (response === "noButtonClicked") { + } else if (response === "noButtonClicked" || response === "messageResponse") { + // A queued conversational message resolves the ask as messageResponse; + // it is feedback, not the JSON payload used by per-file permissions. if (text) await task.say("user_feedback", text, images) task.didRejectTool = true filesToApprove.forEach((fr) => { diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index 6c9e177d38..e71f90b203 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -17,6 +17,7 @@ import path from "path" import { isBinaryFile } from "isbinaryfile" import { readFileTool, ReadFileTool } from "../ReadFileTool" +import { Task } from "../../task/Task" import { formatResponse } from "../../prompts/responses" import { validateImageForProcessing, @@ -649,6 +650,43 @@ describe("ReadFileTool", () => { expect(mockTask.say).toHaveBeenCalledWith("user_feedback", "This file contains secrets", undefined) expect(formatResponse.toolDeniedWithFeedback).toHaveBeenCalledWith("This file contains secrets") }) + + it("denies batch reads and reports queued message feedback without parsing it as permissions", async () => { + const task = Object.create(Task.prototype) as Task + Object.defineProperty(task, "cwd", { value: "/test/workspace", writable: true }) + Object.assign(task, createMockTask()) + const queuedImages = ["data:image/png;base64,queued"] + task.ask = vi.fn().mockResolvedValue({ + response: "messageResponse", + text: "Read a different file instead", + images: queuedImages, + }) + const fileResults = [ + { path: "one.ts", status: "pending" as const, entry: { path: "one.ts", mode: "slice" as const } }, + { path: "two.ts", status: "pending" as const, entry: { path: "two.ts", mode: "slice" as const } }, + ] + const updates = new Map>() + const parseSpy = vi.spyOn(JSON, "parse") + + await readFileTool["requestApproval"](task, fileResults, (filePath, update) => { + updates.set(filePath, update) + }) + + expect(parseSpy).not.toHaveBeenCalled() + expect(task.say).toHaveBeenCalledWith("user_feedback", "Read a different file instead", queuedImages) + expect(task.didRejectTool).toBe(true) + expect(updates.get("one.ts")).toMatchObject({ + status: "denied", + feedbackText: "Read a different file instead", + feedbackImages: queuedImages, + }) + expect(updates.get("two.ts")).toMatchObject({ + status: "denied", + feedbackText: "Read a different file instead", + feedbackImages: queuedImages, + }) + parseSpy.mockRestore() + }) }) describe("output structure", () => { From a2dc754e617cc5d2cdad2e752f1c8e7b97db5881 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Thu, 27 Aug 2026 01:44:13 +0000 Subject: [PATCH 3/8] fix(task): enqueue streaming input before child completion --- src/core/task/Task.ts | 13 +++++-- src/core/tools/__tests__/readFileTool.spec.ts | 16 +++++++++ .../__tests__/api-send-message.spec.ts | 36 +++++++++++++++++++ src/extension/api.ts | 9 +++++ 4 files changed, 72 insertions(+), 2 deletions(-) diff --git a/src/core/task/Task.ts b/src/core/task/Task.ts index a04b199768..b71f4f9425 100644 --- a/src/core/task/Task.ts +++ b/src/core/task/Task.ts @@ -29,6 +29,7 @@ import { type ContextTruncation, type ClineMessage, type ClineSay, + type ClineSayTool, type ClineAsk, type ToolProgressStatus, type HistoryItem, @@ -1264,10 +1265,10 @@ export class Task extends EventEmitter implements TaskLike { return undefined } - private drainQueuedMessageIntoAskResponse(): void { + private drainQueuedMessageIntoAskResponse(allowResolvedAskOverride = false): void { // A synchronous auto-approval may already have resolved the ask before the // entry queue snapshot is acted on. Never replace that resolved response. - if (this.askResponse !== undefined) { + if (this.askResponse !== undefined && !allowResolvedAskOverride) { return } @@ -1451,6 +1452,14 @@ export class Task extends EventEmitter implements TaskLike { // Keep queued user messages intact during command_output asks. Those asks // are terminal flow-control, not conversational turns. const shouldDrainQueuedMessageForAsk = type !== "command_output" + let isFinishTaskAsk = false + if (type === "tool") { + try { + isFinishTaskAsk = (JSON.parse(text || "{}") as ClineSayTool).tool === "finishTask" + } catch { + // Invalid tool payloads are handled by their caller; they are not finishTask asks. + } + } const isStatusMutable = !partial && isBlocking && !isMessageQueued && approval.decision === "ask" let queuedMessageId: string | undefined diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index e71f90b203..862126edad 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -687,6 +687,22 @@ describe("ReadFileTool", () => { }) parseSpy.mockRestore() }) + + it("denies batch reads for a queued message response without text", async () => { + const task = Object.create(Task.prototype) as Task + Object.defineProperty(task, "cwd", { value: "/test/workspace", writable: true }) + Object.assign(task, createMockTask()) + task.ask = vi.fn().mockResolvedValue({ response: "messageResponse", text: undefined, images: undefined }) + const fileResults = [ + { path: "one.ts", status: "pending" as const, entry: { path: "one.ts", mode: "slice" as const } }, + { path: "two.ts", status: "pending" as const, entry: { path: "two.ts", mode: "slice" as const } }, + ] + + await readFileTool["requestApproval"](task, fileResults, () => {}) + + expect(task.say).not.toHaveBeenCalledWith("user_feedback", expect.anything(), expect.anything()) + expect(task.didRejectTool).toBe(true) + }) }) describe("output structure", () => { diff --git a/src/extension/__tests__/api-send-message.spec.ts b/src/extension/__tests__/api-send-message.spec.ts index 23677b1218..d198919b19 100644 --- a/src/extension/__tests__/api-send-message.spec.ts +++ b/src/extension/__tests__/api-send-message.spec.ts @@ -56,6 +56,42 @@ describe("API - SendMessage Command", () => { }) }) + it("should enqueue directly when the current task is streaming", async () => { + const addMessage = vi.fn() + const messageText = "Use this before completing" + const images = ["data:image/png;base64,image1data"] + const currentTask = { + isStreaming: true, + messageQueueService: { addMessage }, + } + mockProvider.getCurrentTask = vi.fn().mockReturnValue(currentTask) + + await api.sendMessage(messageText, images) + + expect(addMessage).toHaveBeenCalledWith(messageText, images) + expect(mockPostMessageToWebview).not.toHaveBeenCalled() + }) + + it("should retain webview routing when the current task is not streaming", async () => { + const addMessage = vi.fn() + const messageText = "Answer the current ask" + const currentTask = { + isStreaming: false, + messageQueueService: { addMessage }, + } + mockProvider.getCurrentTask = vi.fn().mockReturnValue(currentTask) + + await api.sendMessage(messageText) + + expect(addMessage).not.toHaveBeenCalled() + expect(mockPostMessageToWebview).toHaveBeenCalledWith({ + type: "invoke", + invoke: "sendMessage", + text: messageText, + images: undefined, + }) + }) + it("should handle SendMessage command with text and images", async () => { // Arrange const messageText = "Analyze this image" diff --git a/src/extension/api.ts b/src/extension/api.ts index 74ea2e7680..4ba9a6192c 100644 --- a/src/extension/api.ts +++ b/src/extension/api.ts @@ -272,6 +272,15 @@ export class API extends EventEmitter implements RooCodeAPI { public async sendMessage(text?: string, images?: string[]) { const currentTask = this.sidebarProvider.getCurrentTask() + // API callers need the returned promise to mean that sequencing-critical + // input has reached the active task. During a stream, the webview would + // only relay this message back as queueMessage asynchronously, so enqueue + // it in the extension host instead of racing task completion. + if (currentTask?.isStreaming) { + currentTask.messageQueueService.addMessage(text ?? "", images) + return + } + // In headless/sandbox flows the webview may not be launched, so routing // through invoke=sendMessage drops the message. Deliver directly to the // task ask-response channel instead. From a83534e612e1a9eb1f84f3077ffa349c3e37f30e Mon Sep 17 00:00:00 2001 From: Roomote Date: Sat, 5 Sep 2026 00:41:26 +0000 Subject: [PATCH 4/8] test(task): cover rebased queue branches --- src/core/task/Task.ts | 22 ------------- .../ask-queued-message-drain.spec.ts | 1 + src/core/tools/__tests__/readFileTool.spec.ts | 31 +++++++++++++++++-- src/eslint-suppressions.json | 2 +- 4 files changed, 31 insertions(+), 25 deletions(-) diff --git a/src/core/task/Task.ts b/src/core/task/Task.ts index b71f4f9425..37281a9010 100644 --- a/src/core/task/Task.ts +++ b/src/core/task/Task.ts @@ -29,7 +29,6 @@ import { type ContextTruncation, type ClineMessage, type ClineSay, - type ClineSayTool, type ClineAsk, type ToolProgressStatus, type HistoryItem, @@ -1265,19 +1264,6 @@ export class Task extends EventEmitter implements TaskLike { return undefined } - private drainQueuedMessageIntoAskResponse(allowResolvedAskOverride = false): void { - // A synchronous auto-approval may already have resolved the ask before the - // entry queue snapshot is acted on. Never replace that resolved response. - if (this.askResponse !== undefined && !allowResolvedAskOverride) { - return - } - - const message = this.messageQueueService.dequeueMessage() - if (message) { - this.handleWebviewAskResponse("messageResponse", message.text, message.images) - } - } - // Note that `partial` has three valid states true (partial message), // false (completion of partial message), undefined (individual complete // message). @@ -1452,14 +1438,6 @@ export class Task extends EventEmitter implements TaskLike { // Keep queued user messages intact during command_output asks. Those asks // are terminal flow-control, not conversational turns. const shouldDrainQueuedMessageForAsk = type !== "command_output" - let isFinishTaskAsk = false - if (type === "tool") { - try { - isFinishTaskAsk = (JSON.parse(text || "{}") as ClineSayTool).tool === "finishTask" - } catch { - // Invalid tool payloads are handled by their caller; they are not finishTask asks. - } - } const isStatusMutable = !partial && isBlocking && !isMessageQueued && approval.decision === "ask" let queuedMessageId: string | undefined diff --git a/src/core/task/__tests__/ask-queued-message-drain.spec.ts b/src/core/task/__tests__/ask-queued-message-drain.spec.ts index 4a25c790c6..44cbe6d06e 100644 --- a/src/core/task/__tests__/ask-queued-message-drain.spec.ts +++ b/src/core/task/__tests__/ask-queued-message-drain.spec.ts @@ -52,6 +52,7 @@ describe("Task.ask queued message drain", () => { const task = await createTask() const askPromise = task.ask("command_output", "command is still running...", false) + task.messageQueueService.addMessage("1+1=?") setTimeout(() => { task.approveAsk() diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index 862126edad..6adfe6c292 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -688,11 +688,11 @@ describe("ReadFileTool", () => { parseSpy.mockRestore() }) - it("denies batch reads for a queued message response without text", async () => { + it("denies batch reads without feedback text", async () => { const task = Object.create(Task.prototype) as Task Object.defineProperty(task, "cwd", { value: "/test/workspace", writable: true }) Object.assign(task, createMockTask()) - task.ask = vi.fn().mockResolvedValue({ response: "messageResponse", text: undefined, images: undefined }) + task.ask = vi.fn().mockResolvedValue({ response: "noButtonClicked", text: undefined, images: undefined }) const fileResults = [ { path: "one.ts", status: "pending" as const, entry: { path: "one.ts", mode: "slice" as const } }, { path: "two.ts", status: "pending" as const, entry: { path: "two.ts", mode: "slice" as const } }, @@ -703,6 +703,33 @@ describe("ReadFileTool", () => { expect(task.say).not.toHaveBeenCalledWith("user_feedback", expect.anything(), expect.anything()) expect(task.didRejectTool).toBe(true) }) + + it("applies individual decisions for a batch read", async () => { + const task = Object.create(Task.prototype) as Task + Object.defineProperty(task, "cwd", { value: "/test/workspace", writable: true }) + Object.assign(task, createMockTask()) + task.ask = vi.fn().mockImplementation(async (_type, text) => { + const { batchFiles } = JSON.parse(text ?? "{}") as { batchFiles: Array<{ key: string }> } + return { + response: "objectResponse", + text: JSON.stringify({ [batchFiles[0].key]: true, [batchFiles[1].key]: false }), + images: undefined, + } + }) + const fileResults = [ + { path: "one.ts", status: "pending" as const, entry: { path: "one.ts", mode: "slice" as const } }, + { path: "two.ts", status: "pending" as const, entry: { path: "two.ts", mode: "slice" as const } }, + ] + const updates = new Map>() + + await readFileTool["requestApproval"](task, fileResults, (filePath, update) => { + updates.set(filePath, update) + }) + + expect(updates.get("one.ts")).toMatchObject({ status: "approved" }) + expect(updates.get("two.ts")).toMatchObject({ status: "denied" }) + expect(task.didRejectTool).toBe(true) + }) }) describe("output structure", () => { diff --git a/src/eslint-suppressions.json b/src/eslint-suppressions.json index 393e108645..16acfb4469 100644 --- a/src/eslint-suppressions.json +++ b/src/eslint-suppressions.json @@ -831,7 +831,7 @@ }, "core/task/__tests__/ask-queued-message-drain.spec.ts": { "@typescript-eslint/no-explicit-any": { - "count": 18 + "count": 14 } }, "core/task/__tests__/flushPendingToolResultsToHistory.spec.ts": { From 98d3846673f106575f0b7e25f867a31a77542816 Mon Sep 17 00:00:00 2001 From: Roomote Date: Sat, 5 Sep 2026 01:02:40 +0000 Subject: [PATCH 5/8] test(api): cover image-only streaming input --- src/extension/__tests__/api-send-message.spec.ts | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/extension/__tests__/api-send-message.spec.ts b/src/extension/__tests__/api-send-message.spec.ts index d198919b19..7d31a5a5aa 100644 --- a/src/extension/__tests__/api-send-message.spec.ts +++ b/src/extension/__tests__/api-send-message.spec.ts @@ -72,6 +72,20 @@ describe("API - SendMessage Command", () => { expect(mockPostMessageToWebview).not.toHaveBeenCalled() }) + it("should enqueue image-only input when the current task is streaming", async () => { + const addMessage = vi.fn() + const images = ["data:image/png;base64,image1data"] + mockProvider.getCurrentTask = vi.fn().mockReturnValue({ + isStreaming: true, + messageQueueService: { addMessage }, + }) + + await api.sendMessage(undefined, images) + + expect(addMessage).toHaveBeenCalledWith("", images) + expect(mockPostMessageToWebview).not.toHaveBeenCalled() + }) + it("should retain webview routing when the current task is not streaming", async () => { const addMessage = vi.fn() const messageText = "Answer the current ask" From d461e2c2dbe23ceca1b500e9ca2660f349726d34 Mon Sep 17 00:00:00 2001 From: Roomote Date: Sat, 5 Sep 2026 01:10:14 +0000 Subject: [PATCH 6/8] test(read-file): distinguish explicit batch denial --- src/core/tools/__tests__/readFileTool.spec.ts | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index 6adfe6c292..3e665e18e1 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -693,6 +693,7 @@ describe("ReadFileTool", () => { Object.defineProperty(task, "cwd", { value: "/test/workspace", writable: true }) Object.assign(task, createMockTask()) task.ask = vi.fn().mockResolvedValue({ response: "noButtonClicked", text: undefined, images: undefined }) + const parseSpy = vi.spyOn(JSON, "parse") const fileResults = [ { path: "one.ts", status: "pending" as const, entry: { path: "one.ts", mode: "slice" as const } }, { path: "two.ts", status: "pending" as const, entry: { path: "two.ts", mode: "slice" as const } }, @@ -700,8 +701,10 @@ describe("ReadFileTool", () => { await readFileTool["requestApproval"](task, fileResults, () => {}) + expect(parseSpy).not.toHaveBeenCalled() expect(task.say).not.toHaveBeenCalledWith("user_feedback", expect.anything(), expect.anything()) expect(task.didRejectTool).toBe(true) + parseSpy.mockRestore() }) it("applies individual decisions for a batch read", async () => { From e50e99390f2c57acc6887c84dea9564d7d0cdcb0 Mon Sep 17 00:00:00 2001 From: Roomote Date: Sat, 5 Sep 2026 01:29:24 +0000 Subject: [PATCH 7/8] test(e2e): launch MCP fixture with Electron Node mode --- apps/vscode-e2e/src/suite/tools/use-mcp-tool.test.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/apps/vscode-e2e/src/suite/tools/use-mcp-tool.test.ts b/apps/vscode-e2e/src/suite/tools/use-mcp-tool.test.ts index 21e189d7c1..a413e37600 100644 --- a/apps/vscode-e2e/src/suite/tools/use-mcp-tool.test.ts +++ b/apps/vscode-e2e/src/suite/tools/use-mcp-tool.test.ts @@ -64,9 +64,10 @@ suite("Roo Code use_mcp_tool Tool", function () { { mcpServers: { [FILESYSTEM_SERVER_NAME]: { - command: process.env.npm_node_execpath ?? "node", + command: process.execPath, args: [path.join(__dirname, "fixtures", "filesystem-mcp-server.js"), workspaceDir], env: { + ELECTRON_RUN_AS_NODE: "1", MCP_TEST_READY_FILE: mcpServerReadyPath, }, alwaysAllow: [ From da6b088548637e6b6e9c860871b051a99f4fad04 Mon Sep 17 00:00:00 2001 From: Roomote Date: Sat, 5 Sep 2026 01:57:05 +0000 Subject: [PATCH 8/8] test: align focused suites with mutation discovery --- .../__tests__/{readFileTool.spec.ts => ReadFileTool.spec.ts} | 0 src/eslint-suppressions.json | 4 ++-- .../__tests__/{api-send-message.spec.ts => api.spec.ts} | 0 3 files changed, 2 insertions(+), 2 deletions(-) rename src/core/tools/__tests__/{readFileTool.spec.ts => ReadFileTool.spec.ts} (100%) rename src/extension/__tests__/{api-send-message.spec.ts => api.spec.ts} (100%) diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/ReadFileTool.spec.ts similarity index 100% rename from src/core/tools/__tests__/readFileTool.spec.ts rename to src/core/tools/__tests__/ReadFileTool.spec.ts diff --git a/src/eslint-suppressions.json b/src/eslint-suppressions.json index 16acfb4469..02e0bfdc46 100644 --- a/src/eslint-suppressions.json +++ b/src/eslint-suppressions.json @@ -974,7 +974,7 @@ "count": 26 } }, - "core/tools/__tests__/readFileTool.spec.ts": { + "core/tools/__tests__/ReadFileTool.spec.ts": { "@typescript-eslint/no-explicit-any": { "count": 98 } @@ -1139,7 +1139,7 @@ "count": 1 } }, - "extension/__tests__/api-send-message.spec.ts": { + "extension/__tests__/api.spec.ts": { "@typescript-eslint/no-explicit-any": { "count": 7 } diff --git a/src/extension/__tests__/api-send-message.spec.ts b/src/extension/__tests__/api.spec.ts similarity index 100% rename from src/extension/__tests__/api-send-message.spec.ts rename to src/extension/__tests__/api.spec.ts