@jskit-ai/assistant-core 0.1.204 → 0.1.206

package/test/assistantScroll.browser.test.js

@@ -405,7 +405,10 @@ test("upward scrolling loads older history once and preserves retry and selectio
       await expect(page.getByText("Conversation line 70:", { exact: false })).toBeVisible();
       await expect(requests).toHaveText("History requests: 3");
       await external("Exhaust history");
-      await body.focus();
+      await expect.poll(async () => {
+        await body.focus();
+        return body.evaluate(element => document.activeElement === element);
+      }).toBe(true);
       await body.press("Home");
       await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(0);
       await expect(requests).toHaveText("History requests: 3");
@@ -420,6 +423,206 @@ test("upward scrolling loads older history once and preserves retry and selectio
   }
 });
 
+test("retained hidden transcripts preserve readers and follow only at the latest message", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 90_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    for (const width of [390, 800, 1365]) {
+      const page = await browser.newPage({ viewport: { width, height: 900 } });
+      await page.goto(`${vite.baseURL}/?controls=1&history=1&retain-hidden=1&initial-hidden=1`);
+      const body = page.locator(".assistant-transcript__body");
+      const external = name => page.getByRole("button", { name, exact: true }).evaluate(element => element.click());
+      await expect(body).toBeAttached();
+      await expect(body).toBeHidden();
+      await external("Toggle visibility");
+      await expect(body).toBeVisible();
+      await expect(page.locator(".assistant-transcript__settling")).toHaveCount(0);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      const draft = page.getByRole("textbox", { name: "Message AI assistant", exact: true });
+      await draft.fill("Keep my typed draft");
+      await body.hover();
+      await page.mouse.wheel(0, -1000);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeGreaterThan(50);
+      await body.evaluate(element => { element.scrollTop = 420; });
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+      await body.evaluate(element => {
+        window.retainedBody = element;
+        const top = element.getBoundingClientRect().top;
+        const anchor = [...element.querySelectorAll(".assistant-transcript__turn")].find(turn => turn.getBoundingClientRect().bottom > top);
+        window.retainedAnchor = { element: anchor, offset: anchor.getBoundingClientRect().top - top };
+      });
+      await external("Toggle visibility");
+      await expect(body).toBeHidden();
+      await external("Append reply");
+      // Hidden zero-geometry events must not change following or fetch history.
+      await body.evaluate(element => element.dispatchEvent(new Event("scroll")));
+      await expect(page.locator("output")).toHaveText("History requests: 0");
+      await external("Toggle visibility");
+      await expect(body).toBeVisible();
+      assert.equal(await body.evaluate(element => element === window.retainedBody), true);
+      await expect.poll(() => body.evaluate(element => Math.abs(window.retainedAnchor.element.getBoundingClientRect().top - element.getBoundingClientRect().top - window.retainedAnchor.offset))).toBeLessThan(2);
+      await expect(draft).toHaveValue("Keep my typed draft");
+      await body.hover();
+      await page.mouse.wheel(0, 100_000);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      await external("Toggle visibility");
+      await external("Append reply");
+      await external("Toggle visibility");
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      await body.hover();
+      await page.mouse.wheel(0, -1000);
+      await external("Toggle visibility");
+      await external("Change conversation");
+      await external("Toggle visibility");
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      await expect(page.locator(".assistant-transcript__settling")).toHaveCount(0);
+      assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});
+
+test("transient update errors keep the loaded transcript, reader, draft and focus in a compact banner", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 90_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    for (const width of [390, 800, 1365]) {
+      const page = await browser.newPage({ viewport: { width, height: 900 } });
+      await page.goto(`${vite.baseURL}/?controls=1&history=1&update-errors=1`);
+      const body = page.locator(".assistant-transcript__body");
+      const draft = page.getByRole("textbox", { name: "Message AI assistant", exact: true });
+      const external = name => page.getByRole("button", { name, exact: true }).evaluate(element => element.click());
+      await expect(page.locator(".assistant-transcript__settling")).toHaveCount(0);
+      await draft.fill("Keep my draft while updates reconnect.");
+      await body.hover();
+      await page.mouse.wheel(0, -1000);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeGreaterThan(50);
+      await body.evaluate(element => { element.scrollTop = 420; window.updateErrorBody = element; });
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+      await draft.evaluate(element => {
+        element.focus({ preventScroll: true });
+        element.setSelectionRange(2, 7);
+        window.updateErrorDraft = element;
+      });
+      const rows = await body.locator(".assistant-transcript__turn").count();
+      await external("Show update error");
+      const banner = page.locator(".assistant-transcript__error");
+      await expect(banner).toContainText("Conversation updates are temporarily unavailable. Reload to reconnect; the assistant may still be working.");
+      await expect(banner.getByRole("button", { name: "Reload chat", exact: true })).toBeVisible();
+      await expect(body).toBeVisible();
+      assert.equal(await body.evaluate(element => element === window.updateErrorBody), true);
+      await expect(body.locator(".assistant-transcript__turn")).toHaveCount(rows);
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+      await expect(draft).toHaveValue("Keep my draft while updates reconnect.");
+      await expect(draft).toBeFocused();
+      assert.deepEqual(await draft.evaluate(element => [element === window.updateErrorDraft, element.selectionStart, element.selectionEnd]), [true, 2, 7]);
+      const transcriptBox = await page.locator(".assistant-transcript").boundingBox();
+      const bannerBox = await banner.boundingBox();
+      const bodyBox = await body.boundingBox();
+      assert.ok(bannerBox.height < transcriptBox.height / 3);
+      assert.ok(bodyBox.height > transcriptBox.height / 2);
+      assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+      await banner.getByRole("button", { name: "Reload chat", exact: true }).click();
+      await expect(banner).toHaveCount(0);
+      await expect(page.locator(".assistant-conversation")).toHaveAttribute("data-error-reloads", "1");
+      assert.equal(await body.evaluate(element => element === window.updateErrorBody), true);
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+      await expect(draft).toHaveValue("Keep my draft while updates reconnect.");
+      await expect(page.locator("output")).toHaveText("History requests: 0");
+      await body.hover();
+      await page.mouse.wheel(0, 100_000);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      await external("Show update error");
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      await banner.getByRole("button", { name: "Reload chat", exact: true }).click();
+      await expect(banner).toHaveCount(0);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      await expect(page.locator(".assistant-conversation")).toHaveAttribute("data-error-reloads", "2");
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});
+
+test("retained hidden history loads restore their original anchor and invalidate retired requests", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 90_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    for (const width of [390, 800, 1365]) {
+      const page = await browser.newPage({ viewport: { width, height: 900 } });
+      const body = page.locator(".assistant-transcript__body");
+      const external = name => page.getByRole("button", { name, exact: true }).evaluate(element => element.click());
+      const load = async () => {
+        await page.goto(`${vite.baseURL}/?controls=1&history=1&paged-history=1&retain-hidden=1`);
+        await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+        await body.evaluate(element => {
+          element.dispatchEvent(new WheelEvent("wheel", { bubbles: true, deltaY: -1000 }));
+          element.scrollTop = 0;
+          element.dispatchEvent(new Event("scroll", { bubbles: true }));
+        });
+        await expect(page.getByRole("button", { name: "Loading older messages…", exact: true })).toBeDisabled();
+      };
+      await load();
+      const anchor = page.getByText("user message 21.", { exact: false });
+      const before = (await anchor.boundingBox()).y;
+      await body.evaluate(element => { window.retainedBody = element; });
+      await external("Toggle visibility");
+      await external("Complete history load");
+      await expect(page.getByText("user message 1.", { exact: false })).toHaveCount(1);
+      await expect(body).toBeHidden();
+      await external("Toggle visibility");
+      assert.equal(await body.evaluate(element => element === window.retainedBody), true);
+      await expect(body).toBeVisible();
+      await expect.poll(async () => Math.abs((await anchor.boundingBox()).y - before)).toBeLessThan(2);
+      await expect(page.locator("output")).toHaveText("History requests: 1");
+
+      await load();
+      const errorScrollTop = await body.evaluate(element => element.scrollTop);
+      await external("Toggle visibility");
+      await external("Fail history load");
+      await external("Toggle visibility");
+      await expect(page.getByText("History unavailable", { exact: true })).toBeVisible();
+      assert.equal(await body.evaluate(element => element.scrollTop), errorScrollTop, "unchanged/error completion preserves the original scrollTop while showing recovery");
+      await page.getByRole("button", { name: "Load older messages", exact: true }).evaluate(element => element.click());
+      await expect(page.locator("output")).toHaveText("History requests: 2");
+      await external("Toggle visibility");
+      await external("Change conversation");
+      await external("Complete history load");
+      await external("Toggle visibility");
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+
+      await load();
+      await body.evaluate(element => { window.retiredBody = element; });
+      await external("Toggle visibility");
+      await external("Toggle mount");
+      await external("Complete history load");
+      await external("Toggle mount");
+      await external("Toggle visibility");
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      assert.equal(await body.evaluate(element => element === window.retiredBody), false);
+      await expect(page.locator("output")).toHaveText("History requests: 1");
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});
+
 test("conversation composer preserves typing and reacts to external state and pane resizing", {
   skip: !RUN_BROWSER_TEST,
   timeout: 60_000
@@ -630,17 +833,21 @@ test("an optional avatar clamps in a short conversation without consuming its pr
   try {
     for (const width of [390, 800, 1365]) {
       const page = await browser.newPage({ viewport: { width, height: 900 } });
-      await page.goto(`${vite.baseURL}/?conversation=1&avatar=1&capabilities=1`);
+      await page.goto(`${vite.baseURL}/?conversation=1&avatar=1&avatarTools=1&capabilities=1`);
       const panel = page.locator(".fixture");
       const input = page.getByRole("textbox", { name: "Message AI assistant" });
       const body = page.locator(".assistant-transcript__body");
       const artwork = page.locator(".assistant-conversation__avatar-visual");
-      const sizeControl = page.getByRole("button", { name: "Avatar size", exact: true });
+      const sizeControl = page.getByRole("button", { name: /^(Show|Minimise) avatar$/u });
+      await expect(page.getByRole("button", { name: "Avatar size", exact: true })).toHaveCount(0);
+      const avatarTool = page.getByRole("button", { name: "Avatar tool", exact: true, includeHidden: true });
+      await expect(sizeControl).toHaveCount(1);
+      assert.equal(await sizeControl.evaluate(element => Boolean(element.closest(".assistant-conversation__composer"))), false,
+        "Avatar visibility stays outside the original composer");
+      assert.equal(await avatarTool.evaluate(element => Boolean(element.closest(".assistant-conversation__avatar"))), true,
+        "Avatar tools share the artwork region outside the composer");
       const selectSize = async name => {
-        await sizeControl.focus();
-        await sizeControl.press("Enter");
-        await page.getByRole("menuitem", { name, exact: true }).click();
-        await expect(page.getByRole("menu", { name: "Avatar size", exact: true })).toBeHidden();
+        await page.getByRole("combobox", { name: "Avatar preference", exact: true }).selectOption(name.toLowerCase());
         await expect(page.getByText(`Avatar requested: ${name.toLowerCase()}`, { exact: true })).toBeVisible();
       };
       const assertComposerFits = async () => {
@@ -648,23 +855,51 @@ test("an optional avatar clamps in a short conversation without consuming its pr
         const send = await page.getByRole("button", { name: "Send", exact: true }).boundingBox();
         const feedback = await page.getByText("Describe what you want to change.", { exact: true }).boundingBox();
         const avatarButton = await sizeControl.boundingBox();
+        const toolBounds = await avatarTool.boundingBox();
         assert.ok(send.y + send.height <= bounds.y + bounds.height + 1, "Send stays inside the supplied container");
         assert.ok(feedback.y + feedback.height <= bounds.y + bounds.height + 1, "Feedback stays inside the supplied container");
         assert.ok((await input.boundingBox()).height >= 40);
-        assert.ok(avatarButton.width >= 48 && avatarButton.height >= 48, "Avatar sizing retains a reachable touch target");
+        const avatarExpanded = await sizeControl.getAttribute("aria-expanded") === "true";
+        assert.equal(avatarButton.width, avatarExpanded ? 40 : 44, "Expanded minimise is compact; collapsed Show retains its wider target");
+        assert.ok(avatarButton.height >= 44, "Avatar visibility retains its original target height");
+        assert.ok(toolBounds.width >= 48 && toolBounds.height >= 48, "Avatar tools retain a reachable touch target");
         await expect.poll(async () => (await body.boundingBox()).height, { message: "The short container retains readable history" }).toBeGreaterThanOrEqual(100);
         assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
       };
       assert.equal(Math.round((await panel.boundingBox()).width), 320);
       assert.equal(Math.round((await panel.boundingBox()).height), 420);
-      await expect(artwork).toHaveCSS("height", "64px");
+      await expect.poll(async () => (await artwork.boundingBox()).height).toBeGreaterThan(64);
+      assert.ok((await artwork.boundingBox()).height <= 96, "Compact artwork preserves the existing short-container clamp");
+      await page.getByRole("button", { name: "Resize height", exact: true }).evaluate(element => element.click());
+      await expect(artwork).toHaveCSS("height", "96px");
+      await page.getByRole("button", { name: "Resize height", exact: true }).evaluate(element => element.click());
+      await expect.poll(async () => (await panel.boundingBox()).height).toBe(420);
+      await expect(page.locator(".assistant-conversation__avatar")).toHaveCSS("background-color", "rgba(0, 0, 0, 0)");
+      const chatBounds = await page.locator(".assistant-conversation").boundingBox();
+      const faceBounds = await artwork.boundingBox();
+      const hideBounds = await sizeControl.boundingBox();
+      assert.equal(faceBounds.y, chatBounds.y, "The face starts at the top of the chat without a controls row above it");
+      const avatarToolBounds = await avatarTool.boundingBox();
+      assert.ok(Math.abs(hideBounds.y + hideBounds.height / 2 - avatarToolBounds.y - avatarToolBounds.height / 2) < 1,
+        "The round minimise control shares the tools row below the face");
+      assert.equal(hideBounds.x, avatarToolBounds.x + avatarToolBounds.width, "Minimise directly follows the supplied tools without a gap");
+      await expect(sizeControl).toHaveText("");
+      await expect(sizeControl.locator('.assistant-conversation__avatar-size-disc')).toHaveCSS('border-radius', '50%');
       await expect(page.locator('[data-message-role="assistant"]')).toHaveCount(20);
       await page.evaluate(() => {
         window.avatarElements = [document.querySelector(".assistant-conversation"), document.querySelector("textarea"), document.querySelector(".assistant-transcript__body")];
+        window.avatarTool = document.querySelector(".assistant-conversation__avatar-presentation .fixture-avatar-tool");
       });
       await input.fill("Keep my typed support question.");
       await input.evaluate(element => element.setSelectionRange(5, 9));
+      const compactAvatarBounds = await artwork.boundingBox();
+      const composerBounds = [await input.boundingBox(), await page.getByRole("button", { name: "Send", exact: true }).boundingBox()];
+      const fixtureLayout = await panel.evaluate(element => ({
+        panel: element.getBoundingClientRect().toJSON(),
+        controls: document.querySelector(".controls").getBoundingClientRect().toJSON()
+      }));
       await body.evaluate(element => { element.scrollTop = 100; });
+      assert.deepEqual(await artwork.boundingBox(), compactAvatarBounds, "The avatar stays fixed within the chat while messages scroll behind it");
       const before = await body.evaluate(element => element.scrollTop);
       await selectSize("Large");
       await expect.poll(async () => (await artwork.boundingBox()).height).toBeLessThan(176);
@@ -673,7 +908,35 @@ test("an optional avatar clamps in a short conversation without consuming its pr
       await selectSize("Hidden");
       await expect(artwork).toHaveCount(0);
       await expect(sizeControl).toBeVisible();
+      const showBounds = await sizeControl.boundingBox();
+      assert.equal(showBounds.width, 44, "Collapsed Show retains its original wider target");
+      assert.ok(showBounds.height >= 44);
+      const collapsedControls = await page.locator(".assistant-conversation__avatar-controls").boundingBox();
+      assert.equal(collapsedControls.y, chatBounds.y, "The collapsed controls stay at the chat top");
+      assert.equal(showBounds.y + showBounds.height / 2, collapsedControls.y + collapsedControls.height / 2,
+        "Show aligns with the existing taller host control in the top row");
+      assert.equal(showBounds.x + showBounds.width, chatBounds.x + chatBounds.width, "Show stays at the chat right edge");
+      await expect(avatarTool).toHaveCount(1);
+      await expect(avatarTool).toBeHidden();
+      await expect(page.getByRole("button", { name: "Retained avatar control", exact: true })).toBeVisible();
+      assert.equal(await page.evaluate(() => window.avatarTool.isConnected), true, "Hiding retains the local tools target");
+      if (process.env.JSKIT_ASSISTANT_CORE_BROWSER_ARTIFACTS) {
+        await page.screenshot({ path: path.join(process.env.JSKIT_ASSISTANT_CORE_BROWSER_ARTIFACTS, `hidden-${width}.png`) });
+      }
+      assert.deepEqual([await input.boundingBox(), await page.getByRole("button", { name: "Send", exact: true }).boundingBox()], composerBounds,
+        `Collapsing changes no original input or Send rectangle: ${JSON.stringify({ before: fixtureLayout, after: await panel.evaluate(element => ({
+          panel: element.getBoundingClientRect().toJSON(), controls: document.querySelector(".controls").getBoundingClientRect().toJSON()
+        })) })}`);
+      await page.getByRole("button", { name: "Show avatar", exact: true }).click();
+      await expect(page.getByText("Avatar requested: large", { exact: true })).toBeVisible();
+      await expect(avatarTool).toBeVisible();
+      assert.deepEqual([await input.boundingBox(), await page.getByRole("button", { name: "Send", exact: true }).boundingBox()], composerBounds,
+        "Showing the last visible size changes no original input or Send rectangle");
+      await page.getByRole("button", { name: "Minimise avatar", exact: true }).click();
       await selectSize("Standard");
+      await expect(avatarTool).toBeVisible();
+      await expect(avatarTool).toHaveAttribute("data-size", "standard");
+      assert.equal(await avatarTool.evaluate(element => element === window.avatarTool), true, "Showing reuses the original tools node");
       await expect.poll(async () => (await artwork.boundingBox()).height).toBeGreaterThan(0);
       await selectSize("Large");
       await input.focus();
@@ -721,3 +984,168 @@ test("an optional avatar clamps in a short conversation without consuming its pr
     await stopProcess(vite);
   }
 });
+
+
+test("unsent preview edits stay in their bubble and disappear for the canonical message", {
+  skip: !RUN_BROWSER_TEST, timeout: 60_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    const page = await browser.newPage({ viewport: { width: 320, height: 844 } });
+    await page.goto(`${vite.baseURL}/?conversation=1&preview=1`);
+    const input = page.getByRole("textbox", { name: "Message AI assistant" });
+    const discard = page.getByRole("button", { name: "Discard unsent message", exact: true });
+    const edit = page.getByRole("button", { name: "Edit unsent message", exact: true });
+    await page.getByRole("button", { name: "External active", exact: true }).click();
+    await input.fill("Keep this typed draft");
+    await page.getByRole("button", { name: "Add temporary message", exact: true }).click();
+    const bubble = page.locator(".assistant-transcript__message--user");
+    await expect(bubble).toContainText("Exact temporary words");
+    await expect(bubble.getByRole("button", { name: "Discard unsent message" })).toBeVisible();
+    await expect(edit).toBeEnabled();
+    await expect(discard).toBeEnabled();
+    await page.getByRole("button", { name: "Toggle preview eligibility" }).click();
+    await expect(discard).toBeDisabled();
+    await page.getByRole("button", { name: "Toggle preview eligibility" }).click();
+    await discard.click();
+    await expect(bubble).toHaveCount(0);
+    await expect(input).toHaveValue("Keep this typed draft");
+    await page.getByRole("button", { name: "Add temporary message", exact: true }).click();
+    await page.getByRole("button", { name: "Reject preview", exact: true }).click();
+    await expect(bubble).toHaveCount(1);
+    await expect(bubble).toContainText("No active turn; explicit Edit may author a new message.");
+    await expect(bubble.locator(".assistant-transcript__optimistic-actions")).toHaveCount(0);
+    await expect(bubble.locator(".assistant-conversation__preview-actions")).toHaveCount(1);
+    await expect(edit).toBeEnabled();
+    await edit.click();
+    await expect(bubble).not.toContainText("No active turn; explicit Edit may author a new message.");
+    const editor = bubble.getByRole("textbox", { name: "Review your message" });
+    const send = bubble.getByRole("button", { name: "Send", exact: true });
+    await expect(editor).toHaveValue("Exact temporary words");
+    await expect(input).toHaveValue("Keep this typed draft");
+    await expect(page.getByRole("textbox")).toHaveCount(2);
+    await expect(bubble.locator(".assistant-conversation__preview-actions")).toHaveCount(1);
+    await editor.fill("");
+    await expect(editor).toHaveValue("");
+    await expect(bubble).toHaveCount(1);
+    await expect(send).toBeDisabled();
+    await editor.fill("Corrected speech\nwith a second line");
+    await expect(send).toBeEnabled();
+    await expect(input).toHaveValue("Keep this typed draft");
+    await send.click();
+    await expect(bubble).toContainText("Corrected speech");
+    await expect(editor).toHaveCount(0);
+    await expect(discard).toHaveCount(0);
+    await expect(input).toHaveValue("Keep this typed draft");
+    await page.reload();
+    await input.fill("Keep this typed draft");
+    await page.getByRole("button", { name: "External active", exact: true }).click();
+    await page.getByRole("button", { name: "Add temporary message", exact: true }).click();
+    await page.getByRole("button", { name: "Unadmitted preview" }).click();
+    await expect(bubble).toHaveCount(1);
+    await edit.click();
+    await expect(bubble.getByRole("textbox", { name: "Review your message" })).toHaveValue("Exact temporary words");
+    await expect(input).toHaveValue("Keep this typed draft");
+    await page.getByRole("button", { name: "Accept preview" }).click();
+    await expect(bubble).toHaveCount(1);
+    await expect(bubble).toContainText("Exact temporary words");
+    await expect(discard).toHaveCount(0);
+    await expect(edit).toHaveCount(0);
+    await expect(input).toHaveValue("Keep this typed draft");
+    await expect(page.locator("output").last()).toHaveText("active; submitted 0");
+    for (const recovery of ["edit", "discard"]) {
+      await page.reload();
+      await input.fill("Keep this typed draft");
+      await page.getByRole("button", { name: "External active", exact: true }).click();
+      await page.getByRole("button", { name: "Add temporary message", exact: true }).click();
+      await page.getByRole("button", { name: "Reject preview", exact: true }).click();
+      await page.getByRole("button", { name: "Add newer temporary message", exact: true }).click();
+      await expect(bubble).toHaveCount(2);
+      const retained = bubble.first();
+      const newer = bubble.last();
+      await expect(retained).toContainText("No active turn; explicit Edit may author a new message.");
+      await expect(retained.locator(".assistant-transcript__optimistic-actions")).toHaveCount(0);
+      await expect(newer).toContainText("Keep newer live words");
+      await expect(newer.getByRole("button", { name: "Edit unsent message", exact: true })).toBeDisabled();
+      await expect(newer.getByRole("button", { name: "Discard unsent message", exact: true })).toBeEnabled();
+      if (recovery === "edit") {
+        await retained.getByRole("button", { name: "Edit unsent message", exact: true }).click();
+        await expect(newer).toContainText("Keep newer live words");
+        const retainedEditor = retained.getByRole("textbox", { name: "Review your message" });
+        await expect(retainedEditor).toHaveValue("Exact temporary words");
+        await retainedEditor.fill("Edited retained words");
+        await expect(input).toHaveValue("Keep this typed draft");
+        await retained.getByRole("button", { name: "Send", exact: true }).click();
+        await expect(retained).toContainText("Edited retained words");
+        await expect(retained.getByRole("button", { name: "Edit unsent message", exact: true })).toHaveCount(0);
+        await expect(bubble).toHaveCount(2);
+        await expect(newer).toContainText("Keep newer live words");
+      } else {
+        await retained.getByRole("button", { name: "Discard unsent message", exact: true }).click();
+        await expect(bubble).toHaveCount(1);
+        await expect(bubble).toContainText("Keep newer live words");
+      }
+      const current = bubble.last();
+      await expect(current.getByRole("button", { name: "Edit unsent message", exact: true })).toBeEnabled();
+      await expect(input).toHaveValue("Keep this typed draft");
+      await current.getByRole("button", { name: "Discard unsent message", exact: true }).click();
+      await expect(bubble).toHaveCount(recovery === "edit" ? 1 : 0);
+      await expect(input).toHaveValue("Keep this typed draft");
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});
+
+
+test("pending history keeps following the reader when a new reply changes transcript height", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 90_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    for (const width of [390, 1365]) {
+      const page = await browser.newPage({ viewport: { width, height: 900 } });
+      const errors = [];
+      page.on("pageerror", error => errors.push(error.message));
+      await page.goto(`${vite.baseURL}/?controls=1&history=1`);
+      const body = page.locator(".assistant-transcript__body");
+      const requests = page.locator("output");
+      const external = name => page.getByRole("button", { name, exact: true }).evaluate(element => element.click());
+      await expect(page.getByText("Conversation line 70:", { exact: false })).toBeVisible();
+      await body.hover();
+      await page.mouse.wheel(0, -100);
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeGreaterThan(50);
+      await body.evaluate(element => { element.scrollTop = 420; });
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+      await page.mouse.wheel(0, -324);
+      const pending = page.getByRole("button", { name: "Loading older messages…", exact: true });
+      await expect(pending).toBeDisabled();
+      await expect(requests).toHaveText("History requests: 1");
+      const height = await body.evaluate(element => element.scrollHeight);
+      await external("Append reply");
+      await expect.poll(() => body.evaluate(element => element.scrollHeight)).toBeGreaterThan(height);
+      await expect.poll(async () => {
+        await body.focus();
+        return body.evaluate(element => document.activeElement === element);
+      }).toBe(true);
+      await body.press("Home");
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(0);
+      const original = page.getByText("Conversation line 1:", { exact: false }).first();
+      const originalTop = (await original.boundingBox()).y;
+      await external("Complete history load");
+      await expect(pending).toHaveCount(0);
+      await expect.poll(async () => Math.abs((await original.boundingBox()).y - originalTop)).toBeLessThan(2);
+      await expect(requests).toHaveText("History requests: 1");
+      assert.deepEqual(errors, []);
+      assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});

package/test/claudeClient.test.js

@@ -79,6 +79,47 @@ test("Claude control replies bypass slow event persistence while events remain o
   }
 });
 
+test("normal Claude EOF drains held events before closing the half-open stream", async () => {
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const ended = Promise.withResolvers();
+  const observed = [];
+  const failures = [];
+  const stream = fakeStream(() => {});
+  stream.once("end", ended.resolve);
+  const client = createClaudeJsonClient({
+    stream,
+    async onEvent(frame) {
+      if (frame.number === 1) {
+        entered.resolve();
+        await release.promise;
+      }
+      observed.push(frame.number);
+    },
+    onFailure(error) { failures.push(error); }
+  });
+  try {
+    stream.push('{"type":"event","number":1}\n{"type":"event","number":2}\n');
+    stream.push(null);
+    await entered.promise;
+    await ended.promise;
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(stream.writableEnded, false, "EOF does not close the original writable side");
+    assert.equal(stream.destroyed, false, "The stream survives while event persistence is held");
+    assert.deepEqual(observed, []);
+    assert.deepEqual(failures, []);
+    release.resolve();
+    await client.completion;
+    assert.deepEqual(observed, [1, 2]);
+    assert.equal(failures.length, 1);
+    assert.equal(failures[0].code, "assistant_claude_observation_lost");
+    assert.equal(stream.destroyed, true, "The original client still owns final teardown");
+  } finally {
+    release.resolve();
+    client.close();
+  }
+});
+
 test("Claude interrupt uses the common 30-second control deadline", async (t) => {
   t.mock.timers.enable({ apis: ["setTimeout"] });
   const client = createClaudeJsonClient({ stream: fakeStream(() => {}) });

package/test/claudeConversationSession.test.js

@@ -1199,3 +1199,81 @@ test("the same Claude driver reopens a verified closed conversation after retryi
     await local.close();
   }
 });
+
+
+for (const change of ["model", "effort"]) test(`Claude honors a consumer's fresh native policy for ${change} changes and restart`, async t => {
+  const f = await fixture(t);
+  const binding = () => f.storage.read("conversation", async tx => (await tx.readMetadata()).runtime.binding);
+  await f.conversation.send(input);
+  const original = await f.conversation.wait();
+  const previous = await binding();
+  const beforeSelection = await f.trace();
+  const oldHistoryPath = path.join(previous.configRoot, "projects", previous.workdir.replace(/[^a-zA-Z0-9]/gu, "-"), `${previous.conversationId}.jsonl`);
+  const oldHistory = await readFile(oldHistoryPath, "utf8");
+  const selected = { ...configuration, [change]: change === "model" ? "another-model" : "low" };
+  const request = { operationId: `fresh-${change}`, expectedSegmentId: original.segmentId,
+    engine: "claude", configuration: selected, retireNative: true };
+  const receipt = await f.conversation.select(request);
+  assert.notEqual(receipt.segmentId, original.segmentId);
+  const inert = await binding();
+  assert.notEqual(inert.conversationId, previous.conversationId);
+  assert.equal(inert.sent, false);
+  assert.equal(inert.configRoot, previous.configRoot);
+  assert.equal(inert.workdir, previous.workdir);
+  const predecessor = await f.storage.read("conversation", async tx => (await tx.readMetadata()).runtime.predecessors.find(segment => segment.segmentId === original.segmentId));
+  assert.equal(predecessor.binding.conversationId, previous.conversationId);
+  assert.equal(inert.executionId, "");
+  assert.deepEqual(await f.trace(), beforeSelection, "Selecting allocates an inert handle without inference");
+  const retained = await f.conversation.read();
+  assert.equal(retained.id, original.id);
+  assert.deepEqual(retained.conversationLog, original.conversationLog);
+  assert.equal((await f.conversation.select(request)).duplicate, true);
+  await f.conversation.send({ messageId: "changed", text: "Continue after the change" });
+  assert.equal((await f.conversation.wait()).conversationLog.at(-1).metadata.runtime.status, "complete");
+  const fresh = await binding();
+  assert.equal(fresh.conversationId, inert.conversationId);
+  assert.equal(fresh.accountIdentity, previous.accountIdentity);
+  assert.equal(await readFile(oldHistoryPath, "utf8"), oldHistory);
+  const trace = await f.trace();
+  const starts = trace.filter(row => row.args?.includes("--print"));
+  assert.equal(starts.length, 2);
+  assert.equal(starts[1].args[starts[1].args.indexOf("--session-id") + 1], inert.conversationId);
+  assert.equal(starts[1].args.includes("--resume"), false);
+  assert.equal(starts[1].args[starts[1].args.indexOf("--model") + 1], selected.model);
+  assert.equal(trace.filter(row => row.frame?.request?.subtype === "apply_flag_settings").at(-1).frame.request.settings.effortLevel, selected.effort);
+  const nativeMessages = trace.filter(row => row.frame?.type === "user");
+  assert.equal(nativeMessages.length, 2);
+  const handedHistory = JSON.parse(nativeMessages[1].frame.message.content.split("\n").find(line => line.startsWith('{"messages":')));
+  assert.deepEqual(handedHistory.messages.map(({ role, text }) => [role, text]), [["user", "Hello"], ["assistant", "Answer: Hello"]]);
+  assert.deepEqual(handedHistory.removedMessageIds, []);
+  assert.equal(nativeMessages[1].frame.message.content.split("User's message:\n")[1], "Continue after the change");
+  assert.match(nativeMessages[1].frame.message.content, /Hello/);
+  assert.match(nativeMessages[1].frame.message.content, /Answer: Hello/);
+  assert.match(nativeMessages[1].frame.message.content, /Continue after the change/);
+  await f.first.close();
+  const resumed = await f.runtime().open({ id: "conversation" });
+  assert.equal((await resumed.select(request)).duplicate, true);
+  assert.equal((await resumed.send(input)).duplicate, true);
+  assert.equal((await binding()).conversationId, inert.conversationId);
+  await resumed.send({ messageId: "after-restart", text: "Continue after restart" });
+  assert.equal((await resumed.wait()).conversationLog.length, 3);
+  const restarted = await f.trace();
+  assert.equal(restarted.filter(row => row.frame?.type === "user").length, 3);
+  assert.equal(restarted.filter(row => row.frame?.type === "user").at(-1).frame.message.content, "Continue after restart");
+  const restart = restarted.filter(row => row.args?.includes("--print")).at(-1);
+  assert.equal(restart.args[restart.args.indexOf("--resume") + 1], inert.conversationId);
+  const returned = await resumed.select({ operationId: `restore-${change}`, expectedSegmentId: (await resumed.read()).segmentId,
+    engine: "claude", configuration, retireNative: true });
+  assert.notEqual(returned.segmentId, original.segmentId, "The consumer policy cannot restore an older retained segment");
+  assert.notEqual(returned.segmentId, receipt.segmentId);
+  await resumed.send({ messageId: "returned", text: "Back to the original settings" });
+  assert.equal((await resumed.wait()).conversationLog.length, 4);
+  const restored = await binding();
+  assert.notEqual(restored.conversationId, previous.conversationId);
+  assert.notEqual(restored.conversationId, inert.conversationId);
+  assert.equal(restored.accountIdentity, previous.accountIdentity);
+  const restoredPrompt = (await f.trace()).filter(row => row.frame?.type === "user").at(-1).frame.message.content;
+  assert.match(restoredPrompt, /Hello/);
+  assert.match(restoredPrompt, /Continue after the change/);
+  assert.match(restoredPrompt, /Continue after restart/);
+});