From 82c2fe771f0febb07f992da3366defdf14f35802 Mon Sep 17 00:00:00 2001
From: Maximilian Scheurer <11406414+maxscheurer@users.noreply.github.com>
Date: Tue, 28 Jul 2026 11:33:35 +0200
Subject: [PATCH 01/15] chore: open PR for issue 396


From 3425a06c5ab6bc6481de1a2718f0fa14b29da499 Mon Sep 17 00:00:00 2001
From: Maximilian Scheurer <11406414+maxscheurer@users.noreply.github.com>
Date: Tue, 28 Jul 2026 15:09:54 +0200
Subject: [PATCH 02/15] Add ask_user cross-surface UX prototype

---
 packages/dashboard/package.json               |   1 +
 .../test/client/ask-user.browser-harness.html |  12 +
 .../test/client/ask-user.browser-harness.tsx  | 352 ++++++++++++++++++
 .../test/client/ask-user.browser.test.ts      | 142 +++++++
 .../test/client/ask-user.vite.config.ts       |  21 ++
 5 files changed, 528 insertions(+)
 create mode 100644 packages/dashboard/test/client/ask-user.browser-harness.html
 create mode 100644 packages/dashboard/test/client/ask-user.browser-harness.tsx
 create mode 100644 packages/dashboard/test/client/ask-user.browser.test.ts
 create mode 100644 packages/dashboard/test/client/ask-user.vite.config.ts
diff --git a/packages/dashboard/package.json b/packages/dashboard/package.json
index 9f807e6d..9d5fe6b7 100644
--- a/packages/dashboard/package.json
+++ b/packages/dashboard/package.json
@@ -28,6 +28,7 @@
 		"clean": "shx rm -rf dist",
 		"build": "tsgo -p tsconfig.build.json && vite build && shx chmod +x dist/index.js",
 		"dev": "tsgo -p tsconfig.build.json --watch --preserveWatchOutput",
+		"prototype:ask-user": "vite --config test/client/ask-user.vite.config.ts",
 		"profile:mobile": "node scripts/profile-mobile.mjs",
 		"test": "vitest --run",
 		"prepublishOnly": "npm run clean && npm run build"
diff --git a/packages/dashboard/test/client/ask-user.browser-harness.html b/packages/dashboard/test/client/ask-user.browser-harness.html
new file mode 100644
index 00000000..7bbfa33c
--- /dev/null
+++ b/packages/dashboard/test/client/ask-user.browser-harness.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="UTF-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+		<title>ask_user UX prototype — dreb</title>
+	</head>
+	<body>
+		<div id="app"></div>
+		<script type="module" src="./ask-user.browser-harness.tsx"></script>
+	</body>
+</html>
diff --git a/packages/dashboard/test/client/ask-user.browser-harness.tsx b/packages/dashboard/test/client/ask-user.browser-harness.tsx
new file mode 100644
index 00000000..94327981
--- /dev/null
+++ b/packages/dashboard/test/client/ask-user.browser-harness.tsx
@@ -0,0 +1,352 @@
+import { createEffect, createSignal, For, onCleanup, onMount, Show } from "solid-js";
+import { render } from "solid-js/web";
+
+type ScenarioId = "single" | "multiple" | "free-text" | "multiline" | "timeout" | "aborted";
+type Surface = "dashboard" | "tui";
+
+interface Scenario {
+	id: ScenarioId;
+	label: string;
+	title: string;
+	question: string;
+	options: string[];
+	multiSelect?: boolean;
+	multiline?: boolean;
+	terminal?: "timed out" | "cancelled";
+}
+
+const scenarios: Scenario[] = [
+	{
+		id: "single",
+		label: "single choice",
+		title: "Choose an implementation",
+		question: "Which persistence strategy should I use?",
+		options: ["SQLite", "PostgreSQL", "Keep the current JSON file"],
+	},
+	{
+		id: "multiple",
+		label: "multiple choice",
+		title: "Select validation targets",
+		question: "Which checks should run before each release?",
+		options: ["Unit tests", "Browser tests", "Type checking", "Workspace link verification"],
+		multiSelect: true,
+	},
+	{
+		id: "free-text",
+		label: "free text",
+		title: "Name the new command",
+		question: "What should the user-facing command be called?",
+		options: [],
+	},
+	{
+		id: "multiline",
+		label: "multiline",
+		title: "Describe the migration constraint",
+		question: "What compatibility requirements must the migration preserve?",
+		options: [],
+		multiline: true,
+	},
+	{
+		id: "timeout",
+		label: "timeout",
+		title: "Choose a deployment window",
+		question: "When may I restart the production service?",
+		options: ["Now", "After 18:00 UTC"],
+		terminal: "timed out",
+	},
+	{
+		id: "aborted",
+		label: "abort",
+		title: "Confirm the target",
+		question: "Which environment should receive this change?",
+		options: ["Staging", "Production"],
+		terminal: "cancelled",
+	},
+];
+
+function answerSummary(selected: string[], custom: string): string {
+	return [...selected, custom.trim()].filter(Boolean).join("; ");
+}
+
+function AskPanel(props: { scenario: Scenario; surface: Surface }): JSX.Element {
+	const [selected, setSelected] = createSignal<string[]>([]);
+	const [custom, setCustom] = createSignal("");
+	const [outcome, setOutcome] = createSignal<"answered" | "skipped" | undefined>();
+	const terminal = () => props.scenario.terminal;
+	const disabled = () => terminal() !== undefined || outcome() !== undefined;
+	const inputId = () => `${props.surface}-${props.scenario.id}-custom`;
+	const groupName = () => `${props.surface}-${props.scenario.id}-options`;
+
+	createEffect(() => {
+		props.scenario.id;
+		setSelected([]);
+		setCustom("");
+		setOutcome(undefined);
+	});
+
+	const toggle = (option: string) => {
+		if (disabled()) return;
+		if (!props.scenario.multiSelect) {
+			setSelected([option]);
+			return;
+		}
+		setSelected((current) =>
+			current.includes(option) ? current.filter((value) => value !== option) : [...current, option],
+		);
+	};
+	const submit = () => {
+		if (!disabled() && answerSummary(selected(), custom())) setOutcome("answered");
+	};
+
+	return (
+		<section
+			class={`surface surface-${props.surface}`}
+			data-testid={`${props.surface}-surface`}
+			aria-label={`${props.surface === "dashboard" ? "Dashboard" : "TUI"} ask user prototype`}
+		>
+			<div class="surface-heading">
+				<span>{props.surface === "dashboard" ? "Dashboard" : "TUI"}</span>
+				<span class="attention">◆ needs attention</span>
+			</div>
+			<div class="question-frame">
+				<header>
+					<strong>
+						{props.surface === "tui" ? "? " : ""}
+						{props.scenario.title}
+					</strong>
+					<span class="timer" classList={{ expired: terminal() === "timed out" }}>
+						{terminal() === "timed out"
+							? "timed out"
+							: terminal() === "cancelled"
+								? "cancelled"
+								: "01:42 remaining"}
+					</span>
+				</header>
+				<p class="question">{props.scenario.question}</p>
+
+				<Show when={!terminal()} fallback={<TerminalState kind={terminal()!} />}>
+					<Show when={props.scenario.options.length > 0}>
+						<fieldset disabled={disabled()}>
+							<legend>{props.scenario.multiSelect ? "Choose one or more" : "Choose one"}</legend>
+							<For each={props.scenario.options}>
+								{(option) => (
+									<label class="option" classList={{ selected: selected().includes(option) }}>
+										<input
+											type={props.scenario.multiSelect ? "checkbox" : "radio"}
+											name={groupName()}
+											checked={selected().includes(option)}
+											onChange={() => toggle(option)}
+										/>
+										<Show when={props.surface === "tui"}>
+											<span class="control-glyph" aria-hidden="true">
+												{props.scenario.multiSelect
+													? selected().includes(option)
+														? "[x]"
+														: "[ ]"
+													: selected().includes(option)
+														? "(●)"
+														: "( )"}
+											</span>
+										</Show>
+										<span>{option}</span>
+									</label>
+								)}
+							</For>
+						</fieldset>
+					</Show>
+
+					<div class="custom-answer">
+						<label for={inputId()}>
+							{props.scenario.options.length > 0 ? "Or type your own answer" : "Your answer"}
+						</label>
+						<Show
+							when={props.scenario.multiline}
+							fallback={
+								<input
+									id={inputId()}
+									type="text"
+									value={custom()}
+									disabled={disabled()}
+									placeholder="Type a different answer…"
+									onInput={(event) => setCustom(event.currentTarget.value)}
+								/>
+							}
+						>
+							<textarea
+								id={inputId()}
+								rows="5"
+								value={custom()}
+								disabled={disabled()}
+								placeholder="Add details and constraints…"
+								onInput={(event) => setCustom(event.currentTarget.value)}
+							/>
+						</Show>
+					</div>
+
+					<Show
+						when={!outcome()}
+						fallback={
+							<output class={`result result-${outcome()}`}>
+								{outcome() === "skipped"
+									? "Question skipped — the agent will continue."
+									: `Answer: ${answerSummary(selected(), custom())}`}
+							</output>
+						}
+					>
+						<footer>
+							<span class="hint">Esc skips without answering</span>
+							<div class="actions">
+								<button type="button" class="button secondary" onClick={() => setOutcome("skipped")}>
+									Skip
+								</button>
+								<button
+									type="button"
+									class="button primary"
+									disabled={!answerSummary(selected(), custom())}
+									onClick={submit}
+								>
+									Submit answer
+								</button>
+							</div>
+						</footer>
+					</Show>
+				</Show>
+			</div>
+		</section>
+	);
+}
+
+function TerminalState(props: { kind: "timed out" | "cancelled" }): JSX.Element {
+	return (
+		<output class="terminal-state">
+			<strong>{props.kind === "timed out" ? "No answer received" : "Question cancelled"}</strong>
+			<span>
+				{props.kind === "timed out"
+					? "The time limit elapsed. The agent will continue without an answer."
+					: "The request was aborted. The agent will continue without an answer."}
+			</span>
+		</output>
+	);
+}
+
+export function AskUserPrototype(): JSX.Element {
+	const [scenarioId, setScenarioId] = createSignal<ScenarioId>("single");
+	const scenario = () => scenarios.find((item) => item.id === scenarioId()) ?? scenarios[0];
+
+	onMount(() => {
+		const onKeyDown = (event: KeyboardEvent) => {
+			if (event.key !== "Escape") return;
+			document.querySelectorAll<HTMLButtonElement>("[data-testid$='-surface'] .secondary").forEach((button) => {
+				button.click();
+			});
+		};
+		window.addEventListener("keydown", onKeyDown);
+		onCleanup(() => window.removeEventListener("keydown", onKeyDown));
+	});
+
+	return (
+		<main>
+			<style>{prototypeStyles}</style>
+			<header class="prototype-header">
+				<div>
+					<p class="eyebrow">development-only UX prototype</p>
+					<h1>
+						<code>ask_user</code> cross-surface interaction
+					</h1>
+					<p class="intro">Compare equivalent Dashboard and terminal treatments before runtime wiring begins.</p>
+				</div>
+				<section class="contract" aria-label="Interaction contract">
+					<strong>Shared contract</strong>
+					<span>Options stay visible while typing</span>
+					<span>Free text is available by default</span>
+					<span>Multiple selections combine with custom text</span>
+					<span>Skip, Escape, timeout, and abort always continue safely</span>
+				</section>
+			</header>
+
+			<nav class="scenario-picker" aria-label="Prototype state">
+				<For each={scenarios}>
+					{(item) => (
+						<button
+							type="button"
+							classList={{ active: scenarioId() === item.id }}
+							onClick={() => setScenarioId(item.id)}
+						>
+							{item.label}
+						</button>
+					)}
+				</For>
+			</nav>
+
+			<div class="comparison">
+				<AskPanel scenario={scenario()} surface="dashboard" />
+				<AskPanel scenario={scenario()} surface="tui" />
+			</div>
+		</main>
+	);
+}
+
+const prototypeStyles = `
+:root { color-scheme: dark; font-family: "IBM Plex Mono", "SFMono-Regular", Consolas, monospace; background: #0a0a0a; color: #f2f2f2; }
+* { box-sizing: border-box; }
+body { margin: 0; min-width: 320px; background: radial-gradient(circle at 50% -20%, #243226 0, #0a0a0a 38rem); }
+button, input, textarea { font: inherit; }
+button:focus-visible, input:focus-visible, textarea:focus-visible { outline: 2px solid #8bd99b; outline-offset: 2px; }
+main { width: min(1240px, calc(100% - 32px)); margin: 0 auto; padding: 40px 0 64px; }
+.prototype-header { display: grid; grid-template-columns: minmax(0, 1fr) minmax(300px, 440px); gap: 32px; align-items: end; border-bottom: 1px solid #424242; padding-bottom: 26px; }
+.eyebrow { color: #8bd99b; text-transform: uppercase; letter-spacing: .12em; font-size: 12px; margin: 0 0 10px; }
+h1 { font-size: clamp(24px, 4vw, 42px); line-height: 1.08; margin: 0; max-width: 720px; }
+h1 code { color: #8bd99b; }
+.intro { color: #adadad; max-width: 620px; line-height: 1.55; }
+.contract { border: 1px solid #48594c; background: #111a13; padding: 16px; display: grid; gap: 7px; font-size: 12px; color: #c8d6ca; }
+.contract strong { color: #8bd99b; margin-bottom: 4px; }
+.contract span::before { content: "✓ "; color: #8bd99b; }
+.scenario-picker { display: flex; flex-wrap: wrap; gap: 8px; margin: 24px 0; }
+.scenario-picker button { color: #bdbdbd; background: #111; border: 1px solid #444; padding: 8px 12px; cursor: pointer; }
+.scenario-picker button:hover { border-color: #777; color: white; }
+.scenario-picker button.active { background: #d9f7df; border-color: #d9f7df; color: #101510; }
+.comparison { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 24px; align-items: start; }
+.surface { min-width: 0; }
+.surface-heading { display: flex; justify-content: space-between; align-items: center; color: #aaa; font-size: 12px; text-transform: uppercase; letter-spacing: .1em; margin-bottom: 8px; }
+.attention { color: #f0be62; letter-spacing: 0; text-transform: none; }
+.question-frame { min-height: 510px; border: 1px solid #555; background: #151515; box-shadow: 0 20px 50px #0008; padding: 24px; }
+.surface-dashboard .question-frame { border-radius: 8px; background: #171817; }
+.surface-tui .question-frame { border: 1px solid #7b7b7b; box-shadow: inset 0 0 0 1px #202020, 0 20px 50px #0008; }
+.surface-tui .question-frame::before { content: "┌─ dreb question ─────────────────────────────┐"; display: block; color: #777; overflow: hidden; white-space: nowrap; margin: -19px -15px 16px; }
+.question-frame > header { display: flex; align-items: start; justify-content: space-between; gap: 16px; padding-bottom: 14px; border-bottom: 1px solid #414141; }
+.question-frame > header strong { color: #fff; }
+.surface-tui .question-frame > header strong { color: #8bd99b; }
+.timer { color: #91c79b; white-space: nowrap; font-size: 12px; }
+.timer.expired { color: #e69686; }
+.question { color: #ddd; line-height: 1.5; margin: 18px 0; }
+fieldset { border: 0; padding: 0; margin: 0 0 18px; display: grid; gap: 7px; }
+legend { color: #888; font-size: 11px; text-transform: uppercase; letter-spacing: .08em; margin-bottom: 8px; }
+.option { display: flex; gap: 10px; align-items: center; border: 1px solid #3d3d3d; padding: 10px 12px; cursor: pointer; color: #d0d0d0; }
+.surface-dashboard .option { border-radius: 5px; }
+.option:hover { border-color: #777; }
+.option.selected { border-color: #78c989; background: #18251b; color: white; }
+.surface-dashboard .option input { width: 16px; height: 16px; margin: 0 2px 0 0; accent-color: #78c989; flex: 0 0 auto; cursor: pointer; }
+.surface-tui .option input { position: absolute; opacity: 0; pointer-events: none; }
+.control-glyph { color: #777; min-width: 26px; }
+.option.selected .control-glyph { color: #8bd99b; }
+.custom-answer { display: grid; gap: 7px; }
+.custom-answer label { color: #aaa; font-size: 12px; }
+.custom-answer input, .custom-answer textarea { width: 100%; color: #f2f2f2; background: #0b0b0b; border: 1px solid #555; border-radius: 4px; padding: 10px 11px; resize: vertical; }
+.surface-tui .custom-answer input, .surface-tui .custom-answer textarea { border-radius: 0; border-color: #777; }
+footer { border-top: 1px solid #414141; margin-top: 22px; padding-top: 16px; display: flex; gap: 16px; justify-content: space-between; align-items: center; }
+.hint { color: #777; font-size: 11px; }
+.actions { display: flex; gap: 8px; }
+.button { border: 1px solid #666; padding: 8px 12px; cursor: pointer; }
+.button.secondary { color: #ccc; background: transparent; }
+.button.primary { color: #101510; background: #a9e6b5; border-color: #a9e6b5; }
+.button:disabled { opacity: .35; cursor: not-allowed; }
+.result, .terminal-state { display: block; width: 100%; margin-top: 22px; border: 1px solid #4f7657; background: #142019; color: #bce4c4; padding: 14px; line-height: 1.45; }
+.result-skipped, .terminal-state { border-color: #6e624b; background: #211d14; color: #e4d4b5; }
+.terminal-state { min-height: 150px; display: grid; place-content: center; text-align: center; gap: 10px; }
+.terminal-state span { color: #b8ab92; max-width: 400px; }
+@media (max-width: 850px) { .prototype-header, .comparison { grid-template-columns: 1fr; } .question-frame { min-height: 0; } }
+@media (max-width: 500px) { main { width: min(100% - 20px, 1240px); padding-top: 24px; } .question-frame { padding: 17px; } footer { align-items: stretch; flex-direction: column; } .actions { justify-content: flex-end; } }
+`;
+
+const root = document.querySelector("#app");
+if (root) render(() => <AskUserPrototype />, root);
diff --git a/packages/dashboard/test/client/ask-user.browser.test.ts b/packages/dashboard/test/client/ask-user.browser.test.ts
new file mode 100644
index 00000000..171b116c
--- /dev/null
+++ b/packages/dashboard/test/client/ask-user.browser.test.ts
@@ -0,0 +1,142 @@
+import { type AddressInfo, createServer, type Server } from "node:http";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { type Browser, chromium, type Page } from "playwright";
+import { build as viteBuild } from "vite";
+import solid from "vite-plugin-solid";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+let browser: Browser;
+let server: Server;
+let base: string;
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+
+beforeAll(async () => {
+	const bundle = await viteBuild({
+		configFile: false,
+		logLevel: "error",
+		root,
+		plugins: [solid()],
+		build: {
+			minify: false,
+			write: false,
+			rollupOptions: { input: resolve(root, "test/client/ask-user.browser-harness.tsx") },
+		},
+	});
+	const outputs = Array.isArray(bundle) ? bundle.flatMap((item) => item.output) : bundle.output;
+	const entry = outputs.find((item) => item.type === "chunk" && item.isEntry);
+	if (!entry || entry.type !== "chunk") throw new Error("ask_user browser harness bundle has no entry chunk");
+	const script = entry.code.replaceAll("</script", "<\\/script");
+	server = createServer((_req, response) => {
+		response.setHeader("content-type", "text/html; charset=utf-8");
+		response.end(`<!doctype html><html><body><div id="app"></div><script>${script}</script></body></html>`);
+	});
+	await new Promise<void>((resolveStarted) => server.listen(0, "127.0.0.1", resolveStarted));
+	base = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+	browser = await chromium.launch({ headless: true });
+}, 30_000);
+
+afterAll(async () => {
+	await browser?.close();
+	if (server) await new Promise<void>((resolveClosed) => server.close(() => resolveClosed()));
+});
+
+async function openHarness(): Promise<Page> {
+	const page = await browser.newPage({ viewport: { width: 1400, height: 1000 } });
+	page.setDefaultTimeout(2_000);
+	await page.goto(base);
+	await page.getByRole("heading", { name: /ask_user cross-surface interaction/ }).waitFor();
+	return page;
+}
+
+function surface(page: Page, name: "dashboard" | "tui") {
+	return page.getByTestId(`${name}-surface`);
+}
+
+describe("ask_user UX prototype", () => {
+	it("shows equivalent single-choice, free-text, skip, and attention affordances", async () => {
+		const page = await openHarness();
+		for (const name of ["dashboard", "tui"] as const) {
+			const panel = surface(page, name);
+			expect(await panel.getByText("◆ needs attention").textContent()).toContain("needs attention");
+			expect(await panel.getByRole("radio").count()).toBe(3);
+			if (name === "dashboard") {
+				expect(await panel.locator(".control-glyph").count()).toBe(0);
+				expect(
+					await panel
+						.getByRole("radio")
+						.first()
+						.evaluate((input) => getComputedStyle(input).opacity),
+				).toBe("1");
+			} else {
+				expect(await panel.locator(".control-glyph").count()).toBe(3);
+			}
+			await panel.getByText("SQLite", { exact: true }).click();
+			await panel.getByLabel("Or type your own answer").fill("with WAL enabled");
+			await panel.getByRole("button", { name: "Submit answer" }).click();
+			const result = panel.getByRole("status");
+			await result.waitFor();
+			expect(await result.textContent()).toContain("SQLite; with WAL enabled");
+			expect(await result.evaluate((output) => getComputedStyle(output).display)).toBe("block");
+			expect(
+				await result.evaluate((output) => {
+					const input = output.previousElementSibling?.querySelector("input");
+					return input ? output.getBoundingClientRect().top > input.getBoundingClientRect().bottom : false;
+				}),
+			).toBe(true);
+		}
+		await page.close();
+	});
+
+	it("combines multiple selections with custom text on both surfaces", async () => {
+		const page = await openHarness();
+		await page.getByRole("button", { name: "multiple choice" }).click();
+		for (const name of ["dashboard", "tui"] as const) {
+			const panel = surface(page, name);
+			await panel.getByText("Unit tests", { exact: true }).click();
+			await panel.getByText("Type checking", { exact: true }).click();
+			await panel.getByLabel("Or type your own answer").fill("Run smoke tests too");
+			await panel.getByRole("button", { name: "Submit answer" }).click();
+			const result = await panel.getByRole("status").textContent();
+			expect(result).toContain("Unit tests; Type checking; Run smoke tests too");
+		}
+		await page.close();
+	});
+
+	it("covers free-text, multiline, skip, timeout, and abort states", async () => {
+		const page = await openHarness();
+
+		await page.getByRole("button", { name: "free text" }).click();
+		expect(await surface(page, "dashboard").getByLabel("Your answer").getAttribute("type")).toBe("text");
+
+		await page.getByRole("button", { name: "multiline" }).click();
+		expect(
+			await surface(page, "tui")
+				.getByLabel("Your answer")
+				.evaluate((element) => element.tagName),
+		).toBe("TEXTAREA");
+
+		await surface(page, "dashboard").getByRole("button", { name: "Skip" }).click();
+		expect(await surface(page, "dashboard").getByRole("status").textContent()).toContain("Question skipped");
+
+		await page.getByRole("button", { name: "timeout" }).click();
+		for (const name of ["dashboard", "tui"] as const) {
+			expect(await surface(page, name).getByRole("status").textContent()).toContain("No answer received");
+		}
+
+		await page.getByRole("button", { name: "abort" }).click();
+		for (const name of ["dashboard", "tui"] as const) {
+			expect(await surface(page, name).getByRole("status").textContent()).toContain("Question cancelled");
+		}
+		await page.close();
+	});
+
+	it("maps Escape to the explicit safe skip route", async () => {
+		const page = await openHarness();
+		await page.keyboard.press("Escape");
+		for (const name of ["dashboard", "tui"] as const) {
+			expect(await surface(page, name).getByRole("status").textContent()).toContain("Question skipped");
+		}
+		await page.close();
+	});
+});
diff --git a/packages/dashboard/test/client/ask-user.vite.config.ts b/packages/dashboard/test/client/ask-user.vite.config.ts
new file mode 100644
index 00000000..084d8ea0
--- /dev/null
+++ b/packages/dashboard/test/client/ask-user.vite.config.ts
@@ -0,0 +1,21 @@
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+import solid from "vite-plugin-solid";
+
+const root = fileURLToPath(new URL(".", import.meta.url));
+
+export default defineConfig({
+	plugins: [solid()],
+	root,
+	server: {
+		open: "/ask-user.browser-harness.html",
+	},
+	build: {
+		outDir: resolve(root, "../../.ask-user-prototype"),
+		emptyOutDir: true,
+		rollupOptions: {
+			input: resolve(root, "ask-user.browser-harness.html"),
+		},
+	},
+});

From 440ba36f0138c585ab63e5fcc1ff3d123a20da21 Mon Sep 17 00:00:00 2001
From: Maximilian Scheurer <11406414+maxscheurer@users.noreply.github.com>
Date: Wed, 29 Jul 2026 08:10:40 +0200
Subject: [PATCH 03/15] Wire up ask_user tool across TUI, Dashboard, and RPC
 (Stage 2)

---
 README.md                                     |   2 +-
 packages/coding-agent/README.md               |   6 +-
 packages/coding-agent/docs/extensions.md      |  22 +-
 packages/coding-agent/docs/rpc.md             |  27 +-
 .../coding-agent/src/core/agent-session.ts    |   8 +-
 .../coding-agent/src/core/extensions/index.ts |   2 +
 .../src/core/extensions/runner.ts             |   1 +
 .../coding-agent/src/core/extensions/types.ts |  38 +++
 .../coding-agent/src/core/tools/ask-user.ts   | 233 +++++++++++++++
 packages/coding-agent/src/core/tools/index.ts |  12 +
 .../modes/interactive/components/ask-user.ts  | 267 ++++++++++++++++++
 .../src/modes/interactive/interactive-mode.ts |  55 ++++
 .../coding-agent/src/modes/rpc/rpc-mode.ts    |  22 ++
 .../coding-agent/src/modes/rpc/rpc-types.ts   |  13 +
 .../test/ask-user-component.test.ts           | 120 ++++++++
 packages/coding-agent/test/tools.test.ts      |  54 ++++
 .../coding-agent/test/tools/ask-user.test.ts  | 206 ++++++++++++++
 .../dashboard/src/client/screens/session.tsx  | 126 ++++++++-
 .../dashboard/src/client/state/reducer.ts     |  21 +-
 packages/dashboard/src/client/styles/app.css  |  56 ++++
 packages/dashboard/src/server/runtime-pool.ts |   8 +-
 packages/dashboard/test/client/pwa.test.tsx   |  32 +++
 .../dashboard/test/client/screens.test.tsx    |  77 +++++
 packages/dashboard/test/reducer.test.ts       |  30 ++
 24 files changed, 1418 insertions(+), 20 deletions(-)
 create mode 100644 packages/coding-agent/src/core/tools/ask-user.ts
 create mode 100644 packages/coding-agent/src/modes/interactive/components/ask-user.ts
 create mode 100644 packages/coding-agent/test/ask-user-component.test.ts
 create mode 100644 packages/coding-agent/test/tools/ask-user.test.ts

diff --git a/README.md b/README.md
index d3a2f404..32287359 100644
--- a/README.md
+++ b/README.md
@@ -74,7 +74,7 @@ bunx --force dreb
 
 ### Tools and interaction
 
-dreb ships with 12 built-in tools: `read`, `write`, `edit`, `bash`, `grep`, `find`, `ls`, `web_search`, `web_fetch`, `subagent`, `wait`, and `search` (semantic codebase search). Two more tools are always active: `skill` for loading workflows, and `tasks_update` for visible task tracking. `suggest_next` (ghost text command suggestions, Tab to accept) is active by default but excluded when `--tools` is specified.
+dreb ships with 13 built-in tools: `read`, `write`, `edit`, `bash`, `grep`, `find`, `ls`, `web_search`, `web_fetch`, `subagent`, `wait`, `search` (semantic codebase search), and `ask_user` (pause and ask the user a structured multiple-choice or free-text question, rendered natively in the TUI and Dashboard). Two more tools are always active: `skill` for loading workflows, and `tasks_update` for visible task tracking. `suggest_next` (ghost text command suggestions, Tab to accept) is active by default but excluded when `--tools` is specified.
 
 Interactive mode adds slash commands such as `/model`, `/settings`, `/resume`, `/tree`, `/fork`, `/compact`, `/dream`, `/buddy`, `/export`, `/reload`, and `/hotkeys`. The message queue lets you steer a running agent or queue follow-up work without waiting for the current turn to finish.
 
