@antelopejs/dms-ai 0.8.0 → 0.9.1

package/frontend-vue/tests/chat/chat-scroll.test.ts

@@ -0,0 +1,251 @@
+// @vitest-environment jsdom
+import { flushPromises, type VueWrapper } from "@vue/test-utils";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { nextTick } from "vue";
+import {
+	CONVERSATION_ID,
+	createHarness,
+	deliver,
+	type Harness,
+	openPanel,
+	sendMessage,
+	unmountPanel,
+} from "../support/panel-harness";
+import {
+	type FakeScroller,
+	fakeScroller,
+	settleLayout,
+} from "../support/fake-layout";
+
+const BOTTOM_TOLERANCE_PX = 4;
+
+interface OpenChat {
+	harness: Harness;
+	panel: VueWrapper;
+	scroller: FakeScroller;
+}
+
+function transcript(rows: number) {
+	return Array.from({ length: rows }, (_, index) => ({
+		role: index % 2 === 0 ? "user" : "assistant",
+		content: `message ${index}`,
+		timestampMs: 1_700_000_000_000 + index,
+	}));
+}
+
+/** One browser frame: Vue renders, then layout is reported. */
+async function frame(): Promise<void> {
+	await nextTick();
+	await flushPromises();
+	settleLayout();
+}
+
+async function openChat(rows = 30): Promise<OpenChat> {
+	const harness = createHarness();
+	const panel = await openPanel(harness);
+	const scroller = fakeScroller(
+		panel.find<HTMLElement>(".chat-view-body").element,
+	);
+	deliver(harness, {
+		type: "conversation_snapshot",
+		messages: transcript(rows),
+	});
+	await frame();
+	return { harness, panel, scroller };
+}
+
+async function growTranscript(chat: OpenChat, rows: number): Promise<void> {
+	deliver(chat.harness, {
+		type: "conversation_snapshot",
+		messages: transcript(rows),
+	});
+	await frame();
+}
+
+beforeEach(() => {
+	localStorage.setItem("dms-ai-conversation-id", CONVERSATION_ID);
+});
+
+afterEach(() => {
+	unmountPanel();
+	localStorage.clear();
+});
+
+describe("the chat follows the conversation", () => {
+	it("shows the end of a chat opened from its snapshot", async () => {
+		const { scroller } = await openChat(60);
+		expect(scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+	});
+
+	it("stays at the bottom when the view loses height without any message arriving", async () => {
+		const { scroller } = await openChat();
+		scroller.viewportPx -= 250;
+		await frame();
+		expect(scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+	});
+
+	it("stays at the bottom when content grows without any message arriving", async () => {
+		const { scroller } = await openChat();
+		scroller.extraContentPx += 600;
+		await frame();
+		expect(scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+	});
+
+	it("stays at the bottom through one message taller than the old 80px margin", async () => {
+		const { scroller, harness } = await openChat();
+		deliver(harness, { type: "assistant_message_chunk", text: "answer" });
+		scroller.extraContentPx += 900;
+		await frame();
+		expect(scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+	});
+
+	it("does not pull the person back down once they scroll up", async () => {
+		const chat = await openChat();
+		chat.scroller.scrollTo(500);
+		await growTranscript(chat, 40);
+		chat.scroller.extraContentPx += 300;
+		await frame();
+		expect(
+			chat.panel.find<HTMLElement>(".chat-view-body").element.scrollTop,
+		).toBe(500);
+	});
+
+	it("jumps to the bottom when a message is sent from far up", async () => {
+		const chat = await openChat();
+		chat.scroller.scrollTo(200);
+		await sendMessage(chat.panel, "and now this");
+		await frame();
+		expect(chat.scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+	});
+
+	it("follows again once the person scrolls back to the bottom", async () => {
+		const chat = await openChat();
+		chat.scroller.scrollTo(500);
+		const bottom = chat.scroller.viewportPx;
+		chat.scroller.scrollTo(
+			chat.panel.find<HTMLElement>(".chat-view-body").element.scrollHeight -
+				bottom,
+		);
+		await growTranscript(chat, 40);
+		expect(chat.scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+	});
+
+	it("stops following on an upward scroll that carries no input", async () => {
+		const chat = await openChat();
+		chat.scroller.scrollTo(500);
+		await growTranscript(chat, 40);
+		chat.scroller.extraContentPx += 300;
+		await frame();
+		expect(
+			chat.panel.find<HTMLElement>(".chat-view-body").element.scrollTop,
+		).toBe(500);
+	});
+
+	it("keeps following when content above the view collapses and scroll anchoring moves the view up", async () => {
+		const chat = await openChat();
+		chat.scroller.extraContentPx += 800;
+		await frame();
+		chat.scroller.collapseAbove(600);
+		await frame();
+		await frame();
+		expect(chat.scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+		chat.scroller.extraContentPx += 400;
+		await frame();
+		expect(chat.scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+	});
+
+	it("keeps following when a collapse above the view comes with growth below it", async () => {
+		const chat = await openChat();
+		chat.scroller.extraContentPx += 800;
+		await frame();
+		chat.scroller.collapseAbove(600);
+		chat.scroller.extraContentPx += 700;
+		await frame();
+		await frame();
+		expect(chat.scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+	});
+
+	it("keeps following when the view gains height and the browser clamps the scroll", async () => {
+		const chat = await openChat();
+		chat.scroller.viewportPx += 250;
+		await frame();
+		await frame();
+		chat.scroller.extraContentPx += 500;
+		await frame();
+		expect(chat.scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+	});
+
+	it("keeps following after the content shrinks under the view", async () => {
+		const chat = await openChat(60);
+		await growTranscript(chat, 20);
+		await growTranscript(chat, 30);
+		expect(chat.scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+	});
+
+	it("ends at the bottom for a chat started from outside that sends its prompt", async () => {
+		const chat = await openChat();
+		chat.scroller.scrollTo(200);
+		chat.harness.session.startConversation("build me a page", undefined, true);
+		await frame();
+		await frame();
+		expect(chat.scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+	});
+
+	it("opens another chat at its bottom, even after scrolling up in this one", async () => {
+		const chat = await openChat();
+		chat.scroller.scrollTo(200);
+		chat.harness.session.openConversation("conv-other");
+		await frame();
+		deliver(chat.harness, {
+			conversationId: "conv-other",
+			type: "conversation_snapshot",
+			messages: transcript(50),
+		});
+		await frame();
+		expect(chat.scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+	});
+
+	it("keeps following in a shorter chat opened from the bottom of a long one", async () => {
+		const chat = await openChat(60);
+		chat.harness.session.openConversation("conv-other");
+		await frame();
+		deliver(chat.harness, {
+			conversationId: "conv-other",
+			type: "conversation_snapshot",
+			messages: transcript(8),
+		});
+		await frame();
+		await frame();
+		chat.scroller.extraContentPx += 500;
+		await frame();
+		expect(chat.scroller.distanceFromBottom()).toBeLessThanOrEqual(
+			BOTTOM_TOLERANCE_PX,
+		);
+	});
+});

package/frontend-vue/tests/chat/conversation-events.test.ts

@@ -134,7 +134,6 @@ describe("the conversation folds the redesign's events", () => {
 			type: "conversation_mode",
 			mode: "plan",
 			generationMode: "vibe",
-			fullAuto: { duration: "turn" },
 		});
 		expect(conversation.messages.value[0]).toMatchObject({
 			role: "notice",
@@ -144,7 +143,6 @@ describe("the conversation folds the redesign's events", () => {
 		expect(conversation.mode.value).toEqual({
 			mode: "plan",
 			generationMode: "vibe",
-			fullAuto: { duration: "turn" },
 		});
 	});
 
@@ -200,7 +198,7 @@ describe("the conversation folds the redesign's events", () => {
 				},
 			],
 			changeSets: [changeSet()],
-			mode: { mode: "acceptEdits", generationMode: "safe", fullAuto: null },
+			mode: { mode: "acceptEdits", generationMode: "safe" },
 			totalTokens: 1_200,
 		});
 		expect(conversation.messages.value.map((m) => m.role)).toEqual([
@@ -220,6 +218,40 @@ describe("the conversation folds the redesign's events", () => {
 		expect(conversation.totalTokens.value).toBe(1_200);
 	});
 
+	it("shows the model that answered, from a usage event or a snapshot", () => {
+		const b = bus();
+		const conversation = useConversation(b.options as never);
+		expect(conversation.model.value).toBeNull();
+		b.receive({ type: "usage", totalTokens: 10, model: "claude-opus-5-5" });
+		expect(conversation.model.value).toBe("claude-opus-5-5");
+		b.receive({
+			type: "conversation_snapshot",
+			messages: [],
+			changeSets: [],
+			totalTokens: 10,
+			model: "claude-sonnet-4-6",
+		});
+		expect(conversation.model.value).toBe("claude-sonnet-4-6");
+	});
+
+	it("keeps the notice that the configured model was refused", () => {
+		const b = bus();
+		const conversation = useConversation(b.options as never);
+		b.receive({
+			type: "notice",
+			notice: {
+				kind: "model_fallback",
+				requestedModel: "claude-opus-5-5",
+				usedModel: "claude-sonnet-4-6",
+				timestampMs: 7,
+			},
+		});
+		expect(conversation.messages.value[0]).toMatchObject({
+			role: "notice",
+			notice: { kind: "model_fallback", usedModel: "claude-sonnet-4-6" },
+		});
+	});
+
 	it("ignores another conversation's events", () => {
 		const b = bus();
 		const conversation = useConversation(b.options as never);

package/frontend-vue/tests/chat/provider-notice.test.ts

@@ -0,0 +1,33 @@
+// @vitest-environment jsdom
+import { mount } from "@vue/test-utils";
+import { describe, expect, it } from "vitest";
+import ProviderNotice from "../../app/chat/components/ProviderNotice.vue";
+import { CHAT_I18N_KEY } from "../../app/chat/composables/useChatI18n";
+import fr from "../../i18n/locales/dms-ai-panel-fr-FR.json";
+import { createTestI18n } from "../support/i18n";
+import { PANEL_STUBS } from "../support/stubs";
+
+const ENGLISH_REASON =
+	"Sign in with ChatGPT in Assistant › Settings to run Codex on your ChatGPT plan.";
+
+function noticeText(code?: "codex_not_signed_in"): string {
+	return mount(ProviderNotice, {
+		props: { agentName: "Codex", reason: ENGLISH_REASON, code },
+		global: {
+			provide: { [CHAT_I18N_KEY as symbol]: createTestI18n(fr) },
+			stubs: PANEL_STUBS,
+		},
+	}).text();
+}
+
+describe("the agent can't run notice", () => {
+	it("words the ChatGPT sign-in hint in the panel's language", () => {
+		const text = noticeText("codex_not_signed_in");
+		expect(text).toContain("Connectez-vous avec ChatGPT");
+		expect(text).not.toContain(ENGLISH_REASON);
+	});
+
+	it("shows the sidecar's own reason when the panel has no wording for it", () => {
+		expect(noticeText()).toContain(ENGLISH_REASON);
+	});
+});

package/frontend-vue/tests/chat/tool-lexicon.test.ts

@@ -68,6 +68,7 @@ describe("the tool lexicon names a call by what it does", () => {
 			"BuilderRemoveField",
 			"BuilderRemoveQuery",
 			"BuilderQueryTemplates",
+			"BuilderPreviewQuery",
 		];
 		for (const name of [...builder, "AskUser", "Typecheck", "NavigateToPage"])
 			expect(describeTool(`mcp__dms-ai__${name}`, {}).verbKey).not.toBeNull();

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

@@ -47,16 +47,14 @@ describe("the chat as a component of the dashboard", () => {
 		]);
 	});
 
-	it("leaves its conversation when the panel closes, and picks it up again when it opens", async () => {
+	it("picks its conversation up again when the panel reopens, without announcing that it left", async () => {
 		const harness = createHarness();
 		const panel = await openPanel(harness);
 		await sendMessage(panel, "build me a page");
 		harness.session.panel.close();
 		await nextTick();
 		expect(panel.find(".chat-view").exists()).toBe(false);
-		expect(sentOfType(harness, "leave_conversation")).toEqual([
-			{ type: "leave_conversation", conversationId: CONVERSATION_ID },
-		]);
+		expect(sentOfType(harness, "leave_conversation")).toEqual([]);
 		harness.session.panel.toggle();
 		await flushPromises();
 		expect(sentOfType(harness, "hello")).toEqual([

package/frontend-vue/tests/navigation.test.ts

@@ -1,6 +1,7 @@
 // @vitest-environment jsdom
-import { describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { installCurrentPageTracker } from "../app/runtime/current-page";
+import { BLOCK_SETTLE_BUDGET_MS } from "../app/runtime/block-health";
 import { installNavigationCompleteEmitter } from "../app/runtime/navigation-complete";
 
 function navigate(url: string): void {
@@ -61,7 +62,7 @@ describe("Inertia host navigation", () => {
 		document.title = "";
 	});
 
-	it("emits completion only after navigation and removes its event listener", () => {
+	it("emits completion at once after navigation, announcing the block report, and removes its event listener", () => {
 		const send = vi.fn();
 		const stop = installNavigationCompleteEmitter({ send });
 		expect(send).not.toHaveBeenCalled();
@@ -69,9 +70,73 @@ describe("Inertia host navigation", () => {
 		expect(send).toHaveBeenCalledExactlyOnceWith({
 			type: "host_navigation_complete",
 			path: "/finished",
+			blocksWithinMs: BLOCK_SETTLE_BUDGET_MS,
 		});
 		stop();
 		navigate("/ignored");
 		expect(send).toHaveBeenCalledTimes(1);
 	});
+
+	describe("block report", () => {
+		beforeEach(() => {
+			document.body.replaceChildren();
+			vi.useFakeTimers();
+		});
+
+		afterEach(() => {
+			vi.useRealTimers();
+		});
+
+		function addChart(state: string): HTMLElement {
+			const element = document.createElement("div");
+			element.setAttribute("data-dms-block-state", state);
+			element.setAttribute("data-dms-block-type", "ChartCard");
+			element.setAttribute("data-dms-block", "revenue");
+			document.body.append(element);
+			return element;
+		}
+
+		it("follows the completion with the blocks showing no data", async () => {
+			addChart("empty");
+			const send = vi.fn();
+			const stop = installNavigationCompleteEmitter({ send });
+			navigate("/sales");
+			await vi.advanceTimersByTimeAsync(BLOCK_SETTLE_BUDGET_MS);
+			expect(send).toHaveBeenLastCalledWith({
+				type: "host_page_blocks",
+				path: "/sales",
+				status: "settled",
+				checked: 1,
+				blocks: [{ path: "revenue", type: "ChartCard", state: "empty" }],
+			});
+			stop();
+		});
+
+		it("reports the first page as superseded when a second navigation starts", async () => {
+			addChart("loading");
+			const send = vi.fn();
+			const stop = installNavigationCompleteEmitter({ send });
+			navigate("/first");
+			await vi.advanceTimersByTimeAsync(100);
+			navigate("/second");
+			await vi.advanceTimersByTimeAsync(0);
+			expect(send).toHaveBeenCalledWith(
+				expect.objectContaining({
+					type: "host_page_blocks",
+					path: "/first",
+					status: "superseded",
+				}),
+			);
+			stop();
+		});
+
+		it("reports nothing once stopped", async () => {
+			const send = vi.fn();
+			const stop = installNavigationCompleteEmitter({ send });
+			navigate("/sales");
+			stop();
+			await vi.advanceTimersByTimeAsync(BLOCK_SETTLE_BUDGET_MS);
+			expect(send).toHaveBeenCalledTimes(1);
+		});
+	});
 });

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

@@ -0,0 +1,146 @@
+// @vitest-environment jsdom
+import type { VueWrapper } from "@vue/test-utils";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { nextTick } from "vue";
+import {
+	CONVERSATION_ID,
+	createHarness,
+	deliver,
+	openPanel,
+	unmountPanel,
+} from "./support/panel-harness";
+
+beforeEach(() => {
+	localStorage.setItem("dms-ai-conversation-id", CONVERSATION_ID);
+});
+
+afterEach(() => {
+	unmountPanel();
+	localStorage.clear();
+});
+
+const SETTINGS = {
+	defaultModes: { claude: "auto", codex: "normal" },
+	thinking: "medium",
+	generationMode: "safe",
+	allowLocalSkills: false,
+};
+
+const PROVIDERS = {
+	claude: { available: true },
+	codex: { available: true },
+};
+
+function modePill(panel: VueWrapper) {
+	const pills = panel.findAll(".cb-mode-btn");
+	return pills[pills.length - 1];
+}
+
+function pickerItems(panel: VueWrapper): string[] {
+	const menu = modePill(panel).element.closest(".u-dropdown");
+	return Array.from(menu?.querySelectorAll(".u-dropdown-item") ?? []).map(
+		(item) => item.textContent?.trim() ?? "",
+	);
+}
+
+async function useProvider(
+	harness: ReturnType<typeof createHarness>,
+	provider: "claude" | "codex",
+): Promise<void> {
+	deliver(harness, {
+		type: "settings_update",
+		settings: { ...SETTINGS, provider },
+		providers: PROVIDERS,
+	});
+	await nextTick();
+}
+
+describe("the approval mode pill", () => {
+	it("shows Auto review on a fresh Claude chat, without danger styling", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		await useProvider(harness, "claude");
+		const pill = modePill(panel);
+		expect(pill.text()).toBe("Auto review");
+		expect(pickerItems(panel)).toContain("Auto review");
+	});
+
+	it("reads Ask first on Codex for a chat holding auto, and offers no Auto review", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		await useProvider(harness, "codex");
+		deliver(harness, {
+			type: "conversation_mode",
+			mode: "auto",
+			generationMode: "safe",
+		});
+		await nextTick();
+		expect(modePill(panel).text()).toBe("Ask first");
+		expect(pickerItems(panel)).not.toContain("Auto review");
+		expect(pickerItems(panel)).toContain("Ask first");
+	});
+
+	it.each(["claude", "codex"] as const)(
+		"offers no Full auto in the %s mode menu",
+		async (provider) => {
+			const harness = createHarness();
+			const panel = await openPanel(harness);
+			await useProvider(harness, provider);
+			const items = pickerItems(panel);
+			expect(items.length).toBeGreaterThan(0);
+			expect(items.filter((item) => /full auto/i.test(item))).toEqual([]);
+		},
+	);
+
+	it.each([
+		["codex", true],
+		["claude", false],
+	] as const)(
+		"says Accept edits works as Ask first on %s: %s",
+		async (provider, worksAsAskFirst) => {
+			const harness = createHarness();
+			const panel = await openPanel(harness);
+			await useProvider(harness, provider);
+			const acceptEdits = panel
+				.findAll(".u-dropdown-item")
+				.find((item) => item.text() === "Accept edits");
+			const description = acceptEdits?.attributes("data-description") ?? "";
+			expect(description).not.toBe("");
+			expect(description.includes("works as Ask first")).toBe(worksAsAskFirst);
+		},
+	);
+
+	it("keeps the pill on the chat's own mode when an older sidecar still sends Full auto", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		await useProvider(harness, "claude");
+		deliver(harness, {
+			type: "conversation_mode",
+			mode: "auto",
+			generationMode: "safe",
+			fullAuto: { duration: "chat" },
+		});
+		await nextTick();
+		expect(modePill(panel).text()).toBe("Auto review");
+		expect(panel.find(".cb-banner-auto").exists()).toBe(false);
+	});
+
+	it("says Auto review is not available, naming the model", async () => {
+		const harness = createHarness();
+		const panel = await openPanel(harness);
+		deliver(harness, {
+			type: "notice",
+			notice: {
+				kind: "auto_unavailable",
+				model: "claude-haiku-4-5",
+				timestampMs: Date.now(),
+			},
+		});
+		await nextTick();
+		const notice = panel.find(".cb-notice");
+		expect(notice.text()).toContain("Auto review isn't available here.");
+		expect(notice.text()).toContain(
+			"claude-haiku-4-5, this plan or a setting doesn't allow it.",
+		);
+	});
+});

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

@@ -106,35 +106,17 @@ describe("questions, queue and modes", () => {
 		).toEqual(["queue_update", "queue_move", "queue_clear"]);
 	});
 
-	it("switches the chat's mode and scope, and confirms Full auto with a duration", async () => {
+	it("sends the chosen mode alone, with nothing that approves for the person", 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 () => {

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

@@ -60,16 +60,6 @@ describe("the panel's header and empty chat", () => {
 		);
 	});
 
-	it("sends leave_conversation when the panel closes", async () => {
-		const harness = createHarness();
-		await openPanel(harness);
-		harness.session.panel.close();
-		await nextTick();
-		expect(sentOfType(harness, "leave_conversation")).toEqual([
-			{ type: "leave_conversation", conversationId: CONVERSATION_ID },
-		]);
-	});
-
 	it("stamps a message with the page unless its chip was removed", async () => {
 		const harness = createHarness();
 		const panel = await openPanel(harness);
@@ -116,7 +106,7 @@ describe("notices and errors", () => {
 			type: "settings_update",
 			settings: {
 				provider: "codex",
-				mode: "normal",
+				defaultModes: { claude: "auto", codex: "normal" },
 				thinking: "medium",
 				generationMode: "safe",
 				allowLocalSkills: false,
@@ -161,7 +151,7 @@ describe("the history drawer", () => {
 				id: "c-old",
 				title: "Why is order pending?",
 				createdAtMs: 1,
-				updatedAtMs: Date.now() - 3_600_000,
+				updatedAtMs: Date.now() - 1_000,
 				messageCount: 2,
 				filesChanged: 0,
 				filesUndone: 1,
@@ -185,9 +175,7 @@ describe("the history drawer", () => {
 		expect(drawer.text()).toContain("9.6k tok");
 		expect(drawer.text()).toContain("1 file undone");
 		await buttonWithText(drawer, "Why is order pending?").trigger("click");
-		expect(sentOfType(harness, "leave_conversation")[0]).toMatchObject({
-			conversationId: CONVERSATION_ID,
-		});
+		expect(sentOfType(harness, "leave_conversation")).toEqual([]);
 		expect(sentOfType(harness, "hello").at(-1)).toMatchObject({
 			conversationId: "c-old",
 		});