@antelopejs/dms-ai 0.6.1 → 0.7.0

package/frontend-vue/build/backend-boundary.ts

@@ -0,0 +1,89 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, sep } from "node:path";
+import type { Plugin } from "vite";
+
+const BACKEND_PACKAGE = "@antelopejs/dms-ai";
+const BACKEND_SOURCE = "src";
+const QUERY_OR_HASH = /[?#].*$/;
+
+const backendRoots = new Map<string, string | null>();
+
+function packageName(manifest: string): string | undefined {
+	try {
+		const parsed: { name?: string } = JSON.parse(
+			readFileSync(manifest, "utf8"),
+		);
+		return parsed.name;
+	} catch {
+		return undefined;
+	}
+}
+
+function backendRoot(directory: string): string | null {
+	const known = backendRoots.get(directory);
+	if (known !== undefined) return known;
+	const manifest = join(directory, "package.json");
+	const parent = dirname(directory);
+	let root: string | null = null;
+	if (existsSync(manifest)) {
+		root = packageName(manifest) === BACKEND_PACKAGE ? directory : null;
+	} else if (parent !== directory) {
+		root = backendRoot(parent);
+	}
+	backendRoots.set(directory, root);
+	return root;
+}
+
+/**
+ * The real path of a resolved module id when it lies under the `src`
+ * directory of the backend package, or `undefined`. The package that owns the
+ * file decides, not a path, so the answer is the same in the repository and in
+ * the workspace the DMS builds the frontend in. Virtual ids and ids that are
+ * not files are ignored.
+ */
+function backendSourceFile(id: string): string | undefined {
+	const path = id.replace(QUERY_OR_HASH, "");
+	if (!isAbsolute(path)) return undefined;
+	let real: string;
+	try {
+		real = realpathSync(path);
+	} catch {
+		return undefined;
+	}
+	const root = backendRoot(dirname(real));
+	if (root === null) return undefined;
+	return relative(root, real).split(sep)[0] === BACKEND_SOURCE
+		? real
+		: undefined;
+}
+
+/**
+ * Fails the build, the dev server and the tests when a module of the frontend
+ * resolves to a file under the backend's `src`: the browser reaches the
+ * backend only through its HTTP routes. It checks what the whole resolution
+ * chain returns, so an alias is seen through and a symlink the resolver
+ * returns is followed to its real path, and it runs before the other plugins
+ * (`enforce: "pre"`).
+ */
+export function backendBoundary(): Plugin {
+	return {
+		name: "dms-ai:backend-boundary",
+		enforce: "pre",
+		async resolveId(source, importer, options) {
+			const resolved = await this.resolve(source, importer, {
+				...options,
+				skipSelf: true,
+			});
+			if (resolved === null || resolved.external) return resolved;
+			const file = backendSourceFile(resolved.id);
+			if (file === undefined) return resolved;
+			const from =
+				importer === undefined
+					? "an entry point"
+					: importer.replace(QUERY_OR_HASH, "");
+			return this.error(
+				`Backend boundary: ${from} imports ${file}, which is under src of ${BACKEND_PACKAGE}. The frontend reaches the backend only through its HTTP routes.`,
+			);
+		},
+	};
+}

package/frontend-vue/dms.frontend.build.ts

@@ -0,0 +1,6 @@
+import { defineDmsFrontendBuild } from "#dms/frontend-build";
+import { backendBoundary } from "./build/backend-boundary.ts";
+
+export default defineDmsFrontendBuild((build) => {
+	build.registerVitePlugins(() => [backendBoundary()]);
+});

package/frontend-vue/package.json

@@ -6,7 +6,7 @@
 	"license": "Apache-2.0",
 	"packageManager": "pnpm@10.6.5",
 	"engines": {
-		"@antelopejs/dms-frontend": ">=0.9.0 <0.10.0"
+		"@antelopejs/dms-frontend": ">=0.9.1 <0.10.0"
 	},
 	"scripts": {
 		"build": "pnpm --dir \"${DMS_FRONTEND_WORKSPACE:?Set DMS_FRONTEND_WORKSPACE to the generated Inertia workspace}\" build",
@@ -37,6 +37,7 @@
 		"prettier-plugin-tailwindcss": "^0.6.11",
 		"typescript": "^5.8.2",
 		"typescript-eslint": "^8.0.0",
+		"vite": "^7.3.2",
 		"vitest": "^4.1.5",
 		"vue-tsc": "^3.1.1"
 	}

package/frontend-vue/pnpm-lock.yaml

@@ -60,6 +60,9 @@ importers:
       typescript-eslint:
         specifier: ^8.0.0
         version: 8.70.0(eslint@9.39.4(jiti@2.7.0))(typescript@5.9.3)
+      vite:
+        specifier: ^7.3.2
+        version: 7.3.2(jiti@2.7.0)(terser@5.46.2)(yaml@2.8.4)
       vitest:
         specifier: ^4.1.5
         version: 4.1.5(jsdom@29.1.1)(vite@7.3.2(jiti@2.7.0)(terser@5.46.2)(yaml@2.8.4))

package/frontend-vue/tests/assistant-actions.test.ts

@@ -0,0 +1,72 @@
+// @vitest-environment jsdom
+import { flushPromises } from "@vue/test-utils";
+import { afterEach, describe, expect, it } from "vitest";
+import { shallowRef } from "vue";
+import { publicAssistantActions } from "../app/runtime/assistant-actions";
+import {
+	createHarness,
+	openPanel,
+	sentOfType,
+	unmountPanel,
+} from "./support/panel-harness";
+
+afterEach(() => {
+	unmountPanel();
+});
+
+const PROMPT =
+	"Use dms-external-database on connection roaster, module builder-db-roaster-tables.";
+
+describe("the assistant actions another module's layer injects", () => {
+	it("start a new conversation with the composer prefilled and nothing sent", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		const actions = publicAssistantActions(shallowRef(harness.session));
+		expect(actions.isAvailable).toBe(true);
+		actions.startConversation(PROMPT);
+		await flushPromises();
+		expect((panel.find("textarea").element as HTMLTextAreaElement).value).toBe(
+			PROMPT,
+		);
+		expect(sentOfType(harness, "user_message")).toEqual([]);
+		expect(sentOfType(harness, "set_conversation_mode")).toEqual([]);
+	});
+
+	it("set the new conversation to plan mode before prefilling it, when asked", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		const actions = publicAssistantActions(shallowRef(harness.session));
+		actions.startConversation(PROMPT, { mode: "plan" });
+		await flushPromises();
+		const started = sentOfType(harness, "hello").at(-1)?.conversationId;
+		expect(sentOfType(harness, "set_conversation_mode")).toEqual([
+			expect.objectContaining({ conversationId: started, mode: "plan" }),
+		]);
+		expect((panel.find("textarea").element as HTMLTextAreaElement).value).toBe(
+			PROMPT,
+		);
+	});
+
+	it("set plan mode once the stream is up, when the panel opens before it", async () => {
+		const harness = createHarness();
+		await openPanel(harness);
+		harness.setChannelStatus("disconnected");
+		publicAssistantActions(shallowRef(harness.session)).startConversation(
+			PROMPT,
+			{ mode: "plan" },
+		);
+		await flushPromises();
+		expect(sentOfType(harness, "set_conversation_mode")).toEqual([]);
+		harness.setChannelStatus("connected");
+		await flushPromises();
+		expect(sentOfType(harness, "set_conversation_mode")).toEqual([
+			expect.objectContaining({ mode: "plan" }),
+		]);
+	});
+
+	it("are unavailable without a session, and starting then does nothing", () => {
+		const actions = publicAssistantActions(shallowRef(null));
+		expect(actions.isAvailable).toBe(false);
+		expect(() => actions.startConversation(PROMPT)).not.toThrow();
+	});
+});

