From 7d63bba67cd792d9ad013410a889c1fd454159ed Mon Sep 17 00:00:00 2001 From: Roomote Date: Fri, 21 Aug 2026 03:12:45 +0000 Subject: [PATCH 01/12] 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 e3080270dfb3adab6bd3d21a99211efcceb77cbd Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Wed, 26 Aug 2026 02:43:57 +0000 Subject: [PATCH 02/12] 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 543084571d..9306843d6c 100644 --- a/src/core/task/Task.ts +++ b/src/core/task/Task.ts @@ -1284,6 +1284,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 60644797e7d02721085b399147242fcaa02c96e0 Mon Sep 17 00:00:00 2001 From: Elliott de Launay Date: Thu, 27 Aug 2026 01:44:13 +0000 Subject: [PATCH 03/12] 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 9306843d6c..bf465d8908 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, @@ -1284,10 +1285,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 } @@ -1471,6 +1472,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 94f53c34c45157ff42536397edf9d2a0b66e8400 Mon Sep 17 00:00:00 2001 From: Roomote Date: Sat, 5 Sep 2026 00:41:26 +0000 Subject: [PATCH 04/12] 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 bf465d8908..543084571d 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, @@ -1285,19 +1284,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). @@ -1472,14 +1458,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 381cf0c1e0..8d1273b499 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 b9fb2b1398e6e1574bf6a80045712e0d11091dd8 Mon Sep 17 00:00:00 2001 From: Roomote Date: Sat, 5 Sep 2026 01:02:40 +0000 Subject: [PATCH 05/12] 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 d511718e169939e2586b255ee7c8075e0284c781 Mon Sep 17 00:00:00 2001 From: Roomote Date: Sat, 5 Sep 2026 01:10:14 +0000 Subject: [PATCH 06/12] 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 053399d30798a017f73e9e290687bd1f793a7055 Mon Sep 17 00:00:00 2001 From: Roomote Date: Sat, 5 Sep 2026 01:29:24 +0000 Subject: [PATCH 07/12] 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 49ff145e7e4883bdb97ac65917db9cde92f2b1f2 Mon Sep 17 00:00:00 2001 From: Roomote Date: Sat, 5 Sep 2026 01:57:05 +0000 Subject: [PATCH 08/12] 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 8d1273b499..36e4437849 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 From 21b79dbaad64cedddc93ed1f605e025855e01a6c Mon Sep 17 00:00:00 2001 From: Roomote Date: Mon, 7 Sep 2026 18:47:16 +0000 Subject: [PATCH 09/12] fix: preserve image-only read feedback --- apps/vscode-e2e/src/fixtures/subtasks.ts | 2 +- apps/vscode-e2e/src/suite/subtasks.test.ts | 2 +- src/core/tools/ReadFileTool.ts | 30 ++++++++++++------- src/core/tools/__tests__/ReadFileTool.spec.ts | 30 ++++++++++++++++++- 4 files changed, 51 insertions(+), 13 deletions(-) diff --git a/apps/vscode-e2e/src/fixtures/subtasks.ts b/apps/vscode-e2e/src/fixtures/subtasks.ts index 7ce8122185..34eeff2a70 100644 --- a/apps/vscode-e2e/src/fixtures/subtasks.ts +++ b/apps/vscode-e2e/src/fixtures/subtasks.ts @@ -191,7 +191,7 @@ export function addSubtaskFixtures(mock: InstanceType) { mock.addFixture({ match: { - userMessage: new RegExp(SUBTASK_QUEUED_INPUT_PARENT_MARKER), + userMessage: SUBTASK_QUEUED_INPUT_PARENT_MARKER, sequenceIndex: 0, }, response: { diff --git a/apps/vscode-e2e/src/suite/subtasks.test.ts b/apps/vscode-e2e/src/suite/subtasks.test.ts index 1116ebf89c..f4350b90dc 100644 --- a/apps/vscode-e2e/src/suite/subtasks.test.ts +++ b/apps/vscode-e2e/src/suite/subtasks.test.ts @@ -270,7 +270,7 @@ suite("Roo Code Subtasks", function () { const says: Record = {} const messageHandler = ({ taskId, message }: { taskId: string; message: ClineMessage }) => { - if (message.type === "say" && message.partial === false) { + if (message.type === "say" && message.partial !== true) { says[taskId] = says[taskId] || [] says[taskId].push(message) } diff --git a/src/core/tools/ReadFileTool.ts b/src/core/tools/ReadFileTool.ts index fa26e32630..ecf1e08fc5 100644 --- a/src/core/tools/ReadFileTool.ts +++ b/src/core/tools/ReadFileTool.ts @@ -447,16 +447,17 @@ export class ReadFileTool extends BaseTool<"read_file"> { const completeMessage = JSON.stringify({ tool: "readFile", batchFiles } satisfies ClineSayTool) const { response, text, images } = await task.ask("tool", completeMessage, false) + const hasFeedback = Boolean(text || images?.length) if (response === "yesButtonClicked") { - if (text) await task.say("user_feedback", text, images) + if (hasFeedback) await task.say("user_feedback", text, images) filesToApprove.forEach((fr) => { updateFileResult(fr.path, { status: "approved", feedbackText: text, feedbackImages: images }) }) } 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) + if (hasFeedback) await task.say("user_feedback", text, images) task.didRejectTool = true filesToApprove.forEach((fr) => { updateFileResult(fr.path, { @@ -518,9 +519,10 @@ export class ReadFileTool extends BaseTool<"read_file"> { } satisfies ClineSayTool) const { response, text, images } = await task.ask("tool", completeMessage, false) + const hasFeedback = Boolean(text || images?.length) if (response !== "yesButtonClicked") { - if (text) await task.say("user_feedback", text, images) + if (hasFeedback) await task.say("user_feedback", text, images) task.didRejectTool = true updateFileResult(relPath, { status: "denied", @@ -529,7 +531,7 @@ export class ReadFileTool extends BaseTool<"read_file"> { feedbackImages: images, }) } else { - if (text) await task.say("user_feedback", text, images) + if (hasFeedback) await task.say("user_feedback", text, images) updateFileResult(relPath, { status: "approved", feedbackText: text, feedbackImages: images }) } } @@ -582,17 +584,25 @@ export class ReadFileTool extends BaseTool<"read_file"> { let statusMessage = "" let feedbackImages: string[] = [] - const deniedWithFeedback = fileResults.find((r) => r.status === "denied" && r.feedbackText) + const deniedWithFeedback = fileResults.find( + (r) => r.status === "denied" && (r.feedbackText || r.feedbackImages?.length), + ) - if (deniedWithFeedback?.feedbackText) { - statusMessage = formatResponse.toolDeniedWithFeedback(deniedWithFeedback.feedbackText) + if (deniedWithFeedback) { + statusMessage = deniedWithFeedback.feedbackText + ? formatResponse.toolDeniedWithFeedback(deniedWithFeedback.feedbackText) + : formatResponse.toolDenied() feedbackImages = deniedWithFeedback.feedbackImages || [] } else if (task.didRejectTool) { statusMessage = formatResponse.toolDenied() } else { - const approvedWithFeedback = fileResults.find((r) => r.status === "approved" && r.feedbackText) - if (approvedWithFeedback?.feedbackText) { - statusMessage = formatResponse.toolApprovedWithFeedback(approvedWithFeedback.feedbackText) + const approvedWithFeedback = fileResults.find( + (r) => r.status === "approved" && (r.feedbackText || r.feedbackImages?.length), + ) + if (approvedWithFeedback) { + statusMessage = approvedWithFeedback.feedbackText + ? formatResponse.toolApprovedWithFeedback(approvedWithFeedback.feedbackText) + : "" feedbackImages = approvedWithFeedback.feedbackImages || [] } } diff --git a/src/core/tools/__tests__/ReadFileTool.spec.ts b/src/core/tools/__tests__/ReadFileTool.spec.ts index 3e665e18e1..efddf1ca46 100644 --- a/src/core/tools/__tests__/ReadFileTool.spec.ts +++ b/src/core/tools/__tests__/ReadFileTool.spec.ts @@ -698,15 +698,43 @@ describe("ReadFileTool", () => { { 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, () => {}) + await readFileTool["requestApproval"](task, fileResults, (filePath, update) => { + updates.set(filePath, update) + }) expect(parseSpy).not.toHaveBeenCalled() expect(task.say).not.toHaveBeenCalledWith("user_feedback", expect.anything(), expect.anything()) expect(task.didRejectTool).toBe(true) + expect(updates.get("one.ts")).toMatchObject({ status: "denied" }) + expect(updates.get("two.ts")).toMatchObject({ status: "denied" }) parseSpy.mockRestore() }) + it("preserves image-only feedback when denying batch reads", async () => { + const task = Object.create(Task.prototype) as Task + Object.defineProperty(task, "cwd", { value: "/test/workspace", writable: true }) + Object.assign(task, createMockTask({ supportsImages: true })) + const queuedImages = ["data:image/png;base64,queued"] + task.ask = vi.fn().mockResolvedValue({ response: "messageResponse", text: undefined, images: queuedImages }) + const callbacks = createMockCallbacks() + 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, (filePath, update) => { + Object.assign(fileResults.find(({ path }) => path === filePath)!, update) + }) + readFileTool["buildAndPushResult"](task, fileResults, callbacks.pushToolResult) + + expect(task.say).toHaveBeenCalledWith("user_feedback", undefined, queuedImages) + expect(callbacks.pushToolResult).toHaveBeenCalledWith( + expect.arrayContaining([expect.objectContaining({ type: "image" })]), + ) + }) + 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 }) From 5d6a4f42d435f46cf2856629fd61704945ef77db Mon Sep 17 00:00:00 2001 From: Roomote Date: Mon, 7 Sep 2026 18:51:30 +0000 Subject: [PATCH 10/12] refactor: narrow image feedback handling --- src/core/tools/ReadFileTool.ts | 20 +++++++------------- 1 file changed, 7 insertions(+), 13 deletions(-) diff --git a/src/core/tools/ReadFileTool.ts b/src/core/tools/ReadFileTool.ts index ecf1e08fc5..d033acd499 100644 --- a/src/core/tools/ReadFileTool.ts +++ b/src/core/tools/ReadFileTool.ts @@ -447,17 +447,16 @@ export class ReadFileTool extends BaseTool<"read_file"> { const completeMessage = JSON.stringify({ tool: "readFile", batchFiles } satisfies ClineSayTool) const { response, text, images } = await task.ask("tool", completeMessage, false) - const hasFeedback = Boolean(text || images?.length) if (response === "yesButtonClicked") { - if (hasFeedback) await task.say("user_feedback", text, images) + if (text) await task.say("user_feedback", text, images) filesToApprove.forEach((fr) => { updateFileResult(fr.path, { status: "approved", feedbackText: text, feedbackImages: images }) }) } 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 (hasFeedback) await task.say("user_feedback", text, images) + if (text || images?.length) await task.say("user_feedback", text, images) task.didRejectTool = true filesToApprove.forEach((fr) => { updateFileResult(fr.path, { @@ -519,10 +518,9 @@ export class ReadFileTool extends BaseTool<"read_file"> { } satisfies ClineSayTool) const { response, text, images } = await task.ask("tool", completeMessage, false) - const hasFeedback = Boolean(text || images?.length) if (response !== "yesButtonClicked") { - if (hasFeedback) await task.say("user_feedback", text, images) + if (text) await task.say("user_feedback", text, images) task.didRejectTool = true updateFileResult(relPath, { status: "denied", @@ -531,7 +529,7 @@ export class ReadFileTool extends BaseTool<"read_file"> { feedbackImages: images, }) } else { - if (hasFeedback) await task.say("user_feedback", text, images) + if (text) await task.say("user_feedback", text, images) updateFileResult(relPath, { status: "approved", feedbackText: text, feedbackImages: images }) } } @@ -596,13 +594,9 @@ export class ReadFileTool extends BaseTool<"read_file"> { } else if (task.didRejectTool) { statusMessage = formatResponse.toolDenied() } else { - const approvedWithFeedback = fileResults.find( - (r) => r.status === "approved" && (r.feedbackText || r.feedbackImages?.length), - ) - if (approvedWithFeedback) { - statusMessage = approvedWithFeedback.feedbackText - ? formatResponse.toolApprovedWithFeedback(approvedWithFeedback.feedbackText) - : "" + const approvedWithFeedback = fileResults.find((r) => r.status === "approved" && r.feedbackText) + if (approvedWithFeedback?.feedbackText) { + statusMessage = formatResponse.toolApprovedWithFeedback(approvedWithFeedback.feedbackText) feedbackImages = approvedWithFeedback.feedbackImages || [] } } From a194497e03758f40e5a0af1063bdb6e66eff8557 Mon Sep 17 00:00:00 2001 From: Roomote Date: Mon, 7 Sep 2026 18:54:44 +0000 Subject: [PATCH 11/12] test: strengthen batch feedback mutation coverage --- src/core/tools/__tests__/ReadFileTool.spec.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/core/tools/__tests__/ReadFileTool.spec.ts b/src/core/tools/__tests__/ReadFileTool.spec.ts index efddf1ca46..cde9227f42 100644 --- a/src/core/tools/__tests__/ReadFileTool.spec.ts +++ b/src/core/tools/__tests__/ReadFileTool.spec.ts @@ -705,7 +705,7 @@ describe("ReadFileTool", () => { }) expect(parseSpy).not.toHaveBeenCalled() - expect(task.say).not.toHaveBeenCalledWith("user_feedback", expect.anything(), expect.anything()) + expect(task.say).not.toHaveBeenCalled() expect(task.didRejectTool).toBe(true) expect(updates.get("one.ts")).toMatchObject({ status: "denied" }) expect(updates.get("two.ts")).toMatchObject({ status: "denied" }) @@ -727,6 +727,7 @@ describe("ReadFileTool", () => { await readFileTool["requestApproval"](task, fileResults, (filePath, update) => { Object.assign(fileResults.find(({ path }) => path === filePath)!, update) }) + Object.assign(fileResults[0], { status: "approved", feedbackImages: undefined }) readFileTool["buildAndPushResult"](task, fileResults, callbacks.pushToolResult) expect(task.say).toHaveBeenCalledWith("user_feedback", undefined, queuedImages) From 003f164712b4b1dd0604a6a0892a6506ff937127 Mon Sep 17 00:00:00 2001 From: Roomote Date: Mon, 7 Sep 2026 18:58:11 +0000 Subject: [PATCH 12/12] test: distinguish image feedback results --- src/core/tools/__tests__/ReadFileTool.spec.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/core/tools/__tests__/ReadFileTool.spec.ts b/src/core/tools/__tests__/ReadFileTool.spec.ts index cde9227f42..4c4ef50547 100644 --- a/src/core/tools/__tests__/ReadFileTool.spec.ts +++ b/src/core/tools/__tests__/ReadFileTool.spec.ts @@ -727,7 +727,7 @@ describe("ReadFileTool", () => { await readFileTool["requestApproval"](task, fileResults, (filePath, update) => { Object.assign(fileResults.find(({ path }) => path === filePath)!, update) }) - Object.assign(fileResults[0], { status: "approved", feedbackImages: undefined }) + Object.assign(fileResults[0], { feedbackImages: undefined }) readFileTool["buildAndPushResult"](task, fileResults, callbacks.pushToolResult) expect(task.say).toHaveBeenCalledWith("user_feedback", undefined, queuedImages)