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<typeof LLMock>) {
 		},
 	})
 
+	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<string, ClineMessage[]> = {}
+
+		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/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: [
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 () => {
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
similarity index 93%
rename from src/core/tools/__tests__/readFileTool.spec.ts
rename to src/core/tools/__tests__/ReadFileTool.spec.ts
index 6c9e177d38..3e665e18e1 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,89 @@ 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<string, Record<string, unknown>>()
+			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()
+		})
+
+		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: "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 } },
+			]
+
+			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 () => {
+			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<string, Record<string, unknown>>()
+
+			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..02e0bfdc46 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": {
@@ -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 73%
rename from src/extension/__tests__/api-send-message.spec.ts
rename to src/extension/__tests__/api.spec.ts
index 23677b1218..7d31a5a5aa 100644
--- a/src/extension/__tests__/api-send-message.spec.ts
+++ b/src/extension/__tests__/api.spec.ts
@@ -56,6 +56,56 @@ 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 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"
+		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<RooCodeEvents> 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.