package/frontend-vue/tests/backend-boundary.test.ts

@@ -0,0 +1,130 @@
+import {
+	mkdirSync,
+	mkdtempSync,
+	realpathSync,
+	rmSync,
+	symlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { build, type Plugin } from "vite";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { backendBoundary } from "../build/backend-boundary.ts";
+
+let root: string;
+
+function write(file: string, text: string): void {
+	const path = join(root, file);
+	mkdirSync(join(path, ".."), { recursive: true });
+	writeFileSync(path, text);
+}
+
+function manifest(directory: string, name: string): void {
+	write(`${directory}/package.json`, JSON.stringify({ name }));
+}
+
+/** A frontend entry with `source` as its only import, built for real. */
+async function buildEntry(source: string, extra: Plugin[] = []): Promise<void> {
+	write(
+		"frontend/entry.ts",
+		`import "${source}";\nexport const frontend = 1;\n`,
+	);
+	await build({
+		root: join(root, "frontend"),
+		configFile: false,
+		logLevel: "silent",
+		plugins: [backendBoundary(), ...extra],
+		build: {
+			write: false,
+			lib: { entry: join(root, "frontend/entry.ts"), formats: ["es"] },
+		},
+	});
+}
+
+beforeEach(() => {
+	root = realpathSync(mkdtempSync(join(tmpdir(), "dms-ai-boundary-")));
+	manifest("backend", "@antelopejs/dms-ai");
+	write("backend/src/routes/status.ts", "export const status = 1;\n");
+	write("backend/dist/index.js", "export const built = 1;\n");
+	write("backend/srcfoo/index.ts", "export const sibling = 1;\n");
+	manifest("other", "another-package");
+	write("other/src/index.ts", "export const other = 1;\n");
+	manifest("frontend", "@antelopejs/dms-ai-frontend-vue");
+});
+
+afterEach(() => {
+	rmSync(root, { recursive: true, force: true });
+});
+
+describe("the backend boundary of a real build", () => {
+	it("fails when the frontend imports a file under the backend's src", async () => {
+		await expect(buildEntry("../backend/src/routes/status.ts")).rejects.toThrow(
+			/frontend\/entry\.ts imports .*backend\/src\/routes\/status\.ts/,
+		);
+	});
+
+	it("fails when the import carries a query", async () => {
+		await expect(
+			buildEntry("../backend/src/routes/status.ts?raw"),
+		).rejects.toThrow(/Backend boundary/);
+	});
+
+	it("follows a symlink a resolver returns to the file it points at", async () => {
+		symlinkSync(
+			join(root, "backend/src/routes"),
+			join(root, "frontend/routes"),
+		);
+		const linked: Plugin = {
+			name: "test:linked",
+			enforce: "pre",
+			resolveId: (source) =>
+				source === "@linked/status"
+					? join(root, "frontend/routes/status.ts")
+					: null,
+		};
+		await expect(buildEntry("@linked/status", [linked])).rejects.toThrow(
+			/backend\/src\/routes\/status\.ts/,
+		);
+	});
+
+	it("sees through an alias another plugin resolves", async () => {
+		const alias: Plugin = {
+			name: "test:alias",
+			enforce: "pre",
+			resolveId: (source) =>
+				source === "@backend/status"
+					? join(root, "backend/src/routes/status.ts")
+					: null,
+		};
+		await expect(buildEntry("@backend/status", [alias])).rejects.toThrow(
+			/Backend boundary/,
+		);
+	});
+
+	it("lets the backend's built output through", async () => {
+		await expect(
+			buildEntry("../backend/dist/index.js"),
+		).resolves.toBeUndefined();
+	});
+
+	it("lets a sibling directory whose name starts with src through", async () => {
+		await expect(
+			buildEntry("../backend/srcfoo/index.ts"),
+		).resolves.toBeUndefined();
+	});
+
+	it("lets the src of another package through", async () => {
+		await expect(buildEntry("../other/src/index.ts")).resolves.toBeUndefined();
+	});
+
+	it("ignores a virtual module", async () => {
+		const virtual: Plugin = {
+			name: "test:virtual",
+			enforce: "pre",
+			resolveId: (source) => (source === "virtual:ok" ? "\0virtual:ok" : null),
+			load: (id) => (id === "\0virtual:ok" ? "export const v = 1;" : null),
+		};
+		await expect(buildEntry("virtual:ok", [virtual])).resolves.toBeUndefined();
+	});
+});

package/frontend-vue/tests/panel-approvals.test.ts

@@ -0,0 +1,190 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { nextTick } from "vue";
+import {
+	buttonWithText,
+	CONVERSATION_ID,
+	createHarness,
+	deliver,
+	openPanel,
+	sentOfType,
+	unmountPanel,
+} from "./support/panel-harness";
+import {
+	COMMAND_REQUEST,
+	DELETE_REQUEST,
+	DIFF_REQUEST,
+	keydown,
+} from "./support/panel-fixtures";
+
+beforeEach(() => {
+	localStorage.setItem("dms-ai-conversation-id", CONVERSATION_ID);
+});
+
+afterEach(() => {
+	unmountPanel();
+	localStorage.clear();
+	vi.useRealTimers();
+});
+
+describe("the approvals dock", () => {
+	it("previews a diff with line numbers and allows a scope with ↵", async () => {
+		// The countdown reads the clock: frozen at the request's creation, it
+		// shows the full grace period however slow the run is.
+		vi.useFakeTimers({ toFake: ["Date"] });
+		vi.setSystemTime(DIFF_REQUEST.createdAtMs);
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, DIFF_REQUEST);
+		deliver(harness, COMMAND_REQUEST);
+		await nextTick();
+		const dock = panel.find(".cb-approve");
+		expect(dock.attributes("role")).toBe("alertdialog");
+		expect(dock.text()).toContain("Needs your approval · 1 of 2");
+		expect(dock.text()).toContain("denies in 4:12");
+		expect(panel.find(".perm.is-focused .perm__title").text()).toBe(
+			"Edit customer.form.ts",
+		);
+		expect(panel.findAll(".ln").map((row) => row.text())).toEqual([
+			"@@ −42 +42 @@",
+			'42−label: "VAT",',
+			'42+label: "VAT number",',
+		]);
+		expect(dock.text()).toContain("Every edit under crm/customers/");
+		await panel.findAll(".perm.is-focused .scope-opt input")[2].setValue(true);
+		keydown(dock.element, "Enter");
+		await nextTick();
+		expect(sentOfType(harness, "permission_response")[0]).toEqual({
+			type: "permission_response",
+			conversationId: CONVERSATION_ID,
+			requestId: "r1",
+			decision: "allow_rule",
+			rule: { kind: "directory", value: "crm/customers/" },
+		});
+		expect(panel.find(".perm.is-focused .perm__title").text()).toBe(
+			"Run pnpm add jsvat",
+		);
+		expect(panel.find(".perm.is-focused").text()).toContain(
+			"adds a dependency · package.json, pnpm-lock.yaml",
+		);
+	});
+
+	it("moves with J and K, denies with N, and denies everything at once", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, DIFF_REQUEST);
+		deliver(harness, COMMAND_REQUEST);
+		await nextTick();
+		const dock = panel.find(".cb-approve");
+		keydown(dock.element, "j");
+		await nextTick();
+		expect(dock.text()).toContain("2 of 2");
+		keydown(dock.element, "k");
+		await nextTick();
+		expect(dock.text()).toContain("1 of 2");
+		keydown(dock.element, "n");
+		await nextTick();
+		expect(sentOfType(harness, "permission_response")[0]).toMatchObject({
+			requestId: "r1",
+			decision: "deny",
+		});
+		deliver(harness, DIFF_REQUEST);
+		await nextTick();
+		await buttonWithText(
+			panel.find(".cb-approve"),
+			"Deny both and stop",
+		).trigger("click");
+		expect(sentOfType(harness, "permission_response").at(-1)).toMatchObject({
+			decision: "deny_all",
+		});
+	});
+
+	it("denies with the user's suggestion", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, DIFF_REQUEST);
+		await nextTick();
+		await buttonWithText(panel, "Suggest a change").trigger("click");
+		await panel
+			.find(".u-textarea")
+			.setValue("Use the Builder's validation instead");
+		await buttonWithText(panel, "Deny and send").trigger("click");
+		expect(sentOfType(harness, "permission_response")[0]).toMatchObject({
+			decision: "deny",
+			feedback: "Use the Builder's validation instead",
+		});
+	});
+
+	it("makes a data loss typed, offers to keep the data, and never a chat-wide rule", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, DELETE_REQUEST);
+		await nextTick();
+		const card = panel.find(".perm.is-danger");
+		expect(card.text()).toContain("Data loss");
+		expect(card.text()).not.toContain("this chat");
+		const confirm = buttonWithText(card, "Delete");
+		expect(confirm.attributes("disabled")).toBeDefined();
+		await card.find(".perm__confirm input").setValue("legacy_coupons");
+		expect(
+			buttonWithText(card, "Delete").attributes("disabled"),
+		).toBeUndefined();
+		await card.find('input[type="checkbox"]').setValue(true);
+		await buttonWithText(card, "Remove the code only").trigger("click");
+		expect(sentOfType(harness, "permission_response")[0]).toMatchObject({
+			decision: "allow_once",
+			keepData: true,
+		});
+	});
+
+	it("turns an expired request into a card that asks again", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, DIFF_REQUEST);
+		deliver(harness, {
+			type: "permission_expired",
+			requestId: "r1",
+			toolName: "Edit",
+			summary: "Edit customer.form.ts",
+			expiredAtMs: Date.now(),
+		});
+		await nextTick();
+		expect(panel.find(".cb-approve").exists()).toBe(false);
+		const card = panel.find(".cb-expired");
+		expect(card.text()).toContain("Edit file request expired");
+		await buttonWithText(card, "Ask again").trigger("click");
+		expect(sentOfType(harness, "user_message")[0].content).toContain(
+			"Edit customer.form.ts",
+		);
+		expect(panel.find(".cb-expired").exists()).toBe(false);
+	});
+
+	it("lists the rules allowed in this chat and revokes one", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, DIFF_REQUEST);
+		deliver(harness, {
+			type: "rules_state",
+			rules: [
+				{
+					id: "rule-1",
+					kind: "command",
+					value: "pnpm test",
+					label: "Commands starting pnpm test",
+					createdAtMs: 1,
+				},
+			],
+		});
+		await nextTick();
+		const rules = panel.find(".cb-approve .cb-rules");
+		expect(rules.text()).toContain("Commands starting pnpm test");
+		await buttonWithText(rules, "Revoke").trigger("click");
+		expect(sentOfType(harness, "revoke_rule")).toEqual([
+			{
+				type: "revoke_rule",
+				conversationId: CONVERSATION_ID,
+				ruleId: "rule-1",
+			},
+		]);
+	});
+});