diff --git a/packages/coding-agent/README.md b/packages/coding-agent/README.md
index a5e610e9..3b0961c6 100644
--- a/packages/coding-agent/README.md
+++ b/packages/coding-agent/README.md
@@ -79,7 +79,7 @@ dreb
 
 Or use a custom provider (corporate proxy, Bedrock, etc.) — see [Custom providers & models](#providers--models).
 
-Then just talk to dreb. All 11 built-in tools are enabled by default: `read`, `write`, `edit`, `bash`, `grep`, `find`, `ls`, `web_search`, `web_fetch`, `subagent`, and `wait`. Use `--tools` to restrict to a subset (e.g., `--tools read,grep,find,ls` for read-only). Three additional tools — `search`, `skill`, and `tasks_update` — are always active regardless of `--tools`. `suggest_next` is active by default but excluded when `--tools` is specified. The model uses these to fulfill your requests. Add capabilities via [skills](#skills), [prompt templates](#prompt-templates), [extensions](#extensions), or [packages](#packages).
+Then just talk to dreb. All 12 built-in tools are enabled by default: `read`, `write`, `edit`, `bash`, `grep`, `find`, `ls`, `web_search`, `web_fetch`, `subagent`, `wait`, and `ask_user`. Use `--tools` to restrict to a subset (e.g., `--tools read,grep,find,ls` for read-only). Three additional tools — `search`, `skill`, and `tasks_update` — are always active regardless of `--tools`. `suggest_next` is active by default but excluded when `--tools` is specified. The model uses these to fulfill your requests. Add capabilities via [skills](#skills), [prompt templates](#prompt-templates), [extensions](#extensions), or [packages](#packages).
 
 **Also available:** [`@dreb/telegram`](https://www.npmjs.com/package/@dreb/telegram) — run dreb as a Telegram bot with live tool status and visible results for user-facing tools (`npm install -g @dreb/telegram`). [`@dreb/dashboard`](https://www.npmjs.com/package/@dreb/dashboard) — run `dreb dashboard` for a browser UI with fleet overview, full chat steering, inline provider/API failures with partial output preserved, sanitized raster tool images plus sent user uploads retained as bounded transcript previews by default, subagent observability, host file browser, curated appearance themes (per-browser light/dark), and Tailscale/rotating-code pairing (`npm install -g @dreb/dashboard`; see [docs/dashboard.md](docs/dashboard.md)). Tool images cross browser-facing transport as content-addressed references; browser-local Settings offers placeholders, bounded previews, or informed-opt-in originals, with size disclosure and confirmation above 1 MiB. Full-resolution HTML export remains self-contained. Compact SSE snapshots update live fleet cards without repeatedly fetching the cross-project inventory, and session drill-in hydrates state, messages, and background agents through one ordered snapshot request. Terminal provider failures show their reason on fleet cards, while transient failures clear terminal state when automatic retry begins and remain recorded inline on the failed attempt. Its top bar and persistent session header indicators report connecting, connected, retrying, resyncing, disconnected, or auth failed; bounded SSE replay plus an explicit snapshot barrier restores session state, tasks, and image references after a reload, restart, gap, backpressure disconnect, or stalled stream, while authenticated image routes recover bytes separately from authoritative transcripts.
 
@@ -639,7 +639,9 @@ cat README.md | dreb -p "Summarize this text"
 | `--tools <list>` | Comma-separated list of tools to enable (default: all) |
 | `--no-tools` | Disable all built-in tools (extension tools still work) |
 
-Available built-in tools: `read`, `bash`, `edit`, `write`, `grep`, `find`, `ls`, `web_search`, `web_fetch`, `subagent`, `wait`, `search`
+Available built-in tools: `read`, `bash`, `edit`, `write`, `grep`, `find`, `ls`, `web_search`, `web_fetch`, `subagent`, `wait`, `search`, `ask_user`
+
+`ask_user` pauses the turn and asks you a structured clarifying question — optional 2-4 multiple-choice options (single- or multi-select) plus a "type your own answer" field — rendered natively in the TUI and the Dashboard, and over RPC. Skipping, Escape, tool abort, timeout, and headless/no-UI modes all resolve gracefully, so the agent never deadlocks waiting on an absent user. Concurrent `ask_user` calls are shown strictly one at a time (FIFO). In the TUI: `↑`/`↓` move between options and the free-text field, `Space` toggles a checkbox (multi-select), `Enter` submits, and `Esc` skips.
 
 Three additional tools are always active but don't appear in `--tools`:
 - `skill` — invokes [skills](#skills) programmatically
diff --git a/packages/coding-agent/docs/extensions.md b/packages/coding-agent/docs/extensions.md
index 1d984a02..6520c6c1 100644
--- a/packages/coding-agent/docs/extensions.md
+++ b/packages/coding-agent/docs/extensions.md
@@ -9,7 +9,7 @@ Extensions are TypeScript modules that extend dreb's behavior. They can subscrib
 **Key capabilities:**
 - **Custom tools** - Register tools the LLM can call via `dreb.registerTool()`
 - **Event interception** - Block or modify tool calls, inject context, customize compaction
-- **User interaction** - Prompt users via `ctx.ui` (select, confirm, input, notify)
+- **User interaction** - Prompt users via `ctx.ui` (select, confirm, input, ask, notify)
 - **Custom UI components** - Full TUI components with keyboard input via `ctx.ui.custom()` for complex interactions
 - **Custom commands** - Register commands like `/mycommand` via `dreb.registerCommand()`
 - **Session persistence** - Store state that survives restarts via `dreb.appendEntry()`
@@ -161,6 +161,26 @@ export default function (dreb: ExtensionAPI) {
     ctx.ui.notify("Done!", "success");
     ctx.ui.setStatus("my-ext", "Processing...");  // Footer status
     ctx.ui.setWidget("my-ext", ["Line 1", "Line 2"]);  // Widget above editor (default)
+
+    // ctx.ui.ask — a rich clarifying question with options + free text,
+    // rendered natively in the TUI and Dashboard (and over RPC). Resolves to
+    // { selected: string[], customText?: string }, or undefined when skipped,
+    // cancelled, or timed out. This is the same primitive that powers the
+    // built-in `ask_user` tool.
+    const answer = await ctx.ui.ask(
+      {
+        title: "Choose a database",
+        question: "Which persistence strategy should I use?",
+        options: ["SQLite", "PostgreSQL", "Keep the JSON file"],
+        allowFreeText: true, // default; offers a "type your own answer" field
+        multiSelect: false,  // true → checkboxes, combined with any free text
+        multiline: false,    // true → multi-line free-text area
+      },
+      { signal, timeout: 60000 }, // both optional; absent user never deadlocks
+    );
+    if (!answer) {
+      // user skipped / cancelled / timed out — continue gracefully
+    }
   });
 
   // Register tools, commands, shortcuts, flags
diff --git a/packages/coding-agent/docs/rpc.md b/packages/coding-agent/docs/rpc.md
index fdc24aad..2648fe53 100644
--- a/packages/coding-agent/docs/rpc.md
+++ b/packages/coding-agent/docs/rpc.md
@@ -1874,7 +1874,7 @@ Extensions can request user interaction via `ctx.ui.select()`, `ctx.ui.confirm()
 
 There are two categories of extension UI methods:
 
-- **Dialog methods** (`select`, `confirm`, `input`, `editor`): emit an `extension_ui_request` on stdout and block until the client sends back an `extension_ui_response` on stdin with the matching `id`.
+- **Dialog methods** (`select`, `confirm`, `input`, `editor`, `ask`): emit an `extension_ui_request` on stdout and block until the client sends back an `extension_ui_response` on stdin with the matching `id`.
 - **Fire-and-forget methods** (`notify`, `setStatus`, `setWidget`, `setTitle`, `set_editor_text`): emit an `extension_ui_request` on stdout but do not expect a response. The client can display the information or ignore it.
 
 If a dialog method includes a `timeout` field, the agent-side will auto-resolve with a default value when the timeout expires. The client does not need to track timeouts.
@@ -1961,6 +1961,31 @@ Open a multi-line text editor with optional prefilled content.
 
 Expected response: `extension_ui_response` with `value` (the edited text) or `cancelled: true`.
 
+#### ask
+
+Ask the user a rich clarifying question with optional single- or multi-select options and an optional free-text field. This powers the built-in `ask_user` tool. `options` (2-4) is optional; `allowFreeText` (default `true`), `multiSelect`, and `multiline` are optional booleans.
+
+```json
+{
+  "type": "extension_ui_request",
+  "id": "uuid-5",
+  "method": "ask",
+  "title": "Choose a database",
+  "question": "Which persistence strategy should I use?",
+  "options": ["SQLite", "PostgreSQL", "Keep the JSON file"],
+  "allowFreeText": true,
+  "multiSelect": false,
+  "multiline": false,
+  "timeout": 60000
+}
+```
+
+Expected response: `extension_ui_response` with `selected` (array of chosen option strings, possibly empty) and optional `customText` (the typed answer), or `cancelled: true` to skip. The client should treat an empty `selected` with no `customText` as a skip.
+
+```json
+{ "type": "extension_ui_response", "id": "uuid-5", "selected": ["SQLite"], "customText": "with WAL enabled" }
+```
+
 #### notify
 
 Display a notification. Fire-and-forget, no response expected.
diff --git a/packages/coding-agent/src/core/agent-session.ts b/packages/coding-agent/src/core/agent-session.ts
index ae2d6311..9c69c554 100644
--- a/packages/coding-agent/src/core/agent-session.ts
+++ b/packages/coding-agent/src/core/agent-session.ts
@@ -2901,10 +2901,16 @@ export class AgentSession {
 			? wrapRegisteredTools(allCustomTools, this._extensionRunner)
 			: [];
 
+		// Give base tools a per-execution extension context so built-ins like
+		// ask_user can reach ctx.ui. createContext() snapshots hasUI at call time,
+		// so print/RPC-without-host modes degrade to the no-op UI (hasUI === false).
+		const baseToolCtxFactory = this._extensionRunner
+			? () => (this._extensionRunner as ExtensionRunner).createContext()
+			: undefined;
 		const toolRegistry = new Map(
 			Array.from(this._baseToolDefinitions.values()).map((definition) => [
 				definition.name,
-				wrapToolDefinition(definition),
+				wrapToolDefinition(definition, baseToolCtxFactory),
 			]),
 		);
 		for (const tool of wrappedExtensionTools as AgentTool[]) {
diff --git a/packages/coding-agent/src/core/extensions/index.ts b/packages/coding-agent/src/core/extensions/index.ts
index 793d24ba..3089fa4e 100644
--- a/packages/coding-agent/src/core/extensions/index.ts
+++ b/packages/coding-agent/src/core/extensions/index.ts
@@ -28,6 +28,8 @@ export type {
 	AppendEntryHandler,
 	// App keybindings (for custom editors)
 	AppKeybinding,
+	AskRequest,
+	AskResult,
 	// Events - Tool (ToolCallEvent types)
 	BashToolCallEvent,
 	BashToolResultEvent,
diff --git a/packages/coding-agent/src/core/extensions/runner.ts b/packages/coding-agent/src/core/extensions/runner.ts
index 106f9184..d658bc25 100644
--- a/packages/coding-agent/src/core/extensions/runner.ts
+++ b/packages/coding-agent/src/core/extensions/runner.ts
@@ -174,6 +174,7 @@ const noOpUIContext: ExtensionUIContext = {
 	select: async () => undefined,
 	confirm: async () => false,
 	input: async () => undefined,
+	ask: async () => undefined,
 	notify: () => {},
 	onTerminalInput: () => () => {},
 	setStatus: () => {},
diff --git a/packages/coding-agent/src/core/extensions/types.ts b/packages/coding-agent/src/core/extensions/types.ts
index 8c730bac..1ad6ca8d 100644
--- a/packages/coding-agent/src/core/extensions/types.ts
+++ b/packages/coding-agent/src/core/extensions/types.ts
@@ -84,6 +84,37 @@ export interface ExtensionUIDialogOptions {
 	timeout?: number;
 }
 
+/**
+ * A rich question for {@link ExtensionUIContext.ask}. Presents optional
+ * suggested options (single- or multi-select) alongside an optional free-text
+ * field, rendered natively in every surface (TUI, Dashboard, RPC host).
+ */
+export interface AskRequest {
+	/** The question to ask the user. */
+	question: string;
+	/** Short bold header. Defaults to a generic prompt title when omitted. */
+	title?: string;
+	/** 2-4 suggested options. */
+	options?: string[];
+	/** Offer a "type your own answer" field. Defaults to true. */
+	allowFreeText?: boolean;
+	/** Render options as checkboxes (multiple answers) instead of radios. */
+	multiSelect?: boolean;
+	/** Use a multi-line text area for the free-text field. */
+	multiline?: boolean;
+}
+
+/**
+ * The user's answer to an {@link AskRequest}. A cancelled/skipped/timed-out
+ * question resolves to `undefined` instead of an {@link AskResult}.
+ */
+export interface AskResult {
+	/** Options the user selected (empty when only free text was provided). */
+	selected: string[];
+	/** Free-text answer, when the user typed one. */
+	customText?: string;
+}
+
 /** Placement for extension widgets. */
 export type WidgetPlacement = "aboveEditor" | "belowEditor";
 
@@ -110,6 +141,13 @@ export interface ExtensionUIContext {
 	/** Show a text input dialog. */
 	input(title: string, placeholder?: string, opts?: ExtensionUIDialogOptions): Promise<string | undefined>;
 
+	/**
+	 * Show a rich question with suggested options, optional free text, and
+	 * single- or multi-select. Resolves to the user's answer, or `undefined`
+	 * when the question is skipped, cancelled, or times out.
+	 */
+	ask(request: AskRequest, opts?: ExtensionUIDialogOptions): Promise<AskResult | undefined>;
+
 	/** Show a notification to the user. */
 	notify(message: string, type?: "info" | "warning" | "error"): void;
 
diff --git a/packages/coding-agent/src/core/tools/ask-user.ts b/packages/coding-agent/src/core/tools/ask-user.ts
new file mode 100644
index 00000000..048d2ac6
--- /dev/null
+++ b/packages/coding-agent/src/core/tools/ask-user.ts
@@ -0,0 +1,233 @@
+/**
+ * ask_user tool.
+ *
+ * Lets the agent pause and ask the user a structured clarifying question —
+ * with optional multiple-choice options, single- or multi-select, and a
+ * "type your own answer" free-text field — rendered natively in the TUI, the
+ * Dashboard, and over RPC. Cancelling, skipping, aborting, or timing out
+ * always resolves gracefully so the agent never deadlocks on an absent user.
+ *
+ * Concurrent calls are serialized through a per-session FIFO queue: only one
+ * question is ever shown at a time, and a queued call whose signal aborts
+ * resolves as skipped without opening any UI.
+ */
+
+import { Text } from "@dreb/tui";
+import { type Static, Type } from "@sinclair/typebox";
+import type { AskRequest, AskResult, ExtensionContext, ToolDefinition } from "../extensions/types.js";
+
+// ============================================================================
+// Types
+
+export interface AskUserDetails {
+	question: string;
+	title?: string;
+	selected: string[];
+	customText?: string;
+	/** True when the user skipped/cancelled/timed out. */
+	skipped: boolean;
+	/** True when no interactive UI was available (headless/print mode). */
+	unavailable: boolean;
+}
+
+// ============================================================================
+// Schema
+
+const askUserSchema = Type.Object({
+	question: Type.String({
+		description: "The question to ask the user. Be specific about what you need to decide.",
+	}),
+	title: Type.Optional(
+		Type.String({
+			description: "Short bold header shown above the question.",
+		}),
+	),
+	options: Type.Optional(
+		Type.Array(Type.String(), {
+			minItems: 2,
+			maxItems: 4,
+			description: "2-4 suggested answers the user can pick from.",
+		}),
+	),
+	allowFreeText: Type.Optional(
+		Type.Boolean({
+			description: "Offer a 'type your own answer' field. Defaults to true.",
+		}),
+	),
+	multiSelect: Type.Optional(
+		Type.Boolean({
+			description: "Allow selecting multiple options (checkboxes). Only meaningful with options.",
+		}),
+	),
+	multiline: Type.Optional(
+		Type.Boolean({
+			description: "Use a large multi-line text area for open-ended answers.",
+		}),
+	),
+});
+
+export type AskUserInput = Static<typeof askUserSchema>;
+
+// ============================================================================
+// Result helpers
+
+function textResult(text: string, details: AskUserDetails) {
+	return {
+		content: [{ type: "text" as const, text }],
+		details,
+	};
+}
+
+function baseDetails(input: AskUserInput): Omit<AskUserDetails, "selected" | "skipped" | "unavailable"> {
+	return { question: input.question, title: input.title };
+}
+
+function unavailableResult(input: AskUserInput) {
+	return textResult(
+		"The ask_user tool requires an interactive UI, which is not available in this mode. " +
+			"Proceed using your best judgment without waiting for an answer.",
+		{ ...baseDetails(input), selected: [], skipped: true, unavailable: true },
+	);
+}
+
+function skippedResult(input: AskUserInput) {
+	return textResult("The user skipped the question without answering. Continue without this input.", {
+		...baseDetails(input),
+		selected: [],
+		skipped: true,
+		unavailable: false,
+	});
+}
+
+function answeredResult(input: AskUserInput, answer: AskResult) {
+	const customText = answer.customText?.trim() || undefined;
+	const selected = answer.selected;
+	const parts: string[] = [];
+	if (selected.length > 0) {
+		parts.push(
+			selected.length === 1 ? `The user selected: ${selected[0]}` : `The user selected: ${selected.join(", ")}`,
+		);
+	}
+	if (customText) {
+		parts.push(selected.length > 0 ? `They also wrote: "${customText}"` : `The user answered: "${customText}"`);
+	}
+	return textResult(parts.join(" "), {
+		...baseDetails(input),
+		selected,
+		customText,
+		skipped: false,
+		unavailable: false,
+	});
+}
+
+// ============================================================================
+// Render helpers
+
+function formatCall(args: { question?: string; title?: string } | undefined, theme: any): string {
+	const label = (args?.title || args?.question || "").replace(/\s+/g, " ").trim();
+	const shown = label.length > 80 ? `${label.slice(0, 79)}…` : label;
+	return `${theme.fg("toolTitle", theme.bold("ask_user"))} ${theme.fg("accent", shown)}`;
+}
+
+function formatResult(details: AskUserDetails, theme: any): string {
+	if (details.unavailable) return theme.fg("toolOutput", "no interactive UI — continued without asking");
+	if (details.skipped) return theme.fg("toolOutput", "user skipped");
+	const parts: string[] = [];
+	if (details.selected.length > 0) parts.push(details.selected.join(", "));
+	if (details.customText) parts.push(`"${details.customText}"`);
+	return theme.fg("toolOutput", `→ ${parts.join(" + ")}`);
+}
+
+// ============================================================================
+// Tool definition factory
+
+/**
+ * Create an `ask_user` tool definition. Each call creates an isolated FIFO
+ * queue, so concurrent `ask_user` calls in a single session are shown strictly
+ * one at a time.
+ */
+export function createAskUserToolDefinition(): ToolDefinition<typeof askUserSchema, AskUserDetails | undefined> {
+	// Per-session serialization: only one question is ever open at a time.
+	let tail: Promise<void> = Promise.resolve();
+	const serialize = <T>(run: () => Promise<T>): Promise<T> => {
+		const result = tail.then(run, run);
+		// Always advance the queue, whether the call resolved, cancelled, timed
+		// out, or threw — so a failure can never wedge later questions.
+		tail = result.then(
+			() => undefined,
+			() => undefined,
+		);
+		return result;
+	};
+
+	return {
+		name: "ask_user",
+		label: "ask_user",
+		description:
+			"Pause and ask the user a structured clarifying question with optional multiple-choice options and a " +
+			"free-text answer. Use only when genuinely blocked by ambiguity with multiple viable paths — not for routine confirmation.",
+
+		parameters: askUserSchema,
+
+		promptSnippet: "Ask the user a clarifying question with optional multiple-choice options and free text",
+
+		promptGuidelines: [
+			"Call ask_user ONLY when you are genuinely blocked by ambiguity and there are multiple viable paths forward",
+			"Do NOT use it for routine confirmation, permission, or things you can reasonably decide yourself",
+			"Provide 2-4 concrete `options` when there are clear candidate answers; the user can always type their own",
+			"Set `multiSelect: true` when several options can be combined; `multiline: true` for open-ended answers",
+			"The user may skip — always handle a skipped answer gracefully and continue with a sensible default",
+			"Prefer one focused question over many; the question blocks the turn until the user responds or skips",
+		],
+
+		async execute(_toolCallId, input: AskUserInput, signal, _onUpdate, ctx?: ExtensionContext) {
+			const request: AskRequest = {
+				question: input.question,
+				title: input.title,
+				options: input.options,
+				allowFreeText: input.allowFreeText,
+				multiSelect: input.multiSelect,
+				multiline: input.multiline,
+			};
+
+			// Headless / print / no-host modes: never block on an unreachable UI.
+			if (!ctx?.hasUI) {
+				return unavailableResult(input);
+			}
+
+			return serialize(async () => {
+				// A queued call whose signal already aborted resolves as skipped
+				// without ever opening the UI.
+				if (signal?.aborted) return skippedResult(input);
+				try {
+					const answer = await ctx.ui.ask(request, { signal });
+					if (!answer || (answer.selected.length === 0 && !answer.customText?.trim())) {
+						return skippedResult(input);
+					}
+					return answeredResult(input, answer);
+				} catch {
+					// Host failure must still release the queue and never deadlock.
+					return skippedResult(input);
+				}
+			});
+		},
+
+		renderCall(args, theme, context) {
+			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0, undefined, true);
+			text.setText(formatCall(args, theme));
+			return text;
+		},
+
+		renderResult(result, _options, theme, context) {
+			const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0, undefined, true);
+			const details = (result as any).details as AskUserDetails | undefined;
+			if (details) {
+				text.setText(formatResult(details, theme));
+			} else {
+				const content = result.content?.[0];
+				text.setText(theme.fg("toolOutput", content?.type === "text" ? content.text : ""));
+			}
+			return text;
+		},
+	};
+}
diff --git a/packages/coding-agent/src/core/tools/index.ts b/packages/coding-agent/src/core/tools/index.ts
index ad28ee10..5d000f10 100644
--- a/packages/coding-agent/src/core/tools/index.ts
+++ b/packages/coding-agent/src/core/tools/index.ts
@@ -1,3 +1,8 @@
+export {
+	type AskUserDetails,
+	type AskUserInput,
+	createAskUserToolDefinition,
+} from "./ask-user.js";
 export {
 	type BashOperations,
 	type BashSpawnContext,
@@ -157,6 +162,7 @@ export {
 
 import type { AgentTool } from "@dreb/agent-core";
 import type { ToolDefinition } from "../extensions/types.js";
+import { createAskUserToolDefinition } from "./ask-user.js";
 import {
 	type BashToolOptions,
 	bashTool,
@@ -211,6 +217,8 @@ export const readOnlyTools: Tool[] = [readTool, grepTool, findTool, lsTool];
 const tmpReadToolDefinition = createTmpReadToolDefinition();
 const tmpReadTool = wrapToolDefinition(tmpReadToolDefinition);
 const waitTool = wrapToolDefinition(waitToolDefinition);
+const askUserToolDefinition = createAskUserToolDefinition();
+const askUserTool = wrapToolDefinition(askUserToolDefinition);
 
 export const allTools = {
 	read: readTool,
@@ -226,6 +234,7 @@ export const allTools = {
 	tmp_read: tmpReadTool,
 	wait: waitTool,
 	search: searchTool,
+	ask_user: askUserTool,
 };
 
 export const allToolDefinitions = {
@@ -242,6 +251,7 @@ export const allToolDefinitions = {
 	tmp_read: tmpReadToolDefinition,
 	wait: waitToolDefinition,
 	search: searchToolDefinition,
+	ask_user: askUserToolDefinition,
 };
 
 export type ToolName = keyof typeof allTools;
@@ -288,6 +298,7 @@ export function createAllToolDefinitions(cwd: string, options?: ToolsOptions): R
 		tmp_read: createTmpReadToolDefinition(options?.read),
 		wait: createWaitToolDefinition({ getRunningAgents: getRunningBackgroundAgents }),
 		search: createSearchToolDefinition(cwd),
+		ask_user: createAskUserToolDefinition(),
 	};
 	if (options?.skill) {
 		tools.skill = createSkillToolDefinition(cwd, options.skill);
@@ -329,6 +340,7 @@ export function createAllTools(cwd: string, options?: ToolsOptions): Record<Tool
 		tmp_read: wrapToolDefinition(createTmpReadToolDefinition(options?.read)),
 		wait: wrapToolDefinition(createWaitToolDefinition({ getRunningAgents: getRunningBackgroundAgents })),
 		search: createSearchTool(cwd),
+		ask_user: wrapToolDefinition(createAskUserToolDefinition()),
 	};
 	if (options?.skill) {
 		tools.skill = createSkillTool(cwd, options.skill);
diff --git a/packages/coding-agent/src/modes/interactive/components/ask-user.ts b/packages/coding-agent/src/modes/interactive/components/ask-user.ts
new file mode 100644
index 00000000..295439a3
--- /dev/null
+++ b/packages/coding-agent/src/modes/interactive/components/ask-user.ts
@@ -0,0 +1,267 @@
+/**
+ * ask_user question component.
+ *
+ * Renders a clarifying question with optional single- or multi-select options
+ * and an optional free-text field, matching the approved cross-surface design.
+ *
+ * Keyboard model (settled in issue 396 discussion):
+ *   ↑/↓        move a single cursor through the options and, last, the free-text field
+ *   Space      toggle the highlighted checkbox (multi-select only)
+ *   Enter      single-select: pick the highlighted option and submit;
+ *              free-text field: submit the typed answer;
+ *              multi-select: submit all checked options plus any free text
+ *   Shift+Enter insert a newline in the multiline free-text field
+ *   Esc        skip without answering (always safe)
+ */
+
+import { Container, Editor, type Focusable, getKeybindings, Input, Spacer, Text, type TUI } from "@dreb/tui";
+import type { AskRequest, AskResult } from "../../../core/extensions/types.js";
+import { getEditorTheme, theme } from "../theme/theme.js";
+import { CountdownTimer } from "./countdown-timer.js";
+import { DynamicBorder } from "./dynamic-border.js";
+import { keyHint, rawKeyHint } from "./keybinding-hints.js";
+
+export interface AskUserComponentOptions {
+	tui?: TUI;
+	timeout?: number;
+}
+
+export class AskUserComponent extends Container implements Focusable {
+	private options: string[];
+	private allowFreeText: boolean;
+	private multiSelect: boolean;
+	private multiline: boolean;
+
+	/** Cursor over [options..., freeTextRow?]. */
+	private cursorIndex = 0;
+	/** Checkbox state for multi-select, aligned to options. */
+	private checked: boolean[];
+
+	private onSubmitCallback: (result: AskResult) => void;
+	private onCancelCallback: () => void;
+
+	private titleText: Text;
+	private baseTitle: string;
+	private optionsContainer: Container;
+	private fieldLabel: Text | undefined;
+	private input: Input | undefined;
+	private editor: Editor | undefined;
+	private countdown: CountdownTimer | undefined;
+	private submitted = false;
+
+	private _focused = false;
+	get focused(): boolean {
+		return this._focused;
+	}
+	set focused(value: boolean) {
+		this._focused = value;
+		this.syncFieldFocus();
+	}
+
+	private get freeTextRow(): number {
+		return this.allowFreeText ? this.options.length : -1;
+	}
+
+	private get lastRow(): number {
+		return this.allowFreeText ? this.options.length : this.options.length - 1;
+	}
+
+	private cursorOnField(): boolean {
+		return this.allowFreeText && this.cursorIndex === this.freeTextRow;
+	}
+
+	constructor(
+		request: AskRequest,
+		onSubmit: (result: AskResult) => void,
+		onCancel: () => void,
+		opts?: AskUserComponentOptions,
+	) {
+		super();
+
+		this.options = request.options ?? [];
+		this.allowFreeText = request.allowFreeText !== false;
+		this.multiSelect = request.multiSelect === true && this.options.length > 0;
+		this.multiline = request.multiline === true;
+		this.checked = this.options.map(() => false);
+		this.onSubmitCallback = onSubmit;
+		this.onCancelCallback = onCancel;
+		this.baseTitle = request.title?.trim() || "Question";
+
+		// Start the cursor on the first option, or the free-text field when there
+		// are no options.
+		this.cursorIndex = this.options.length > 0 ? 0 : this.freeTextRow;
+
+		this.addChild(new DynamicBorder());
+		this.addChild(new Spacer(1));
+
+		this.titleText = new Text(theme.fg("accent", theme.bold(this.baseTitle)), 1, 0);
+		this.addChild(this.titleText);
+		this.addChild(new Spacer(1));
+
+		this.addChild(new Text(theme.fg("text", request.question), 1, 0));
+		this.addChild(new Spacer(1));
+
+		if (opts?.timeout && opts.timeout > 0 && opts.tui) {
+			this.countdown = new CountdownTimer(
+				opts.timeout,
+				opts.tui,
+				(s) => this.titleText.setText(theme.fg("accent", theme.bold(`${this.baseTitle} (${s}s)`))),
+				() => this.cancel(),
+			);
+		}
+
+		this.optionsContainer = new Container();
+		this.addChild(this.optionsContainer);
+
+		if (this.allowFreeText) {
+			this.addChild(new Spacer(1));
+			this.fieldLabel = new Text("", 1, 0);
+			this.addChild(this.fieldLabel);
+			if (this.multiline && opts?.tui) {
+				this.editor = new Editor(opts.tui, getEditorTheme(), {});
+				this.editor.onSubmit = () => this.submit();
+				this.addChild(this.editor);
+			} else {
+				this.input = new Input();
+				this.addChild(this.input);
+			}
+		}
+
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(this.buildHint(), 1, 0));
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder());
+
+		this.renderRows();
+		this.syncFieldFocus();
+	}
+
+	private buildHint(): string {
+		const parts = [rawKeyHint("↑↓", "move")];
+		if (this.multiSelect) parts.push(rawKeyHint("Space", "toggle"));
+		parts.push(keyHint("tui.select.confirm", "submit"));
+		if (this.multiline) parts.push(keyHint("tui.input.newLine", "newline"));
+		parts.push(keyHint("tui.select.cancel", "skip"));
+		return parts.join("  ");
+	}
+
+	private renderRows(): void {
+		this.optionsContainer.clear();
+		for (let i = 0; i < this.options.length; i++) {
+			const focused = this.cursorIndex === i;
+			const cursor = focused ? theme.fg("accent", "→ ") : "  ";
+			const glyph = this.multiSelect ? (this.checked[i] ? "[x]" : "[ ]") : focused ? "(•)" : "( )";
+			const label = focused ? theme.fg("accent", this.options[i]) : theme.fg("text", this.options[i]);
+			const glyphColored = this.checked[i] || (!this.multiSelect && focused) ? theme.fg("accent", glyph) : glyph;
+			this.optionsContainer.addChild(new Text(`${cursor}${glyphColored} ${label}`, 1, 0));
+		}
+		if (this.fieldLabel) {
+			const focused = this.cursorOnField();
+			const prefix = focused ? theme.fg("accent", "→ ") : "  ";
+			const labelText = this.options.length > 0 ? "Or type your own answer:" : "Your answer:";
+			this.fieldLabel.setText(prefix + (focused ? theme.fg("accent", labelText) : theme.fg("muted", labelText)));
+		}
+	}
+
+	private syncFieldFocus(): void {
+		const fieldFocused = this._focused && this.cursorOnField();
+		if (this.input) this.input.focused = fieldFocused;
+		if (this.editor) this.editor.focused = fieldFocused;
+	}
+
+	private moveCursor(delta: number): void {
+		const first = this.options.length > 0 ? 0 : this.freeTextRow;
+		const next = Math.max(first, Math.min(this.lastRow, this.cursorIndex + delta));
+		if (next === this.cursorIndex) return;
+		this.cursorIndex = next;
+		this.renderRows();
+		this.syncFieldFocus();
+	}
+
+	private fieldText(): string {
+		if (this.editor) return this.editor.getText().trim();
+		if (this.input) return this.input.getValue().trim();
+		return "";
+	}
+
+	private currentAnswer(): AskResult | undefined {
+		const customText = this.fieldText() || undefined;
+		if (this.multiSelect) {
+			const selected = this.options.filter((_, i) => this.checked[i]);
+			if (selected.length === 0 && !customText) return undefined;
+			return { selected, customText };
+		}
+		if (this.cursorOnField()) {
+			if (!customText) return undefined;
+			return { selected: [], customText };
+		}
+		const option = this.options[this.cursorIndex];
+		return option ? { selected: [option], customText: undefined } : undefined;
+	}
+
+	private submit(): void {
+		if (this.submitted) return;
+		const answer = this.currentAnswer();
+		if (!answer) return; // Nothing to submit yet — Esc skips instead.
+		this.submitted = true;
+		this.onSubmitCallback(answer);
+	}
+
+	private cancel(): void {
+		if (this.submitted) return;
+		this.submitted = true;
+		this.onCancelCallback();
+	}
+
+	handleInput(keyData: string): void {
+		const kb = getKeybindings();
+
+		if (kb.matches(keyData, "tui.select.cancel")) {
+			this.cancel();
+			return;
+		}
+
+		if (this.cursorOnField()) {
+			// Multiline editor: Enter submits (via onSubmit), Shift+Enter inserts a
+			// newline, ↑ at the top line leaves to the options, everything else edits.
+			if (this.editor) {
+				if (kb.matches(keyData, "tui.select.up") && this.editor.getCursor().line === 0) {
+					this.moveCursor(-1);
+					return;
+				}
+				this.editor.handleInput(keyData);
+				return;
+			}
+			// Single-line input: ↑ leaves to the options, Enter submits, else edits.
+			if (this.input) {
+				if (kb.matches(keyData, "tui.select.up")) {
+					this.moveCursor(-1);
+					return;
+				}
+				if (kb.matches(keyData, "tui.select.confirm") || keyData === "\n") {
+					this.submit();
+					return;
+				}
+				this.input.handleInput(keyData);
+				return;
+			}
+			return;
+		}
+
+		// Cursor on an option row.
+		if (kb.matches(keyData, "tui.select.up")) {
+			this.moveCursor(-1);
+		} else if (kb.matches(keyData, "tui.select.down")) {
+			this.moveCursor(1);
+		} else if (this.multiSelect && keyData === " ") {
+			this.checked[this.cursorIndex] = !this.checked[this.cursorIndex];
+			this.renderRows();
+		} else if (kb.matches(keyData, "tui.select.confirm") || keyData === "\n") {
+			this.submit();
+		}
+	}
+
+	dispose(): void {
+		this.countdown?.dispose();
+	}
+}
diff --git a/packages/coding-agent/src/modes/interactive/interactive-mode.ts b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
index 4a531408..f5e4ca69 100644
--- a/packages/coding-agent/src/modes/interactive/interactive-mode.ts
+++ b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
@@ -55,6 +55,8 @@ import {
 	validateMemoryLinks,
 } from "../../core/dream.js";
 import type {
+	AskRequest,
+	AskResult,
 	ExtensionContext,
 	ExtensionRunner,
 	ExtensionUIContext,
@@ -88,6 +90,7 @@ import {
 } from "../../utils/message-text.js";
 import { ensureTool } from "../../utils/tools-manager.js";
 import { ArminComponent } from "./components/armin.js";
+import { AskUserComponent } from "./components/ask-user.js";
 import { AssistantMessageComponent } from "./components/assistant-message.js";
 import { BashExecutionComponent } from "./components/bash-execution.js";
 import { BorderedLoader } from "./components/bordered-loader.js";
@@ -254,6 +257,7 @@ export class InteractiveMode {
 	private extensionSelector: ExtensionSelectorComponent | undefined = undefined;
 	private extensionInput: ExtensionInputComponent | undefined = undefined;
 	private extensionEditor: ExtensionEditorComponent | undefined = undefined;
+	private extensionAsk: AskUserComponent | undefined = undefined;
 	private extensionTerminalInputUnsubscribers = new Set<() => void>();
 
 	// Extension widgets (components rendered above/below the editor)
@@ -1512,6 +1516,9 @@ export class InteractiveMode {
 		if (this.extensionEditor) {
 			this.hideExtensionEditor();
 		}
+		if (this.extensionAsk) {
+			this.hideExtensionAsk();
+		}
 		this.ui.hideOverlay();
 		this.clearExtensionTerminalInputListeners();
 		this.setExtensionFooter(undefined);
@@ -1777,6 +1784,7 @@ export class InteractiveMode {
 			select: (title, options, opts) => this.showExtensionSelector(title, options, opts),
 			confirm: (title, message, opts) => this.showExtensionConfirm(title, message, opts),
 			input: (title, placeholder, opts) => this.showExtensionInput(title, placeholder, opts),
+			ask: (request, opts) => this.showExtensionAsk(request, opts),
 			notify: (message, type) => this.showExtensionNotify(message, type),
 			onTerminalInput: (handler) => this.addExtensionTerminalInputListener(handler),
 			setStatus: (key, text) => this.setExtensionStatus(key, text),
@@ -1932,6 +1940,53 @@ export class InteractiveMode {
 		this.restoreEditorComponent();
 	}
 
+	/**
+	 * Show a rich ask_user question for extensions/built-in tools.
+	 */
+	private showExtensionAsk(request: AskRequest, opts?: ExtensionUIDialogOptions): Promise<AskResult | undefined> {
+		return new Promise((resolve) => {
+			if (opts?.signal?.aborted) {
+				resolve(undefined);
+				return;
+			}
+
+			const onAbort = () => {
+				this.hideExtensionAsk();
+				resolve(undefined);
+			};
+			opts?.signal?.addEventListener("abort", onAbort, { once: true });
+
+			this.extensionAsk = new AskUserComponent(
+				request,
+				(result) => {
+					opts?.signal?.removeEventListener("abort", onAbort);
+					this.hideExtensionAsk();
+					resolve(result);
+				},
+				() => {
+					opts?.signal?.removeEventListener("abort", onAbort);
+					this.hideExtensionAsk();
+					resolve(undefined);
+				},
+				{ tui: this.ui, timeout: opts?.timeout },
+			);
+
+			this.editorContainer.clear();
+			this.editorContainer.addChild(this.extensionAsk);
+			this.ui.setFocus(this.extensionAsk);
+			this.ui.requestRender();
+		});
+	}
+
+	/**
+	 * Hide the ask_user question.
+	 */
+	private hideExtensionAsk(): void {
+		this.extensionAsk?.dispose();
+		this.extensionAsk = undefined;
+		this.restoreEditorComponent();
+	}
+
 	/**
 	 * Show a multi-line editor for extensions (with Ctrl+G support).
 	 */
diff --git a/packages/coding-agent/src/modes/rpc/rpc-mode.ts b/packages/coding-agent/src/modes/rpc/rpc-mode.ts
index f04a4739..e4ea6fd7 100644
--- a/packages/coding-agent/src/modes/rpc/rpc-mode.ts
+++ b/packages/coding-agent/src/modes/rpc/rpc-mode.ts
@@ -1114,6 +1114,28 @@ export async function runRpcMode(session: AgentSession, modelFallbackMessage?: s
 				"cancelled" in r && r.cancelled ? undefined : "value" in r ? r.value : undefined,
 			),
 
+		ask: (request, opts) =>
+			createDialogPromise(
+				opts,
+				undefined,
+				{
+					method: "ask",
+					title: request.title ?? "Question",
+					question: request.question,
+					options: request.options,
+					allowFreeText: request.allowFreeText,
+					multiSelect: request.multiSelect,
+					multiline: request.multiline,
+					timeout: opts?.timeout,
+				},
+				(r) =>
+					"cancelled" in r && r.cancelled
+						? undefined
+						: "selected" in r
+							? { selected: r.selected, customText: r.customText }
+							: undefined,
+			),
+
 		notify(message: string, type?: "info" | "warning" | "error"): void {
 			// Fire and forget - no response needed
 			output({
diff --git a/packages/coding-agent/src/modes/rpc/rpc-types.ts b/packages/coding-agent/src/modes/rpc/rpc-types.ts
index 78823c77..225fe228 100644
--- a/packages/coding-agent/src/modes/rpc/rpc-types.ts
+++ b/packages/coding-agent/src/modes/rpc/rpc-types.ts
@@ -643,6 +643,18 @@ export type RpcExtensionUIRequest =
 			timeout?: number;
 	  }
 	| { type: "extension_ui_request"; id: string; method: "editor"; title: string; prefill?: string }
+	| {
+			type: "extension_ui_request";
+			id: string;
+			method: "ask";
+			title: string;
+			question: string;
+			options?: string[];
+			allowFreeText?: boolean;
+			multiSelect?: boolean;
+			multiline?: boolean;
+			timeout?: number;
+	  }
 	| {
 			type: "extension_ui_request";
 			id: string;
@@ -676,6 +688,7 @@ export type RpcExtensionUIRequest =
 export type RpcExtensionUIResponse =
 	| { type: "extension_ui_response"; id: string; value: string }
 	| { type: "extension_ui_response"; id: string; confirmed: boolean }
+	| { type: "extension_ui_response"; id: string; selected: string[]; customText?: string }
 	| { type: "extension_ui_response"; id: string; cancelled: true };
 
 // ============================================================================
diff --git a/packages/coding-agent/test/ask-user-component.test.ts b/packages/coding-agent/test/ask-user-component.test.ts
new file mode 100644
index 00000000..a3466d67
--- /dev/null
+++ b/packages/coding-agent/test/ask-user-component.test.ts
@@ -0,0 +1,120 @@
+import { setKeybindings } from "@dreb/tui";
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import type { AskRequest, AskResult } from "../src/core/extensions/types.js";
+import { KeybindingsManager } from "../src/core/keybindings.js";
+import { AskUserComponent } from "../src/modes/interactive/components/ask-user.js";
+import { initTheme } from "../src/modes/interactive/theme/theme.js";
+
+const UP = "\x1b[A";
+const DOWN = "\x1b[B";
+const ENTER = "\n";
+const ESC = "\x1b";
+const SPACE = " ";
+
+beforeAll(() => {
+	initTheme("dark");
+});
+
+beforeEach(() => {
+	setKeybindings(new KeybindingsManager());
+});
+
+function mount(request: AskRequest) {
+	const onSubmit = vi.fn<(result: AskResult) => void>();
+	const onCancel = vi.fn<() => void>();
+	const component = new AskUserComponent(request, onSubmit, onCancel);
+	component.focused = true;
+	return { component, onSubmit, onCancel };
+}
+
+function type(component: AskUserComponent, text: string) {
+	for (const char of text) component.handleInput(char);
+}
+
+describe("AskUserComponent", () => {
+	it("single-select: Enter picks the highlighted option and submits", () => {
+		const { component, onSubmit } = mount({ question: "DB?", options: ["SQLite", "Postgres", "JSON"] });
+		component.handleInput(DOWN); // move to Postgres
+		component.handleInput(ENTER);
+		expect(onSubmit).toHaveBeenCalledWith({ selected: ["Postgres"], customText: undefined });
+	});
+
+	it("single-select: submitting the free-text field returns only the typed text", () => {
+		const { component, onSubmit } = mount({ question: "DB?", options: ["SQLite", "Postgres"] });
+		component.handleInput(DOWN); // Postgres
+		component.handleInput(DOWN); // free-text row
+		type(component, "duckdb");
+		component.handleInput(ENTER);
+		expect(onSubmit).toHaveBeenCalledWith({ selected: [], customText: "duckdb" });
+	});
+
+	it("multi-select: Space toggles checkboxes and Enter submits the combined answer", () => {
+		const { component, onSubmit } = mount({
+			question: "Checks?",
+			options: ["unit", "browser", "types"],
+			multiSelect: true,
+		});
+		component.handleInput(SPACE); // check unit
+		component.handleInput(DOWN);
+		component.handleInput(DOWN); // types
+		component.handleInput(SPACE); // check types
+		component.handleInput(ENTER);
+		expect(onSubmit).toHaveBeenCalledWith({ selected: ["unit", "types"], customText: undefined });
+	});
+
+	it("multi-select: combines checked options with free text", () => {
+		const { component, onSubmit } = mount({
+			question: "Checks?",
+			options: ["unit", "browser"],
+			multiSelect: true,
+		});
+		component.handleInput(SPACE); // check unit
+		component.handleInput(DOWN); // browser
+		component.handleInput(DOWN); // free-text row
+		type(component, "lint");
+		component.handleInput(ENTER);
+		expect(onSubmit).toHaveBeenCalledWith({ selected: ["unit"], customText: "lint" });
+	});
+
+	it("Esc skips without answering", () => {
+		const { component, onSubmit, onCancel } = mount({ question: "DB?", options: ["a", "b"] });
+		component.handleInput(ESC);
+		expect(onCancel).toHaveBeenCalledTimes(1);
+		expect(onSubmit).not.toHaveBeenCalled();
+	});
+
+	it("ignores Enter on an empty free-text field (Esc is the way to skip)", () => {
+		const { component, onSubmit } = mount({ question: "Name?" });
+		// Free-text-only question: cursor starts on the field, which is empty.
+		component.handleInput(ENTER);
+		expect(onSubmit).not.toHaveBeenCalled();
+		type(component, "hi");
+		component.handleInput(ENTER);
+		expect(onSubmit).toHaveBeenCalledWith({ selected: [], customText: "hi" });
+	});
+
+	it("does not offer a free-text field when allowFreeText is false", () => {
+		const { component, onSubmit } = mount({ question: "Pick", options: ["a", "b"], allowFreeText: false });
+		// Arrowing down past the last option must not reach a field — Enter still
+		// submits the highlighted option.
+		component.handleInput(DOWN);
+		component.handleInput(DOWN);
+		component.handleInput(ENTER);
+		expect(onSubmit).toHaveBeenCalledWith({ selected: ["b"], customText: undefined });
+	});
+
+	it("submits only once even if Enter is pressed repeatedly", () => {
+		const { component, onSubmit } = mount({ question: "DB?", options: ["a", "b"] });
+		component.handleInput(ENTER);
+		component.handleInput(ENTER);
+		expect(onSubmit).toHaveBeenCalledTimes(1);
+	});
+
+	it("does not navigate above the first row", () => {
+		const { component, onSubmit } = mount({ question: "DB?", options: ["a", "b"] });
+		component.handleInput(UP);
+		component.handleInput(UP);
+		component.handleInput(ENTER);
+		expect(onSubmit).toHaveBeenCalledWith({ selected: ["a"], customText: undefined });
+	});
+});
diff --git a/packages/coding-agent/test/tools.test.ts b/packages/coding-agent/test/tools.test.ts
index 66288a90..67139c23 100644
--- a/packages/coding-agent/test/tools.test.ts
+++ b/packages/coding-agent/test/tools.test.ts
@@ -10,6 +10,7 @@ import { createGrepTool, type GrepOperations, grepTool } from "../src/core/tools
 import { allToolDefinitions, allTools, createAllToolDefinitions, createAllTools } from "../src/core/tools/index.js";
 import { lsTool } from "../src/core/tools/ls.js";
 import { readTool } from "../src/core/tools/read.js";
+import { wrapToolDefinition } from "../src/core/tools/tool-definition-wrapper.js";
 import { writeTool } from "../src/core/tools/write.js";
 import * as shellModule from "../src/utils/shell.js";
 
@@ -948,4 +949,57 @@ describe("allTools / allToolDefinitions", () => {
 		const tools = createAllTools("/tmp");
 		expect(tools.search).toBeDefined();
 	});
+
+	it("includes ask_user in both registries unconditionally", () => {
+		expect("ask_user" in allTools).toBe(true);
+		expect("ask_user" in allToolDefinitions).toBe(true);
+		expect(allTools.ask_user.name).toBe("ask_user");
+		expect(typeof allTools.ask_user.execute).toBe("function");
+		expect(createAllToolDefinitions("/tmp").ask_user).toBeDefined();
+		expect(createAllTools("/tmp").ask_user).toBeDefined();
+	});
+});
+
+describe("wrapToolDefinition ctxFactory (base-tool ctx.ui wiring)", () => {
+	it("forwards a per-execution ExtensionContext from the factory to execute", async () => {
+		const seen: unknown[] = [];
+		const definition = {
+			name: "probe",
+			label: "probe",
+			description: "d",
+			parameters: {} as any,
+			execute: async (_id: string, _params: any, _signal: any, _onUpdate: any, ctx: any) => {
+				seen.push(ctx);
+				return { content: [{ type: "text" as const, text: "ok" }] };
+			},
+		};
+		let created = 0;
+		const factory = () => {
+			created += 1;
+			return { hasUI: true, ui: {} } as any;
+		};
+		const tool = wrapToolDefinition(definition as any, factory);
+		await tool.execute("c1", {}, undefined, undefined);
+		await tool.execute("c2", {}, undefined, undefined);
+		expect(created).toBe(2); // resolved fresh per execution
+		expect(seen).toHaveLength(2);
+		expect((seen[0] as any).hasUI).toBe(true);
+	});
+
+	it("passes undefined ctx when no factory is provided", async () => {
+		let received: unknown = "sentinel";
+		const definition = {
+			name: "probe2",
+			label: "probe2",
+			description: "d",
+			parameters: {} as any,
+			execute: async (_id: string, _params: any, _signal: any, _onUpdate: any, ctx: any) => {
+				received = ctx;
+				return { content: [{ type: "text" as const, text: "ok" }] };
+			},
+		};
+		const tool = wrapToolDefinition(definition as any);
+		await tool.execute("c1", {}, undefined, undefined);
+		expect(received).toBeUndefined();
+	});
 });
diff --git a/packages/coding-agent/test/tools/ask-user.test.ts b/packages/coding-agent/test/tools/ask-user.test.ts
new file mode 100644
index 00000000..01a47850
--- /dev/null
+++ b/packages/coding-agent/test/tools/ask-user.test.ts
@@ -0,0 +1,206 @@
+import { describe, expect, it, vi } from "vitest";
+import type { AskRequest, AskResult, ExtensionContext } from "../../src/core/extensions/types.js";
+import { type AskUserDetails, createAskUserToolDefinition } from "../../src/core/tools/ask-user.js";
+
+const mockTheme = {
+	fg: (_color: string, text: string) => text,
+	bold: (text: string) => text,
+};
+
+interface ExecResult {
+	content: Array<{ type: string; text?: string }>;
+	details?: AskUserDetails;
+	endTurn?: boolean;
+}
+
+/** Build a ctx whose ui.ask returns a scripted answer (or undefined for skip). */
+function makeCtx(
+	ask: (request: AskRequest, opts?: { signal?: AbortSignal }) => Promise<AskResult | undefined>,
+	hasUI = true,
+): ExtensionContext {
+	return { hasUI, ui: { ask } } as unknown as ExtensionContext;
+}
+
+function run(
+	def: ReturnType<typeof createAskUserToolDefinition>,
+	params: Record<string, unknown>,
+	ctx?: ExtensionContext,
+	signal?: AbortSignal,
+): Promise<ExecResult> {
+	return (def.execute as any)("call-1", params, signal, undefined, ctx) as Promise<ExecResult>;
+}
+
+describe("ask_user tool", () => {
+	it("exposes narrow usage guidance in prompt metadata", () => {
+		const def = createAskUserToolDefinition();
+		expect(def.name).toBe("ask_user");
+		expect(def.promptSnippet).toBeTruthy();
+		const guidelines = (def.promptGuidelines as string[]).join(" ").toLowerCase();
+		expect(guidelines).toContain("only");
+		expect(guidelines).toContain("blocked");
+		expect(guidelines).toContain("skip");
+	});
+
+	it("validates option bounds (2-4) in its schema", () => {
+		const def = createAskUserToolDefinition();
+		const props = (def.parameters as any).properties;
+		expect(props.options.minItems).toBe(2);
+		expect(props.options.maxItems).toBe(4);
+		expect(props.question.type).toBe("string");
+	});
+
+	it("returns a graceful non-blocking result when no UI is available", async () => {
+		const def = createAskUserToolDefinition();
+		const ask = vi.fn();
+		const result = await run(def, { question: "Which?" }, makeCtx(ask, false));
+		expect(ask).not.toHaveBeenCalled();
+		expect(result.details?.unavailable).toBe(true);
+		expect(result.details?.skipped).toBe(true);
+		expect(result.content[0].text).toContain("not available");
+	});
+
+	it("returns unavailable when ctx is entirely absent", async () => {
+		const def = createAskUserToolDefinition();
+		const result = await run(def, { question: "Which?" }, undefined);
+		expect(result.details?.unavailable).toBe(true);
+	});
+
+	it("formats a single selected option", async () => {
+		const def = createAskUserToolDefinition();
+		const ctx = makeCtx(async () => ({ selected: ["SQLite"] }));
+		const result = await run(def, { question: "DB?", options: ["SQLite", "Postgres"] }, ctx);
+		expect(result.details?.skipped).toBe(false);
+		expect(result.details?.selected).toEqual(["SQLite"]);
+		expect(result.content[0].text).toBe("The user selected: SQLite");
+	});
+
+	it("combines multiple selections with custom text", async () => {
+		const def = createAskUserToolDefinition();
+		const ctx = makeCtx(async () => ({ selected: ["A", "B"], customText: "plus C" }));
+		const result = await run(def, { question: "Pick", options: ["A", "B"], multiSelect: true }, ctx);
+		expect(result.details?.selected).toEqual(["A", "B"]);
+		expect(result.details?.customText).toBe("plus C");
+		expect(result.content[0].text).toContain("The user selected: A, B");
+		expect(result.content[0].text).toContain('They also wrote: "plus C"');
+	});
+
+	it("formats a free-text-only answer", async () => {
+		const def = createAskUserToolDefinition();
+		const ctx = makeCtx(async () => ({ selected: [], customText: "my own answer" }));
+		const result = await run(def, { question: "Name?" }, ctx);
+		expect(result.content[0].text).toBe('The user answered: "my own answer"');
+	});
+
+	it("treats an undefined answer as a graceful skip", async () => {
+		const def = createAskUserToolDefinition();
+		const ctx = makeCtx(async () => undefined);
+		const result = await run(def, { question: "Which?" }, ctx);
+		expect(result.details?.skipped).toBe(true);
+		expect(result.details?.unavailable).toBe(false);
+		expect(result.content[0].text).toContain("skipped");
+	});
+
+	it("treats an empty answer as a skip", async () => {
+		const def = createAskUserToolDefinition();
+		const ctx = makeCtx(async () => ({ selected: [], customText: "   " }));
+		const result = await run(def, { question: "Which?" }, ctx);
+		expect(result.details?.skipped).toBe(true);
+	});
+
+	it("resolves as skipped without opening UI when the signal is already aborted", async () => {
+		const def = createAskUserToolDefinition();
+		const ask = vi.fn(async () => ({ selected: ["x"] }));
+		const controller = new AbortController();
+		controller.abort();
+		const result = await run(def, { question: "Which?" }, makeCtx(ask), controller.signal);
+		expect(ask).not.toHaveBeenCalled();
+		expect(result.details?.skipped).toBe(true);
+		expect(result.details?.unavailable).toBe(false);
+	});
+
+	it("resolves gracefully when the host throws", async () => {
+		const def = createAskUserToolDefinition();
+		const ctx = makeCtx(async () => {
+			throw new Error("host exploded");
+		});
+		const result = await run(def, { question: "Which?" }, ctx);
+		expect(result.details?.skipped).toBe(true);
+	});
+
+	it("serializes concurrent calls strictly one at a time (FIFO)", async () => {
+		const def = createAskUserToolDefinition();
+		let active = 0;
+		let maxActive = 0;
+		const order: string[] = [];
+		const ctx = makeCtx(async (request) => {
+			active += 1;
+			maxActive = Math.max(maxActive, active);
+			await new Promise((r) => setTimeout(r, 10));
+			order.push(request.question);
+			active -= 1;
+			return { selected: [request.question] };
+		});
+
+		const results = await Promise.all([
+			run(def, { question: "first" }, ctx),
+			run(def, { question: "second" }, ctx),
+			run(def, { question: "third" }, ctx),
+		]);
+
+		expect(maxActive).toBe(1); // never two questions open at once
+		expect(order).toEqual(["first", "second", "third"]);
+		expect(results.map((r) => r.details?.selected?.[0])).toEqual(["first", "second", "third"]);
+	});
+
+	it("releases the queue after a failure so later calls still run", async () => {
+		const def = createAskUserToolDefinition();
+		let calls = 0;
+		const ctx = makeCtx(async (request) => {
+			calls += 1;
+			if (request.question === "boom") throw new Error("fail");
+			return { selected: [request.question] };
+		});
+		const [first, second] = await Promise.all([
+			run(def, { question: "boom" }, ctx),
+			run(def, { question: "ok" }, ctx),
+		]);
+		expect(calls).toBe(2);
+		expect(first.details?.skipped).toBe(true);
+		expect(second.details?.selected).toEqual(["ok"]);
+	});
+
+	it("passes the abort signal through to the UI layer", async () => {
+		const def = createAskUserToolDefinition();
+		const controller = new AbortController();
+		let receivedSignal: AbortSignal | undefined;
+		const ctx = makeCtx(async (_req, opts) => {
+			receivedSignal = opts?.signal;
+			return { selected: ["x"] };
+		});
+		await run(def, { question: "Which?" }, ctx, controller.signal);
+		expect(receivedSignal).toBe(controller.signal);
+	});
+
+	it("renders a call and result without throwing", () => {
+		const def = createAskUserToolDefinition();
+		const call = def.renderCall?.(
+			{ question: "Which database?" } as any,
+			mockTheme as any,
+			{
+				lastComponent: undefined,
+			} as any,
+		);
+		expect(call).toBeDefined();
+
+		const result = def.renderResult?.(
+			{
+				content: [{ type: "text", text: "done" }],
+				details: { question: "q", selected: ["A"], skipped: false, unavailable: false },
+			} as any,
+			{} as any,
+			mockTheme as any,
+			{ lastComponent: undefined } as any,
+		);
+		expect(result).toBeDefined();
+	});
+});
diff --git a/packages/dashboard/src/client/screens/session.tsx b/packages/dashboard/src/client/screens/session.tsx
index dc1f2900..a7c8919d 100644
--- a/packages/dashboard/src/client/screens/session.tsx
+++ b/packages/dashboard/src/client/screens/session.tsx
@@ -182,6 +182,103 @@ function ExtensionUiModal(props: {
 	);
 }
 
+function AskUiModal(props: {
+	request: ExtensionUiRequest;
+	onRespond: (response: Record<string, unknown>) => void;
+}): JSX.Element {
+	const options = () => props.request.options ?? [];
+	const allowFreeText = () => props.request.allowFreeText !== false;
+	const multiSelect = () => props.request.multiSelect === true && options().length > 0;
+	const [selected, setSelected] = createSignal<string[]>([]);
+	const [customText, setCustomText] = createSignal("");
+	const respond = (body: Record<string, unknown>) =>
+		props.onRespond({ type: "extension_ui_response", id: props.request.id, ...body });
+
+	const toggle = (option: string) => {
+		if (multiSelect()) {
+			setSelected((current) =>
+				current.includes(option) ? current.filter((value) => value !== option) : [...current, option],
+			);
+		} else {
+			setSelected([option]);
+		}
+	};
+
+	const answer = () => {
+		const text = customText().trim();
+		return { selected: selected(), customText: text ? text : undefined };
+	};
+	const canSubmit = () => answer().selected.length > 0 || answer().customText !== undefined;
+	const submit = () => {
+		if (canSubmit()) respond(answer());
+	};
+
+	return (
+		<Modal
+			title={props.request.title}
+			onDismiss={() => respond({ cancelled: true })}
+			actions={
+				<>
+					<button type="button" class="btn btn-small" onClick={() => respond({ cancelled: true })}>
+						skip
+					</button>
+					<button type="button" class="btn btn-small btn-primary" disabled={!canSubmit()} onClick={submit}>
+						submit
+					</button>
+				</>
+			}
+		>
+			<Show when={props.request.question}>
+				<p style={{ "margin-bottom": "12px" }}>{props.request.question}</p>
+			</Show>
+			<Show when={options().length > 0}>
+				<fieldset class="ask-options">
+					<legend class="ask-options-legend">Answer options</legend>
+					<For each={options()}>
+						{(option) => (
+							<label class="ask-option" classList={{ selected: selected().includes(option) }}>
+								<input
+									type={multiSelect() ? "checkbox" : "radio"}
+									name={`ask-${props.request.id}`}
+									checked={selected().includes(option)}
+									onChange={() => toggle(option)}
+								/>
+								<span>{option}</span>
+							</label>
+						)}
+					</For>
+				</fieldset>
+			</Show>
+			<Show when={allowFreeText()}>
+				<div class="field">
+					<label class="ask-custom-label" for={`ask-custom-${props.request.id}`}>
+						{options().length > 0 ? "Or type your own answer" : "Your answer"}
+					</label>
+					<Show
+						when={props.request.multiline}
+						fallback={
+							<input
+								id={`ask-custom-${props.request.id}`}
+								type="text"
+								value={customText()}
+								placeholder="Type a different answer…"
+								onInput={(e) => setCustomText(e.currentTarget.value)}
+							/>
+						}
+					>
+						<textarea
+							id={`ask-custom-${props.request.id}`}
+							rows="5"
+							value={customText()}
+							onInput={(e) => setCustomText(e.currentTarget.value)}
+						/>
+					</Show>
+				</div>
+			</Show>
+		</Modal>
+	);
+}
+
 function LoadedContextModal(props: { resources?: ResourcesDto; error?: string; onClose: () => void }): JSX.Element {
 	const section = (title: string, items: JSX.Element[]) => (
 		<section class="context-section">
@@ -1539,18 +1636,23 @@ export function SessionScreen(props: { store: AppStore; sessionKey: string }): J
 			</footer>
 
 			<Show when={session()?.uiRequests[0]}>
-				{(request) => (
-					<ExtensionUiModal
-						request={request()}
-						onRespond={async (response) => {
-							try {
-								await api.extensionUiResponse(props.sessionKey, response);
-							} catch (err) {
-								setActionError(err instanceof Error ? err.message : String(err));
-							}
-						}}
-					/>
-				)}
+				{(request) => {
+					const onRespond = async (response: Record<string, unknown>) => {
+						try {
+							await api.extensionUiResponse(props.sessionKey, response);
+						} catch (err) {
+							setActionError(err instanceof Error ? err.message : String(err));
+						}
+					};
+					return (
+						<Show
+							when={request().method === "ask"}
+							fallback={<ExtensionUiModal request={request()} onRespond={onRespond} />}
+						>
+							<AskUiModal request={request()} onRespond={onRespond} />
+						</Show>
+					);
+				}}
 			</Show>
 
 			<Show when={showModelSelector()}>
diff --git a/packages/dashboard/src/client/state/reducer.ts b/packages/dashboard/src/client/state/reducer.ts
index fdb522f4..7af67920 100644
--- a/packages/dashboard/src/client/state/reducer.ts
+++ b/packages/dashboard/src/client/state/reducer.ts
@@ -104,12 +104,20 @@ export interface StatusLineEntry {
 
 export interface ExtensionUiRequest {
 	id: string;
-	method: "select" | "confirm" | "input" | "editor";
+	method: "select" | "confirm" | "input" | "editor" | "ask";
 	title: string;
 	message?: string;
 	options?: string[];
 	prefill?: string;
 	placeholder?: string;
+	/** ask: the question body shown under the title. */
+	question?: string;
+	/** ask: offer a free-text field (defaults true). */
+	allowFreeText?: boolean;
+	/** ask: render options as checkboxes instead of radios. */
+	multiSelect?: boolean;
+	/** ask: use a multi-line text area for free text. */
+	multiline?: boolean;
 }
 
 export interface Toast {
@@ -807,6 +815,17 @@ export function applySessionEvent(state: SessionViewState, event: any): void {
 					prefill: event.prefill as string | undefined,
 					placeholder: event.placeholder as string | undefined,
 				});
+			} else if (method === "ask") {
+				state.uiRequests.push({
+					id: String(event.id),
+					method: "ask",
+					title: String(event.title ?? "Question"),
+					question: String(event.question ?? ""),
+					options: event.options as string[] | undefined,
+					allowFreeText: event.allowFreeText as boolean | undefined,
+					multiSelect: event.multiSelect as boolean | undefined,
+					multiline: event.multiline as boolean | undefined,
+				});
 			} else if (method === "notify") {
 				toastCounter += 1;
 				const tone = (event.notifyType as "info" | "warning" | "error" | undefined) ?? "info";
diff --git a/packages/dashboard/src/client/styles/app.css b/packages/dashboard/src/client/styles/app.css
index 2d32c222..8b81b0a2 100644
--- a/packages/dashboard/src/client/styles/app.css
+++ b/packages/dashboard/src/client/styles/app.css
@@ -2207,6 +2207,62 @@ details.thinking .thinking-body {
 	outline: none;
 }
 
+/* ------------------------------------------------------------- ask_user dialog */
+
+.ask-options {
+	display: flex;
+	flex-direction: column;
+	gap: var(--space-2);
+	margin: 0 0 var(--space-3);
+	padding: 0;
+	border: 0;
+	min-width: 0;
+}
+
+.ask-options-legend {
+	position: absolute;
+	width: 1px;
+	height: 1px;
+	padding: 0;
+	margin: -1px;
+	overflow: hidden;
+	clip: rect(0, 0, 0, 0);
+	white-space: nowrap;
+	border: 0;
+}
+
+.ask-option {
+	display: flex;
+	align-items: center;
+	gap: var(--space-2);
+	border: var(--hairline);
+	border-radius: var(--radius);
+	padding: var(--space-2) var(--space-3);
+	cursor: pointer;
+	color: var(--text);
+}
+
+.ask-option:hover {
+	border-color: var(--text);
+}
+
+.ask-option.selected {
+	border-color: var(--status-running);
+	background: color-mix(in srgb, var(--status-running) 12%, transparent);
+}
+
+.ask-option input {
+	width: auto;
+	margin: 0;
+	accent-color: var(--status-running);
+	cursor: pointer;
+}
+
+.ask-custom-label {
+	font-size: var(--fs-small);
+	color: var(--muted);
+}
+
 .recent-projects {
 	display: flex;
 	flex-direction: column;
diff --git a/packages/dashboard/src/server/runtime-pool.ts b/packages/dashboard/src/server/runtime-pool.ts
index ee0f11a6..4dae85d1 100644
--- a/packages/dashboard/src/server/runtime-pool.ts
+++ b/packages/dashboard/src/server/runtime-pool.ts
@@ -446,7 +446,13 @@ export class RuntimePool {
 		// paused, error states.
 		if (type === "extension_ui_request") {
 			const method = event.method as string;
-			if (method === "select" || method === "confirm" || method === "input" || method === "editor") {
+			if (
+				method === "select" ||
+				method === "confirm" ||
+				method === "input" ||
+				method === "editor" ||
+				method === "ask"
+			) {
 				handle.attention.set(`ui:${event.id}`, `extension ${method} awaiting response`);
 			}
 		}
diff --git a/packages/dashboard/test/client/pwa.test.tsx b/packages/dashboard/test/client/pwa.test.tsx
index fa340bd2..bddccfa0 100644
--- a/packages/dashboard/test/client/pwa.test.tsx
+++ b/packages/dashboard/test/client/pwa.test.tsx
@@ -376,6 +376,38 @@ describe("PWA client — notification dispatch gating", () => {
 		);
 	});
 
+	it("fires for an ask_user question with the question title as the reason", async () => {
+		setPermission("granted");
+		setHidden(true);
+		const stream = captureEnvelopeHandler();
+		await mountAppAndFlush();
+
+		stream.push({ seq: 1, key: "sess-ask", event: { type: "session_name_changed", name: "Ask Session" } });
+		stream.push({
+			seq: 2,
+			key: "sess-ask",
+			event: {
+				type: "extension_ui_request",
+				id: "ask-1",
+				method: "ask",
+				title: "Choose a database",
+				question: "Which persistence strategy?",
+				options: ["SQLite", "Postgres"],
+			},
+		});
+		await flushEffects();
+
+		expect(document.title).toContain("◆");
+		expect(showNotification).toHaveBeenCalledWith(
+			"dreb — Ask Session",
+			expect.objectContaining({
+				body: "waiting for input — Choose a database",
+				tag: "sess-ask",
+				data: { sessionKey: "sess-ask" },
+			}),
+		);
+	});
+
 	it("fires for store.sessions error status entries with the error text as the reason", async () => {
 		setPermission("granted");
 		setHidden(true);
diff --git a/packages/dashboard/test/client/screens.test.tsx b/packages/dashboard/test/client/screens.test.tsx
index c5fd9e9a..c1fbd17a 100644
--- a/packages/dashboard/test/client/screens.test.tsx
+++ b/packages/dashboard/test/client/screens.test.tsx
@@ -21,6 +21,7 @@ vi.mock("../../src/client/api.js", () => ({
 	},
 	api: {
 		auth: vi.fn(async () => ({ mode: "local", needsPairing: false })),
+		extensionUiResponse: vi.fn(async () => ({ ok: true })),
 		fleet: vi.fn(async () => ({ runtimes: [], diskSessions: [] })),
 		sessions: vi.fn(async () => ({ sessions: [] })),
 		resync: vi.fn(async () => ({ fleet: { runtimes: [], diskSessions: [] }, barrierSeq: 0 })),
@@ -1060,6 +1061,82 @@ describe("screen smoke tests", () => {
 		expect(el.textContent).not.toContain("follow-up");
 	});
 
+	it("ask_user dialog: native checkboxes + free text combine into one response", async () => {
+		const store = makeStore() as any;
+		const session = createSessionViewState("k-ask");
+		session.uiRequests = [
+			{
+				id: "a1",
+				method: "ask",
+				title: "Choose validation",
+				question: "Which checks?",
+				options: ["unit", "browser"],
+				multiSelect: true,
+				allowFreeText: true,
+			},
+		];
+		const fakeStore = {
+			...store,
+			sessions: { "k-ask": session },
+			fleet: () => ({ runtimes: [], diskSessions: [] }),
+			hydrateSession: async () => {},
+		};
+		const el = mount(() => <SessionScreen store={fakeStore} sessionKey="k-ask" />);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		expect(el.textContent).toContain("Which checks?");
+		const checkboxes = el.querySelectorAll<HTMLInputElement>('.ask-option input[type="checkbox"]');
+		expect(checkboxes.length).toBe(2);
+		expect(el.querySelector('.ask-option input[type="radio"]')).toBeNull();
+
+		checkboxes[0].click(); // check "unit"
+		const custom = el.querySelector<HTMLInputElement>('input[id^="ask-custom-"]');
+		if (!custom) throw new Error("free-text field missing");
+		custom.value = "lint";
+		custom.dispatchEvent(new Event("input", { bubbles: true }));
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		const submit = [...el.querySelectorAll("button")].find((b) => b.textContent === "submit");
+		submit?.click();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		expect(vi.mocked(api.extensionUiResponse)).toHaveBeenCalledWith(
+			"k-ask",
+			expect.objectContaining({
+				type: "extension_ui_response",
+				id: "a1",
+				selected: ["unit"],
+				customText: "lint",
+			}),
+		);
+	});
+
+	it("ask_user dialog: single-select renders radios and skip cancels", async () => {
+		const store = makeStore() as any;
+		const session = createSessionViewState("k-ask2");
+		session.uiRequests = [{ id: "a2", method: "ask", title: "Pick", question: "Which one?", options: ["A", "B"] }];
+		const fakeStore = {
+			...store,
+			sessions: { "k-ask2": session },
+			fleet: () => ({ runtimes: [], diskSessions: [] }),
+			hydrateSession: async () => {},
+		};
+		const el = mount(() => <SessionScreen store={fakeStore} sessionKey="k-ask2" />);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		const radios = el.querySelectorAll<HTMLInputElement>('.ask-option input[type="radio"]');
+		expect(radios.length).toBe(2);
+
+		vi.mocked(api.extensionUiResponse).mockClear();
+		const skip = [...el.querySelectorAll("button")].find((b) => b.textContent === "skip");
+		skip?.click();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		expect(vi.mocked(api.extensionUiResponse)).toHaveBeenCalledWith(
+			"k-ask2",
+			expect.objectContaining({ type: "extension_ui_response", id: "a2", cancelled: true }),
+		);
+	});
+
 	it("session header prefers live session_name_changed state", () => {
 		const store = makeStore() as any;
 		const session = createSessionViewState("k-live");
diff --git a/packages/dashboard/test/reducer.test.ts b/packages/dashboard/test/reducer.test.ts
index 5d44a4ba..dedcdacd 100644
--- a/packages/dashboard/test/reducer.test.ts
+++ b/packages/dashboard/test/reducer.test.ts
@@ -958,6 +958,36 @@ describe("applySessionEvent — extension UI", () => {
 		expect(state.needsAttention).toBe(false);
 	});
 
+	it("ask requests populate uiRequests with question/options and set attention", () => {
+		const state = makeState();
+		applySessionEvent(state, {
+			type: "extension_ui_request",
+			id: "a1",
+			method: "ask",
+			title: "Choose a database",
+			question: "Which persistence strategy?",
+			options: ["SQLite", "Postgres"],
+			multiSelect: true,
+			multiline: false,
+			allowFreeText: true,
+		});
+		expect(state.uiRequests).toHaveLength(1);
+		expect(state.uiRequests[0]).toMatchObject({
+			id: "a1",
+			method: "ask",
+			title: "Choose a database",
+			question: "Which persistence strategy?",
+			options: ["SQLite", "Postgres"],
+			multiSelect: true,
+			allowFreeText: true,
+		});
+		expect(state.needsAttention).toBe(true);
+
+		resolveUiRequest(state, "a1");
+		expect(state.uiRequests).toHaveLength(0);
+		expect(state.needsAttention).toBe(false);
+	});
+
 	it("agent_start clears pending UI requests (server resolved them)", () => {
 		const state = makeState();
 		applySessionEvent(state, {

From 97528138f1596932279672317564a986229d2e22 Mon Sep 17 00:00:00 2001
From: Maximilian Scheurer <11406414+maxscheurer@users.noreply.github.com>
Date: Wed, 29 Jul 2026 08:58:08 +0200
Subject: [PATCH 04/15] Make ask_user available by default and render inline in
 the Dashboard

Availability: add ask_user to the default active-tool lists (agent-session
runtime and sdk) so it no longer needs an explicit --tools flag, and create
the ExtensionRunner unconditionally so the RPC-bound UI context reaches
built-in tools (previously ctx.ui.ask was a no-op without third-party
extensions). Restore a synchronous fast-path in _emitExtensionEvent via a new
hasExtensions getter so the async event queue still drains agent_end before
prompt() resolves.

Dashboard UX: render the ask_user question inline at the end of the transcript
instead of a blocking modal overlay, so the chat area stays scrollable while
the agent waits. Dismiss the request optimistically on answer/skip (the
response is fire-and-forget with no server acknowledgement event, so skip
previously left the dialog stuck until the next agent_start).

Tests: ask_user activation + UI context binding with no extensions; retry-test
mock runners declare hasExtensions; store.resolveUiRequest optimistic dismiss;
inline (non-modal) rendering assertions.
---
 .../coding-agent/src/core/agent-session.ts    | 31 +++++---
 .../src/core/extensions/runner.ts             | 10 +++
 packages/coding-agent/src/core/sdk.ts         |  1 +
 .../test/agent-session-dynamic-tools.test.ts  | 27 +++++++
 .../test/agent-session-retry.test.ts          |  4 +
 .../dashboard/src/client/screens/session.tsx  | 79 +++++++++++--------
 packages/dashboard/src/client/state/store.ts  | 10 +++
 packages/dashboard/src/client/styles/app.css  | 31 ++++++++
 .../dashboard/test/client/screens.test.tsx    |  4 +
 packages/dashboard/test/client/store.test.ts  | 27 +++++++
 10 files changed, 176 insertions(+), 48 deletions(-)

diff --git a/packages/coding-agent/src/core/agent-session.ts b/packages/coding-agent/src/core/agent-session.ts
index 9c69c554..1ad27da6 100644
--- a/packages/coding-agent/src/core/agent-session.ts
+++ b/packages/coding-agent/src/core/agent-session.ts
@@ -1099,7 +1099,12 @@ export class AgentSession {
 
 	/** Emit extension events based on agent events */
 	private async _emitExtensionEvent(event: AgentEvent): Promise<void> {
-		if (!this._extensionRunner) return;
+		// The runner is created unconditionally (so built-in tools like ask_user
+		// always have a UI context). When no extensions are loaded there are no
+		// handlers to invoke — return synchronously to avoid inserting an extra
+		// await tick per event, which would otherwise delay the final agent_end
+		// emission past when prompt() resolves.
+		if (!this._extensionRunner || !this._extensionRunner.hasExtensions) return;
 
 		if (event.type === "agent_start") {
 			this._turnIndex = 0;
@@ -3016,18 +3021,17 @@ export class AgentSession {
 			}
 		}
 
-		const hasExtensions = extensionsResult.extensions.length > 0;
-		const hasCustomTools = this._customTools.length > 0;
-		this._extensionRunner =
-			hasExtensions || hasCustomTools
-				? new ExtensionRunner(
-						extensionsResult.extensions,
-						extensionsResult.runtime,
-						this._cwd,
-						this.sessionManager,
-						this._modelRegistry,
-					)
-				: undefined;
+		// The runner also owns the cross-surface UI context used by built-in
+		// tools such as ask_user. Create it even when no third-party extensions
+		// are loaded; otherwise ordinary TUI/Dashboard sessions give base tools
+		// no ctx.ui and ask_user can never open its dialog.
+		this._extensionRunner = new ExtensionRunner(
+			extensionsResult.extensions,
+			extensionsResult.runtime,
+			this._cwd,
+			this.sessionManager,
+			this._modelRegistry,
+		);
 		if (this._extensionRunnerRef) {
 			this._extensionRunnerRef.current = this._extensionRunner;
 		}
@@ -3051,6 +3055,7 @@ export class AgentSession {
 					"subagent",
 					"wait",
 					"search",
+					"ask_user",
 					"skill",
 					"tasks_update",
 					"suggest_next",
diff --git a/packages/coding-agent/src/core/extensions/runner.ts b/packages/coding-agent/src/core/extensions/runner.ts
index d658bc25..2009317d 100644
--- a/packages/coding-agent/src/core/extensions/runner.ts
+++ b/packages/coding-agent/src/core/extensions/runner.ts
@@ -449,6 +449,16 @@ export class ExtensionRunner {
 		}
 	}
 
+	/**
+	 * Whether any extensions are loaded. The runner is now created
+	 * unconditionally so built-in tools (e.g. ask_user) always have a UI
+	 * context, but when no extensions are present there are no event handlers
+	 * to run — callers can skip the async emit path entirely.
+	 */
+	get hasExtensions(): boolean {
+		return this.extensions.length > 0;
+	}
+
 	hasHandlers(eventType: string): boolean {
 		for (const ext of this.extensions) {
 			const handlers = ext.handlers.get(eventType);
diff --git a/packages/coding-agent/src/core/sdk.ts b/packages/coding-agent/src/core/sdk.ts
index d4f274c6..727f0d34 100644
--- a/packages/coding-agent/src/core/sdk.ts
+++ b/packages/coding-agent/src/core/sdk.ts
@@ -277,6 +277,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		"web_fetch",
 		"subagent",
 		"wait",
+		"ask_user",
 	];
 	const initialActiveToolNames: string[] = options.tools
 		? [...options.tools.map((t) => t.name).filter((n): n is ToolName => n in allTools), ...alwaysActiveBuiltins]
diff --git a/packages/coding-agent/test/agent-session-dynamic-tools.test.ts b/packages/coding-agent/test/agent-session-dynamic-tools.test.ts
index 8dbee997..d92f0f21 100644
--- a/packages/coding-agent/test/agent-session-dynamic-tools.test.ts
+++ b/packages/coding-agent/test/agent-session-dynamic-tools.test.ts
@@ -91,6 +91,33 @@ describe("AgentSession dynamic tool registration", () => {
 		session.dispose();
 	});
 
+	it("keeps ask_user active and binds UI context when no extensions are installed", async () => {
+		const settingsManager = SettingsManager.create(tempDir, agentDir);
+		const sessionManager = SessionManager.inMemory();
+		const resourceLoader = new DefaultResourceLoader({ cwd: tempDir, agentDir, settingsManager });
+		await resourceLoader.reload();
+
+		const { session } = await createAgentSession({
+			cwd: tempDir,
+			agentDir,
+			model: findModel("anthropic", "sonnet")!,
+			settingsManager,
+			sessionManager,
+			resourceLoader,
+		});
+
+		expect(session.getActiveToolNames()).toContain("ask_user");
+		expect(session.extensionRunner).toBeDefined();
+		expect(session.extensionRunner?.hasUI()).toBe(false);
+
+		const ask = async () => ({ selected: ["SQLite"] });
+		await session.bindExtensions({ uiContext: { ask } as any });
+		expect(session.extensionRunner?.hasUI()).toBe(true);
+		expect(session.extensionRunner?.createContext().ui.ask).toBe(ask);
+
+		session.dispose();
+	});
+
 	it("returns source metadata for SDK custom tools", async () => {
 		const settingsManager = SettingsManager.create(tempDir, agentDir);
 		const sessionManager = SessionManager.inMemory();
diff --git a/packages/coding-agent/test/agent-session-retry.test.ts b/packages/coding-agent/test/agent-session-retry.test.ts
index a7f900fb..113303b0 100644
--- a/packages/coding-agent/test/agent-session-retry.test.ts
+++ b/packages/coding-agent/test/agent-session-retry.test.ts
@@ -49,6 +49,7 @@ function createAssistantMessage(text: string, overrides?: Partial<AssistantMessa
 type SessionWithExtensionEmitHook = {
 	_emitExtensionEvent: (event: AgentEvent) => Promise<void>;
 	_extensionRunner?: {
+		hasExtensions: boolean;
 		hasHandlers: (eventType: string) => boolean;
 		emit: (event: { type: string; [key: string]: unknown }) => Promise<void>;
 		emitBeforeAgentStart: () => Promise<undefined>;
@@ -250,6 +251,7 @@ describe("AgentSession retry", () => {
 		const extensionEvents: Array<{ type: string; [key: string]: unknown }> = [];
 		const sessionWithRunner = session as unknown as SessionWithExtensionEmitHook;
 		sessionWithRunner._extensionRunner = {
+			hasExtensions: true,
 			hasHandlers: () => false,
 			emit: async (event) => {
 				extensionEvents.push(event);
@@ -333,6 +335,7 @@ describe("AgentSession retry", () => {
 		const extensionEvents: Array<{ type: string; [key: string]: unknown }> = [];
 		const sessionWithRunner = session as unknown as SessionWithExtensionEmitHook;
 		sessionWithRunner._extensionRunner = {
+			hasExtensions: true,
 			hasHandlers: () => false,
 			emit: async (event) => {
 				extensionEvents.push(event);
@@ -409,6 +412,7 @@ describe("AgentSession retry", () => {
 		const extensionEvents: Array<{ type: string; [key: string]: unknown }> = [];
 		const sessionWithRunner = session as unknown as SessionWithExtensionEmitHook;
 		sessionWithRunner._extensionRunner = {
+			hasExtensions: true,
 			hasHandlers: () => false,
 			emit: async (event) => {
 				extensionEvents.push(event);
diff --git a/packages/dashboard/src/client/screens/session.tsx b/packages/dashboard/src/client/screens/session.tsx
index a7c8919d..3a663b0c 100644
--- a/packages/dashboard/src/client/screens/session.tsx
+++ b/packages/dashboard/src/client/screens/session.tsx
@@ -182,7 +182,7 @@ function ExtensionUiModal(props: {
 	);
 }
 
-function AskUiModal(props: {
+function AskUiInline(props: {
 	request: ExtensionUiRequest;
 	onRespond: (response: Record<string, unknown>) => void;
 }): JSX.Element {
@@ -214,22 +214,10 @@ function AskUiModal(props: {
 	};
 
 	return (
-		<Modal
-			title={props.request.title}
-			onDismiss={() => respond({ cancelled: true })}
-			actions={
-				<>
-					<button type="button" class="btn btn-small" onClick={() => respond({ cancelled: true })}>
-						skip
-					</button>
-					<button type="button" class="btn btn-small btn-primary" disabled={!canSubmit()} onClick={submit}>
-						submit
-					</button>
-				</>
-			}
-		>
+		<section class="ask-inline" aria-label={props.request.title}>
+			<header class="ask-inline-header">{props.request.title}</header>
 			<Show when={props.request.question}>
-				<p style={{ "margin-bottom": "12px" }}>{props.request.question}</p>
+				<p class="ask-inline-question">{props.request.question}</p>
 			</Show>
 			<Show when={options().length > 0}>
 				<fieldset class="ask-options">
@@ -275,7 +263,15 @@ function AskUiModal(props: {
 					</Show>
 				</div>
 			</Show>
-		</Modal>
+			<div class="ask-inline-actions">
+				<button type="button" class="btn btn-small" onClick={() => respond({ cancelled: true })}>
+					skip
+				</button>
+				<button type="button" class="btn btn-small btn-primary" disabled={!canSubmit()} onClick={submit}>
+					submit
+				</button>
+			</div>
+		</section>
 	);
 }
 
@@ -564,6 +560,22 @@ export function SessionScreen(props: { store: AppStore; sessionKey: string }): J
 		}
 	}
 
+	// Answer or skip an extension UI request. Dismiss the dialog optimistically
+	// so it disappears immediately — the response is fire-and-forget and the
+	// server emits no acknowledgement event, so nothing else would clear it
+	// until the next agent_start (that's why skip previously appeared stuck).
+	const respondToUiRequest = async (response: Record<string, unknown>) => {
+		const id = response.id;
+		if (typeof id === "string") {
+			props.store.resolveUiRequest(props.sessionKey, id);
+		}
+		try {
+			await api.extensionUiResponse(props.sessionKey, response);
+		} catch (err) {
+			setActionError(err instanceof Error ? err.message : String(err));
+		}
+	};
+
 	function bytesFromBase64(data: string): Uint8Array<ArrayBuffer> {
 		const binary = atob(data);
 		return Uint8Array.from(binary, (char) => char.charCodeAt(0));
@@ -1270,6 +1282,13 @@ export function SessionScreen(props: { store: AppStore; sessionKey: string }): J
 							resetKey={props.sessionKey}
 							imageScope={{ runtimeKey: props.sessionKey }}
 						/>
+						<Show when={session()!.uiRequests[0]} keyed>
+							{(request) => (
+								<Show when={request.method === "ask"}>
+									<AskUiInline request={request} onRespond={respondToUiRequest} />
+								</Show>
+							)}
+						</Show>
 						<For each={session()!.widgets.below}>{(line) => <div class="widget-block">{line}</div>}</For>
 					</Show>
 				</div>
@@ -1635,24 +1654,14 @@ export function SessionScreen(props: { store: AppStore; sessionKey: string }): J
 				</Show>
 			</footer>
 
-			<Show when={session()?.uiRequests[0]}>
-				{(request) => {
-					const onRespond = async (response: Record<string, unknown>) => {
-						try {
-							await api.extensionUiResponse(props.sessionKey, response);
-						} catch (err) {
-							setActionError(err instanceof Error ? err.message : String(err));
-						}
-					};
-					return (
-						<Show
-							when={request().method === "ask"}
-							fallback={<ExtensionUiModal request={request()} onRespond={onRespond} />}
-						>
-							<AskUiModal request={request()} onRespond={onRespond} />
-						</Show>
-					);
-				}}
+			<Show when={session()?.uiRequests[0]} keyed>
+				{(request) => (
+					// ask_user renders inline in the transcript (see .chat-inner); only
+					// the other extension UI methods use a blocking modal overlay.
+					<Show when={request.method !== "ask"}>
+						<ExtensionUiModal request={request} onRespond={respondToUiRequest} />
+					</Show>
+				)}
 			</Show>
 
 			<Show when={showModelSelector()}>
diff --git a/packages/dashboard/src/client/state/store.ts b/packages/dashboard/src/client/state/store.ts
index a8fbc27f..08112bfd 100644
--- a/packages/dashboard/src/client/state/store.ts
+++ b/packages/dashboard/src/client/state/store.ts
@@ -26,6 +26,7 @@ import {
 	deriveProviderErrorState,
 	dismissToast as dismissReducerToast,
 	messagesToEntries,
+	resolveUiRequest as resolveReducerUiRequest,
 	type SessionViewState,
 	type Toast,
 } from "./reducer.js";
@@ -991,6 +992,15 @@ export function createAppStore() {
 		start,
 		stop,
 		dismissToast,
+		/**
+		 * Optimistically dismiss an extension UI request (ask/select/confirm/…)
+		 * as soon as the user answers or skips, so the dialog disappears
+		 * immediately without waiting for a server round-trip or the next
+		 * agent_start. Safe to call for an already-removed id (no-op).
+		 */
+		resolveUiRequest(key: string, id: string): void {
+			mutateSession(key, (session) => resolveReducerUiRequest(session, id));
+		},
 		hydrateSession,
 		hydrateSubagent,
 	};
diff --git a/packages/dashboard/src/client/styles/app.css b/packages/dashboard/src/client/styles/app.css
index 8b81b0a2..de1c7e0b 100644
--- a/packages/dashboard/src/client/styles/app.css
+++ b/packages/dashboard/src/client/styles/app.css
@@ -2209,6 +2209,37 @@ details.thinking .thinking-body {
 
 /* ------------------------------------------------------------- ask_user dialog */
 
+/* Inline ask card — flows at the end of the transcript so the whole chat area
+   stays scrollable while the agent waits for an answer. */
+.ask-inline {
+	display: flex;
+	flex-direction: column;
+	gap: var(--space-2);
+	margin: var(--space-3) 0;
+	padding: var(--space-3);
+	border: var(--hairline);
+	border-left: 3px solid var(--status-running);
+	border-radius: var(--radius);
+	background: color-mix(in srgb, var(--status-running) 6%, var(--surface, transparent));
+}
+
+.ask-inline-header {
+	font-weight: 600;
+	color: var(--text);
+}
+
+.ask-inline-question {
+	margin: 0 0 var(--space-2);
+	color: var(--text);
+}
+
+.ask-inline-actions {
+	display: flex;
+	justify-content: flex-end;
+	gap: var(--space-2);
+	margin-top: var(--space-1);
+}
+
 .ask-options {
 	display: flex;
 	flex-direction: column;
diff --git a/packages/dashboard/test/client/screens.test.tsx b/packages/dashboard/test/client/screens.test.tsx
index c1fbd17a..339cc8f6 100644
--- a/packages/dashboard/test/client/screens.test.tsx
+++ b/packages/dashboard/test/client/screens.test.tsx
@@ -1085,6 +1085,10 @@ describe("screen smoke tests", () => {
 		await new Promise((resolve) => setTimeout(resolve, 0));
 
 		expect(el.textContent).toContain("Which checks?");
+		// ask_user renders inline in the transcript flow (scrollable), not as a
+		// blocking modal overlay.
+		expect(el.querySelector(".chat-inner .ask-inline")).not.toBeNull();
+		expect(el.querySelector(".modal-backdrop")).toBeNull();
 		const checkboxes = el.querySelectorAll<HTMLInputElement>('.ask-option input[type="checkbox"]');
 		expect(checkboxes.length).toBe(2);
 		expect(el.querySelector('.ask-option input[type="radio"]')).toBeNull();
diff --git a/packages/dashboard/test/client/store.test.ts b/packages/dashboard/test/client/store.test.ts
index 61816031..f7c9d162 100644
--- a/packages/dashboard/test/client/store.test.ts
+++ b/packages/dashboard/test/client/store.test.ts
@@ -486,6 +486,33 @@ describe("app store SSE sync", () => {
 		expect(store.sessions.a?.needsAttention).toBe(false);
 	});
 
+	it("resolveUiRequest optimistically dismisses an ask request and clears attention", async () => {
+		const store = await makeStartedStore();
+
+		emit("a", {
+			type: "extension_ui_request",
+			method: "ask",
+			id: "ask-1",
+			title: "Choose a database",
+			question: "Which one?",
+			options: ["SQLite", "Postgres"],
+		});
+		expect(store.sessions.a?.uiRequests).toMatchObject([{ id: "ask-1", method: "ask" }]);
+		expect(store.sessions.a?.needsAttention).toBe(true);
+
+		// Skipping/answering removes the dialog immediately — there is no server
+		// acknowledgement event, so without this the dialog would linger until
+		// the next agent_start.
+		store.resolveUiRequest("a", "ask-1");
+
+		expect(store.sessions.a?.uiRequests).toEqual([]);
+		expect(store.sessions.a?.needsAttention).toBe(false);
+
+		// Idempotent — resolving an already-removed id is a safe no-op.
+		store.resolveUiRequest("a", "ask-1");
+		expect(store.sessions.a?.uiRequests).toEqual([]);
+	});
+
 	it("clears stale extension UI state before replaying post-barrier requests", async () => {
 		const snapshot = runtimeSnapshot("a", false);
 		const request = deferred<Awaited<ReturnType<typeof api.resync>>>();

From df5b3dd30e248ceb14378d3ff1b26e695aa125d6 Mon Sep 17 00:00:00 2001
From: Maximilian Scheurer <11406414+maxscheurer@users.noreply.github.com>
Date: Wed, 29 Jul 2026 09:09:52 +0200
Subject: [PATCH 05/15] Dashboard ask_user: collapse tool card, use attention
 accent for the inline card
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The ask_user tool call 'runs' for the whole time it awaits an answer, so it
was force-opened (and un-collapsible) like other in-flight tools, showing a
redundant options JSON dump. Exempt ask_user from force-open-while-running so
its tool card stays collapsed by default and the user can expand/collapse it
freely; the inline question card carries the actual UI.

Recolor the inline question card's accent bar and tint from --status-running
(green) to --status-attention (orange in the default theme) so it matches the
session's needs-attention signal — an unanswered question is the primary
your-move cue. (Needs-attention already fires for ask requests via uiRequests.)

Test: ask_user tool card stays collapsed while running, while a running bash
card auto-opens.
---
 .../src/client/components/transcript.tsx      | 11 +++--
 packages/dashboard/src/client/styles/app.css  |  6 ++-
 .../dashboard/test/client/screens.test.tsx    | 41 +++++++++++++++++++
 3 files changed, 53 insertions(+), 5 deletions(-)

diff --git a/packages/dashboard/src/client/components/transcript.tsx b/packages/dashboard/src/client/components/transcript.tsx
index 38f433d7..6ec893e4 100644
--- a/packages/dashboard/src/client/components/transcript.tsx
+++ b/packages/dashboard/src/client/components/transcript.tsx
@@ -590,7 +590,12 @@ function ToolCard(props: { entry: ToolEntry; imageScope: TranscriptImageScope })
 	const isBash = () => props.entry.toolName === "bash" || props.entry.toolName === "bash (user)";
 	const inputSections = () => toolInputSections(props.entry);
 	const autoOpen = () => isToolAutoOpen(props.entry.toolName);
-	const [open, setOpen] = createSignal(autoOpen() || props.entry.status === "running");
+	// ask_user "runs" for the entire time it waits on the user, and its body
+	// (the raw options JSON) is redundant with the inline question card. Keep it
+	// collapsed by default and let the user expand/collapse freely instead of
+	// force-opening it while running like other in-flight tools.
+	const forceOpenWhileRunning = props.entry.toolName !== "ask_user";
+	const [open, setOpen] = createSignal(autoOpen() || (props.entry.status === "running" && forceOpenWhileRunning));
 	let wasRunning = props.entry.status === "running";
 	let userToggled = false;
 	let suppressToggle = false;
@@ -608,7 +613,7 @@ function ToolCard(props: { entry: ToolEntry; imageScope: TranscriptImageScope })
 	createEffect(() => {
 		const running = props.entry.status === "running";
 		const shouldAutoOpen = autoOpen();
-		if (running) {
+		if (running && forceOpenWhileRunning) {
 			userToggled = false;
 			setProgrammaticOpen(true);
 		} else if (wasRunning) {
@@ -632,7 +637,7 @@ function ToolCard(props: { entry: ToolEntry; imageScope: TranscriptImageScope })
 					setOpen(next);
 					return;
 				}
-				if (props.entry.status === "running" && !next) {
+				if (props.entry.status === "running" && forceOpenWhileRunning && !next) {
 					suppressToggle = true;
 					event.currentTarget.open = true;
 					setOpen(true);
diff --git a/packages/dashboard/src/client/styles/app.css b/packages/dashboard/src/client/styles/app.css
index de1c7e0b..a8e6b9f9 100644
--- a/packages/dashboard/src/client/styles/app.css
+++ b/packages/dashboard/src/client/styles/app.css
@@ -2218,9 +2218,11 @@ details.thinking .thinking-body {
 	margin: var(--space-3) 0;
 	padding: var(--space-3);
 	border: var(--hairline);
-	border-left: 3px solid var(--status-running);
+	/* Match the needs-attention accent (orange in the default theme) — an
+	   unanswered question is the primary "your move" signal for the session. */
+	border-left: 3px solid var(--status-attention);
 	border-radius: var(--radius);
-	background: color-mix(in srgb, var(--status-running) 6%, var(--surface, transparent));
+	background: color-mix(in srgb, var(--status-attention) 6%, var(--surface, transparent));
 }
 
 .ask-inline-header {
diff --git a/packages/dashboard/test/client/screens.test.tsx b/packages/dashboard/test/client/screens.test.tsx
index 339cc8f6..939b8b9d 100644
--- a/packages/dashboard/test/client/screens.test.tsx
+++ b/packages/dashboard/test/client/screens.test.tsx
@@ -1141,6 +1141,47 @@ describe("screen smoke tests", () => {
 		);
 	});
 
+	it("ask_user tool card stays collapsed while running (unlike other running tools)", async () => {
+		const store = makeStore() as any;
+		const session = createSessionViewState("k-ask-collapse");
+		session.entries = [
+			{
+				kind: "tool",
+				toolCallId: "ask-tc",
+				toolName: "ask_user",
+				args: { title: "Favorite Composer", options: ["Bach", "Mozart"] },
+				status: "running",
+				resultText: "",
+				startedAt: Date.now(),
+			},
+			{
+				kind: "tool",
+				toolCallId: "bash-tc",
+				toolName: "bash",
+				args: { command: "pwd" },
+				status: "running",
+				resultText: "",
+				startedAt: Date.now(),
+			},
+		] as any;
+		const fakeStore = {
+			...store,
+			sessions: { "k-ask-collapse": session },
+			fleet: () => ({ runtimes: [], diskSessions: [] }),
+			hydrateSession: async () => {},
+		};
+		const el = mount(() => <SessionScreen store={fakeStore} sessionKey="k-ask-collapse" />);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		const cards = [...el.querySelectorAll<HTMLDetailsElement>("details.tool")];
+		const askCard = cards.find((c) => c.querySelector(".tool-name")?.textContent === "ask_user");
+		const bashCard = cards.find((c) => c.querySelector(".tool-name")?.textContent === "bash");
+		if (!askCard || !bashCard) throw new Error("expected both tool cards to render");
+		// The still-running ask_user card is collapsed; a normal running tool (bash) auto-opens.
+		expect(askCard.open).toBe(false);
+		expect(bashCard.open).toBe(true);
+	});
+
 	it("session header prefers live session_name_changed state", () => {
 		const store = makeStore() as any;
 		const session = createSessionViewState("k-live");

From 9c7d0fd2ceafb6fcc6116cb312c9405768a23a63 Mon Sep 17 00:00:00 2001
From: Maximilian Scheurer <11406414+maxscheurer@users.noreply.github.com>
Date: Wed, 29 Jul 2026 11:16:38 +0200
Subject: [PATCH 06/15] Fix ask_user dialog lifecycle failures

---
 packages/coding-agent/docs/rpc.md             | 13 ++++-
 .../src/modes/interactive/interactive-mode.ts | 43 ++++++++++++---
 .../coding-agent/src/modes/rpc/rpc-mode.ts    | 54 ++++++++++---------
 .../test/interactive-mode-status.test.ts      | 32 +++++++++++
 .../dashboard/src/client/screens/session.tsx  | 18 ++++---
 .../dashboard/src/client/state/reducer.ts     |  4 ++
 .../dashboard/test/client/screens.test.tsx    | 32 +++++++++++
 packages/dashboard/test/reducer.test.ts       | 10 ++++
 packages/dashboard/test/runtime-pool.test.ts  |  4 +-
 9 files changed, 169 insertions(+), 41 deletions(-)

diff --git a/packages/coding-agent/docs/rpc.md b/packages/coding-agent/docs/rpc.md
index 2648fe53..0b7a4d78 100644
--- a/packages/coding-agent/docs/rpc.md
+++ b/packages/coding-agent/docs/rpc.md
@@ -2063,7 +2063,7 @@ Set the text in the input editor. Fire-and-forget.
 
 ### Extension UI Responses (stdin)
 
-Responses are sent for dialog methods only (`select`, `confirm`, `input`, `editor`). The `id` must match the request.
+Responses are sent for dialog methods only (`select`, `confirm`, `input`, `editor`, `ask`). The `id` must match the request.
 
 #### Value response (select, input, editor)
 
@@ -2085,6 +2085,17 @@ Dismiss any dialog method. The extension receives `undefined` (for select/input/
 {"type": "extension_ui_response", "id": "uuid-3", "cancelled": true}
 ```
 
+After any dialog settles, RPC emits a lifecycle event on stdout so hosts can
+remove the matching UI even when the dialog ended locally because of timeout,
+abort, or runtime shutdown:
+
+```json
+{"type": "extension_ui_response_handled", "id": "uuid-3"}
+```
+
+Hosts should treat this event as idempotent; it can arrive after the host has
+already removed a successfully answered request.
+
 ## Error Handling
 
 Failed commands return a response with `success: false`:
diff --git a/packages/coding-agent/src/modes/interactive/interactive-mode.ts b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
index f5e4ca69..02b21aa2 100644
--- a/packages/coding-agent/src/modes/interactive/interactive-mode.ts
+++ b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
@@ -258,6 +258,7 @@ export class InteractiveMode {
 	private extensionInput: ExtensionInputComponent | undefined = undefined;
 	private extensionEditor: ExtensionEditorComponent | undefined = undefined;
 	private extensionAsk: AskUserComponent | undefined = undefined;
+	private extensionDialogQueue: Promise<void> = Promise.resolve();
 	private extensionTerminalInputUnsubscribers = new Set<() => void>();
 
 	// Extension widgets (components rendered above/below the editor)
@@ -1781,10 +1782,26 @@ export class InteractiveMode {
 	 */
 	private createExtensionUIContext(): ExtensionUIContext {
 		return {
-			select: (title, options, opts) => this.showExtensionSelector(title, options, opts),
-			confirm: (title, message, opts) => this.showExtensionConfirm(title, message, opts),
-			input: (title, placeholder, opts) => this.showExtensionInput(title, placeholder, opts),
-			ask: (request, opts) => this.showExtensionAsk(request, opts),
+			select: (title, options, opts) =>
+				this.enqueueExtensionDialog(() => this.showExtensionSelector(title, options, opts), {
+					signal: opts?.signal,
+					abortedValue: undefined,
+				}),
+			confirm: (title, message, opts) =>
+				this.enqueueExtensionDialog(() => this.showExtensionConfirm(title, message, opts), {
+					signal: opts?.signal,
+					abortedValue: false,
+				}),
+			input: (title, placeholder, opts) =>
+				this.enqueueExtensionDialog(() => this.showExtensionInput(title, placeholder, opts), {
+					signal: opts?.signal,
+					abortedValue: undefined,
+				}),
+			ask: (request, opts) =>
+				this.enqueueExtensionDialog(() => this.showExtensionAsk(request, opts), {
+					signal: opts?.signal,
+					abortedValue: undefined,
+				}),
 			notify: (message, type) => this.showExtensionNotify(message, type),
 			onTerminalInput: (handler) => this.addExtensionTerminalInputListener(handler),
 			setStatus: (key, text) => this.setExtensionStatus(key, text),
@@ -1793,11 +1810,11 @@ export class InteractiveMode {
 			setFooter: (factory) => this.setExtensionFooter(factory),
 			setHeader: (factory) => this.setExtensionHeader(factory),
 			setTitle: (title) => this.ui.terminal.setTitle(title),
-			custom: (factory, options) => this.showExtensionCustom(factory, options),
+			custom: (factory, options) => this.enqueueExtensionDialog(() => this.showExtensionCustom(factory, options)),
 			pasteToEditor: (text) => this.editor.handleInput(`\x1b[200~${text}\x1b[201~`),
 			setEditorText: (text) => this.editor.setText(text),
 			getEditorText: () => this.editor.getExpandedText?.() ?? this.editor.getText(),
-			editor: (title, prefill) => this.showExtensionEditor(title, prefill),
+			editor: (title, prefill) => this.enqueueExtensionDialog(() => this.showExtensionEditor(title, prefill)),
 			setEditorComponent: (factory) => this.setCustomEditorComponent(factory),
 			get theme() {
 				return theme;
@@ -1824,6 +1841,20 @@ export class InteractiveMode {
 		};
 	}
 
+	/** Serialize every blocking extension dialog that can take over keyboard focus. */
+	private enqueueExtensionDialog<T>(
+		open: () => Promise<T>,
+		opts?: { signal?: AbortSignal; abortedValue: T },
+	): Promise<T> {
+		const run = () => (opts?.signal?.aborted ? Promise.resolve(opts.abortedValue) : open());
+		const result = this.extensionDialogQueue.then(run, run);
+		this.extensionDialogQueue = result.then(
+			() => undefined,
+			() => undefined,
+		);
+		return result;
+	}
+
 	/**
 	 * Show a selector for extensions.
 	 */
diff --git a/packages/coding-agent/src/modes/rpc/rpc-mode.ts b/packages/coding-agent/src/modes/rpc/rpc-mode.ts
index e4ea6fd7..7c77a4f7 100644
--- a/packages/coding-agent/src/modes/rpc/rpc-mode.ts
+++ b/packages/coding-agent/src/modes/rpc/rpc-mode.ts
@@ -1064,32 +1064,44 @@ export async function runRpcMode(session: AgentSession, modelFallbackMessage?: s
 		const id = crypto.randomUUID();
 		return new Promise((resolve, reject) => {
 			let timeoutId: ReturnType<typeof setTimeout> | undefined;
+			let settled = false;
 
-			const cleanup = () => {
+			const cleanup = (): boolean => {
+				if (settled) return false;
+				settled = true;
 				if (timeoutId) clearTimeout(timeoutId);
 				opts?.signal?.removeEventListener("abort", onAbort);
 				pendingExtensionRequests.delete(id);
+				output({ type: "extension_ui_response_handled", id });
+				return true;
 			};
 
 			const onAbort = () => {
-				cleanup();
+				if (!cleanup()) return;
 				resolve(defaultValue);
 			};
 			opts?.signal?.addEventListener("abort", onAbort, { once: true });
 
 			if (opts?.timeout) {
 				timeoutId = setTimeout(() => {
-					cleanup();
+					if (!cleanup()) return;
 					resolve(defaultValue);
 				}, opts.timeout);
 			}
 
 			pendingExtensionRequests.set(id, {
 				resolve: (response: RpcExtensionUIResponse) => {
-					cleanup();
-					resolve(parseResponse(response));
+					if (!cleanup()) return;
+					try {
+						resolve(parseResponse(response));
+					} catch (error) {
+						reject(error);
+					}
+				},
+				reject: (error) => {
+					if (!cleanup()) return;
+					reject(error);
 				},
-				reject,
 			});
 			output({ type: "extension_ui_request", id, ...request } as RpcExtensionUIRequest);
 		});
@@ -1226,24 +1238,14 @@ export async function runRpcMode(session: AgentSession, modelFallbackMessage?: s
 			return "";
 		},
 
-		async editor(title: string, prefill?: string): Promise<string | undefined> {
-			const id = crypto.randomUUID();
-			return new Promise((resolve, reject) => {
-				pendingExtensionRequests.set(id, {
-					resolve: (response: RpcExtensionUIResponse) => {
-						if ("cancelled" in response && response.cancelled) {
-							resolve(undefined);
-						} else if ("value" in response) {
-							resolve(response.value);
-						} else {
-							resolve(undefined);
-						}
-					},
-					reject,
-				});
-				output({ type: "extension_ui_request", id, method: "editor", title, prefill } as RpcExtensionUIRequest);
-			});
-		},
+		editor: (title, prefill) =>
+			createDialogPromise(undefined, undefined, { method: "editor", title, prefill }, (response) =>
+				"cancelled" in response && response.cancelled
+					? undefined
+					: "value" in response
+						? response.value
+						: undefined,
+			),
 
 		setEditorComponent(): void {
 			// Custom editor components not supported in RPC mode
@@ -1827,6 +1829,10 @@ export async function runRpcMode(session: AgentSession, modelFallbackMessage?: s
 	let detachInput = () => {};
 
 	async function shutdown(): Promise<never> {
+		for (const [id, pending] of [...pendingExtensionRequests]) {
+			pending.resolve({ type: "extension_ui_response", id, cancelled: true });
+		}
+
 		const currentRunner = session.extensionRunner;
 		if (currentRunner?.hasHandlers("session_shutdown")) {
 			await currentRunner.emit({ type: "session_shutdown" });
diff --git a/packages/coding-agent/test/interactive-mode-status.test.ts b/packages/coding-agent/test/interactive-mode-status.test.ts
index d5522024..5a35d7d2 100644
--- a/packages/coding-agent/test/interactive-mode-status.test.ts
+++ b/packages/coding-agent/test/interactive-mode-status.test.ts
@@ -480,6 +480,38 @@ describe("InteractiveMode.createExtensionUIContext setTheme", () => {
 	});
 });
 
+describe("InteractiveMode extension dialog queue", () => {
+	test("serializes ask with other blocking extension dialogs", async () => {
+		let resolveSelector!: (value: string | undefined) => void;
+		const showExtensionSelector = vi.fn(
+			() =>
+				new Promise<string | undefined>((resolve) => {
+					resolveSelector = resolve;
+				}),
+		);
+		const showExtensionAsk = vi.fn(async () => ({ selected: ["yes"] }));
+		const fakeThis: any = {
+			extensionDialogQueue: Promise.resolve(),
+			enqueueExtensionDialog: (InteractiveMode as any).prototype.enqueueExtensionDialog,
+			showExtensionSelector,
+			showExtensionAsk,
+		};
+		const uiContext = (InteractiveMode as any).prototype.createExtensionUIContext.call(fakeThis);
+
+		const selector = uiContext.select("First", ["a", "b"]);
+		const ask = uiContext.ask({ question: "Second?", options: ["yes", "no"] });
+		await Promise.resolve();
+
+		expect(showExtensionSelector).toHaveBeenCalledTimes(1);
+		expect(showExtensionAsk).not.toHaveBeenCalled();
+
+		resolveSelector("a");
+		await expect(selector).resolves.toBe("a");
+		await expect(ask).resolves.toEqual({ selected: ["yes"] });
+		expect(showExtensionAsk).toHaveBeenCalledTimes(1);
+	});
+});
+
 describe("InteractiveMode.showLoadedResources", () => {
 	beforeAll(() => {
 		initTheme("dark");
diff --git a/packages/dashboard/src/client/screens/session.tsx b/packages/dashboard/src/client/screens/session.tsx
index 3a663b0c..4b3566be 100644
--- a/packages/dashboard/src/client/screens/session.tsx
+++ b/packages/dashboard/src/client/screens/session.tsx
@@ -560,19 +560,21 @@ export function SessionScreen(props: { store: AppStore; sessionKey: string }): J
 		}
 	}
 
-	// Answer or skip an extension UI request. Dismiss the dialog optimistically
-	// so it disappears immediately — the response is fire-and-forget and the
-	// server emits no acknowledgement event, so nothing else would clear it
-	// until the next agent_start (that's why skip previously appeared stuck).
+	// Keep a question visible until the server accepts its response. Removing it
+	// before the POST succeeds would leave an unreachable RPC promise on network
+	// or authentication failure. The in-flight set also prevents duplicate sends.
+	const uiResponsesInFlight = new Set<string>();
 	const respondToUiRequest = async (response: Record<string, unknown>) => {
-		const id = response.id;
-		if (typeof id === "string") {
-			props.store.resolveUiRequest(props.sessionKey, id);
-		}
+		const id = typeof response.id === "string" ? response.id : undefined;
+		if (id && uiResponsesInFlight.has(id)) return;
+		if (id) uiResponsesInFlight.add(id);
 		try {
 			await api.extensionUiResponse(props.sessionKey, response);
+			if (id) props.store.resolveUiRequest(props.sessionKey, id);
 		} catch (err) {
 			setActionError(err instanceof Error ? err.message : String(err));
+		} finally {
+			if (id) uiResponsesInFlight.delete(id);
 		}
 	};
 
diff --git a/packages/dashboard/src/client/state/reducer.ts b/packages/dashboard/src/client/state/reducer.ts
index 7af67920..c8bb2e84 100644
--- a/packages/dashboard/src/client/state/reducer.ts
+++ b/packages/dashboard/src/client/state/reducer.ts
@@ -803,6 +803,10 @@ export function applySessionEvent(state: SessionViewState, event: any): void {
 			});
 			break;
 		}
+		case "extension_ui_response_handled": {
+			resolveUiRequest(state, String(event.id));
+			break;
+		}
 		case "extension_ui_request": {
 			const method = event.method as string;
 			if (method === "select" || method === "confirm" || method === "input" || method === "editor") {
diff --git a/packages/dashboard/test/client/screens.test.tsx b/packages/dashboard/test/client/screens.test.tsx
index 939b8b9d..fb0e72da 100644
--- a/packages/dashboard/test/client/screens.test.tsx
+++ b/packages/dashboard/test/client/screens.test.tsx
@@ -1141,6 +1141,38 @@ describe("screen smoke tests", () => {
 		);
 	});
 
+	it("keeps an ask request recoverable when sending the response fails", async () => {
+		const store = makeStore() as any;
+		const session = createSessionViewState("k-ask-retry");
+		session.uiRequests = [
+			{ id: "a-retry", method: "ask", title: "Retry", question: "Still there?", options: ["A", "B"] },
+		];
+		const resolveUiRequest = vi.fn();
+		const fakeStore = {
+			...store,
+			sessions: { "k-ask-retry": session },
+			fleet: () => ({ runtimes: [], diskSessions: [] }),
+			hydrateSession: async () => {},
+			resolveUiRequest,
+		};
+		vi.mocked(api.extensionUiResponse).mockRejectedValueOnce(new Error("offline"));
+		const el = mount(() => <SessionScreen store={fakeStore} sessionKey="k-ask-retry" />);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		const skip = [...el.querySelectorAll("button")].find((button) => button.textContent === "skip");
+		skip?.click();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		expect(resolveUiRequest).not.toHaveBeenCalled();
+		expect(el.querySelector(".ask-inline")).not.toBeNull();
+		expect(el.textContent).toContain("offline");
+
+		vi.mocked(api.extensionUiResponse).mockResolvedValueOnce({ ok: true });
+		skip?.click();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		expect(resolveUiRequest).toHaveBeenCalledWith("k-ask-retry", "a-retry");
+	});
+
 	it("ask_user tool card stays collapsed while running (unlike other running tools)", async () => {
 		const store = makeStore() as any;
 		const session = createSessionViewState("k-ask-collapse");
diff --git a/packages/dashboard/test/reducer.test.ts b/packages/dashboard/test/reducer.test.ts
index dedcdacd..4c4a3072 100644
--- a/packages/dashboard/test/reducer.test.ts
+++ b/packages/dashboard/test/reducer.test.ts
@@ -958,6 +958,16 @@ describe("applySessionEvent — extension UI", () => {
 		expect(state.needsAttention).toBe(false);
 	});
 
+	it("handled events dismiss requests that timed out or aborted in the runtime", () => {
+		const state = makeState();
+		applySessionEvent(state, { type: "extension_ui_request", id: "u1", method: "confirm", title: "Proceed?" });
+
+		applySessionEvent(state, { type: "extension_ui_response_handled", id: "u1" });
+
+		expect(state.uiRequests).toHaveLength(0);
+		expect(state.needsAttention).toBe(false);
+	});
+
 	it("ask requests populate uiRequests with question/options and set attention", () => {
 		const state = makeState();
 		applySessionEvent(state, {
diff --git a/packages/dashboard/test/runtime-pool.test.ts b/packages/dashboard/test/runtime-pool.test.ts
index cc38099b..397c8849 100644
--- a/packages/dashboard/test/runtime-pool.test.ts
+++ b/packages/dashboard/test/runtime-pool.test.ts
@@ -520,12 +520,12 @@ describe("RuntimePool", () => {
 		expect(seen).toEqual([[handle.key, { type: "agent_start" }]]);
 	});
 
-	it("tracks needs-attention from extension UI requests and clears on agent_start", async () => {
+	it("tracks needs-attention from extension UI requests and clears when handled", async () => {
 		const { pool, clients } = makePool();
 		const handle = await pool.create("/tmp");
 		clients[0].emit({ type: "extension_ui_request", id: "u1", method: "confirm" });
 		expect(handle.attention.size).toBe(1);
-		clients[0].emit({ type: "agent_start" });
+		clients[0].emit({ type: "extension_ui_response_handled", id: "u1" });
 		expect(handle.attention.size).toBe(0);
 	});
 

From 9991463b43a29c0346b897c969de0edfc0b8aaf2 Mon Sep 17 00:00:00 2001
From: Maximilian Scheurer <11406414+maxscheurer@users.noreply.github.com>
Date: Wed, 29 Jul 2026 13:43:46 +0200
Subject: [PATCH 07/15] ask_user: fix TUI single-select parity, add RPC and TUI
 host tests

---
 .../modes/interactive/components/ask-user.ts  |   5 +-
 .../coding-agent/src/modes/rpc/rpc-mode.ts    | 104 +++++++------
 .../test/ask-user-component.test.ts           |  12 ++
 .../test/interactive-mode-status.test.ts      | 128 ++++++++++++++++
 .../test/rpc-extension-ui-ask.test.ts         | 140 ++++++++++++++++++
 5 files changed, 344 insertions(+), 45 deletions(-)
 create mode 100644 packages/coding-agent/test/rpc-extension-ui-ask.test.ts

diff --git a/packages/coding-agent/src/modes/interactive/components/ask-user.ts b/packages/coding-agent/src/modes/interactive/components/ask-user.ts
index 295439a3..829acd56 100644
--- a/packages/coding-agent/src/modes/interactive/components/ask-user.ts
+++ b/packages/coding-agent/src/modes/interactive/components/ask-user.ts
@@ -196,7 +196,10 @@ export class AskUserComponent extends Container implements Focusable {
 			return { selected: [], customText };
 		}
 		const option = this.options[this.cursorIndex];
-		return option ? { selected: [option], customText: undefined } : undefined;
+		// Single-select: submit the highlighted option together with any typed
+		// free text, matching the Dashboard, which combines a radio selection with
+		// custom text (and the tool's own combined-answer result formatting).
+		return option ? { selected: [option], customText } : undefined;
 	}
 
 	private submit(): void {
diff --git a/packages/coding-agent/src/modes/rpc/rpc-mode.ts b/packages/coding-agent/src/modes/rpc/rpc-mode.ts
index 7c77a4f7..3ff78dd3 100644
--- a/packages/coding-agent/src/modes/rpc/rpc-mode.ts
+++ b/packages/coding-agent/src/modes/rpc/rpc-mode.ts
@@ -1010,48 +1010,16 @@ export async function navigateTreeForRpc(
  * Run in RPC mode.
  * Listens for JSON commands on stdin, outputs events and responses on stdout.
  */
-export async function runRpcMode(session: AgentSession, modelFallbackMessage?: string): Promise<never> {
-	takeOverStdout();
-
-	const output = (obj: RpcResponse | RpcExtensionUIRequest | object) => {
-		writeRawStdout(serializeJsonLine(obj));
-	};
-
-	const success = <T extends RpcCommand["type"]>(
-		id: string | undefined,
-		command: T,
-		data?: object | null,
-	): RpcResponse => {
-		if (data === undefined) {
-			return { id, type: "response", command, success: true } as RpcResponse;
-		}
-		return { id, type: "response", command, success: true, data } as RpcResponse;
-	};
-
-	const error = (id: string | undefined, command: string, message: string): RpcResponse => {
-		return { id, type: "response", command, success: false, error: message };
-	};
-
-	if (session.sessionFile && session.messages.length > 0) {
-		const rehydratedCount = rehydrateBackgroundAgentsFromDisk(session.sessionFile);
-		if (rehydratedCount > 0) {
-			console.error(
-				`[rpc] Rehydrated ${rehydratedCount} background subagent${rehydratedCount === 1 ? "" : "s"} from disk`,
-			);
-		}
-	}
-
-	// Pending extension UI requests waiting for response
-	const pendingExtensionRequests = new Map<
-		string,
-		{ resolve: (value: any) => void; reject: (error: Error) => void }
-	>();
-
-	// Shutdown request flag
-	let shutdownRequested = false;
-	let dailyCostTracker: DailyCostTracker | undefined;
-	let dailyCostTrackerPrimed = false;
-
+/**
+ * Build the RPC-mode extension UI context. Extracted from `runRpcMode` so the
+ * dialog request emission and response mapping (select/confirm/input/ask/editor)
+ * can be unit-tested without spawning the CLI. `output` is the JSONL sink and
+ * `pendingExtensionRequests` is the shared map keyed by request id.
+ */
+export function createRpcExtensionUIContext(
+	output: (obj: RpcResponse | RpcExtensionUIRequest | object) => void,
+	pendingExtensionRequests: Map<string, { resolve: (value: any) => void; reject: (error: Error) => void }>,
+): ExtensionUIContext {
 	/** Helper for dialog methods with signal/timeout support */
 	function createDialogPromise<T>(
 		opts: ExtensionUIDialogOptions | undefined,
@@ -1110,7 +1078,7 @@ export async function runRpcMode(session: AgentSession, modelFallbackMessage?: s
 	/**
 	 * Create an extension UI context that uses the RPC protocol.
 	 */
-	const createExtensionUIContext = (): ExtensionUIContext => ({
+	return {
 		select: (title, options, opts) =>
 			createDialogPromise(opts, undefined, { method: "select", title, options, timeout: opts?.timeout }, (r) =>
 				"cancelled" in r && r.cancelled ? undefined : "value" in r ? r.value : undefined,
@@ -1276,7 +1244,55 @@ export async function runRpcMode(session: AgentSession, modelFallbackMessage?: s
 		setToolsExpanded(_expanded: boolean) {
 			// Tool expansion not supported in RPC mode - no TUI
 		},
-	});
+	};
+}
+
+export async function runRpcMode(session: AgentSession, modelFallbackMessage?: string): Promise<never> {
+	takeOverStdout();
+
+	const output = (obj: RpcResponse | RpcExtensionUIRequest | object) => {
+		writeRawStdout(serializeJsonLine(obj));
+	};
+
+	const success = <T extends RpcCommand["type"]>(
+		id: string | undefined,
+		command: T,
+		data?: object | null,
+	): RpcResponse => {
+		if (data === undefined) {
+			return { id, type: "response", command, success: true } as RpcResponse;
+		}
+		return { id, type: "response", command, success: true, data } as RpcResponse;
+	};
+
+	const error = (id: string | undefined, command: string, message: string): RpcResponse => {
+		return { id, type: "response", command, success: false, error: message };
+	};
+
+	if (session.sessionFile && session.messages.length > 0) {
+		const rehydratedCount = rehydrateBackgroundAgentsFromDisk(session.sessionFile);
+		if (rehydratedCount > 0) {
+			console.error(
+				`[rpc] Rehydrated ${rehydratedCount} background subagent${rehydratedCount === 1 ? "" : "s"} from disk`,
+			);
+		}
+	}
+
+	// Pending extension UI requests waiting for response
+	const pendingExtensionRequests = new Map<
+		string,
+		{ resolve: (value: any) => void; reject: (error: Error) => void }
+	>();
+
+	// Shutdown request flag
+	let shutdownRequested = false;
+	let dailyCostTracker: DailyCostTracker | undefined;
+	let dailyCostTrackerPrimed = false;
+
+	// Extension UI context uses the RPC protocol; built by a module-scope
+	// factory so the dialog round trip is unit-testable (see createRpcExtensionUIContext).
+	const createExtensionUIContext = (): ExtensionUIContext =>
+		createRpcExtensionUIContext(output, pendingExtensionRequests);
 
 	// Set up extensions with RPC-based UI context
 	await session.bindExtensions({
diff --git a/packages/coding-agent/test/ask-user-component.test.ts b/packages/coding-agent/test/ask-user-component.test.ts
index a3466d67..47288974 100644
--- a/packages/coding-agent/test/ask-user-component.test.ts
+++ b/packages/coding-agent/test/ask-user-component.test.ts
@@ -48,6 +48,18 @@ describe("AskUserComponent", () => {
 		expect(onSubmit).toHaveBeenCalledWith({ selected: [], customText: "duckdb" });
 	});
 
+	it("single-select: submits the highlighted option together with typed free text", () => {
+		// Parity with the Dashboard, which combines a radio selection with custom
+		// text. Type in the field, move back up to an option, then submit.
+		const { component, onSubmit } = mount({ question: "DB?", options: ["SQLite", "Postgres"] });
+		component.handleInput(DOWN); // Postgres
+		component.handleInput(DOWN); // free-text row
+		type(component, "duckdb");
+		component.handleInput(UP); // back to Postgres, keeping the typed text
+		component.handleInput(ENTER);
+		expect(onSubmit).toHaveBeenCalledWith({ selected: ["Postgres"], customText: "duckdb" });
+	});
+
 	it("multi-select: Space toggles checkboxes and Enter submits the combined answer", () => {
 		const { component, onSubmit } = mount({
 			question: "Checks?",
diff --git a/packages/coding-agent/test/interactive-mode-status.test.ts b/packages/coding-agent/test/interactive-mode-status.test.ts
index 5a35d7d2..ecd5bb44 100644
--- a/packages/coding-agent/test/interactive-mode-status.test.ts
+++ b/packages/coding-agent/test/interactive-mode-status.test.ts
@@ -512,6 +512,134 @@ describe("InteractiveMode extension dialog queue", () => {
 	});
 });
 
+describe("InteractiveMode.showExtensionAsk lifecycle", () => {
+	beforeAll(() => {
+		initTheme("dark");
+	});
+
+	type AskFakeThis = {
+		ui: { setFocus: ReturnType<typeof vi.fn>; requestRender: ReturnType<typeof vi.fn> };
+		editorContainer: Container;
+		extensionAsk: unknown;
+		restoreEditorComponent: ReturnType<typeof vi.fn>;
+		hideExtensionAsk: unknown;
+	};
+
+	function createAskFakeThis(): AskFakeThis {
+		const fakeThis: AskFakeThis = {
+			ui: { setFocus: vi.fn(), requestRender: vi.fn() },
+			editorContainer: new Container(),
+			extensionAsk: undefined,
+			restoreEditorComponent: vi.fn(),
+			hideExtensionAsk: (InteractiveMode as any).prototype.hideExtensionAsk,
+		};
+		return fakeThis;
+	}
+
+	function show(fakeThis: AskFakeThis, request: object, opts?: object) {
+		return (InteractiveMode as any).prototype.showExtensionAsk.call(fakeThis, request, opts);
+	}
+
+	test("mounts the question, focuses it, and resolves the submitted answer, then restores the editor", async () => {
+		const fakeThis = createAskFakeThis();
+		const p = show(fakeThis, { question: "DB?", options: ["a", "b"] });
+
+		// Mounted into the shared editor container and focused exactly once.
+		expect(fakeThis.editorContainer.children).toHaveLength(1);
+		expect(fakeThis.ui.setFocus).toHaveBeenCalledWith(fakeThis.extensionAsk);
+		expect(fakeThis.extensionAsk).toBeDefined();
+
+		// Submit the highlighted option.
+		(fakeThis.extensionAsk as any).handleInput("\n");
+
+		await expect(p).resolves.toEqual({ selected: ["a"], customText: undefined });
+		// Torn down exactly once: component disposed/cleared and editor restored.
+		expect(fakeThis.extensionAsk).toBeUndefined();
+		expect(fakeThis.restoreEditorComponent).toHaveBeenCalledTimes(1);
+	});
+
+	test("Esc skips and resolves undefined without leaving a mounted component", async () => {
+		const fakeThis = createAskFakeThis();
+		const p = show(fakeThis, { question: "DB?", options: ["a", "b"] });
+		(fakeThis.extensionAsk as any).handleInput("\x1b"); // Esc
+		await expect(p).resolves.toBeUndefined();
+		expect(fakeThis.extensionAsk).toBeUndefined();
+		expect(fakeThis.restoreEditorComponent).toHaveBeenCalledTimes(1);
+	});
+
+	test("aborting while pending resolves undefined, disposes, and restores the editor (no orphaned promise)", async () => {
+		const fakeThis = createAskFakeThis();
+		const controller = new AbortController();
+		const p = show(fakeThis, { question: "DB?", options: ["a"] }, { signal: controller.signal });
+		expect(fakeThis.extensionAsk).toBeDefined();
+
+		controller.abort();
+		await expect(p).resolves.toBeUndefined();
+		expect(fakeThis.extensionAsk).toBeUndefined();
+		expect(fakeThis.restoreEditorComponent).toHaveBeenCalledTimes(1);
+	});
+
+	test("an already-aborted signal resolves undefined without mounting or focusing", async () => {
+		const fakeThis = createAskFakeThis();
+		const controller = new AbortController();
+		controller.abort();
+		const p = show(fakeThis, { question: "DB?", options: ["a"] }, { signal: controller.signal });
+		await expect(p).resolves.toBeUndefined();
+		expect(fakeThis.editorContainer.children).toHaveLength(0);
+		expect(fakeThis.ui.setFocus).not.toHaveBeenCalled();
+		expect(fakeThis.extensionAsk).toBeUndefined();
+	});
+
+	test("a multiline request builds the editor branch and tears down cleanly on abort", async () => {
+		// The multiline Editor is only constructed when a real TUI is provided.
+		const terminal = new VirtualTerminal(60, 16);
+		const ui = new TUI(terminal);
+		const fakeThis: any = {
+			ui,
+			editorContainer: new Container(),
+			extensionAsk: undefined,
+			restoreEditorComponent: vi.fn(),
+			hideExtensionAsk: (InteractiveMode as any).prototype.hideExtensionAsk,
+		};
+		const controller = new AbortController();
+		const p = (InteractiveMode as any).prototype.showExtensionAsk.call(
+			fakeThis,
+			{ question: "Notes?", multiline: true },
+			{ signal: controller.signal },
+		);
+		// Constructed and mounted without throwing (exercises the Editor branch).
+		expect(fakeThis.editorContainer.children).toHaveLength(1);
+		expect(fakeThis.extensionAsk).toBeDefined();
+
+		controller.abort();
+		await expect(p).resolves.toBeUndefined();
+		expect(fakeThis.extensionAsk).toBeUndefined();
+		expect(fakeThis.restoreEditorComponent).toHaveBeenCalledTimes(1);
+	});
+
+	test("a timeout builds a countdown that expires to a skip and disposes the interval", async () => {
+		vi.useFakeTimers();
+		try {
+			const fakeThis = createAskFakeThis();
+			const p = show(fakeThis, { question: "DB?", options: ["a"] }, { timeout: 3000 });
+			expect(fakeThis.extensionAsk).toBeDefined();
+
+			// The countdown ticks every second and expires at 0 → skip (undefined).
+			vi.advanceTimersByTime(3000);
+			await expect(p).resolves.toBeUndefined();
+			expect(fakeThis.extensionAsk).toBeUndefined();
+			expect(fakeThis.restoreEditorComponent).toHaveBeenCalledTimes(1);
+
+			// Interval disposed: no further ticks drive renders after teardown.
+			const rendersAfter = fakeThis.ui.requestRender.mock.calls.length;
+			vi.advanceTimersByTime(5000);
+			expect(fakeThis.ui.requestRender.mock.calls.length).toBe(rendersAfter);
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+});
+
 describe("InteractiveMode.showLoadedResources", () => {
 	beforeAll(() => {
 		initTheme("dark");
diff --git a/packages/coding-agent/test/rpc-extension-ui-ask.test.ts b/packages/coding-agent/test/rpc-extension-ui-ask.test.ts
new file mode 100644
index 00000000..17b85351
--- /dev/null
+++ b/packages/coding-agent/test/rpc-extension-ui-ask.test.ts
@@ -0,0 +1,140 @@
+import { describe, expect, it, vi } from "vitest";
+import type { AskResult } from "../src/core/extensions/types.js";
+import { createRpcExtensionUIContext } from "../src/modes/rpc/rpc-mode.js";
+import type { RpcExtensionUIRequest, RpcExtensionUIResponse } from "../src/modes/rpc/rpc-types.js";
+
+type Pending = { resolve: (value: any) => void; reject: (error: Error) => void };
+
+/**
+ * Round-trip tests for the RPC `ask` dialog: request emission, response
+ * mapping, cancellation, timeout, abort, and cleanup dedup. These exercise
+ * `createRpcExtensionUIContext` directly (no CLI spawn) so the transport is
+ * verified deterministically.
+ */
+function harness() {
+	const emitted: RpcExtensionUIRequest[] = [];
+	const handled: string[] = [];
+	const pending = new Map<string, Pending>();
+	const output = (obj: any) => {
+		if (obj?.type === "extension_ui_request") emitted.push(obj as RpcExtensionUIRequest);
+		else if (obj?.type === "extension_ui_response_handled") handled.push(obj.id as string);
+	};
+	const ctx = createRpcExtensionUIContext(output, pending);
+	// The only emitted request in these tests is the ask, so its id is the map key.
+	const lastRequestId = () => emitted[emitted.length - 1]!.id;
+	const respond = (response: Omit<RpcExtensionUIResponse, "id" | "type">) => {
+		const id = lastRequestId();
+		pending.get(id)?.resolve({ type: "extension_ui_response", id, ...response } as RpcExtensionUIResponse);
+	};
+	return { ctx, emitted, handled, pending, lastRequestId, respond };
+}
+
+describe("RPC ask round trip", () => {
+	it("emits an extension_ui_request with all ask fields and defaults the title", async () => {
+		const h = harness();
+		const p = h.ctx.ask({
+			question: "Which DB?",
+			options: ["SQLite", "Postgres"],
+			allowFreeText: true,
+			multiSelect: false,
+			multiline: false,
+		});
+		expect(h.emitted).toHaveLength(1);
+		const req = h.emitted[0]!;
+		expect(req).toMatchObject({
+			type: "extension_ui_request",
+			method: "ask",
+			title: "Question",
+			question: "Which DB?",
+			options: ["SQLite", "Postgres"],
+			allowFreeText: true,
+			multiSelect: false,
+			multiline: false,
+		});
+		expect(typeof req.id).toBe("string");
+		h.respond({ selected: ["SQLite"] } as any);
+		await p;
+	});
+
+	it("uses the provided title when set", async () => {
+		const h = harness();
+		const p = h.ctx.ask({ title: "Pick storage", question: "Which DB?", options: ["a"] });
+		expect((h.emitted[0] as any).title).toBe("Pick storage");
+		h.respond({ selected: ["a"] } as any);
+		await p;
+	});
+
+	it("maps a selected + customText response into an AskResult", async () => {
+		const h = harness();
+		const p = h.ctx.ask({ question: "Which?", options: ["a", "b"] });
+		h.respond({ selected: ["b"], customText: "duckdb" } as any);
+		const result = (await p) as AskResult;
+		expect(result).toEqual({ selected: ["b"], customText: "duckdb" });
+	});
+
+	it("maps a cancelled response to undefined (skip)", async () => {
+		const h = harness();
+		const p = h.ctx.ask({ question: "Which?", options: ["a"] });
+		h.respond({ cancelled: true } as any);
+		await expect(p).resolves.toBeUndefined();
+	});
+
+	it("emits extension_ui_response_handled exactly once on response and clears the pending entry", async () => {
+		const h = harness();
+		const p = h.ctx.ask({ question: "Which?", options: ["a"] });
+		const id = h.lastRequestId();
+		h.respond({ selected: ["a"] } as any);
+		await p;
+		expect(h.handled).toEqual([id]);
+		expect(h.pending.has(id)).toBe(false);
+	});
+
+	it("ignores a duplicate/late response after the first settles", async () => {
+		const h = harness();
+		const p = h.ctx.ask({ question: "Which?", options: ["a", "b"] });
+		const id = h.lastRequestId();
+		const pending = h.pending.get(id)!;
+		pending.resolve({ type: "extension_ui_response", id, selected: ["a"] });
+		const result = (await p) as AskResult;
+		// Second resolve must be a no-op (settled guard) — no throw, no re-handle.
+		pending.resolve({ type: "extension_ui_response", id, selected: ["b"] });
+		expect(result).toEqual({ selected: ["a"], customText: undefined });
+		expect(h.handled).toEqual([id]);
+	});
+
+	it("resolves undefined without emitting when the signal is already aborted", async () => {
+		const h = harness();
+		const controller = new AbortController();
+		controller.abort();
+		const p = h.ctx.ask({ question: "Which?", options: ["a"] }, { signal: controller.signal });
+		await expect(p).resolves.toBeUndefined();
+		expect(h.emitted).toHaveLength(0);
+	});
+
+	it("resolves undefined and cleans up when the signal aborts while pending", async () => {
+		const h = harness();
+		const controller = new AbortController();
+		const p = h.ctx.ask({ question: "Which?", options: ["a"] }, { signal: controller.signal });
+		const id = h.lastRequestId();
+		expect(h.pending.has(id)).toBe(true);
+		controller.abort();
+		await expect(p).resolves.toBeUndefined();
+		expect(h.handled).toEqual([id]);
+		expect(h.pending.has(id)).toBe(false);
+	});
+
+	it("resolves undefined on timeout and emits the handled event", async () => {
+		vi.useFakeTimers();
+		try {
+			const h = harness();
+			const p = h.ctx.ask({ question: "Which?", options: ["a"] }, { timeout: 50 });
+			const id = h.lastRequestId();
+			vi.advanceTimersByTime(50);
+			await expect(p).resolves.toBeUndefined();
+			expect(h.handled).toEqual([id]);
+			expect(h.pending.has(id)).toBe(false);
+		} finally {
+			vi.useRealTimers();
+		}
+	});
+});

From f14c9b518b351f11a246cd1a4fd50ea444f96702 Mon Sep 17 00:00:00 2001
From: Maximilian Scheurer <11406414+maxscheurer@users.noreply.github.com>
Date: Wed, 29 Jul 2026 16:00:25 +0200
Subject: [PATCH 08/15] Fix ask_user recovery and lifecycle coverage

---
 packages/coding-agent/docs/rpc.md             |  6 +--
 .../coding-agent/src/modes/rpc/rpc-mode.ts    | 40 ++++++++++----
 .../coding-agent/src/modes/rpc/rpc-types.ts   |  8 +++
 .../test/agent-session-dynamic-tools.test.ts  | 40 ++++++++++++--
 .../test/rpc-dashboard-commands.test.ts       | 33 ++++++++----
 .../test/rpc-extension-ui-ask.test.ts         | 36 +++++++++++--
 .../dashboard/src/client/state/reducer.ts     | 52 +++++++++++--------
 packages/dashboard/src/client/state/store.ts  | 14 +++--
 packages/dashboard/src/server/runtime-pool.ts |  9 +---
 packages/dashboard/src/server/server.ts       |  1 +
 packages/dashboard/src/shared/protocol.ts     | 19 +++++++
 packages/dashboard/test/client/store.test.ts  | 42 +++++++++++++++
 12 files changed, 234 insertions(+), 66 deletions(-)

diff --git a/packages/coding-agent/docs/rpc.md b/packages/coding-agent/docs/rpc.md
index 0b7a4d78..eafe6448 100644
--- a/packages/coding-agent/docs/rpc.md
+++ b/packages/coding-agent/docs/rpc.md
@@ -224,17 +224,17 @@ The `model` field is a full [Model](#model) object or `null`. `scopedModels` is
 
 #### get_dashboard_snapshot
 
-Capture the dashboard-visible parent-session state, full parent transcript, and background-agent registry at one RPC command boundary. This is for authoritative recovery, not ordinary incremental refreshes.
+Capture the dashboard-visible parent-session state, full parent transcript, background-agent registry, and blocking extension UI requests at one RPC command boundary. This is for authoritative recovery, not ordinary incremental refreshes.
 
 ```json
 {"id": "snapshot-7", "type": "get_dashboard_snapshot"}
 ```
 
-The `RpcDashboardSnapshot` result is a `snapshotId`, a complete `RpcSessionState` (including `tasks`), `messages`, and `backgroundAgents`. The RPC child writes a `RpcDashboardSnapshotBarrierEvent` to stdout **immediately before** the matching response line:
+The `RpcDashboardSnapshot` result is a `snapshotId`, a complete `RpcSessionState` (including `tasks`), `messages`, `backgroundAgents`, and `pendingExtensionUiRequests`. The last field contains every blocking `select`, `confirm`, `input`, `editor`, or `ask` request still awaiting a host response, so a recovering Dashboard can restore the answer UI instead of leaving the runtime blocked. The RPC child writes a `RpcDashboardSnapshotBarrierEvent` to stdout **immediately before** the matching response line:
 
 ```json
 {"type":"dashboard_snapshot_barrier","snapshotId":"snapshot-7"}
-{"id":"snapshot-7","type":"response","command":"get_dashboard_snapshot","success":true,"data":{"snapshotId":"snapshot-7","state":{...},"messages":[...],"backgroundAgents":[...]}}
+{"id":"snapshot-7","type":"response","command":"get_dashboard_snapshot","success":true,"data":{"snapshotId":"snapshot-7","state":{...},"messages":[...],"backgroundAgents":[...],"pendingExtensionUiRequests":[...]}}
 ```
 
 Stdout JSONL ordering is the contract: a relay records its current event-stream sequence when the marker arrives, before resolving the response, and pairs the snapshot only with that exact marker. The dashboard returns that captured sequence as `/api/resync.barrierSeq`; consumers discard queued events through it and replay only later events. The marker itself is not broadcast as another browser event, so one recovering client does not interrupt healthy clients. Do not infer ordering from request/response timing; see [dashboard recovery](dashboard.md#live-connection-and-recovery).
diff --git a/packages/coding-agent/src/modes/rpc/rpc-mode.ts b/packages/coding-agent/src/modes/rpc/rpc-mode.ts
index 3ff78dd3..226034ec 100644
--- a/packages/coding-agent/src/modes/rpc/rpc-mode.ts
+++ b/packages/coding-agent/src/modes/rpc/rpc-mode.ts
@@ -47,6 +47,7 @@ import { attachJsonlLineReader, serializeJsonLine } from "./jsonl.js";
 import type {
 	RpcAgentTypeInfo,
 	RpcBackgroundAgentInfo,
+	RpcBlockingExtensionUIRequest,
 	RpcCommand,
 	RpcContextTrustEvaluation,
 	RpcContextTrustMutationResult,
@@ -1016,9 +1017,15 @@ export async function navigateTreeForRpc(
  * can be unit-tested without spawning the CLI. `output` is the JSONL sink and
  * `pendingExtensionRequests` is the shared map keyed by request id.
  */
+export interface PendingRpcExtensionRequest {
+	request: RpcBlockingExtensionUIRequest;
+	resolve: (value: any) => void;
+	reject: (error: Error) => void;
+}
+
 export function createRpcExtensionUIContext(
 	output: (obj: RpcResponse | RpcExtensionUIRequest | object) => void,
-	pendingExtensionRequests: Map<string, { resolve: (value: any) => void; reject: (error: Error) => void }>,
+	pendingExtensionRequests: Map<string, PendingRpcExtensionRequest>,
 ): ExtensionUIContext {
 	/** Helper for dialog methods with signal/timeout support */
 	function createDialogPromise<T>(
@@ -1057,7 +1064,13 @@ export function createRpcExtensionUIContext(
 				}, opts.timeout);
 			}
 
+			const rpcRequest = {
+				type: "extension_ui_request",
+				id,
+				...request,
+			} as RpcBlockingExtensionUIRequest;
 			pendingExtensionRequests.set(id, {
+				request: rpcRequest,
 				resolve: (response: RpcExtensionUIResponse) => {
 					if (!cleanup()) return;
 					try {
@@ -1071,7 +1084,7 @@ export function createRpcExtensionUIContext(
 					reject(error);
 				},
 			});
-			output({ type: "extension_ui_request", id, ...request } as RpcExtensionUIRequest);
+			output(rpcRequest);
 		});
 	}
 
@@ -1247,6 +1260,15 @@ export function createRpcExtensionUIContext(
 	};
 }
 
+/** Cancel every pending dialog during RPC host teardown. */
+export function cancelPendingRpcExtensionRequests(
+	pendingExtensionRequests: Map<string, PendingRpcExtensionRequest>,
+): void {
+	for (const [id, pending] of [...pendingExtensionRequests]) {
+		pending.resolve({ type: "extension_ui_response", id, cancelled: true });
+	}
+}
+
 export async function runRpcMode(session: AgentSession, modelFallbackMessage?: string): Promise<never> {
 	takeOverStdout();
 
@@ -1278,11 +1300,10 @@ export async function runRpcMode(session: AgentSession, modelFallbackMessage?: s
 		}
 	}
 
-	// Pending extension UI requests waiting for response
-	const pendingExtensionRequests = new Map<
-		string,
-		{ resolve: (value: any) => void; reject: (error: Error) => void }
-	>();
+	// Pending extension UI requests waiting for response. Keep the emitted
+	// payload alongside its callbacks so recovery snapshots can reconstruct the
+	// answer UI after a Dashboard reload or replay gap.
+	const pendingExtensionRequests = new Map<string, PendingRpcExtensionRequest>();
 
 	// Shutdown request flag
 	let shutdownRequested = false;
@@ -1447,6 +1468,7 @@ export async function runRpcMode(session: AgentSession, modelFallbackMessage?: s
 					state: getStateForRpc(session, modelFallbackMessage),
 					messages: getDashboardMessagesForRpc(session),
 					backgroundAgents: getBackgroundAgents().map(toRpcBackgroundAgentInfo),
+					pendingExtensionUiRequests: [...pendingExtensionRequests.values()].map(({ request }) => request),
 				};
 				return success(id, "get_dashboard_snapshot", data);
 			}
@@ -1845,9 +1867,7 @@ export async function runRpcMode(session: AgentSession, modelFallbackMessage?: s
 	let detachInput = () => {};
 
 	async function shutdown(): Promise<never> {
-		for (const [id, pending] of [...pendingExtensionRequests]) {
-			pending.resolve({ type: "extension_ui_response", id, cancelled: true });
-		}
+		cancelPendingRpcExtensionRequests(pendingExtensionRequests);
 
 		const currentRunner = session.extensionRunner;
 		if (currentRunner?.hasHandlers("session_shutdown")) {
diff --git a/packages/coding-agent/src/modes/rpc/rpc-types.ts b/packages/coding-agent/src/modes/rpc/rpc-types.ts
index 225fe228..ef85b9a5 100644
--- a/packages/coding-agent/src/modes/rpc/rpc-types.ts
+++ b/packages/coding-agent/src/modes/rpc/rpc-types.ts
@@ -184,6 +184,8 @@ export interface RpcDashboardSnapshot {
 	messages: AgentMessage[];
 	/** Current background-agent registry at that boundary. */
 	backgroundAgents: RpcBackgroundAgentInfo[];
+	/** Blocking UI requests that are still waiting for a host response. */
+	pendingExtensionUiRequests: RpcBlockingExtensionUIRequest[];
 }
 
 /** Ordering marker emitted immediately before a matching dashboard snapshot response. */
@@ -680,6 +682,12 @@ export type RpcExtensionUIRequest =
 	| { type: "extension_ui_request"; id: string; method: "setTitle"; title: string }
 	| { type: "extension_ui_request"; id: string; method: "set_editor_text"; text: string };
 
+/** Blocking dialog requests retained until a matching host response arrives. */
+export type RpcBlockingExtensionUIRequest = Extract<
+	RpcExtensionUIRequest,
+	{ method: "select" | "confirm" | "input" | "editor" | "ask" }
+>;
+
 // ============================================================================
 // Extension UI Commands (stdin)
 // ============================================================================
diff --git a/packages/coding-agent/test/agent-session-dynamic-tools.test.ts b/packages/coding-agent/test/agent-session-dynamic-tools.test.ts
index d92f0f21..082d8e52 100644
--- a/packages/coding-agent/test/agent-session-dynamic-tools.test.ts
+++ b/packages/coding-agent/test/agent-session-dynamic-tools.test.ts
@@ -3,7 +3,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { findModel } from "@dreb/ai";
 import { Type } from "@sinclair/typebox";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { DefaultResourceLoader } from "../src/core/resource-loader.js";
 import { createAgentSession } from "../src/core/sdk.js";
 import { SessionManager } from "../src/core/session-manager.js";
@@ -110,10 +110,40 @@ describe("AgentSession dynamic tool registration", () => {
 		expect(session.extensionRunner).toBeDefined();
 		expect(session.extensionRunner?.hasUI()).toBe(false);
 
-		const ask = async () => ({ selected: ["SQLite"] });
-		await session.bindExtensions({ uiContext: { ask } as any });
-		expect(session.extensionRunner?.hasUI()).toBe(true);
-		expect(session.extensionRunner?.createContext().ui.ask).toBe(ask);
+		const executeAskUser = async () => {
+			const tool = session.agent.state.tools.find((candidate) => candidate.name === "ask_user");
+			expect(tool).toBeDefined();
+			return tool!.execute(
+				"ask-call",
+				{ question: "Which database?", options: ["SQLite", "Postgres"] },
+				new AbortController().signal,
+				() => {},
+			);
+		};
+
+		// The actual session-wrapped tool must receive the no-host context rather
+		// than calling an unreachable UI implementation.
+		await expect(executeAskUser()).resolves.toMatchObject({
+			details: { unavailable: true, skipped: true },
+		});
+
+		const firstAsk = vi.fn(async () => ({ selected: ["SQLite"] }));
+		await session.bindExtensions({ uiContext: { ask: firstAsk } as any });
+		await expect(executeAskUser()).resolves.toMatchObject({
+			details: { selected: ["SQLite"], unavailable: false, skipped: false },
+		});
+		expect(firstAsk).toHaveBeenCalledWith(
+			expect.objectContaining({ question: "Which database?" }),
+			expect.objectContaining({ signal: expect.any(AbortSignal) }),
+		);
+
+		// Context is resolved for each execution, so rebinding the host UI must
+		// not leave the base-tool wrapper pointing at the previous implementation.
+		const secondAsk = vi.fn(async () => ({ selected: ["Postgres"] }));
+		await session.bindExtensions({ uiContext: { ask: secondAsk } as any });
+		await expect(executeAskUser()).resolves.toMatchObject({ details: { selected: ["Postgres"] } });
+		expect(firstAsk).toHaveBeenCalledTimes(1);
+		expect(secondAsk).toHaveBeenCalledTimes(1);
 
 		session.dispose();
 	});
diff --git a/packages/coding-agent/test/rpc-dashboard-commands.test.ts b/packages/coding-agent/test/rpc-dashboard-commands.test.ts
index 420a8eb0..3c976285 100644
--- a/packages/coding-agent/test/rpc-dashboard-commands.test.ts
+++ b/packages/coding-agent/test/rpc-dashboard-commands.test.ts
@@ -273,7 +273,7 @@ describe("git branch helper used by RPC", () => {
 });
 
 describe("runRpcMode dashboard dispatcher", () => {
-	it("emits a dashboard snapshot barrier before the snapshot response", async () => {
+	it("emits a dashboard snapshot barrier and includes pending UI requests in the response", async () => {
 		const { session, cleanup } = createTestSession({ inMemory: true });
 		const tasks = [
 			{ id: "read", title: "Read dispatcher pattern", status: "completed" as const },
@@ -282,9 +282,9 @@ describe("runRpcMode dashboard dispatcher", () => {
 		(session as unknown as { _tasks: typeof tasks })._tasks = tasks;
 		const outputs: Array<Record<string, unknown>> = [];
 		let handleInputLine: ((line: string) => void) | undefined;
-		let resolveTwoOutputs: (() => void) | undefined;
-		const twoOutputs = new Promise<void>((resolve) => {
-			resolveTwoOutputs = resolve;
+		let resolveSnapshotOutputs: (() => void) | undefined;
+		const snapshotOutputs = new Promise<void>((resolve) => {
+			resolveSnapshotOutputs = resolve;
 		});
 		const existingEndListeners = new Set(process.stdin.listeners("end"));
 		const existingErrorListeners = new Set(process.stdin.listeners("error"));
@@ -292,8 +292,8 @@ describe("runRpcMode dashboard dispatcher", () => {
 		vi.spyOn(outputGuard, "takeOverStdout").mockImplementation(() => {});
 		vi.spyOn(outputGuard, "writeRawStdout").mockImplementation((line) => {
 			outputs.push(JSON.parse(line) as Record<string, unknown>);
-			if (outputs.length === 2) {
-				resolveTwoOutputs?.();
+			if (outputs.length === 3) {
+				resolveSnapshotOutputs?.();
 			}
 		});
 		vi.spyOn(jsonl, "attachJsonlLineReader").mockImplementation((_stream, onLine) => {
@@ -307,12 +307,20 @@ describe("runRpcMode dashboard dispatcher", () => {
 			void runRpcMode(session);
 			await vi.waitFor(() => expect(handleInputLine).toBeDefined());
 
+			const pendingAsk = session.extensionRunner!.createContext().ui.ask({
+				title: "Choose a database",
+				question: "Which one?",
+				options: ["SQLite", "Postgres"],
+			});
+			const request = outputs[0]!;
+			expect(request).toMatchObject({ type: "extension_ui_request", method: "ask" });
+
 			handleInputLine!(JSON.stringify({ type: "get_dashboard_snapshot" }));
-			await twoOutputs;
+			await snapshotOutputs;
 
-			expect(outputs).toHaveLength(2);
-			const barrier = outputs[0]!;
-			const response = outputs[1]!;
+			expect(outputs).toHaveLength(3);
+			const barrier = outputs[1]!;
+			const response = outputs[2]!;
 
 			expect(barrier).toEqual({ type: "dashboard_snapshot_barrier", snapshotId: expect.any(String) });
 			const snapshotId = barrier.snapshotId;
@@ -324,8 +332,12 @@ describe("runRpcMode dashboard dispatcher", () => {
 				data: {
 					snapshotId,
 					state: { tasks },
+					pendingExtensionUiRequests: [request],
 				},
 			});
+
+			handleInputLine!(JSON.stringify({ type: "extension_ui_response", id: request.id, selected: ["SQLite"] }));
+			await expect(pendingAsk).resolves.toEqual({ selected: ["SQLite"], customText: undefined });
 		} finally {
 			cleanup();
 			for (const listener of process.stdin.listeners("end")) {
@@ -396,6 +408,7 @@ describe("RpcClient dashboard command methods", () => {
 			},
 			messages: [],
 			backgroundAgents: [],
+			pendingExtensionUiRequests: [],
 		} satisfies RpcDashboardSnapshot;
 		const aggregateSnapshot: AggregateRpcDashboardSnapshot = snapshot;
 
diff --git a/packages/coding-agent/test/rpc-extension-ui-ask.test.ts b/packages/coding-agent/test/rpc-extension-ui-ask.test.ts
index 17b85351..282b76ad 100644
--- a/packages/coding-agent/test/rpc-extension-ui-ask.test.ts
+++ b/packages/coding-agent/test/rpc-extension-ui-ask.test.ts
@@ -1,10 +1,12 @@
 import { describe, expect, it, vi } from "vitest";
 import type { AskResult } from "../src/core/extensions/types.js";
-import { createRpcExtensionUIContext } from "../src/modes/rpc/rpc-mode.js";
+import {
+	cancelPendingRpcExtensionRequests,
+	createRpcExtensionUIContext,
+	type PendingRpcExtensionRequest,
+} from "../src/modes/rpc/rpc-mode.js";
 import type { RpcExtensionUIRequest, RpcExtensionUIResponse } from "../src/modes/rpc/rpc-types.js";
 
-type Pending = { resolve: (value: any) => void; reject: (error: Error) => void };
-
 /**
  * Round-trip tests for the RPC `ask` dialog: request emission, response
  * mapping, cancellation, timeout, abort, and cleanup dedup. These exercise
@@ -14,7 +16,7 @@ type Pending = { resolve: (value: any) => void; reject: (error: Error) => void }
 function harness() {
 	const emitted: RpcExtensionUIRequest[] = [];
 	const handled: string[] = [];
-	const pending = new Map<string, Pending>();
+	const pending = new Map<string, PendingRpcExtensionRequest>();
 	const output = (obj: any) => {
 		if (obj?.type === "extension_ui_request") emitted.push(obj as RpcExtensionUIRequest);
 		else if (obj?.type === "extension_ui_response_handled") handled.push(obj.id as string);
@@ -64,6 +66,15 @@ describe("RPC ask round trip", () => {
 		await p;
 	});
 
+	it("retains the emitted request payload while waiting for a response", async () => {
+		const h = harness();
+		const p = h.ctx.ask({ question: "Which?", options: ["a", "b"] });
+		const id = h.lastRequestId();
+		expect(h.pending.get(id)?.request).toBe(h.emitted[0]);
+		h.respond({ selected: ["a"] } as any);
+		await p;
+	});
+
 	it("maps a selected + customText response into an AskResult", async () => {
 		const h = harness();
 		const p = h.ctx.ask({ question: "Which?", options: ["a", "b"] });
@@ -123,6 +134,23 @@ describe("RPC ask round trip", () => {
 		expect(h.pending.has(id)).toBe(false);
 	});
 
+	it("cancels pending dialogs exactly once during RPC shutdown", async () => {
+		const h = harness();
+		const first = h.ctx.ask({ question: "First?", options: ["a"] });
+		const firstId = h.lastRequestId();
+		const second = h.ctx.ask({ question: "Second?", options: ["b"] });
+		const secondId = h.lastRequestId();
+
+		cancelPendingRpcExtensionRequests(h.pending);
+
+		await expect(first).resolves.toBeUndefined();
+		await expect(second).resolves.toBeUndefined();
+		expect(h.pending.size).toBe(0);
+		expect(h.handled).toEqual([firstId, secondId]);
+		cancelPendingRpcExtensionRequests(h.pending);
+		expect(h.handled).toEqual([firstId, secondId]);
+	});
+
 	it("resolves undefined on timeout and emits the handled event", async () => {
 		vi.useFakeTimers();
 		try {
diff --git a/packages/dashboard/src/client/state/reducer.ts b/packages/dashboard/src/client/state/reducer.ts
index c8bb2e84..fbbca05b 100644
--- a/packages/dashboard/src/client/state/reducer.ts
+++ b/packages/dashboard/src/client/state/reducer.ts
@@ -120,6 +120,34 @@ export interface ExtensionUiRequest {
 	multiline?: boolean;
 }
 
+export function extensionUiRequestFromEvent(event: any): ExtensionUiRequest | undefined {
+	const method = event?.method as string | undefined;
+	if (method === "select" || method === "confirm" || method === "input" || method === "editor") {
+		return {
+			id: String(event.id),
+			method,
+			title: String(event.title ?? ""),
+			message: event.message as string | undefined,
+			options: event.options as string[] | undefined,
+			prefill: event.prefill as string | undefined,
+			placeholder: event.placeholder as string | undefined,
+		};
+	}
+	if (method === "ask") {
+		return {
+			id: String(event.id),
+			method: "ask",
+			title: String(event.title ?? "Question"),
+			question: String(event.question ?? ""),
+			options: event.options as string[] | undefined,
+			allowFreeText: event.allowFreeText as boolean | undefined,
+			multiSelect: event.multiSelect as boolean | undefined,
+			multiline: event.multiline as boolean | undefined,
+		};
+	}
+	return undefined;
+}
+
 export interface Toast {
 	id: number;
 	text: string;
@@ -809,27 +837,9 @@ export function applySessionEvent(state: SessionViewState, event: any): void {
 		}
 		case "extension_ui_request": {
 			const method = event.method as string;
-			if (method === "select" || method === "confirm" || method === "input" || method === "editor") {
-				state.uiRequests.push({
-					id: String(event.id),
-					method,
-					title: String(event.title ?? ""),
-					message: event.message as string | undefined,
-					options: event.options as string[] | undefined,
-					prefill: event.prefill as string | undefined,
-					placeholder: event.placeholder as string | undefined,
-				});
-			} else if (method === "ask") {
-				state.uiRequests.push({
-					id: String(event.id),
-					method: "ask",
-					title: String(event.title ?? "Question"),
-					question: String(event.question ?? ""),
-					options: event.options as string[] | undefined,
-					allowFreeText: event.allowFreeText as boolean | undefined,
-					multiSelect: event.multiSelect as boolean | undefined,
-					multiline: event.multiline as boolean | undefined,
-				});
+			const blockingRequest = extensionUiRequestFromEvent(event);
+			if (blockingRequest) {
+				state.uiRequests.push(blockingRequest);
 			} else if (method === "notify") {
 				toastCounter += 1;
 				const tone = (event.notifyType as "info" | "warning" | "error" | undefined) ?? "info";
diff --git a/packages/dashboard/src/client/state/store.ts b/packages/dashboard/src/client/state/store.ts
index 08112bfd..2b15d06b 100644
--- a/packages/dashboard/src/client/state/store.ts
+++ b/packages/dashboard/src/client/state/store.ts
@@ -25,10 +25,12 @@ import {
 	createSessionViewState,
 	deriveProviderErrorState,
 	dismissToast as dismissReducerToast,
+	extensionUiRequestFromEvent,
 	messagesToEntries,
 	resolveUiRequest as resolveReducerUiRequest,
 	type SessionViewState,
 	type Toast,
+	updateAttention,
 } from "./reducer.js";
 
 export type Route =
@@ -622,11 +624,12 @@ export function createAppStore() {
 			session.sessionName = active.state.sessionName;
 			session.model = active.state.model?.id;
 			session.contextUsage = active.state.contextUsage;
-			// Authoritative recovery snapshots do not carry transient reducer UI
-			// state. Clear pre-gap extension/status affordances so the restored
-			// transcript/runtime state is the source of truth until replay applies
-			// post-barrier events below.
-			session.uiRequests = [];
+			// Restore blocking dialogs from the same authoritative RPC boundary as
+			// transcript/state. Other transient affordances are still cleared until
+			// post-barrier replay applies newer events below.
+			session.uiRequests = (active.pendingExtensionUiRequests ?? [])
+				.map((request) => extensionUiRequestFromEvent(request))
+				.filter((request) => request !== undefined);
 			session.statusEntries = [];
 			session.suggestedCommand = undefined;
 			session.lastError = undefined;
@@ -659,6 +662,7 @@ export function createAppStore() {
 					streaming: agent.status === "running",
 				};
 			}
+			updateAttention(session);
 		});
 		bumpTaskRevision(active.key);
 	}
diff --git a/packages/dashboard/src/server/runtime-pool.ts b/packages/dashboard/src/server/runtime-pool.ts
index 4dae85d1..3d272d2f 100644
--- a/packages/dashboard/src/server/runtime-pool.ts
+++ b/packages/dashboard/src/server/runtime-pool.ts
@@ -11,7 +11,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
-import { RpcClient, type RpcExitInfo } from "@dreb/coding-agent/rpc";
+import { RpcClient, type RpcDashboardSnapshot, type RpcExitInfo } from "@dreb/coding-agent/rpc";
 import {
 	type BackgroundAgentDto,
 	type FleetRuntimeSnapshotDto,
@@ -40,13 +40,6 @@ export type FleetSnapshotListener = (event: FleetSnapshotEventDto) => void;
 
 export { MAX_COMPLETED_BACKGROUND_AGENTS };
 
-interface RpcDashboardSnapshot {
-	snapshotId: string;
-	state: SessionStateDto;
-	messages: unknown[];
-	backgroundAgents: BackgroundAgentDto[];
-}
-
 type DashboardSnapshotClient = RpcClient & { getDashboardSnapshot(): Promise<RpcDashboardSnapshot> };
 
 export interface DashboardRuntimeSnapshot {
diff --git a/packages/dashboard/src/server/server.ts b/packages/dashboard/src/server/server.ts
index cb3cfd94..8de05268 100644
--- a/packages/dashboard/src/server/server.ts
+++ b/packages/dashboard/src/server/server.ts
@@ -446,6 +446,7 @@ export function createDashboardServer(options: DashboardServerOptions): Dashboar
 		state: snapshot.snapshot.state,
 		messages: images.project(snapshot.snapshot.messages, { runtimeKey: snapshot.key }),
 		backgroundAgents: snapshot.snapshot.backgroundAgents,
+		pendingExtensionUiRequests: snapshot.snapshot.pendingExtensionUiRequests ?? [],
 		barrierSeq: snapshot.barrierSeq,
 	});
 
diff --git a/packages/dashboard/src/shared/protocol.ts b/packages/dashboard/src/shared/protocol.ts
index 80f782b0..e6061559 100644
--- a/packages/dashboard/src/shared/protocol.ts
+++ b/packages/dashboard/src/shared/protocol.ts
@@ -268,6 +268,23 @@ export interface FleetDto {
 	diskSessions: SessionInfoDto[];
 }
 
+/** A blocking extension UI request that can be restored from a runtime snapshot. */
+export interface ExtensionUiRequestDto {
+	type: "extension_ui_request";
+	id: string;
+	method: "select" | "confirm" | "input" | "editor" | "ask";
+	title: string;
+	message?: string;
+	options?: string[];
+	prefill?: string;
+	placeholder?: string;
+	question?: string;
+	allowFreeText?: boolean;
+	multiSelect?: boolean;
+	multiline?: boolean;
+	timeout?: number;
+}
+
 /**
  * Atomic parent-session snapshot for drill-in hydration. Its barrier sequence
  * marks the SSE ordering point captured by the matching RPC snapshot marker.
@@ -277,6 +294,8 @@ export interface RuntimeHydrationDto {
 	state: SessionStateDto;
 	messages: unknown[];
 	backgroundAgents: BackgroundAgentDto[];
+	/** Dialogs still waiting for a host response at the snapshot boundary. */
+	pendingExtensionUiRequests?: ExtensionUiRequestDto[];
 	barrierSeq: number;
 }
 
diff --git a/packages/dashboard/test/client/store.test.ts b/packages/dashboard/test/client/store.test.ts
index f7c9d162..b69a39e1 100644
--- a/packages/dashboard/test/client/store.test.ts
+++ b/packages/dashboard/test/client/store.test.ts
@@ -486,6 +486,48 @@ describe("app store SSE sync", () => {
 		expect(store.sessions.a?.needsAttention).toBe(false);
 	});
 
+	it("restores a pending ask and attention from the authoritative resync", async () => {
+		const snapshot = runtimeSnapshot("a", true);
+		vi.mocked(api.resync).mockResolvedValueOnce({
+			fleet: { runtimes: [snapshot], diskSessions: [] },
+			active: {
+				key: "a",
+				state: snapshot.state,
+				messages: [],
+				backgroundAgents: [],
+				pendingExtensionUiRequests: [
+					{
+						type: "extension_ui_request",
+						id: "ask-pending",
+						method: "ask",
+						title: "Choose a database",
+						question: "Which one?",
+						options: ["SQLite", "Postgres"],
+						allowFreeText: true,
+						multiSelect: false,
+						multiline: false,
+					},
+				],
+				barrierSeq: 20,
+			},
+			barrierSeq: 20,
+		});
+		const store = await makeStartedStore();
+
+		emit("", { type: "dashboard_resync", reason: "buffer_gap" });
+		await vi.waitFor(() => expect(store.resyncing()).toBe(false));
+
+		expect(store.sessions.a?.uiRequests).toEqual([
+			expect.objectContaining({
+				id: "ask-pending",
+				method: "ask",
+				question: "Which one?",
+				options: ["SQLite", "Postgres"],
+			}),
+		]);
+		expect(store.sessions.a?.needsAttention).toBe(true);
+	});
+
 	it("resolveUiRequest optimistically dismisses an ask request and clears attention", async () => {
 		const store = await makeStartedStore();
 

From 96155481cb4def56f347cb36af6d6b669d9ecba3 Mon Sep 17 00:00:00 2001
From: Maximilian Scheurer <11406414+maxscheurer@users.noreply.github.com>
Date: Wed, 29 Jul 2026 16:18:02 +0200
Subject: [PATCH 09/15] ask_user: normalize schema, optional timeout, Dashboard
 Escape/countdown, and coverage

Normalize the schema so a question is always answerable (free text when no
options; drop meaningless multiSelect/multiline). Add an optional
timeoutSeconds that auto-skips with a live countdown across surfaces. Add
production Dashboard Escape-to-skip and a visible countdown. Fix a multiline
TUI bug where Editor cleared its state before onSubmit, dropping the typed
answer. Add tests for queued-abort, multiline editing, Dashboard retry
state/dedup, and the server ask needs-attention branch.
---
 packages/coding-agent/README.md               |   2 +-
 .../coding-agent/src/core/tools/ask-user.ts   |  27 +++-
 .../modes/interactive/components/ask-user.ts  |  16 ++-
 .../test/ask-user-component.test.ts           |  44 +++++-
 .../coding-agent/test/tools/ask-user.test.ts  |  91 ++++++++++++
 .../dashboard/src/client/screens/session.tsx  |  37 ++++-
 .../dashboard/src/client/state/reducer.ts     |   3 +
 packages/dashboard/src/client/styles/app.css  |   5 +
 .../dashboard/test/client/screens.test.tsx    | 129 ++++++++++++++++++
 packages/dashboard/test/runtime-pool.test.ts  |  12 ++
 10 files changed, 351 insertions(+), 15 deletions(-)

diff --git a/packages/coding-agent/README.md b/packages/coding-agent/README.md
index 3b0961c6..8c81f128 100644
--- a/packages/coding-agent/README.md
+++ b/packages/coding-agent/README.md
@@ -641,7 +641,7 @@ cat README.md | dreb -p "Summarize this text"
 
 Available built-in tools: `read`, `bash`, `edit`, `write`, `grep`, `find`, `ls`, `web_search`, `web_fetch`, `subagent`, `wait`, `search`, `ask_user`
 
-`ask_user` pauses the turn and asks you a structured clarifying question — optional 2-4 multiple-choice options (single- or multi-select) plus a "type your own answer" field — rendered natively in the TUI and the Dashboard, and over RPC. Skipping, Escape, tool abort, timeout, and headless/no-UI modes all resolve gracefully, so the agent never deadlocks waiting on an absent user. Concurrent `ask_user` calls are shown strictly one at a time (FIFO). In the TUI: `↑`/`↓` move between options and the free-text field, `Space` toggles a checkbox (multi-select), `Enter` submits, and `Esc` skips.
+`ask_user` pauses the turn and asks you a structured clarifying question — optional 2-4 multiple-choice options (single- or multi-select) plus a "type your own answer" field — rendered natively in the TUI and the Dashboard, and over RPC. Skipping, Escape, tool abort, timeout, and headless/no-UI modes all resolve gracefully, so the agent never deadlocks waiting on an absent user. When there are no options the free-text field is always shown, so every question is answerable. An optional `timeoutSeconds` auto-skips the question after the given number of seconds with a live countdown on every surface. Concurrent `ask_user` calls are shown strictly one at a time (FIFO). In the TUI: `↑`/`↓` move between options and the free-text field, `Space` toggles a checkbox (multi-select), `Enter` submits, and `Esc` skips. In the Dashboard: native radios/checkboxes plus a text field, a skip button, and `Esc` to skip.
 
 Three additional tools are always active but don't appear in `--tools`:
 - `skill` — invokes [skills](#skills) programmatically
diff --git a/packages/coding-agent/src/core/tools/ask-user.ts b/packages/coding-agent/src/core/tools/ask-user.ts
index 048d2ac6..d534051a 100644
--- a/packages/coding-agent/src/core/tools/ask-user.ts
+++ b/packages/coding-agent/src/core/tools/ask-user.ts
@@ -64,6 +64,15 @@ const askUserSchema = Type.Object({
 			description: "Use a large multi-line text area for open-ended answers.",
 		}),
 	),
+	timeoutSeconds: Type.Optional(
+		Type.Number({
+			minimum: 5,
+			maximum: 3600,
+			description:
+				"Optional: auto-skip the question after this many seconds if the user does not respond. " +
+				"Shows a live countdown. Omit to wait indefinitely.",
+		}),
+	),
 });
 
 export type AskUserInput = Static<typeof askUserSchema>;
@@ -181,15 +190,25 @@ export function createAskUserToolDefinition(): ToolDefinition<typeof askUserSche
 		],
 
 		async execute(_toolCallId, input: AskUserInput, signal, _onUpdate, ctx?: ExtensionContext) {
+			const hasOptions = (input.options?.length ?? 0) > 0;
 			const request: AskRequest = {
 				question: input.question,
 				title: input.title,
 				options: input.options,
-				allowFreeText: input.allowFreeText,
-				multiSelect: input.multiSelect,
-				multiline: input.multiline,
+				// Guarantee at least one answer control: with no options, free text
+				// must be offered regardless of the requested flag, otherwise both
+				// surfaces would render only a Skip button and no way to answer.
+				allowFreeText: hasOptions ? input.allowFreeText : true,
+				// multiSelect is only meaningful with options; multiline only with
+				// free text — normalize away impossible combinations.
+				multiSelect: hasOptions ? input.multiSelect : undefined,
+				multiline: hasOptions ? (input.allowFreeText === false ? undefined : input.multiline) : input.multiline,
 			};
 
+			// Optional auto-skip timeout, forwarded to every UI surface (TUI
+			// countdown, RPC/Dashboard). Model-facing units are seconds.
+			const timeout = input.timeoutSeconds && input.timeoutSeconds > 0 ? input.timeoutSeconds * 1000 : undefined;
+
 			// Headless / print / no-host modes: never block on an unreachable UI.
 			if (!ctx?.hasUI) {
 				return unavailableResult(input);
@@ -200,7 +219,7 @@ export function createAskUserToolDefinition(): ToolDefinition<typeof askUserSche
 				// without ever opening the UI.
 				if (signal?.aborted) return skippedResult(input);
 				try {
-					const answer = await ctx.ui.ask(request, { signal });
+					const answer = await ctx.ui.ask(request, { signal, timeout });
 					if (!answer || (answer.selected.length === 0 && !answer.customText?.trim())) {
 						return skippedResult(input);
 					}
diff --git a/packages/coding-agent/src/modes/interactive/components/ask-user.ts b/packages/coding-agent/src/modes/interactive/components/ask-user.ts
index 829acd56..4412729b 100644
--- a/packages/coding-agent/src/modes/interactive/components/ask-user.ts
+++ b/packages/coding-agent/src/modes/interactive/components/ask-user.ts
@@ -119,7 +119,9 @@ export class AskUserComponent extends Container implements Focusable {
 			this.addChild(this.fieldLabel);
 			if (this.multiline && opts?.tui) {
 				this.editor = new Editor(opts.tui, getEditorTheme(), {});
-				this.editor.onSubmit = () => this.submit();
+				// The Editor clears its own state before invoking onSubmit, so we must
+				// use the text it hands us rather than re-reading the now-empty editor.
+				this.editor.onSubmit = (text) => this.submit(text);
 				this.addChild(this.editor);
 			} else {
 				this.input = new Input();
@@ -178,14 +180,14 @@ export class AskUserComponent extends Container implements Focusable {
 		this.syncFieldFocus();
 	}
 
-	private fieldText(): string {
-		if (this.editor) return this.editor.getText().trim();
+	private fieldText(editorTextOverride?: string): string {
+		if (this.editor) return (editorTextOverride ?? this.editor.getText()).trim();
 		if (this.input) return this.input.getValue().trim();
 		return "";
 	}
 
-	private currentAnswer(): AskResult | undefined {
-		const customText = this.fieldText() || undefined;
+	private currentAnswer(editorTextOverride?: string): AskResult | undefined {
+		const customText = this.fieldText(editorTextOverride) || undefined;
 		if (this.multiSelect) {
 			const selected = this.options.filter((_, i) => this.checked[i]);
 			if (selected.length === 0 && !customText) return undefined;
@@ -202,9 +204,9 @@ export class AskUserComponent extends Container implements Focusable {
 		return option ? { selected: [option], customText } : undefined;
 	}
 
-	private submit(): void {
+	private submit(editorTextOverride?: string): void {
 		if (this.submitted) return;
-		const answer = this.currentAnswer();
+		const answer = this.currentAnswer(editorTextOverride);
 		if (!answer) return; // Nothing to submit yet — Esc skips instead.
 		this.submitted = true;
 		this.onSubmitCallback(answer);
diff --git a/packages/coding-agent/test/ask-user-component.test.ts b/packages/coding-agent/test/ask-user-component.test.ts
index 47288974..b695bf2a 100644
--- a/packages/coding-agent/test/ask-user-component.test.ts
+++ b/packages/coding-agent/test/ask-user-component.test.ts
@@ -1,5 +1,6 @@
-import { setKeybindings } from "@dreb/tui";
+import { setKeybindings, TUI } from "@dreb/tui";
 import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { VirtualTerminal } from "../../tui/test/virtual-terminal.js";
 import type { AskRequest, AskResult } from "../src/core/extensions/types.js";
 import { KeybindingsManager } from "../src/core/keybindings.js";
 import { AskUserComponent } from "../src/modes/interactive/components/ask-user.js";
@@ -27,6 +28,16 @@ function mount(request: AskRequest) {
 	return { component, onSubmit, onCancel };
 }
 
+/** Mount with a real TUI so the multiline `Editor` branch is exercised. */
+function mountWithTui(request: AskRequest) {
+	const tui = new TUI(new VirtualTerminal(80, 24));
+	const onSubmit = vi.fn<(result: AskResult) => void>();
+	const onCancel = vi.fn<() => void>();
+	const component = new AskUserComponent(request, onSubmit, onCancel, { tui });
+	component.focused = true;
+	return { component, onSubmit, onCancel, tui };
+}
+
 function type(component: AskUserComponent, text: string) {
 	for (const char of text) component.handleInput(char);
 }
@@ -129,4 +140,35 @@ describe("AskUserComponent", () => {
 		component.handleInput(ENTER);
 		expect(onSubmit).toHaveBeenCalledWith({ selected: ["a"], customText: undefined });
 	});
+
+	describe("multiline (real Editor branch)", () => {
+		const CR = "\r"; // Enter → submit in the Editor
+		const LF = "\n"; // bare LF → insert a newline in the Editor
+
+		it("inserts newlines without submitting, then submits the multi-line answer", () => {
+			const { component, onSubmit } = mountWithTui({ question: "Describe", multiline: true });
+			type(component, "line1");
+			component.handleInput(LF); // newline, not a submit
+			type(component, "line2");
+			expect(onSubmit).not.toHaveBeenCalled();
+			component.handleInput(CR); // Enter submits
+			expect(onSubmit).toHaveBeenCalledWith({ selected: [], customText: "line1\nline2" });
+		});
+
+		it("submits only once even if Enter is pressed repeatedly (one-time teardown)", () => {
+			const { component, onSubmit } = mountWithTui({ question: "Describe", multiline: true });
+			type(component, "hello");
+			component.handleInput(CR);
+			component.handleInput(CR);
+			expect(onSubmit).toHaveBeenCalledTimes(1);
+		});
+
+		it("dispose is safe and idempotent", () => {
+			const { component } = mountWithTui({ question: "Describe", multiline: true });
+			expect(() => {
+				component.dispose();
+				component.dispose();
+			}).not.toThrow();
+		});
+	});
 });
diff --git a/packages/coding-agent/test/tools/ask-user.test.ts b/packages/coding-agent/test/tools/ask-user.test.ts
index 01a47850..b0f914c7 100644
--- a/packages/coding-agent/test/tools/ask-user.test.ts
+++ b/packages/coding-agent/test/tools/ask-user.test.ts
@@ -181,6 +181,97 @@ describe("ask_user tool", () => {
 		expect(receivedSignal).toBe(controller.signal);
 	});
 
+	it("always offers free text when there are no options (never an unanswerable question)", async () => {
+		const def = createAskUserToolDefinition();
+		let received: AskRequest | undefined;
+		const ctx = makeCtx(async (request) => {
+			received = request;
+			return { selected: [], customText: "x" };
+		});
+		// allowFreeText:false with no options would leave only a Skip button —
+		// the tool must normalize this so the question can always be answered.
+		await run(def, { question: "Open ended?", allowFreeText: false }, ctx);
+		expect(received?.allowFreeText).toBe(true);
+	});
+
+	it("drops multiSelect and preserves free text when there are no options", async () => {
+		const def = createAskUserToolDefinition();
+		let received: AskRequest | undefined;
+		const ctx = makeCtx(async (request) => {
+			received = request;
+			return { selected: [], customText: "x" };
+		});
+		await run(def, { question: "Open ended?", multiSelect: true }, ctx);
+		expect(received?.multiSelect).toBeUndefined();
+		expect(received?.allowFreeText).toBe(true);
+	});
+
+	it("exposes a validated optional timeoutSeconds field in its schema", () => {
+		const def = createAskUserToolDefinition();
+		const props = (def.parameters as any).properties;
+		expect(props.timeoutSeconds.minimum).toBe(5);
+		expect(props.timeoutSeconds.maximum).toBe(3600);
+	});
+
+	it("forwards an optional timeout (seconds → milliseconds) to the UI layer", async () => {
+		const def = createAskUserToolDefinition();
+		let receivedOpts: { signal?: AbortSignal; timeout?: number } | undefined;
+		const ctx = makeCtx(async (_req, opts) => {
+			receivedOpts = opts;
+			return { selected: ["x"] };
+		});
+		await run(def, { question: "?", options: ["a", "b"], timeoutSeconds: 30 }, ctx);
+		expect(receivedOpts?.timeout).toBe(30_000);
+	});
+
+	it("passes no timeout when timeoutSeconds is omitted", async () => {
+		const def = createAskUserToolDefinition();
+		let receivedOpts: { signal?: AbortSignal; timeout?: number } | undefined;
+		const ctx = makeCtx(async (_req, opts) => {
+			receivedOpts = opts;
+			return { selected: ["x"] };
+		});
+		await run(def, { question: "?", options: ["a", "b"] }, ctx);
+		expect(receivedOpts?.timeout).toBeUndefined();
+	});
+
+	it("aborts a call while it waits in the queue without ever opening UI", async () => {
+		const def = createAskUserToolDefinition();
+		const asked: string[] = [];
+		let releaseFirst!: (result: AskResult) => void;
+		const firstGate = new Promise<AskResult>((resolve) => {
+			releaseFirst = resolve;
+		});
+		const ctx = makeCtx(async (request) => {
+			asked.push(request.question);
+			if (request.question === "first") return firstGate; // hangs until released
+			return { selected: [request.question] };
+		});
+
+		const controller = new AbortController();
+		const first = run(def, { question: "first" }, ctx);
+		const second = run(def, { question: "second" }, ctx, controller.signal);
+		const third = run(def, { question: "third" }, ctx);
+
+		// Let the active first call open its UI; the others must wait behind it.
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		expect(asked).toEqual(["first"]);
+
+		// Abort the second call while it is genuinely queued behind the active one.
+		controller.abort();
+		// Release the first so the queue can advance to the queued calls.
+		releaseFirst({ selected: ["first"] });
+
+		const [r1, r2, r3] = await Promise.all([first, second, third]);
+		expect(r1.details?.selected).toEqual(["first"]);
+		// The queued-then-aborted call resolves skipped and never opened the UI.
+		expect(r2.details?.skipped).toBe(true);
+		expect(r2.details?.unavailable).toBe(false);
+		// A later call still advances after the aborted one is dequeued.
+		expect(r3.details?.selected).toEqual(["third"]);
+		expect(asked).toEqual(["first", "third"]);
+	});
+
 	it("renders a call and result without throwing", () => {
 		const def = createAskUserToolDefinition();
 		const call = def.renderCall?.(
diff --git a/packages/dashboard/src/client/screens/session.tsx b/packages/dashboard/src/client/screens/session.tsx
index 4b3566be..d0f451ee 100644
--- a/packages/dashboard/src/client/screens/session.tsx
+++ b/packages/dashboard/src/client/screens/session.tsx
@@ -212,10 +212,43 @@ function AskUiInline(props: {
 	const submit = () => {
 		if (canSubmit()) respond(answer());
 	};
+	const skip = () => respond({ cancelled: true });
+
+	// Escape-to-skip, matching the TUI. A skip is always safe.
+	const onKeyDown = (event: KeyboardEvent) => {
+		if (event.key === "Escape") {
+			event.preventDefault();
+			skip();
+		}
+	};
+	onMount(() => window.addEventListener("keydown", onKeyDown));
+	onCleanup(() => window.removeEventListener("keydown", onKeyDown));
+
+	// Optional visible countdown. The host also auto-resolves on timeout; this
+	// mirrors the TUI countdown and auto-skips as a client-side backstop.
+	const [remaining, setRemaining] = createSignal(props.request.timeout ? Math.ceil(props.request.timeout / 1000) : 0);
+	if (props.request.timeout && props.request.timeout > 0) {
+		const interval = setInterval(() => {
+			setRemaining((current) => {
+				const next = current - 1;
+				if (next <= 0) {
+					clearInterval(interval);
+					skip();
+				}
+				return next;
+			});
+		}, 1000);
+		onCleanup(() => clearInterval(interval));
+	}
 
 	return (
 		<section class="ask-inline" aria-label={props.request.title}>
-			<header class="ask-inline-header">{props.request.title}</header>
+			<header class="ask-inline-header">
+				{props.request.title}
+				<Show when={props.request.timeout && props.request.timeout > 0}>
+					<span class="ask-inline-countdown"> (auto-skips in {remaining()}s)</span>
+				</Show>
+			</header>
 			<Show when={props.request.question}>
 				<p class="ask-inline-question">{props.request.question}</p>
 			</Show>
@@ -264,7 +297,7 @@ function AskUiInline(props: {
 				</div>
 			</Show>
 			<div class="ask-inline-actions">
-				<button type="button" class="btn btn-small" onClick={() => respond({ cancelled: true })}>
+				<button type="button" class="btn btn-small" onClick={skip}>
 					skip
 				</button>
 				<button type="button" class="btn btn-small btn-primary" disabled={!canSubmit()} onClick={submit}>
diff --git a/packages/dashboard/src/client/state/reducer.ts b/packages/dashboard/src/client/state/reducer.ts
index fbbca05b..e7a7e7e3 100644
--- a/packages/dashboard/src/client/state/reducer.ts
+++ b/packages/dashboard/src/client/state/reducer.ts
@@ -118,6 +118,8 @@ export interface ExtensionUiRequest {
 	multiSelect?: boolean;
 	/** ask: use a multi-line text area for free text. */
 	multiline?: boolean;
+	/** ask: auto-skip after this many milliseconds; drives the visible countdown. */
+	timeout?: number;
 }
 
 export function extensionUiRequestFromEvent(event: any): ExtensionUiRequest | undefined {
@@ -143,6 +145,7 @@ export function extensionUiRequestFromEvent(event: any): ExtensionUiRequest | un
 			allowFreeText: event.allowFreeText as boolean | undefined,
 			multiSelect: event.multiSelect as boolean | undefined,
 			multiline: event.multiline as boolean | undefined,
+			timeout: typeof event.timeout === "number" ? (event.timeout as number) : undefined,
 		};
 	}
 	return undefined;
diff --git a/packages/dashboard/src/client/styles/app.css b/packages/dashboard/src/client/styles/app.css
index a8e6b9f9..217f647e 100644
--- a/packages/dashboard/src/client/styles/app.css
+++ b/packages/dashboard/src/client/styles/app.css
@@ -2230,6 +2230,11 @@ details.thinking .thinking-body {
 	color: var(--text);
 }
 
+.ask-inline-countdown {
+	font-weight: 400;
+	color: var(--muted);
+}
+
 .ask-inline-question {
 	margin: 0 0 var(--space-2);
 	color: var(--text);
diff --git a/packages/dashboard/test/client/screens.test.tsx b/packages/dashboard/test/client/screens.test.tsx
index fb0e72da..a4363504 100644
--- a/packages/dashboard/test/client/screens.test.tsx
+++ b/packages/dashboard/test/client/screens.test.tsx
@@ -1173,6 +1173,135 @@ describe("screen smoke tests", () => {
 		expect(resolveUiRequest).toHaveBeenCalledWith("k-ask-retry", "a-retry");
 	});
 
+	it("retains a selected + typed answer across a failed send and resends it on retry", async () => {
+		const store = makeStore() as any;
+		const session = createSessionViewState("k-ask-state");
+		session.uiRequests = [
+			{
+				id: "a-state",
+				method: "ask",
+				title: "Pick",
+				question: "Which?",
+				options: ["A", "B"],
+				allowFreeText: true,
+			},
+		];
+		const resolveUiRequest = vi.fn();
+		const fakeStore = {
+			...store,
+			sessions: { "k-ask-state": session },
+			fleet: () => ({ runtimes: [], diskSessions: [] }),
+			hydrateSession: async () => {},
+			resolveUiRequest,
+		};
+		vi.mocked(api.extensionUiResponse).mockClear();
+		vi.mocked(api.extensionUiResponse).mockRejectedValueOnce(new Error("offline"));
+		const el = mount(() => <SessionScreen store={fakeStore} sessionKey="k-ask-state" />);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		// Choose an option and type free text, then fail the send.
+		const radio = el.querySelector<HTMLInputElement>('.ask-option input[type="radio"]');
+		if (!radio) throw new Error("radio missing");
+		radio.click();
+		const custom = el.querySelector<HTMLInputElement>('input[id^="ask-custom-"]');
+		if (!custom) throw new Error("free-text field missing");
+		custom.value = "extra";
+		custom.dispatchEvent(new Event("input", { bubbles: true }));
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		const submitButton = () => [...el.querySelectorAll("button")].find((b) => b.textContent === "submit");
+		submitButton()?.click();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		// Failure keeps the question and preserves the entered answer state.
+		expect(resolveUiRequest).not.toHaveBeenCalled();
+		expect(el.querySelector(".ask-inline")).not.toBeNull();
+		expect(el.querySelector<HTMLInputElement>('.ask-option input[type="radio"]')?.checked).toBe(true);
+		expect(el.querySelector<HTMLInputElement>('input[id^="ask-custom-"]')?.value).toBe("extra");
+
+		// Retry succeeds and sends the same retained answer, not a stateless skip.
+		vi.mocked(api.extensionUiResponse).mockResolvedValueOnce({ ok: true });
+		submitButton()?.click();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		expect(vi.mocked(api.extensionUiResponse)).toHaveBeenLastCalledWith(
+			"k-ask-state",
+			expect.objectContaining({ id: "a-state", selected: ["A"], customText: "extra" }),
+		);
+		expect(resolveUiRequest).toHaveBeenCalledWith("k-ask-state", "a-state");
+	});
+
+	it("suppresses duplicate sends while a response POST is still in flight", async () => {
+		const store = makeStore() as any;
+		const session = createSessionViewState("k-ask-dedup");
+		session.uiRequests = [{ id: "a-dedup", method: "ask", title: "Pick", question: "Which?", options: ["A", "B"] }];
+		const fakeStore = {
+			...store,
+			sessions: { "k-ask-dedup": session },
+			fleet: () => ({ runtimes: [], diskSessions: [] }),
+			hydrateSession: async () => {},
+		};
+		vi.mocked(api.extensionUiResponse).mockClear();
+		let release!: () => void;
+		vi.mocked(api.extensionUiResponse).mockReturnValueOnce(
+			new Promise((resolve) => {
+				release = () => resolve({ ok: true });
+			}),
+		);
+		const el = mount(() => <SessionScreen store={fakeStore} sessionKey="k-ask-dedup" />);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		const radio = el.querySelector<HTMLInputElement>('.ask-option input[type="radio"]');
+		if (!radio) throw new Error("radio missing");
+		radio.click();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		const submitButton = () => [...el.querySelectorAll("button")].find((b) => b.textContent === "submit");
+		// Three rapid clicks while the first POST is still pending.
+		submitButton()?.click();
+		submitButton()?.click();
+		submitButton()?.click();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		expect(vi.mocked(api.extensionUiResponse)).toHaveBeenCalledTimes(1);
+		release();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+	});
+
+	it("skips an ask request when Escape is pressed and shows a timeout countdown", async () => {
+		const store = makeStore() as any;
+		const session = createSessionViewState("k-ask-esc");
+		session.uiRequests = [
+			{
+				id: "a-esc",
+				method: "ask",
+				title: "Pick",
+				question: "Which?",
+				options: ["A", "B"],
+				timeout: 30_000,
+			},
+		];
+		const fakeStore = {
+			...store,
+			sessions: { "k-ask-esc": session },
+			fleet: () => ({ runtimes: [], diskSessions: [] }),
+			hydrateSession: async () => {},
+		};
+		vi.mocked(api.extensionUiResponse).mockClear();
+		const el = mount(() => <SessionScreen store={fakeStore} sessionKey="k-ask-esc" />);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		// A visible auto-skip countdown mirrors the TUI.
+		expect(el.textContent).toContain("auto-skips in");
+
+		// Escape skips, matching the TUI keyboard model.
+		window.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape" }));
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		expect(vi.mocked(api.extensionUiResponse)).toHaveBeenCalledWith(
+			"k-ask-esc",
+			expect.objectContaining({ type: "extension_ui_response", id: "a-esc", cancelled: true }),
+		);
+	});
+
 	it("ask_user tool card stays collapsed while running (unlike other running tools)", async () => {
 		const store = makeStore() as any;
 		const session = createSessionViewState("k-ask-collapse");
diff --git a/packages/dashboard/test/runtime-pool.test.ts b/packages/dashboard/test/runtime-pool.test.ts
index 397c8849..6e369bc4 100644
--- a/packages/dashboard/test/runtime-pool.test.ts
+++ b/packages/dashboard/test/runtime-pool.test.ts
@@ -529,6 +529,18 @@ describe("RuntimePool", () => {
 		expect(handle.attention.size).toBe(0);
 	});
 
+	it("tracks needs-attention from an ask_user request and clears when handled", async () => {
+		const { pool, clients } = makePool();
+		const handle = await pool.create("/tmp");
+		// The `ask` method must be in the needs-attention allowlist just like the
+		// other blocking dialog methods, so fleet snapshots surface an open
+		// ask_user question.
+		clients[0].emit({ type: "extension_ui_request", id: "ask-1", method: "ask" });
+		expect(handle.attention.get("ui:ask-1")).toBe("extension ask awaiting response");
+		clients[0].emit({ type: "extension_ui_response_handled", id: "ask-1" });
+		expect(handle.attention.size).toBe(0);
+	});
+
 	it("tracks needs-attention from parent_paused and clears on agent_end", async () => {
 		const { pool, clients } = makePool();
 		const handle = await pool.create("/tmp");

From ac968b14a2f6953fb489cbf97e6eefc498db44e6 Mon Sep 17 00:00:00 2001
From: Maximilian Scheurer <11406414+maxscheurer@users.noreply.github.com>
Date: Wed, 29 Jul 2026 22:27:26 +0200
Subject: [PATCH 10/15] ask_user: restore pending Dashboard question on
 drill-in, cover timeout backstop

---
 packages/dashboard/src/client/state/store.ts  |  9 ++++
 .../dashboard/test/client/screens.test.tsx    | 41 +++++++++++++++++++
 packages/dashboard/test/client/store.test.ts  | 31 ++++++++++++++
 3 files changed, 81 insertions(+)

diff --git a/packages/dashboard/src/client/state/store.ts b/packages/dashboard/src/client/state/store.ts
index 2b15d06b..3e2151bb 100644
--- a/packages/dashboard/src/client/state/store.ts
+++ b/packages/dashboard/src/client/state/store.ts
@@ -931,7 +931,16 @@ export function createAppStore() {
 					session.workingSince = undefined;
 					session.workingText = undefined;
 				}
+				// Restore blocking dialogs from the same authoritative RPC boundary as
+				// the recovery snapshot path (hydrateSnapshot). Without this a drill-in
+				// into a session with a pending ask_user question would silently drop
+				// the only answer UI, leaving the agent blocked on an unreachable
+				// promise. Post-barrier replay below applies any newer resolve/request.
+				session.uiRequests = (snapshot.pendingExtensionUiRequests ?? [])
+					.map((request) => extensionUiRequestFromEvent(request))
+					.filter((request) => request !== undefined);
 				restoreSnapshotOutcomeState(session, messages, snapshot.state);
+				updateAttention(session);
 			});
 			bumpTaskRevision(key);
 			// The runtime snapshot is authoritative, including a lower count after a
diff --git a/packages/dashboard/test/client/screens.test.tsx b/packages/dashboard/test/client/screens.test.tsx
index a4363504..fc0703a7 100644
--- a/packages/dashboard/test/client/screens.test.tsx
+++ b/packages/dashboard/test/client/screens.test.tsx
@@ -1302,6 +1302,47 @@ describe("screen smoke tests", () => {
 		);
 	});
 
+	it("auto-skips an ask request exactly once when the client-side countdown reaches zero", async () => {
+		vi.useFakeTimers();
+		const store = makeStore() as any;
+		const session = createSessionViewState("k-ask-timeout");
+		session.uiRequests = [
+			{
+				id: "a-timeout",
+				method: "ask",
+				title: "Pick",
+				question: "Which?",
+				options: ["A", "B"],
+				timeout: 30_000,
+			},
+		];
+		const fakeStore = {
+			...store,
+			sessions: { "k-ask-timeout": session },
+			fleet: () => ({ runtimes: [], diskSessions: [] }),
+			hydrateSession: async () => {},
+		};
+		vi.mocked(api.extensionUiResponse).mockClear();
+		mount(() => <SessionScreen store={fakeStore} sessionKey="k-ask-timeout" />);
+		await vi.advanceTimersByTimeAsync(0);
+
+		// Not yet fired one tick before the deadline.
+		await vi.advanceTimersByTimeAsync(29_000);
+		expect(vi.mocked(api.extensionUiResponse)).not.toHaveBeenCalled();
+
+		// The countdown backstop auto-skips with a single cancelled response at zero.
+		await vi.advanceTimersByTimeAsync(1_000);
+		expect(vi.mocked(api.extensionUiResponse)).toHaveBeenCalledTimes(1);
+		expect(vi.mocked(api.extensionUiResponse)).toHaveBeenCalledWith(
+			"k-ask-timeout",
+			expect.objectContaining({ type: "extension_ui_response", id: "a-timeout", cancelled: true }),
+		);
+
+		// clearInterval on fire prevents any repeated auto-skip.
+		await vi.advanceTimersByTimeAsync(60_000);
+		expect(vi.mocked(api.extensionUiResponse)).toHaveBeenCalledTimes(1);
+	});
+
 	it("ask_user tool card stays collapsed while running (unlike other running tools)", async () => {
 		const store = makeStore() as any;
 		const session = createSessionViewState("k-ask-collapse");
diff --git a/packages/dashboard/test/client/store.test.ts b/packages/dashboard/test/client/store.test.ts
index b69a39e1..f98bdef8 100644
--- a/packages/dashboard/test/client/store.test.ts
+++ b/packages/dashboard/test/client/store.test.ts
@@ -1080,6 +1080,37 @@ describe("app store hydration", () => {
 		expect(store.sessions.s1?.workingSince).toEqual(expect.any(Number));
 	});
 
+	it("restores a pending ask and attention when drilling into a session", async () => {
+		const snapshot = hydrationSnapshot("s1", false);
+		snapshot.pendingExtensionUiRequests = [
+			{
+				type: "extension_ui_request",
+				id: "ask-pending",
+				method: "ask",
+				title: "Choose a database",
+				question: "Which one?",
+				options: ["SQLite", "Postgres"],
+				allowFreeText: true,
+				multiSelect: false,
+				multiline: false,
+			},
+		];
+		vi.mocked(api.hydrate).mockResolvedValueOnce(snapshot);
+		const store = createAppStore();
+
+		await store.hydrateSession("s1");
+
+		expect(store.sessions.s1?.uiRequests).toEqual([
+			expect.objectContaining({
+				id: "ask-pending",
+				method: "ask",
+				question: "Which one?",
+				options: ["SQLite", "Postgres"],
+			}),
+		]);
+		expect(store.sessions.s1?.needsAttention).toBe(true);
+	});
+
 	it("restores an idle terminal provider failure during hydration", async () => {
 		const snapshot = hydrationSnapshot("s1", false);
 		snapshot.messages = [

From f4ba1dac4ddff07f3648d3de26779b00ae800023 Mon Sep 17 00:00:00 2001
From: Maximilian Scheurer <11406414+maxscheurer@users.noreply.github.com>
Date: Thu, 30 Jul 2026 16:31:50 +0200
Subject: [PATCH 11/15] ask_user: cover timeout wire-chain and multiline
 normalization

---
 .../test/rpc-extension-ui-ask.test.ts         | 18 +++++++++++
 .../coding-agent/test/tools/ask-user.test.ts  | 29 +++++++++++++++++
 packages/dashboard/test/reducer.test.ts       | 31 +++++++++++++++++++
 3 files changed, 78 insertions(+)

diff --git a/packages/coding-agent/test/rpc-extension-ui-ask.test.ts b/packages/coding-agent/test/rpc-extension-ui-ask.test.ts
index 282b76ad..46963fcf 100644
--- a/packages/coding-agent/test/rpc-extension-ui-ask.test.ts
+++ b/packages/coding-agent/test/rpc-extension-ui-ask.test.ts
@@ -58,6 +58,24 @@ describe("RPC ask round trip", () => {
 		await p;
 	});
 
+	it("emits the auto-skip timeout in the ask request when one is provided", async () => {
+		const h = harness();
+		const p = h.ctx.ask({ question: "Which?", options: ["a"] }, { timeout: 30_000 });
+		// The Dashboard countdown and client auto-skip backstop are driven by this
+		// field; without it in the emitted request the browser never counts down.
+		expect((h.emitted[0] as any).timeout).toBe(30_000);
+		h.respond({ selected: ["a"] } as any);
+		await p;
+	});
+
+	it("omits the timeout in the ask request when none is provided", async () => {
+		const h = harness();
+		const p = h.ctx.ask({ question: "Which?", options: ["a"] });
+		expect((h.emitted[0] as any).timeout).toBeUndefined();
+		h.respond({ selected: ["a"] } as any);
+		await p;
+	});
+
 	it("uses the provided title when set", async () => {
 		const h = harness();
 		const p = h.ctx.ask({ title: "Pick storage", question: "Which DB?", options: ["a"] });
diff --git a/packages/coding-agent/test/tools/ask-user.test.ts b/packages/coding-agent/test/tools/ask-user.test.ts
index b0f914c7..da54cc46 100644
--- a/packages/coding-agent/test/tools/ask-user.test.ts
+++ b/packages/coding-agent/test/tools/ask-user.test.ts
@@ -206,6 +206,35 @@ describe("ask_user tool", () => {
 		expect(received?.allowFreeText).toBe(true);
 	});
 
+	it("drops multiline when options exist and free text is disabled", async () => {
+		const def = createAskUserToolDefinition();
+		let received: AskRequest | undefined;
+		const ctx = makeCtx(async (request) => {
+			received = request;
+			return { selected: ["a"] };
+		});
+		// With options and no free-text field there is no text area to make
+		// multiline; the flag must be dropped rather than forwarded meaninglessly.
+		await run(def, { question: "Pick?", options: ["a", "b"], allowFreeText: false, multiline: true }, ctx);
+		expect(received?.multiline).toBeUndefined();
+		expect(received?.allowFreeText).toBe(false);
+	});
+
+	it("preserves multiline for an open-ended question with no options", async () => {
+		const def = createAskUserToolDefinition();
+		let received: AskRequest | undefined;
+		const ctx = makeCtx(async (request) => {
+			received = request;
+			return { selected: [], customText: "line1\nline2" };
+		});
+		// No options → free text is always offered, so a multiline request must
+		// survive normalization (otherwise open-ended answers silently collapse
+		// to a single-line input on both surfaces).
+		await run(def, { question: "Describe the bug", multiline: true }, ctx);
+		expect(received?.multiline).toBe(true);
+		expect(received?.allowFreeText).toBe(true);
+	});
+
 	it("exposes a validated optional timeoutSeconds field in its schema", () => {
 		const def = createAskUserToolDefinition();
 		const props = (def.parameters as any).properties;
diff --git a/packages/dashboard/test/reducer.test.ts b/packages/dashboard/test/reducer.test.ts
index 4c4a3072..b6a38d07 100644
--- a/packages/dashboard/test/reducer.test.ts
+++ b/packages/dashboard/test/reducer.test.ts
@@ -998,6 +998,37 @@ describe("applySessionEvent — extension UI", () => {
 		expect(state.needsAttention).toBe(false);
 	});
 
+	it("extracts a numeric ask timeout onto the ui request (drives the countdown)", () => {
+		const state = makeState();
+		applySessionEvent(state, {
+			type: "extension_ui_request",
+			id: "a-timeout",
+			method: "ask",
+			title: "Choose",
+			question: "Which?",
+			options: ["a", "b"],
+			timeout: 30_000,
+		});
+		// The visible countdown and client auto-skip backstop read this value; if
+		// the reducer drops it, the Dashboard never counts down even though the
+		// runtime auto-skips.
+		expect(state.uiRequests[0]?.timeout).toBe(30_000);
+	});
+
+	it("ignores a non-numeric ask timeout (guards against malformed events)", () => {
+		const state = makeState();
+		applySessionEvent(state, {
+			type: "extension_ui_request",
+			id: "a-bad-timeout",
+			method: "ask",
+			title: "Choose",
+			question: "Which?",
+			options: ["a"],
+			timeout: "soon",
+		});
+		expect(state.uiRequests[0]?.timeout).toBeUndefined();
+	});
+
 	it("agent_start clears pending UI requests (server resolved them)", () => {
 		const state = makeState();
 		applySessionEvent(state, {

From 578919b1b9c6284288ffd22529ad69d08da286c7 Mon Sep 17 00:00:00 2001
From: Maximilian Scheurer <11406414+maxscheurer@users.noreply.github.com>
Date: Thu, 30 Jul 2026 16:42:03 +0200
Subject: [PATCH 12/15] ask_user: remove Stage-1 UX prototype scaffolding

---
 packages/dashboard/package.json               |   1 -
 .../test/client/ask-user.browser-harness.html |  12 -
 .../test/client/ask-user.browser-harness.tsx  | 352 ------------------
 .../test/client/ask-user.browser.test.ts      | 142 -------
 .../test/client/ask-user.vite.config.ts       |  21 --
 5 files changed, 528 deletions(-)
 delete mode 100644 packages/dashboard/test/client/ask-user.browser-harness.html
 delete mode 100644 packages/dashboard/test/client/ask-user.browser-harness.tsx
 delete mode 100644 packages/dashboard/test/client/ask-user.browser.test.ts
 delete mode 100644 packages/dashboard/test/client/ask-user.vite.config.ts

diff --git a/packages/dashboard/package.json b/packages/dashboard/package.json
index 9d5fe6b7..9f807e6d 100644
--- a/packages/dashboard/package.json
+++ b/packages/dashboard/package.json
@@ -28,7 +28,6 @@
 		"clean": "shx rm -rf dist",
 		"build": "tsgo -p tsconfig.build.json && vite build && shx chmod +x dist/index.js",
 		"dev": "tsgo -p tsconfig.build.json --watch --preserveWatchOutput",
-		"prototype:ask-user": "vite --config test/client/ask-user.vite.config.ts",
 		"profile:mobile": "node scripts/profile-mobile.mjs",
 		"test": "vitest --run",
 		"prepublishOnly": "npm run clean && npm run build"
diff --git a/packages/dashboard/test/client/ask-user.browser-harness.html b/packages/dashboard/test/client/ask-user.browser-harness.html
deleted file mode 100644
index 7bbfa33c..00000000
--- a/packages/dashboard/test/client/ask-user.browser-harness.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<!doctype html>
-<html lang="en">
-	<head>
-		<meta charset="UTF-8" />
-		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
-		<title>ask_user UX prototype — dreb</title>
-	</head>
-	<body>
-		<div id="app"></div>
-		<script type="module" src="./ask-user.browser-harness.tsx"></script>
-	</body>
-</html>
diff --git a/packages/dashboard/test/client/ask-user.browser-harness.tsx b/packages/dashboard/test/client/ask-user.browser-harness.tsx
deleted file mode 100644
index 94327981..00000000
--- a/packages/dashboard/test/client/ask-user.browser-harness.tsx
+++ /dev/null
@@ -1,352 +0,0 @@
-import { createEffect, createSignal, For, onCleanup, onMount, Show } from "solid-js";
-import { render } from "solid-js/web";
-
-type ScenarioId = "single" | "multiple" | "free-text" | "multiline" | "timeout" | "aborted";
-type Surface = "dashboard" | "tui";
-
-interface Scenario {
-	id: ScenarioId;
-	label: string;
-	title: string;
-	question: string;
-	options: string[];
-	multiSelect?: boolean;
-	multiline?: boolean;
-	terminal?: "timed out" | "cancelled";
-}
-
-const scenarios: Scenario[] = [
-	{
-		id: "single",
-		label: "single choice",
-		title: "Choose an implementation",
-		question: "Which persistence strategy should I use?",
-		options: ["SQLite", "PostgreSQL", "Keep the current JSON file"],
-	},
-	{
-		id: "multiple",
-		label: "multiple choice",
-		title: "Select validation targets",
-		question: "Which checks should run before each release?",
-		options: ["Unit tests", "Browser tests", "Type checking", "Workspace link verification"],
-		multiSelect: true,
-	},
-	{
-		id: "free-text",
-		label: "free text",
-		title: "Name the new command",
-		question: "What should the user-facing command be called?",
-		options: [],
-	},
-	{
-		id: "multiline",
-		label: "multiline",
-		title: "Describe the migration constraint",
-		question: "What compatibility requirements must the migration preserve?",
-		options: [],
-		multiline: true,
-	},
-	{
-		id: "timeout",
-		label: "timeout",
-		title: "Choose a deployment window",
-		question: "When may I restart the production service?",
-		options: ["Now", "After 18:00 UTC"],
-		terminal: "timed out",
-	},
-	{
-		id: "aborted",
-		label: "abort",
-		title: "Confirm the target",
-		question: "Which environment should receive this change?",
-		options: ["Staging", "Production"],
-		terminal: "cancelled",
-	},
-];
-
-function answerSummary(selected: string[], custom: string): string {
-	return [...selected, custom.trim()].filter(Boolean).join("; ");
-}
-
-function AskPanel(props: { scenario: Scenario; surface: Surface }): JSX.Element {
-	const [selected, setSelected] = createSignal<string[]>([]);
-	const [custom, setCustom] = createSignal("");
-	const [outcome, setOutcome] = createSignal<"answered" | "skipped" | undefined>();
-	const terminal = () => props.scenario.terminal;
-	const disabled = () => terminal() !== undefined || outcome() !== undefined;
-	const inputId = () => `${props.surface}-${props.scenario.id}-custom`;
-	const groupName = () => `${props.surface}-${props.scenario.id}-options`;
-
-	createEffect(() => {
-		props.scenario.id;
-		setSelected([]);
-		setCustom("");
-		setOutcome(undefined);
-	});
-
-	const toggle = (option: string) => {
-		if (disabled()) return;
-		if (!props.scenario.multiSelect) {
-			setSelected([option]);
-			return;
-		}
-		setSelected((current) =>
-			current.includes(option) ? current.filter((value) => value !== option) : [...current, option],
-		);
-	};
-	const submit = () => {
-		if (!disabled() && answerSummary(selected(), custom())) setOutcome("answered");
-	};
-
-	return (
-		<section
-			class={`surface surface-${props.surface}`}
-			data-testid={`${props.surface}-surface`}
-			aria-label={`${props.surface === "dashboard" ? "Dashboard" : "TUI"} ask user prototype`}
-		>
-			<div class="surface-heading">
-				<span>{props.surface === "dashboard" ? "Dashboard" : "TUI"}</span>
-				<span class="attention">◆ needs attention</span>
-			</div>
-			<div class="question-frame">
-				<header>
-					<strong>
-						{props.surface === "tui" ? "? " : ""}
-						{props.scenario.title}
-					</strong>
-					<span class="timer" classList={{ expired: terminal() === "timed out" }}>
-						{terminal() === "timed out"
-							? "timed out"
-							: terminal() === "cancelled"
-								? "cancelled"
-								: "01:42 remaining"}
-					</span>
-				</header>
-				<p class="question">{props.scenario.question}</p>
-
-				<Show when={!terminal()} fallback={<TerminalState kind={terminal()!} />}>
-					<Show when={props.scenario.options.length > 0}>
-						<fieldset disabled={disabled()}>
-							<legend>{props.scenario.multiSelect ? "Choose one or more" : "Choose one"}</legend>
-							<For each={props.scenario.options}>
-								{(option) => (
-									<label class="option" classList={{ selected: selected().includes(option) }}>
-										<input
-											type={props.scenario.multiSelect ? "checkbox" : "radio"}
-											name={groupName()}
-											checked={selected().includes(option)}
-											onChange={() => toggle(option)}
-										/>
-										<Show when={props.surface === "tui"}>
-											<span class="control-glyph" aria-hidden="true">
-												{props.scenario.multiSelect
-													? selected().includes(option)
-														? "[x]"
-														: "[ ]"
-													: selected().includes(option)
-														? "(●)"
-														: "( )"}
-											</span>
-										</Show>
-										<span>{option}</span>
-									</label>
-								)}
-							</For>
-						</fieldset>
-					</Show>
-
-					<div class="custom-answer">
-						<label for={inputId()}>
-							{props.scenario.options.length > 0 ? "Or type your own answer" : "Your answer"}
-						</label>
-						<Show
-							when={props.scenario.multiline}
-							fallback={
-								<input
-									id={inputId()}
-									type="text"
-									value={custom()}
-									disabled={disabled()}
-									placeholder="Type a different answer…"
-									onInput={(event) => setCustom(event.currentTarget.value)}
-								/>
-							}
-						>
-							<textarea
-								id={inputId()}
-								rows="5"
-								value={custom()}
-								disabled={disabled()}
-								placeholder="Add details and constraints…"
-								onInput={(event) => setCustom(event.currentTarget.value)}
-							/>
-						</Show>
-					</div>
-
-					<Show
-						when={!outcome()}
-						fallback={
-							<output class={`result result-${outcome()}`}>
-								{outcome() === "skipped"
-									? "Question skipped — the agent will continue."
-									: `Answer: ${answerSummary(selected(), custom())}`}
-							</output>
-						}
-					>
-						<footer>
-							<span class="hint">Esc skips without answering</span>
-							<div class="actions">
-								<button type="button" class="button secondary" onClick={() => setOutcome("skipped")}>
-									Skip
-								</button>
-								<button
-									type="button"
-									class="button primary"
-									disabled={!answerSummary(selected(), custom())}
-									onClick={submit}
-								>
-									Submit answer
-								</button>
-							</div>
-						</footer>
-					</Show>
-				</Show>
-			</div>
-		</section>
-	);
-}
-
-function TerminalState(props: { kind: "timed out" | "cancelled" }): JSX.Element {
-	return (
-		<output class="terminal-state">
-			<strong>{props.kind === "timed out" ? "No answer received" : "Question cancelled"}</strong>
-			<span>
-				{props.kind === "timed out"
-					? "The time limit elapsed. The agent will continue without an answer."
-					: "The request was aborted. The agent will continue without an answer."}
-			</span>
-		</output>
-	);
-}
-
-export function AskUserPrototype(): JSX.Element {
-	const [scenarioId, setScenarioId] = createSignal<ScenarioId>("single");
-	const scenario = () => scenarios.find((item) => item.id === scenarioId()) ?? scenarios[0];
-
-	onMount(() => {
-		const onKeyDown = (event: KeyboardEvent) => {
-			if (event.key !== "Escape") return;
-			document.querySelectorAll<HTMLButtonElement>("[data-testid$='-surface'] .secondary").forEach((button) => {
-				button.click();
-			});
-		};
-		window.addEventListener("keydown", onKeyDown);
-		onCleanup(() => window.removeEventListener("keydown", onKeyDown));
-	});
-
-	return (
-		<main>
-			<style>{prototypeStyles}</style>
-			<header class="prototype-header">
-				<div>
-					<p class="eyebrow">development-only UX prototype</p>
-					<h1>
-						<code>ask_user</code> cross-surface interaction
-					</h1>
-					<p class="intro">Compare equivalent Dashboard and terminal treatments before runtime wiring begins.</p>
-				</div>
-				<section class="contract" aria-label="Interaction contract">
-					<strong>Shared contract</strong>
-					<span>Options stay visible while typing</span>
-					<span>Free text is available by default</span>
-					<span>Multiple selections combine with custom text</span>
-					<span>Skip, Escape, timeout, and abort always continue safely</span>
-				</section>
-			</header>
-
-			<nav class="scenario-picker" aria-label="Prototype state">
-				<For each={scenarios}>
-					{(item) => (
-						<button
-							type="button"
-							classList={{ active: scenarioId() === item.id }}
-							onClick={() => setScenarioId(item.id)}
-						>
-							{item.label}
-						</button>
-					)}
-				</For>
-			</nav>
-
-			<div class="comparison">
-				<AskPanel scenario={scenario()} surface="dashboard" />
-				<AskPanel scenario={scenario()} surface="tui" />
-			</div>
-		</main>
-	);
-}
-
-const prototypeStyles = `
-:root { color-scheme: dark; font-family: "IBM Plex Mono", "SFMono-Regular", Consolas, monospace; background: #0a0a0a; color: #f2f2f2; }
-* { box-sizing: border-box; }
-body { margin: 0; min-width: 320px; background: radial-gradient(circle at 50% -20%, #243226 0, #0a0a0a 38rem); }
-button, input, textarea { font: inherit; }
-button:focus-visible, input:focus-visible, textarea:focus-visible { outline: 2px solid #8bd99b; outline-offset: 2px; }
-main { width: min(1240px, calc(100% - 32px)); margin: 0 auto; padding: 40px 0 64px; }
-.prototype-header { display: grid; grid-template-columns: minmax(0, 1fr) minmax(300px, 440px); gap: 32px; align-items: end; border-bottom: 1px solid #424242; padding-bottom: 26px; }
-.eyebrow { color: #8bd99b; text-transform: uppercase; letter-spacing: .12em; font-size: 12px; margin: 0 0 10px; }
-h1 { font-size: clamp(24px, 4vw, 42px); line-height: 1.08; margin: 0; max-width: 720px; }
-h1 code { color: #8bd99b; }
-.intro { color: #adadad; max-width: 620px; line-height: 1.55; }
-.contract { border: 1px solid #48594c; background: #111a13; padding: 16px; display: grid; gap: 7px; font-size: 12px; color: #c8d6ca; }
-.contract strong { color: #8bd99b; margin-bottom: 4px; }
-.contract span::before { content: "✓ "; color: #8bd99b; }
-.scenario-picker { display: flex; flex-wrap: wrap; gap: 8px; margin: 24px 0; }
-.scenario-picker button { color: #bdbdbd; background: #111; border: 1px solid #444; padding: 8px 12px; cursor: pointer; }
-.scenario-picker button:hover { border-color: #777; color: white; }
-.scenario-picker button.active { background: #d9f7df; border-color: #d9f7df; color: #101510; }
-.comparison { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 24px; align-items: start; }
-.surface { min-width: 0; }
-.surface-heading { display: flex; justify-content: space-between; align-items: center; color: #aaa; font-size: 12px; text-transform: uppercase; letter-spacing: .1em; margin-bottom: 8px; }
-.attention { color: #f0be62; letter-spacing: 0; text-transform: none; }
-.question-frame { min-height: 510px; border: 1px solid #555; background: #151515; box-shadow: 0 20px 50px #0008; padding: 24px; }
-.surface-dashboard .question-frame { border-radius: 8px; background: #171817; }
-.surface-tui .question-frame { border: 1px solid #7b7b7b; box-shadow: inset 0 0 0 1px #202020, 0 20px 50px #0008; }
-.surface-tui .question-frame::before { content: "┌─ dreb question ─────────────────────────────┐"; display: block; color: #777; overflow: hidden; white-space: nowrap; margin: -19px -15px 16px; }
-.question-frame > header { display: flex; align-items: start; justify-content: space-between; gap: 16px; padding-bottom: 14px; border-bottom: 1px solid #414141; }
-.question-frame > header strong { color: #fff; }
-.surface-tui .question-frame > header strong { color: #8bd99b; }
-.timer { color: #91c79b; white-space: nowrap; font-size: 12px; }
-.timer.expired { color: #e69686; }
-.question { color: #ddd; line-height: 1.5; margin: 18px 0; }
-fieldset { border: 0; padding: 0; margin: 0 0 18px; display: grid; gap: 7px; }
-legend { color: #888; font-size: 11px; text-transform: uppercase; letter-spacing: .08em; margin-bottom: 8px; }
-.option { display: flex; gap: 10px; align-items: center; border: 1px solid #3d3d3d; padding: 10px 12px; cursor: pointer; color: #d0d0d0; }
-.surface-dashboard .option { border-radius: 5px; }
-.option:hover { border-color: #777; }
-.option.selected { border-color: #78c989; background: #18251b; color: white; }
-.surface-dashboard .option input { width: 16px; height: 16px; margin: 0 2px 0 0; accent-color: #78c989; flex: 0 0 auto; cursor: pointer; }
-.surface-tui .option input { position: absolute; opacity: 0; pointer-events: none; }
-.control-glyph { color: #777; min-width: 26px; }
-.option.selected .control-glyph { color: #8bd99b; }
-.custom-answer { display: grid; gap: 7px; }
-.custom-answer label { color: #aaa; font-size: 12px; }
-.custom-answer input, .custom-answer textarea { width: 100%; color: #f2f2f2; background: #0b0b0b; border: 1px solid #555; border-radius: 4px; padding: 10px 11px; resize: vertical; }
-.surface-tui .custom-answer input, .surface-tui .custom-answer textarea { border-radius: 0; border-color: #777; }
-footer { border-top: 1px solid #414141; margin-top: 22px; padding-top: 16px; display: flex; gap: 16px; justify-content: space-between; align-items: center; }
-.hint { color: #777; font-size: 11px; }
-.actions { display: flex; gap: 8px; }
-.button { border: 1px solid #666; padding: 8px 12px; cursor: pointer; }
-.button.secondary { color: #ccc; background: transparent; }
-.button.primary { color: #101510; background: #a9e6b5; border-color: #a9e6b5; }
-.button:disabled { opacity: .35; cursor: not-allowed; }
-.result, .terminal-state { display: block; width: 100%; margin-top: 22px; border: 1px solid #4f7657; background: #142019; color: #bce4c4; padding: 14px; line-height: 1.45; }
-.result-skipped, .terminal-state { border-color: #6e624b; background: #211d14; color: #e4d4b5; }
-.terminal-state { min-height: 150px; display: grid; place-content: center; text-align: center; gap: 10px; }
-.terminal-state span { color: #b8ab92; max-width: 400px; }
-@media (max-width: 850px) { .prototype-header, .comparison { grid-template-columns: 1fr; } .question-frame { min-height: 0; } }
-@media (max-width: 500px) { main { width: min(100% - 20px, 1240px); padding-top: 24px; } .question-frame { padding: 17px; } footer { align-items: stretch; flex-direction: column; } .actions { justify-content: flex-end; } }
-`;
-
-const root = document.querySelector("#app");
-if (root) render(() => <AskUserPrototype />, root);
diff --git a/packages/dashboard/test/client/ask-user.browser.test.ts b/packages/dashboard/test/client/ask-user.browser.test.ts
deleted file mode 100644
index 171b116c..00000000
--- a/packages/dashboard/test/client/ask-user.browser.test.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-import { type AddressInfo, createServer, type Server } from "node:http";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { type Browser, chromium, type Page } from "playwright";
-import { build as viteBuild } from "vite";
-import solid from "vite-plugin-solid";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-
-let browser: Browser;
-let server: Server;
-let base: string;
-const root = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
-
-beforeAll(async () => {
-	const bundle = await viteBuild({
-		configFile: false,
-		logLevel: "error",
-		root,
-		plugins: [solid()],
-		build: {
-			minify: false,
-			write: false,
-			rollupOptions: { input: resolve(root, "test/client/ask-user.browser-harness.tsx") },
-		},
-	});
-	const outputs = Array.isArray(bundle) ? bundle.flatMap((item) => item.output) : bundle.output;
-	const entry = outputs.find((item) => item.type === "chunk" && item.isEntry);
-	if (!entry || entry.type !== "chunk") throw new Error("ask_user browser harness bundle has no entry chunk");
-	const script = entry.code.replaceAll("</script", "<\\/script");
-	server = createServer((_req, response) => {
-		response.setHeader("content-type", "text/html; charset=utf-8");
-		response.end(`<!doctype html><html><body><div id="app"></div><script>${script}</script></body></html>`);
-	});
-	await new Promise<void>((resolveStarted) => server.listen(0, "127.0.0.1", resolveStarted));
-	base = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
-	browser = await chromium.launch({ headless: true });
-}, 30_000);
-
-afterAll(async () => {
-	await browser?.close();
-	if (server) await new Promise<void>((resolveClosed) => server.close(() => resolveClosed()));
-});
-
-async function openHarness(): Promise<Page> {
-	const page = await browser.newPage({ viewport: { width: 1400, height: 1000 } });
-	page.setDefaultTimeout(2_000);
-	await page.goto(base);
-	await page.getByRole("heading", { name: /ask_user cross-surface interaction/ }).waitFor();
-	return page;
-}
-
-function surface(page: Page, name: "dashboard" | "tui") {
-	return page.getByTestId(`${name}-surface`);
-}
-
-describe("ask_user UX prototype", () => {
-	it("shows equivalent single-choice, free-text, skip, and attention affordances", async () => {
-		const page = await openHarness();
-		for (const name of ["dashboard", "tui"] as const) {
-			const panel = surface(page, name);
-			expect(await panel.getByText("◆ needs attention").textContent()).toContain("needs attention");
-			expect(await panel.getByRole("radio").count()).toBe(3);
-			if (name === "dashboard") {
-				expect(await panel.locator(".control-glyph").count()).toBe(0);
-				expect(
-					await panel
-						.getByRole("radio")
-						.first()
-						.evaluate((input) => getComputedStyle(input).opacity),
-				).toBe("1");
-			} else {
-				expect(await panel.locator(".control-glyph").count()).toBe(3);
-			}
-			await panel.getByText("SQLite", { exact: true }).click();
-			await panel.getByLabel("Or type your own answer").fill("with WAL enabled");
-			await panel.getByRole("button", { name: "Submit answer" }).click();
-			const result = panel.getByRole("status");
-			await result.waitFor();
-			expect(await result.textContent()).toContain("SQLite; with WAL enabled");
-			expect(await result.evaluate((output) => getComputedStyle(output).display)).toBe("block");
-			expect(
-				await result.evaluate((output) => {
-					const input = output.previousElementSibling?.querySelector("input");
-					return input ? output.getBoundingClientRect().top > input.getBoundingClientRect().bottom : false;
-				}),
-			).toBe(true);
-		}
-		await page.close();
-	});
-
-	it("combines multiple selections with custom text on both surfaces", async () => {
-		const page = await openHarness();
-		await page.getByRole("button", { name: "multiple choice" }).click();
-		for (const name of ["dashboard", "tui"] as const) {
-			const panel = surface(page, name);
-			await panel.getByText("Unit tests", { exact: true }).click();
-			await panel.getByText("Type checking", { exact: true }).click();
-			await panel.getByLabel("Or type your own answer").fill("Run smoke tests too");
-			await panel.getByRole("button", { name: "Submit answer" }).click();
-			const result = await panel.getByRole("status").textContent();
-			expect(result).toContain("Unit tests; Type checking; Run smoke tests too");
-		}
-		await page.close();
-	});
-
-	it("covers free-text, multiline, skip, timeout, and abort states", async () => {
-		const page = await openHarness();
-
-		await page.getByRole("button", { name: "free text" }).click();
-		expect(await surface(page, "dashboard").getByLabel("Your answer").getAttribute("type")).toBe("text");
-
-		await page.getByRole("button", { name: "multiline" }).click();
-		expect(
-			await surface(page, "tui")
-				.getByLabel("Your answer")
-				.evaluate((element) => element.tagName),
-		).toBe("TEXTAREA");
-
-		await surface(page, "dashboard").getByRole("button", { name: "Skip" }).click();
-		expect(await surface(page, "dashboard").getByRole("status").textContent()).toContain("Question skipped");
-
-		await page.getByRole("button", { name: "timeout" }).click();
-		for (const name of ["dashboard", "tui"] as const) {
-			expect(await surface(page, name).getByRole("status").textContent()).toContain("No answer received");
-		}
-
-		await page.getByRole("button", { name: "abort" }).click();
-		for (const name of ["dashboard", "tui"] as const) {
-			expect(await surface(page, name).getByRole("status").textContent()).toContain("Question cancelled");
-		}
-		await page.close();
-	});
-
-	it("maps Escape to the explicit safe skip route", async () => {
-		const page = await openHarness();
-		await page.keyboard.press("Escape");
-		for (const name of ["dashboard", "tui"] as const) {
-			expect(await surface(page, name).getByRole("status").textContent()).toContain("Question skipped");
-		}
-		await page.close();
-	});
-});
diff --git a/packages/dashboard/test/client/ask-user.vite.config.ts b/packages/dashboard/test/client/ask-user.vite.config.ts
deleted file mode 100644
index 084d8ea0..00000000
--- a/packages/dashboard/test/client/ask-user.vite.config.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { defineConfig } from "vite";
-import solid from "vite-plugin-solid";
-
-const root = fileURLToPath(new URL(".", import.meta.url));
-
-export default defineConfig({
-	plugins: [solid()],
-	root,
-	server: {
-		open: "/ask-user.browser-harness.html",
-	},
-	build: {
-		outDir: resolve(root, "../../.ask-user-prototype"),
-		emptyOutDir: true,
-		rollupOptions: {
-			input: resolve(root, "ask-user.browser-harness.html"),
-		},
-	},
-});

From c81c8adbbd32b9a6495b5f52c852b776fe9559b1 Mon Sep 17 00:00:00 2001
From: Drew Brereton <andrew@brereton.me>
Date: Thu, 30 Jul 2026 18:50:17 -0400
Subject: [PATCH 13/15] Fix ask_user merge-readiness findings

---
 packages/coding-agent/README.md               |  2 +-
 packages/coding-agent/docs/rpc.md             |  7 ++-
 .../coding-agent/src/core/tools/ask-user.ts   | 26 ++++++++--
 .../src/modes/interactive/interactive-mode.ts | 30 ++++++++++--
 .../coding-agent/src/modes/rpc/rpc-mode.ts    | 22 ++++++---
 .../coding-agent/src/modes/rpc/rpc-types.ts   |  2 +
 .../test/interactive-mode-status.test.ts      | 38 +++++++++++++++
 .../test/rpc-extension-ui-ask.test.ts         | 40 ++++++++++++----
 .../coding-agent/test/tools/ask-user.test.ts  | 16 +++++--
 .../dashboard/src/client/screens/session.tsx  | 47 ++++++++++++-------
 .../dashboard/src/client/state/reducer.ts     |  5 +-
 packages/dashboard/src/shared/protocol.ts     |  2 +
 .../dashboard/test/client/screens.test.tsx    | 38 +++++++++++++++
 packages/dashboard/test/client/store.test.ts  |  8 ++++
 packages/dashboard/test/reducer.test.ts       | 14 +++---
 15 files changed, 243 insertions(+), 54 deletions(-)

diff --git a/packages/coding-agent/README.md b/packages/coding-agent/README.md
index 8c81f128..2f94d723 100644
--- a/packages/coding-agent/README.md
+++ b/packages/coding-agent/README.md
@@ -641,7 +641,7 @@ cat README.md | dreb -p "Summarize this text"
 
 Available built-in tools: `read`, `bash`, `edit`, `write`, `grep`, `find`, `ls`, `web_search`, `web_fetch`, `subagent`, `wait`, `search`, `ask_user`
 
-`ask_user` pauses the turn and asks you a structured clarifying question — optional 2-4 multiple-choice options (single- or multi-select) plus a "type your own answer" field — rendered natively in the TUI and the Dashboard, and over RPC. Skipping, Escape, tool abort, timeout, and headless/no-UI modes all resolve gracefully, so the agent never deadlocks waiting on an absent user. When there are no options the free-text field is always shown, so every question is answerable. An optional `timeoutSeconds` auto-skips the question after the given number of seconds with a live countdown on every surface. Concurrent `ask_user` calls are shown strictly one at a time (FIFO). In the TUI: `↑`/`↓` move between options and the free-text field, `Space` toggles a checkbox (multi-select), `Enter` submits, and `Esc` skips. In the Dashboard: native radios/checkboxes plus a text field, a skip button, and `Esc` to skip.
+`ask_user` pauses the turn and asks you a structured clarifying question — optional 2-4 multiple-choice options (single- or multi-select) plus a "type your own answer" field — rendered natively in the TUI and the Dashboard, and over RPC. Skipping, Escape, tool abort, timeout, and headless/no-UI modes all resolve gracefully, so the agent never deadlocks waiting on an absent user. Options must contain nonblank text. When there are no options the free-text field is always shown, so every question is answerable. An optional `timeoutSeconds` auto-skips the question after the given number of seconds with a live countdown on every surface; recovered Dashboard sessions retain the original deadline rather than restarting it. UI or response-protocol failures are reported distinctly from an intentional user skip. Concurrent `ask_user` calls are shown strictly one at a time (FIFO). In the TUI: `↑`/`↓` move between options and the free-text field, `Space` toggles a checkbox (multi-select), `Enter` submits, and `Esc` skips. In the Dashboard: native radios/checkboxes plus a text field, a skip button, and `Esc` to skip.
 
 Three additional tools are always active but don't appear in `--tools`:
 - `skill` — invokes [skills](#skills) programmatically
diff --git a/packages/coding-agent/docs/rpc.md b/packages/coding-agent/docs/rpc.md
index eafe6448..8c5a1e24 100644
--- a/packages/coding-agent/docs/rpc.md
+++ b/packages/coding-agent/docs/rpc.md
@@ -1976,11 +1976,14 @@ Ask the user a rich clarifying question with optional single- or multi-select op
   "allowFreeText": true,
   "multiSelect": false,
   "multiline": false,
-  "timeout": 60000
+  "timeout": 60000,
+  "expiresAt": 1785434460000
 }
 ```
 
-Expected response: `extension_ui_response` with `selected` (array of chosen option strings, possibly empty) and optional `customText` (the typed answer), or `cancelled: true` to skip. The client should treat an empty `selected` with no `customText` as a skip.
+`timeout` is the original duration in milliseconds. `expiresAt` is the corresponding absolute Unix timestamp in milliseconds; Dashboard clients should use it for the visible countdown so reload, resync, or drill-in recovery does not restart the full duration.
+
+Expected response: `extension_ui_response` with `selected` (an array of strings, possibly empty) and optional string `customText` (the typed answer), or `cancelled: true` to skip. The client should treat an empty `selected` with no `customText` as a skip. Malformed ask responses are rejected as protocol failures rather than being reported to the model as user skips.
 
 ```json
 { "type": "extension_ui_response", "id": "uuid-5", "selected": ["SQLite"], "customText": "with WAL enabled" }
diff --git a/packages/coding-agent/src/core/tools/ask-user.ts b/packages/coding-agent/src/core/tools/ask-user.ts
index d534051a..25e20a86 100644
--- a/packages/coding-agent/src/core/tools/ask-user.ts
+++ b/packages/coding-agent/src/core/tools/ask-user.ts
@@ -28,6 +28,8 @@ export interface AskUserDetails {
 	skipped: boolean;
 	/** True when no interactive UI was available (headless/print mode). */
 	unavailable: boolean;
+	/** True when the UI host or response protocol failed. */
+	failed?: boolean;
 }
 
 // ============================================================================
@@ -43,10 +45,10 @@ const askUserSchema = Type.Object({
 		}),
 	),
 	options: Type.Optional(
-		Type.Array(Type.String(), {
+		Type.Array(Type.String({ minLength: 1, pattern: "\\S" }), {
 			minItems: 2,
 			maxItems: 4,
-			description: "2-4 suggested answers the user can pick from.",
+			description: "2-4 nonblank suggested answers the user can pick from.",
 		}),
 	),
 	allowFreeText: Type.Optional(
@@ -108,6 +110,20 @@ function skippedResult(input: AskUserInput) {
 	});
 }
 
+function failedResult(input: AskUserInput) {
+	return textResult(
+		"The question could not be delivered because the interactive UI or response protocol failed. " +
+			"Continue without this input.",
+		{
+			...baseDetails(input),
+			selected: [],
+			skipped: false,
+			unavailable: false,
+			failed: true,
+		},
+	);
+}
+
 function answeredResult(input: AskUserInput, answer: AskResult) {
 	const customText = answer.customText?.trim() || undefined;
 	const selected = answer.selected;
@@ -140,6 +156,7 @@ function formatCall(args: { question?: string; title?: string } | undefined, the
 
 function formatResult(details: AskUserDetails, theme: any): string {
 	if (details.unavailable) return theme.fg("toolOutput", "no interactive UI — continued without asking");
+	if (details.failed) return theme.fg("toolOutput", "interactive UI failed — continued without an answer");
 	if (details.skipped) return theme.fg("toolOutput", "user skipped");
 	const parts: string[] = [];
 	if (details.selected.length > 0) parts.push(details.selected.join(", "));
@@ -225,8 +242,9 @@ export function createAskUserToolDefinition(): ToolDefinition<typeof askUserSche
 					}
 					return answeredResult(input, answer);
 				} catch {
-					// Host failure must still release the queue and never deadlock.
-					return skippedResult(input);
+					// Host/protocol failure must still release the queue and never
+					// deadlock, but it must not masquerade as an intentional user skip.
+					return failedResult(input);
 				}
 			});
 		},
diff --git a/packages/coding-agent/src/modes/interactive/interactive-mode.ts b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
index 02b21aa2..6b923b66 100644
--- a/packages/coding-agent/src/modes/interactive/interactive-mode.ts
+++ b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
@@ -1846,13 +1846,35 @@ export class InteractiveMode {
 		open: () => Promise<T>,
 		opts?: { signal?: AbortSignal; abortedValue: T },
 	): Promise<T> {
-		const run = () => (opts?.signal?.aborted ? Promise.resolve(opts.abortedValue) : open());
-		const result = this.extensionDialogQueue.then(run, run);
-		this.extensionDialogQueue = result.then(
+		if (!opts?.signal) {
+			const result = this.extensionDialogQueue.then(open, open);
+			this.extensionDialogQueue = result.then(
+				() => undefined,
+				() => undefined,
+			);
+			return result;
+		}
+		const { signal, abortedValue } = opts;
+		if (signal.aborted) return Promise.resolve(abortedValue);
+
+		// Settle the caller as soon as a queued dialog aborts, even if an earlier
+		// unbounded dialog still owns the UI. Its queue slot remains as a no-op so
+		// later dialogs keep their FIFO order.
+		let onQueuedAbort!: () => void;
+		const aborted = new Promise<T>((resolve) => {
+			onQueuedAbort = () => resolve(abortedValue);
+			signal.addEventListener("abort", onQueuedAbort, { once: true });
+		});
+		const run = () => {
+			signal.removeEventListener("abort", onQueuedAbort);
+			return signal.aborted ? Promise.resolve(abortedValue) : open();
+		};
+		const queued = this.extensionDialogQueue.then(run, run);
+		this.extensionDialogQueue = queued.then(
 			() => undefined,
 			() => undefined,
 		);
-		return result;
+		return Promise.race([queued, aborted]).finally(() => signal.removeEventListener("abort", onQueuedAbort));
 	}
 
 	/**
diff --git a/packages/coding-agent/src/modes/rpc/rpc-mode.ts b/packages/coding-agent/src/modes/rpc/rpc-mode.ts
index 226034ec..c2b5bac1 100644
--- a/packages/coding-agent/src/modes/rpc/rpc-mode.ts
+++ b/packages/coding-agent/src/modes/rpc/rpc-mode.ts
@@ -1120,13 +1120,23 @@ export function createRpcExtensionUIContext(
 					multiSelect: request.multiSelect,
 					multiline: request.multiline,
 					timeout: opts?.timeout,
+					// Preserve the authoritative deadline across Dashboard reload,
+					// resync, and drill-in hydration instead of restarting the full
+					// duration whenever the question component remounts.
+					expiresAt: opts?.timeout ? Date.now() + opts.timeout : undefined,
+				},
+				(response) => {
+					if ("cancelled" in response && response.cancelled) return undefined;
+					const selected = (response as { selected?: unknown }).selected;
+					const customText = (response as { customText?: unknown }).customText;
+					if (!Array.isArray(selected) || !selected.every((value) => typeof value === "string")) {
+						throw new Error("Invalid RPC ask response: selected must be an array of strings");
+					}
+					if (customText !== undefined && typeof customText !== "string") {
+						throw new Error("Invalid RPC ask response: customText must be a string");
+					}
+					return { selected, customText };
 				},
-				(r) =>
-					"cancelled" in r && r.cancelled
-						? undefined
-						: "selected" in r
-							? { selected: r.selected, customText: r.customText }
-							: undefined,
 			),
 
 		notify(message: string, type?: "info" | "warning" | "error"): void {
diff --git a/packages/coding-agent/src/modes/rpc/rpc-types.ts b/packages/coding-agent/src/modes/rpc/rpc-types.ts
index ef85b9a5..b3f718c4 100644
--- a/packages/coding-agent/src/modes/rpc/rpc-types.ts
+++ b/packages/coding-agent/src/modes/rpc/rpc-types.ts
@@ -656,6 +656,8 @@ export type RpcExtensionUIRequest =
 			multiSelect?: boolean;
 			multiline?: boolean;
 			timeout?: number;
+			/** Absolute Unix timestamp in milliseconds when the RPC-side timeout fires. */
+			expiresAt?: number;
 	  }
 	| {
 			type: "extension_ui_request";
diff --git a/packages/coding-agent/test/interactive-mode-status.test.ts b/packages/coding-agent/test/interactive-mode-status.test.ts
index ecd5bb44..8337b5f2 100644
--- a/packages/coding-agent/test/interactive-mode-status.test.ts
+++ b/packages/coding-agent/test/interactive-mode-status.test.ts
@@ -510,6 +510,44 @@ describe("InteractiveMode extension dialog queue", () => {
 		await expect(ask).resolves.toEqual({ selected: ["yes"] });
 		expect(showExtensionAsk).toHaveBeenCalledTimes(1);
 	});
+
+	test("settles a queued ask immediately on abort without opening it or reordering later dialogs", async () => {
+		let resolveSelector!: (value: string | undefined) => void;
+		const showExtensionSelector = vi.fn(
+			() =>
+				new Promise<string | undefined>((resolve) => {
+					resolveSelector = resolve;
+				}),
+		);
+		const showExtensionAsk = vi.fn(async (request: { question: string }) => ({ selected: [request.question] }));
+		const fakeThis: any = {
+			extensionDialogQueue: Promise.resolve(),
+			enqueueExtensionDialog: (InteractiveMode as any).prototype.enqueueExtensionDialog,
+			showExtensionSelector,
+			showExtensionAsk,
+		};
+		const uiContext = (InteractiveMode as any).prototype.createExtensionUIContext.call(fakeThis);
+		const controller = new AbortController();
+
+		const selector = uiContext.select("First", ["a", "b"]);
+		const abortedAsk = uiContext.ask({ question: "aborted" }, { signal: controller.signal });
+		const laterAsk = uiContext.ask({ question: "later" });
+		await Promise.resolve();
+		expect(showExtensionSelector).toHaveBeenCalledTimes(1);
+		expect(showExtensionAsk).not.toHaveBeenCalled();
+
+		controller.abort();
+		// This must settle before the unrelated selector does; the old queue only
+		// observed the abort after the selector released its slot.
+		await expect(abortedAsk).resolves.toBeUndefined();
+		expect(showExtensionAsk).not.toHaveBeenCalled();
+
+		resolveSelector("a");
+		await expect(selector).resolves.toBe("a");
+		await expect(laterAsk).resolves.toEqual({ selected: ["later"] });
+		expect(showExtensionAsk).toHaveBeenCalledTimes(1);
+		expect(showExtensionAsk).toHaveBeenCalledWith({ question: "later" }, undefined);
+	});
 });
 
 describe("InteractiveMode.showExtensionAsk lifecycle", () => {
diff --git a/packages/coding-agent/test/rpc-extension-ui-ask.test.ts b/packages/coding-agent/test/rpc-extension-ui-ask.test.ts
index 46963fcf..a9cc57d7 100644
--- a/packages/coding-agent/test/rpc-extension-ui-ask.test.ts
+++ b/packages/coding-agent/test/rpc-extension-ui-ask.test.ts
@@ -58,20 +58,25 @@ describe("RPC ask round trip", () => {
 		await p;
 	});
 
-	it("emits the auto-skip timeout in the ask request when one is provided", async () => {
-		const h = harness();
-		const p = h.ctx.ask({ question: "Which?", options: ["a"] }, { timeout: 30_000 });
-		// The Dashboard countdown and client auto-skip backstop are driven by this
-		// field; without it in the emitted request the browser never counts down.
-		expect((h.emitted[0] as any).timeout).toBe(30_000);
-		h.respond({ selected: ["a"] } as any);
-		await p;
+	it("emits the auto-skip duration and absolute deadline in the ask request", async () => {
+		const now = vi.spyOn(Date, "now").mockReturnValue(1_000_000);
+		try {
+			const h = harness();
+			const p = h.ctx.ask({ question: "Which?", options: ["a"] }, { timeout: 30_000 });
+			// The absolute deadline keeps a recovered Dashboard countdown aligned
+			// with the already-running authoritative RPC timer.
+			expect(h.emitted[0]).toMatchObject({ timeout: 30_000, expiresAt: 1_030_000 });
+			h.respond({ selected: ["a"] } as any);
+			await p;
+		} finally {
+			now.mockRestore();
+		}
 	});
 
-	it("omits the timeout in the ask request when none is provided", async () => {
+	it("omits the timeout and deadline when none is provided", async () => {
 		const h = harness();
 		const p = h.ctx.ask({ question: "Which?", options: ["a"] });
-		expect((h.emitted[0] as any).timeout).toBeUndefined();
+		expect(h.emitted[0]).toMatchObject({ timeout: undefined, expiresAt: undefined });
 		h.respond({ selected: ["a"] } as any);
 		await p;
 	});
@@ -108,6 +113,21 @@ describe("RPC ask round trip", () => {
 		await expect(p).resolves.toBeUndefined();
 	});
 
+	it.each([
+		{ selected: null },
+		{ selected: ["a", 2] },
+		{ selected: ["a"], customText: 42 },
+		{ value: "wrong response variant" },
+	])("rejects a malformed ask response: %o", async (response) => {
+		const h = harness();
+		const p = h.ctx.ask({ question: "Which?", options: ["a"] });
+		const id = h.lastRequestId();
+		h.pending.get(id)?.resolve({ type: "extension_ui_response", id, ...response } as any);
+		await expect(p).rejects.toThrow("Invalid RPC ask response");
+		expect(h.handled).toEqual([id]);
+		expect(h.pending.has(id)).toBe(false);
+	});
+
 	it("emits extension_ui_response_handled exactly once on response and clears the pending entry", async () => {
 		const h = harness();
 		const p = h.ctx.ask({ question: "Which?", options: ["a"] });
diff --git a/packages/coding-agent/test/tools/ask-user.test.ts b/packages/coding-agent/test/tools/ask-user.test.ts
index da54cc46..88b0deef 100644
--- a/packages/coding-agent/test/tools/ask-user.test.ts
+++ b/packages/coding-agent/test/tools/ask-user.test.ts
@@ -1,3 +1,4 @@
+import { Value } from "@sinclair/typebox/value";
 import { describe, expect, it, vi } from "vitest";
 import type { AskRequest, AskResult, ExtensionContext } from "../../src/core/extensions/types.js";
 import { type AskUserDetails, createAskUserToolDefinition } from "../../src/core/tools/ask-user.js";
@@ -41,12 +42,15 @@ describe("ask_user tool", () => {
 		expect(guidelines).toContain("skip");
 	});
 
-	it("validates option bounds (2-4) in its schema", () => {
+	it("validates option bounds (2-4) and rejects blank options in its schema", () => {
 		const def = createAskUserToolDefinition();
 		const props = (def.parameters as any).properties;
 		expect(props.options.minItems).toBe(2);
 		expect(props.options.maxItems).toBe(4);
 		expect(props.question.type).toBe("string");
+		expect(Value.Check(def.parameters, { question: "Pick", options: ["A", "B"] })).toBe(true);
+		expect(Value.Check(def.parameters, { question: "Pick", options: ["", "B"] })).toBe(false);
+		expect(Value.Check(def.parameters, { question: "Pick", options: ["   ", "B"] })).toBe(false);
 	});
 
 	it("returns a graceful non-blocking result when no UI is available", async () => {
@@ -118,13 +122,16 @@ describe("ask_user tool", () => {
 		expect(result.details?.unavailable).toBe(false);
 	});
 
-	it("resolves gracefully when the host throws", async () => {
+	it("reports a host failure distinctly from an intentional user skip", async () => {
 		const def = createAskUserToolDefinition();
 		const ctx = makeCtx(async () => {
 			throw new Error("host exploded");
 		});
 		const result = await run(def, { question: "Which?" }, ctx);
-		expect(result.details?.skipped).toBe(true);
+		expect(result.details?.failed).toBe(true);
+		expect(result.details?.skipped).toBe(false);
+		expect(result.content[0].text).toContain("interactive UI or response protocol failed");
+		expect(result.content[0].text).not.toContain("user skipped");
 	});
 
 	it("serializes concurrent calls strictly one at a time (FIFO)", async () => {
@@ -165,7 +172,8 @@ describe("ask_user tool", () => {
 			run(def, { question: "ok" }, ctx),
 		]);
 		expect(calls).toBe(2);
-		expect(first.details?.skipped).toBe(true);
+		expect(first.details?.failed).toBe(true);
+		expect(first.details?.skipped).toBe(false);
 		expect(second.details?.selected).toEqual(["ok"]);
 	});
 
diff --git a/packages/dashboard/src/client/screens/session.tsx b/packages/dashboard/src/client/screens/session.tsx
index d0f451ee..343619e0 100644
--- a/packages/dashboard/src/client/screens/session.tsx
+++ b/packages/dashboard/src/client/screens/session.tsx
@@ -224,28 +224,43 @@ function AskUiInline(props: {
 	onMount(() => window.addEventListener("keydown", onKeyDown));
 	onCleanup(() => window.removeEventListener("keydown", onKeyDown));
 
-	// Optional visible countdown. The host also auto-resolves on timeout; this
-	// mirrors the TUI countdown and auto-skips as a client-side backstop.
-	const [remaining, setRemaining] = createSignal(props.request.timeout ? Math.ceil(props.request.timeout / 1000) : 0);
-	if (props.request.timeout && props.request.timeout > 0) {
-		const interval = setInterval(() => {
-			setRemaining((current) => {
-				const next = current - 1;
-				if (next <= 0) {
-					clearInterval(interval);
-					skip();
-				}
-				return next;
-			});
-		}, 1000);
-		onCleanup(() => clearInterval(interval));
+	// Optional visible countdown. `expiresAt` is the authoritative RPC-side
+	// deadline and survives reload/resync/drill-in recovery. Fall back to a
+	// local deadline for older runtimes that only send the original duration.
+	const expiresAt =
+		typeof props.request.expiresAt === "number"
+			? props.request.expiresAt
+			: props.request.timeout && props.request.timeout > 0
+				? Date.now() + props.request.timeout
+				: undefined;
+	const secondsRemaining = () =>
+		expiresAt === undefined ? 0 : Math.max(0, Math.ceil((expiresAt - Date.now()) / 1000));
+	const [remaining, setRemaining] = createSignal(secondsRemaining());
+	if (expiresAt !== undefined) {
+		let interval: ReturnType<typeof setInterval> | undefined;
+		const updateCountdown = () => {
+			const next = secondsRemaining();
+			setRemaining(next);
+			if (next <= 0) {
+				if (interval !== undefined) clearInterval(interval);
+				interval = undefined;
+				skip();
+			}
+		};
+		onMount(() => {
+			updateCountdown();
+			if (expiresAt > Date.now()) interval = setInterval(updateCountdown, 1000);
+		});
+		onCleanup(() => {
+			if (interval !== undefined) clearInterval(interval);
+		});
 	}
 
 	return (
 		<section class="ask-inline" aria-label={props.request.title}>
 			<header class="ask-inline-header">
 				{props.request.title}
-				<Show when={props.request.timeout && props.request.timeout > 0}>
+				<Show when={expiresAt !== undefined}>
 					<span class="ask-inline-countdown"> (auto-skips in {remaining()}s)</span>
 				</Show>
 			</header>
diff --git a/packages/dashboard/src/client/state/reducer.ts b/packages/dashboard/src/client/state/reducer.ts
index e7a7e7e3..7413a1bb 100644
--- a/packages/dashboard/src/client/state/reducer.ts
+++ b/packages/dashboard/src/client/state/reducer.ts
@@ -118,8 +118,10 @@ export interface ExtensionUiRequest {
 	multiSelect?: boolean;
 	/** ask: use a multi-line text area for free text. */
 	multiline?: boolean;
-	/** ask: auto-skip after this many milliseconds; drives the visible countdown. */
+	/** ask: original auto-skip duration in milliseconds. */
 	timeout?: number;
+	/** ask: absolute runtime deadline; survives reload/resync/drill-in recovery. */
+	expiresAt?: number;
 }
 
 export function extensionUiRequestFromEvent(event: any): ExtensionUiRequest | undefined {
@@ -146,6 +148,7 @@ export function extensionUiRequestFromEvent(event: any): ExtensionUiRequest | un
 			multiSelect: event.multiSelect as boolean | undefined,
 			multiline: event.multiline as boolean | undefined,
 			timeout: typeof event.timeout === "number" ? (event.timeout as number) : undefined,
+			expiresAt: typeof event.expiresAt === "number" ? (event.expiresAt as number) : undefined,
 		};
 	}
 	return undefined;
diff --git a/packages/dashboard/src/shared/protocol.ts b/packages/dashboard/src/shared/protocol.ts
index e6061559..a9cf7189 100644
--- a/packages/dashboard/src/shared/protocol.ts
+++ b/packages/dashboard/src/shared/protocol.ts
@@ -283,6 +283,8 @@ export interface ExtensionUiRequestDto {
 	multiSelect?: boolean;
 	multiline?: boolean;
 	timeout?: number;
+	/** Absolute Unix timestamp in milliseconds when the runtime timeout fires. */
+	expiresAt?: number;
 }
 
 /**
diff --git a/packages/dashboard/test/client/screens.test.tsx b/packages/dashboard/test/client/screens.test.tsx
index fc0703a7..93d7d927 100644
--- a/packages/dashboard/test/client/screens.test.tsx
+++ b/packages/dashboard/test/client/screens.test.tsx
@@ -1343,6 +1343,44 @@ describe("screen smoke tests", () => {
 		expect(vi.mocked(api.extensionUiResponse)).toHaveBeenCalledTimes(1);
 	});
 
+	it("uses the authoritative remaining deadline after a timed ask is recovered", async () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(new Date("2026-07-30T18:00:00Z"));
+		const store = makeStore() as any;
+		const session = createSessionViewState("k-ask-recovered-timeout");
+		session.uiRequests = [
+			{
+				id: "a-recovered-timeout",
+				method: "ask",
+				title: "Pick",
+				question: "Which?",
+				options: ["A", "B"],
+				timeout: 30_000,
+				// Twenty-five seconds elapsed before reload; only five remain.
+				expiresAt: Date.now() + 5_000,
+			},
+		];
+		const fakeStore = {
+			...store,
+			sessions: { "k-ask-recovered-timeout": session },
+			fleet: () => ({ runtimes: [], diskSessions: [] }),
+			hydrateSession: async () => {},
+		};
+		vi.mocked(api.extensionUiResponse).mockClear();
+		const el = mount(() => <SessionScreen store={fakeStore} sessionKey="k-ask-recovered-timeout" />);
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(el.textContent).toContain("auto-skips in 5s");
+		await vi.advanceTimersByTimeAsync(4_000);
+		expect(vi.mocked(api.extensionUiResponse)).not.toHaveBeenCalled();
+		await vi.advanceTimersByTimeAsync(1_000);
+		expect(vi.mocked(api.extensionUiResponse)).toHaveBeenCalledTimes(1);
+		expect(vi.mocked(api.extensionUiResponse)).toHaveBeenCalledWith(
+			"k-ask-recovered-timeout",
+			expect.objectContaining({ type: "extension_ui_response", id: "a-recovered-timeout", cancelled: true }),
+		);
+	});
+
 	it("ask_user tool card stays collapsed while running (unlike other running tools)", async () => {
 		const store = makeStore() as any;
 		const session = createSessionViewState("k-ask-collapse");
diff --git a/packages/dashboard/test/client/store.test.ts b/packages/dashboard/test/client/store.test.ts
index f98bdef8..6c2e1ef7 100644
--- a/packages/dashboard/test/client/store.test.ts
+++ b/packages/dashboard/test/client/store.test.ts
@@ -506,6 +506,8 @@ describe("app store SSE sync", () => {
 						allowFreeText: true,
 						multiSelect: false,
 						multiline: false,
+						timeout: 30_000,
+						expiresAt: 1_030_000,
 					},
 				],
 				barrierSeq: 20,
@@ -523,6 +525,8 @@ describe("app store SSE sync", () => {
 				method: "ask",
 				question: "Which one?",
 				options: ["SQLite", "Postgres"],
+				timeout: 30_000,
+				expiresAt: 1_030_000,
 			}),
 		]);
 		expect(store.sessions.a?.needsAttention).toBe(true);
@@ -1093,6 +1097,8 @@ describe("app store hydration", () => {
 				allowFreeText: true,
 				multiSelect: false,
 				multiline: false,
+				timeout: 30_000,
+				expiresAt: 1_030_000,
 			},
 		];
 		vi.mocked(api.hydrate).mockResolvedValueOnce(snapshot);
@@ -1106,6 +1112,8 @@ describe("app store hydration", () => {
 				method: "ask",
 				question: "Which one?",
 				options: ["SQLite", "Postgres"],
+				timeout: 30_000,
+				expiresAt: 1_030_000,
 			}),
 		]);
 		expect(store.sessions.s1?.needsAttention).toBe(true);
diff --git a/packages/dashboard/test/reducer.test.ts b/packages/dashboard/test/reducer.test.ts
index b6a38d07..7da6783c 100644
--- a/packages/dashboard/test/reducer.test.ts
+++ b/packages/dashboard/test/reducer.test.ts
@@ -998,7 +998,7 @@ describe("applySessionEvent — extension UI", () => {
 		expect(state.needsAttention).toBe(false);
 	});
 
-	it("extracts a numeric ask timeout onto the ui request (drives the countdown)", () => {
+	it("extracts the numeric ask timeout and absolute deadline onto the ui request", () => {
 		const state = makeState();
 		applySessionEvent(state, {
 			type: "extension_ui_request",
@@ -1008,14 +1008,14 @@ describe("applySessionEvent — extension UI", () => {
 			question: "Which?",
 			options: ["a", "b"],
 			timeout: 30_000,
+			expiresAt: 1_030_000,
 		});
-		// The visible countdown and client auto-skip backstop read this value; if
-		// the reducer drops it, the Dashboard never counts down even though the
-		// runtime auto-skips.
-		expect(state.uiRequests[0]?.timeout).toBe(30_000);
+		// The deadline keeps the visible countdown aligned with the authoritative
+		// runtime timer when this request is restored after a reload or resync.
+		expect(state.uiRequests[0]).toMatchObject({ timeout: 30_000, expiresAt: 1_030_000 });
 	});
 
-	it("ignores a non-numeric ask timeout (guards against malformed events)", () => {
+	it("ignores non-numeric ask timeout metadata (guards against malformed events)", () => {
 		const state = makeState();
 		applySessionEvent(state, {
 			type: "extension_ui_request",
@@ -1025,8 +1025,10 @@ describe("applySessionEvent — extension UI", () => {
 			question: "Which?",
 			options: ["a"],
 			timeout: "soon",
+			expiresAt: "later",
 		});
 		expect(state.uiRequests[0]?.timeout).toBeUndefined();
+		expect(state.uiRequests[0]?.expiresAt).toBeUndefined();
 	});
 
 	it("agent_start clears pending UI requests (server resolved them)", () => {

From 9df54e6699130343132e472dead5755fd5ebd8d3 Mon Sep 17 00:00:00 2001
From: Drew Brereton <andrew@brereton.me>
Date: Thu, 30 Jul 2026 20:26:59 -0400
Subject: [PATCH 14/15] Bump version to 2.47.0

---
 package-lock.json                              | 18 +++++++++---------
 package.json                                   |  2 +-
 packages/agent/package.json                    |  2 +-
 packages/ai/package.json                       |  2 +-
 packages/coding-agent/package.json             |  2 +-
 packages/dashboard/package.json                |  2 +-
 .../semantic-search/.claude-plugin/plugin.json |  2 +-
 packages/semantic-search/package.json          |  2 +-
 packages/telegram/package.json                 |  2 +-
 packages/tui/package.json                      |  2 +-
 10 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 18ea6ada..ab961110 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
 	"name": "dreb",
-	"version": "2.46.0",
+	"version": "2.47.0",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "dreb",
-			"version": "2.46.0",
+			"version": "2.47.0",
 			"workspaces": [
 				"packages/*",
 				"packages/coding-agent/examples/extensions/with-deps",
@@ -10955,7 +10955,7 @@
 		},
 		"packages/agent": {
 			"name": "@dreb/agent-core",
-			"version": "2.46.0",
+			"version": "2.47.0",
 			"license": "MIT",
 			"dependencies": {
 				"@dreb/ai": "*"
@@ -10984,7 +10984,7 @@
 		},
 		"packages/ai": {
 			"name": "@dreb/ai",
-			"version": "2.46.0",
+			"version": "2.47.0",
 			"license": "MIT",
 			"dependencies": {
 				"@anthropic-ai/sdk": "^0.73.0",
@@ -11040,7 +11040,7 @@
 		},
 		"packages/coding-agent": {
 			"name": "@dreb/coding-agent",
-			"version": "2.46.0",
+			"version": "2.47.0",
 			"license": "MIT",
 			"dependencies": {
 				"@dreb/agent-core": "*",
@@ -11169,7 +11169,7 @@
 		},
 		"packages/dashboard": {
 			"name": "@dreb/dashboard",
-			"version": "2.46.0",
+			"version": "2.47.0",
 			"license": "MIT",
 			"dependencies": {
 				"@dreb/coding-agent": "*",
@@ -11401,7 +11401,7 @@
 		},
 		"packages/semantic-search": {
 			"name": "@dreb/semantic-search",
-			"version": "2.46.0",
+			"version": "2.47.0",
 			"license": "MIT",
 			"dependencies": {
 				"@huggingface/transformers": "^4.0.1",
@@ -11450,7 +11450,7 @@
 		},
 		"packages/telegram": {
 			"name": "@dreb/telegram",
-			"version": "2.46.0",
+			"version": "2.47.0",
 			"license": "MIT",
 			"dependencies": {
 				"@dreb/coding-agent": "*",
@@ -11483,7 +11483,7 @@
 		},
 		"packages/tui": {
 			"name": "@dreb/tui",
-			"version": "2.46.0",
+			"version": "2.47.0",
 			"license": "MIT",
 			"dependencies": {
 				"@types/mime-types": "^2.1.4",
diff --git a/package.json b/package.json
index 9e19810d..c657c256 100644
--- a/package.json
+++ b/package.json
@@ -39,7 +39,7 @@
     "node": "22.x"
   },
   "packageManager": "npm@11.5.1",
-  "version": "2.46.0",
+  "version": "2.47.0",
   "dependencies": {
     "@dreb/coding-agent": "*",
     "@mariozechner/jiti": "^2.6.5",
diff --git a/packages/agent/package.json b/packages/agent/package.json
index 75136da5..5e7c1034 100644
--- a/packages/agent/package.json
+++ b/packages/agent/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "@dreb/agent-core",
-	"version": "2.46.0",
+	"version": "2.47.0",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"type": "module",
 	"main": "./dist/index.js",
diff --git a/packages/ai/package.json b/packages/ai/package.json
index 82b3e703..75611769 100644
--- a/packages/ai/package.json
+++ b/packages/ai/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "@dreb/ai",
-	"version": "2.46.0",
+	"version": "2.47.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./dist/index.js",
diff --git a/packages/coding-agent/package.json b/packages/coding-agent/package.json
index 9455bb8e..09272fcf 100644
--- a/packages/coding-agent/package.json
+++ b/packages/coding-agent/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "@dreb/coding-agent",
-	"version": "2.46.0",
+	"version": "2.47.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"drebConfig": {
diff --git a/packages/dashboard/package.json b/packages/dashboard/package.json
index a8b867c0..10c0f16d 100644
--- a/packages/dashboard/package.json
+++ b/packages/dashboard/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "@dreb/dashboard",
-	"version": "2.46.0",
+	"version": "2.47.0",
 	"description": "Web dashboard for dreb — fleet overview, chat parity, subagent observability",
 	"license": "MIT",
 	"type": "module",
diff --git a/packages/semantic-search/.claude-plugin/plugin.json b/packages/semantic-search/.claude-plugin/plugin.json
index 7571d8ea..1dca40cb 100644
--- a/packages/semantic-search/.claude-plugin/plugin.json
+++ b/packages/semantic-search/.claude-plugin/plugin.json
@@ -1,7 +1,7 @@
 {
   "name": "semantic-search",
   "description": "Semantic codebase search — natural language queries over code and docs using embeddings, tree-sitter parsing, and POEM multi-signal ranking",
-  "version": "2.46.0",
+  "version": "2.47.0",
   "author": {
     "name": "Drew Brereton"
   },
diff --git a/packages/semantic-search/package.json b/packages/semantic-search/package.json
index 6f7892f0..8d119ff8 100644
--- a/packages/semantic-search/package.json
+++ b/packages/semantic-search/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "@dreb/semantic-search",
-	"version": "2.46.0",
+	"version": "2.47.0",
 	"description": "Semantic codebase search engine with embedding-based ranking and MCP server",
 	"publishConfig": {
 		"access": "public"
diff --git a/packages/telegram/package.json b/packages/telegram/package.json
index 3a128168..b704df40 100644
--- a/packages/telegram/package.json
+++ b/packages/telegram/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "@dreb/telegram",
-	"version": "2.46.0",
+	"version": "2.47.0",
 	"description": "Telegram bot frontend for dreb coding agent",
 	"license": "MIT",
 	"type": "module",
diff --git a/packages/tui/package.json b/packages/tui/package.json
index 21f3c56e..49f16b30 100644
--- a/packages/tui/package.json
+++ b/packages/tui/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "@dreb/tui",
-	"version": "2.46.0",
+	"version": "2.47.0",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "dist/index.js",

From fbd7de7480aa3ae3079a93b903ba3feeabaffc3c Mon Sep 17 00:00:00 2001
From: Drew Brereton <andrew@brereton.me>
Date: Thu, 30 Jul 2026 20:30:43 -0400
Subject: [PATCH 15/15] Document ask_user Dashboard and extension behavior

---
 packages/coding-agent/docs/dashboard.md  | 2 +-
 packages/coding-agent/docs/extensions.md | 9 +++++++++
 packages/coding-agent/docs/rpc.md        | 2 +-
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/packages/coding-agent/docs/dashboard.md b/packages/coding-agent/docs/dashboard.md
index a0d5d91b..4f274c97 100644
--- a/packages/coding-agent/docs/dashboard.md
+++ b/packages/coding-agent/docs/dashboard.md
@@ -120,7 +120,7 @@ networking window above.
 | Screen | What it does |
 |---|---|
 | **Fleet** | Home. Live-first: one grid of every live session at the top — status chip (● running / ◆ needs-attention / ○ idle / ✕ error), project path, activity line, live subagent lines, tasks progress, ctx%, model, terminal provider-error reason, last activity. Live cards keep a deterministic order by project path, then session start time; needs-attention cards badge the browser tab without jumping around. Below the grid: past sessions grouped by project, three compact rows per group with an "all N on disk" expander, resume and delete. |
-| **Session view** | Full chat drill-in. Markdown streaming transcript (text, thinking blocks with expand preference, inline provider/API failures with partial output preserved, agent-result cards, tool cards with bespoke read/write/edit/bash bodies plus full expandable inputs, markdown-rendered results for markdown-contract tools like subagent/skill/web_fetch/suggest_next, and inline tool-result images, compaction/branch summaries, custom messages), per-message copy, tasks panel, subagent strip, status line with elapsed time plus ■ stop and compaction/retry aborts, a persistent session-header live indicator, and an info bar with cwd, branch, session name, token breakdown, cost/(sub)/daily rollup, ctx%, median tok/s, and a stats popover. Composer supports auto-grow, history, `/` autocomplete from `get_commands`, image attach/paste with sent images retained as user-message previews, queued-message chips with restore-all, steer/follow-up modes, and suggest-next. The ⋯ menu covers export HTML, compact, rename, fork-from-message, loaded context, and tool expand/collapse. Session names update live from manual rename or auto-naming. Extension UI requests (select/confirm/input/editor) render as modals; notifications as toasts. |
+| **Session view** | Full chat drill-in. Markdown streaming transcript (text, thinking blocks with expand preference, inline provider/API failures with partial output preserved, agent-result cards, tool cards with bespoke read/write/edit/bash bodies plus full expandable inputs, markdown-rendered results for markdown-contract tools like subagent/skill/web_fetch/suggest_next, and inline tool-result images, compaction/branch summaries, custom messages), per-message copy, tasks panel, subagent strip, status line with elapsed time plus ■ stop and compaction/retry aborts, a persistent session-header live indicator, and an info bar with cwd, branch, session name, token breakdown, cost/(sub)/daily rollup, ctx%, median tok/s, and a stats popover. Composer supports auto-grow, history, `/` autocomplete from `get_commands`, image attach/paste with sent images retained as user-message previews, queued-message chips with restore-all, steer/follow-up modes, and suggest-next. The ⋯ menu covers export HTML, compact, rename, fork-from-message, loaded context, and tool expand/collapse. Session names update live from manual rename or auto-naming. Extension UI requests for select/confirm/input/editor render as modals; rich `ask`/`ask_user` questions render inline with choices, optional free text, skip/Escape, and the authoritative timeout countdown. Pending questions set needs-attention state and use the existing hidden-page notification path. Extension notifications render as toasts. |
 | **Subagent view** | Read-only transcript of a background agent: live events via the RPC relay, hydrated from the agent's on-disk session log (`/subagents/:agentId/messages`) so the transcript survives browser reloads. Shows the task, streaming output, tool activity, and any safe Dispatch Arbiter changed/unchanged/failure records with the final agent/model/thinking. No raw arbiter output is displayed or transported. No composer — subagents can't be steered yet; the parent session controls them. |
 | **Files** | Host-wide browser with places shortcuts (home, /tmp, project roots), breadcrumbs to `/`, new-folder, download, drop-zone/picker upload with explicit collision prompts, and "new session here" on any directory. It also shows the **effective global nested-context trust** for the displayed canonical directory: untrusted, trusted by that root, inherited from a granting root, or global expert trust-all. You can trust the displayed folder and descendants, or untrust the actual granting root; untrusting an inherited folder removes that root's trust for all descendants. |
 | **Settings** | Persistent defaults (default model, thinking level, steering/follow-up queue modes, auto-compaction, auto-retry) via `get_settings`/`set_settings` — validation errors are shown verbatim. The global-only Dispatch Arbiter card exposes enable/disable, exact authenticated model selection, thinking, guide path, and readiness guidance; model-less enablement is blocked and RPC/runtime validation remains fail-closed. Entering Settings flushes pending writes and reloads durable global + project settings, so external edits appear; read, parse, or write failures fail loudly instead of showing stale settings. The global-only nested-context policy lists every explicit trusted root for audit and revoke, offers a simple add-by-path control, and includes a prominently warned expert trust-all toggle; the Files view remains the primary place to grant trust while browsing. Most defaults seed new sessions; context-trust changes are observed by active main/subagent processes for future lazy loads, but cannot remove already injected content. Dashboard-local preferences (always expand thinking, transcript image display mode, needs-attention notification permission) live in the browser, alongside an appearance section: a theme gallery of eight curated themes (entropist.ca, Dim, Solarized, Gruvbox, Caves of Qud, Van Gogh, and the colorblind-safe Okabe-Ito and Paul Tol) with live preview cards and a system/light/dark mode selector, saved per browser. Shows the current rotating pairing code on the host/local dashboard, plus the paired-devices list with unpair. |
diff --git a/packages/coding-agent/docs/extensions.md b/packages/coding-agent/docs/extensions.md
index 6520c6c1..cd28d7e5 100644
--- a/packages/coding-agent/docs/extensions.md
+++ b/packages/coding-agent/docs/extensions.md
@@ -1802,6 +1802,14 @@ const ok = await ctx.ui.confirm("Delete?", "This cannot be undone");
 // Text input
 const name = await ctx.ui.input("Name:", "placeholder");
 
+// Rich question: options and free text can be combined; undefined means skipped
+const answer = await ctx.ui.ask({
+  title: "Choose a database",
+  question: "Which persistence strategy should I use?",
+  options: ["SQLite", "PostgreSQL"],
+  allowFreeText: true,
+});
+
 // Multi-line editor
 const text = await ctx.ui.editor("Edit:", "prefilled text");
 
@@ -1832,6 +1840,7 @@ if (confirmed) {
 - `select()` returns `undefined`
 - `confirm()` returns `false`
 - `input()` returns `undefined`
+- `ask()` returns `undefined`
 
 #### Manual Dismissal with AbortSignal
 
diff --git a/packages/coding-agent/docs/rpc.md b/packages/coding-agent/docs/rpc.md
index 772f904c..1b7aabd7 100644
--- a/packages/coding-agent/docs/rpc.md
+++ b/packages/coding-agent/docs/rpc.md
@@ -2014,7 +2014,7 @@ Expected response: `extension_ui_response` with `value` (the edited text) or `ca
 
 #### ask
 
-Ask the user a rich clarifying question with optional single- or multi-select options and an optional free-text field. This powers the built-in `ask_user` tool. `options` (2-4) is optional; `allowFreeText` (default `true`), `multiSelect`, and `multiline` are optional booleans.
+Ask the user a rich clarifying question with optional single- or multi-select options and an optional free-text field. This powers the built-in `ask_user` tool. `options` (2-4 nonblank strings) is optional; `allowFreeText` (default `true`), `multiSelect`, and `multiline` are optional booleans.
 
 ```json
 {