package/frontend-vue/tests/panel-questions.test.ts

@@ -0,0 +1,169 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { nextTick } from "vue";
+import {
+	buttonWithText,
+	CONVERSATION_ID,
+	createHarness,
+	deliver,
+	openPanel,
+	sendMessage,
+	sentOfType,
+	unmountPanel,
+} from "./support/panel-harness";
+import { keydown } from "./support/panel-fixtures";
+
+beforeEach(() => {
+	localStorage.setItem("dms-ai-conversation-id", CONVERSATION_ID);
+});
+
+afterEach(() => {
+	unmountPanel();
+	localStorage.clear();
+	vi.useRealTimers();
+});
+
+describe("questions, queue and modes", () => {
+	const QUESTIONS = {
+		type: "ask_question",
+		requestId: "q1",
+		questions: [
+			{
+				question: "Where should the page live?",
+				header: "Placement",
+				options: [
+					{
+						label: "Finance › Overdue invoices",
+						description: "Next to Invoices",
+					},
+					{ label: "A tab on Invoices", description: "" },
+				],
+			},
+			{
+				question: "Default sort?",
+				header: "Sort",
+				options: [
+					{ label: "Days overdue", description: "" },
+					{ label: "Amount", description: "" },
+				],
+			},
+		],
+	};
+
+	it("pages through questions with numbers, Other… and Skip, then keeps the answers", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, QUESTIONS);
+		await nextTick();
+		const dock = panel.find(".cb-ask");
+		expect(dock.text()).toContain("Question 1 of 2 · Placement");
+		expect(dock.find(".opt-card.is-selected").text()).toContain("Suggested");
+		keydown(dock.element, "3");
+		await nextTick();
+		await dock.find(".cb-ask__custom").setValue("Under Finance, as a tab");
+		await buttonWithText(dock.find(".cb-ask__foot"), "Next").trigger("click");
+		expect(dock.text()).toContain("Question 2 of 2 · Sort");
+		await buttonWithText(dock, "Skip, you decide").trigger("click");
+		expect(sentOfType(harness, "question_response")[0]).toEqual({
+			type: "question_response",
+			conversationId: CONVERSATION_ID,
+			requestId: "q1",
+			answers: ["Under Finance, as a tab", ""],
+			skipped: [false, true],
+		});
+		await nextTick();
+		const record = panel.find(".cb-answers");
+		expect(record.text()).toContain("“Under Finance, as a tab”");
+		expect(record.text()).toContain("Skipped: the assistant decides");
+	});
+
+	it("edits, reorders and clears the queue", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, {
+			type: "queue_state",
+			items: [
+				{ id: "a", content: "Sort by order count" },
+				{ id: "b", content: "Limit to 3 orders" },
+			],
+		});
+		await nextTick();
+		await panel
+			.find('button[aria-label="Edit queued message"]')
+			.trigger("click");
+		await panel.find(".cb-queued__editor").setValue("Sort by revenue");
+		await buttonWithText(panel.find(".cb-queue"), "Save").trigger("click");
+		keydown(panel.findAll(".cb-queued__handle")[1].element, "ArrowUp");
+		await nextTick();
+		expect(panel.findAll(".cb-queued__txt").map((item) => item.text())).toEqual(
+			["Limit to 3 orders", "Sort by revenue"],
+		);
+		await buttonWithText(panel.find(".cb-queue"), "Clear").trigger("click");
+		expect(
+			harness.sent
+				.map((msg) => msg.type)
+				.filter((type) => String(type).startsWith("queue_")),
+		).toEqual(["queue_update", "queue_move", "queue_clear"]);
+	});
+
+	it("switches the chat's mode and scope, and confirms Full auto with a duration", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		await buttonWithText(panel, "Plan only").trigger("click");
+		await buttonWithText(panel, "Full auto…").trigger("click");
+		await nextTick();
+		const modal = panel.find(".u-modal");
+		expect(modal.text()).toContain("Turn on Full auto?");
+		await buttonWithText(modal, "30 minutes").trigger("click");
+		await buttonWithText(modal, "Turn on Full auto").trigger("click");
+		expect(sentOfType(harness, "set_conversation_mode")).toEqual([
+			{
+				type: "set_conversation_mode",
+				conversationId: CONVERSATION_ID,
+				mode: "plan",
+			},
+			{
+				type: "set_conversation_mode",
+				conversationId: CONVERSATION_ID,
+				fullAuto: { duration: "30m" },
+			},
+		]);
+		await nextTick();
+		const banner = panel.find(".cb-banner-auto");
+		expect(banner.text()).toContain("Full auto · for 30 minutes");
+		await buttonWithText(banner, "Turn off").trigger("click");
+		expect(sentOfType(harness, "set_conversation_mode").at(-1)).toMatchObject({
+			fullAuto: null,
+		});
+	});
+
+	it("runs a proposed plan in Ask first", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		await sendMessage(panel, "plan a customer health page");
+		deliver(harness, {
+			type: "tool_call_start",
+			callId: "p1",
+			toolName: "ExitPlanMode",
+			args: { plan: "1. Create the page\n2. Add a query" },
+		});
+		deliver(harness, {
+			type: "tool_call_end",
+			callId: "p1",
+			status: "success",
+			result: "",
+			outcome: "done",
+		});
+		deliver(harness, { type: "run_done" });
+		await nextTick();
+		const plan = panel.find(".cb-plan");
+		expect(plan.text()).toContain("Proposed plan · 2 steps");
+		await buttonWithText(plan, "Run with Ask first").trigger("click");
+		expect(sentOfType(harness, "set_conversation_mode")[0]).toMatchObject({
+			mode: "normal",
+		});
+		expect(sentOfType(harness, "user_message").at(-1)).toMatchObject({
+			content: "Go ahead with the plan.",
+		});
+	});
+});