@jskit-ai/assistant-core 0.1.212 → 0.1.214

package/test/assistantBoundedToolLoop.test.js

@@ -283,3 +283,335 @@ test("bounded structured alternatives keep exact output bounds and reject open o
     required: ["nested"], properties: { nested: deep } };
   assert.throws(() => validateConversationOutputSchema(deep, { maxOutputCharacters: 16_000 }), /nested too deeply/u);
 });
+
+// Original fixed-envelope policy: Public 869ebb69 protocol.js:7–39 and
+// colleague/service.js:221–224,364–431. Existing default assertions above stay intact.
+import { readAssistantResponseEnvelope, readPartialAssistantReply } from "../src/server/lib/assistantToolLoop.js";
+import { createConversationTools } from "../src/server/conversation/tools.js";
+
+const envelopeReply = text => JSON.stringify({ kind: "reply", text, toolName: "", arguments: "" });
+const envelopeTool = (text = "") => JSON.stringify({ kind: "tool", text, toolName: "bounded_read", arguments: '{"value":"1"}' });
+const envelopeCall = value => JSON.stringify({ kind: "tool", text: "", toolName: "bounded_read", arguments: JSON.stringify({ value }) });
+const envelopePolicy = { maximumResponses: 24, timeoutMs: 90_000 };
+const useEnvelope = ({ phase }) => phase === "before-parse" ? "use" : "end";
+
+function durableEnvelopeTools({ effect = () => ({ prompt: "Verified" }), authorize = () => {}, prepareContext,
+  save = () => {}, emit = () => {}, propagateErrors = false, previousCalls = [] } = {}) {
+  return createConversationTools({ catalog: boundedTools(effect), context: { actor: { id: "captured" }, surface: "app" },
+    signal: new AbortController().signal, authorize, prepareContext, save, emit, propagateErrors, previousCalls });
+}
+
+function envelopeLoop(options) {
+  let completed = 0;
+  return runBoundedAssistantToolLoop({ prompt: "Product-owned prompt", policy: envelopePolicy,
+    completedEnvelope: true, settle: useEnvelope, limitError: new Error("Original 24-response limit"),
+    invalidResponseError: new Error("Original invalid response"), ...options,
+    async complete(...args) {
+      // Fixture identities stand for distinct verified completed native responses.
+      const result = await options.complete(...args);
+      return { toolCallId: `completed-response-${++completed}`, ...result };
+    } });
+}
+
+test("fixed envelope mode requires its original lifetime policy and explicit application settlement", async () => {
+  for (const options of [{ policy }, { settle: undefined }]) {
+    await assert.rejects(envelopeLoop({ ...options, complete() { assert.fail("Do not infer with an invalid mode contract"); } }),
+      /24 responses and application settlement/u);
+  }
+  await assert.rejects(envelopeLoop({ completedEnvelope: "yes", complete() { assert.fail("Do not infer"); } }), /must be a boolean/u);
+});
+
+test("fixed envelopes preserve decoded reply, progress, name and string-argument bounds", () => {
+  assert.equal(readAssistantResponseEnvelope(envelopeReply("x".repeat(16000))).text.length, 16000);
+  assert.throws(() => readAssistantResponseEnvelope(envelopeReply("x".repeat(16001))), /Invalid assistant response/u);
+  assert.equal(readAssistantResponseEnvelope(envelopeTool("x".repeat(280))).text.length, 280);
+  assert.throws(() => readAssistantResponseEnvelope(envelopeTool("x".repeat(281))), /progress text/u);
+  const value = { kind: "tool", text: "", toolName: "x".repeat(256), arguments: "x".repeat(262144) };
+  assert.equal(readAssistantResponseEnvelope(JSON.stringify(value)).arguments.length, 262144);
+  for (const invalid of [{ ...value, toolName: "x".repeat(257) }, { ...value, arguments: "x".repeat(262145) },
+    { ...value, arguments: {} }, { ...value, extra: true }, [], { kind: "reply", text: "" },
+    { kind: "reply", text: "hello", toolName: "hidden" }]) {
+    assert.throws(() => readAssistantResponseEnvelope(JSON.stringify(invalid)));
+  }
+});
+
+// Body moved from frozen vibe64Colleague.unit.test.js:161–173; generic names only.
+test("fixed envelopes decode only reply text, including every split inside JSON escapes", () => {
+  const text = 'Hello "there"!\n\\path 🐈 café';
+  const encoded = envelopeReply(text).replace("🐈", "\\ud83d\\udc08").replace("é", "\\u00e9");
+  for (let end = 0; end <= encoded.length; end += 1) {
+    const partial = readPartialAssistantReply(encoded.slice(0, end));
+    assert.ok(text.startsWith(partial), JSON.stringify(partial));
+    assert.doesNotMatch(partial, /[\uD800-\uDBFF]$/);
+  }
+  assert.equal(readPartialAssistantReply(encoded), text);
+  for (const hidden of [envelopeCall("private arguments"), '{"kind":"tool","text":"secret', 'Thinking first', '{"text":"unknown kind']) {
+    assert.equal(readPartialAssistantReply(hidden), "");
+  }
+});
+
+test("fixed envelope mode passes finite fixed wire fields and actual prior tool results to the product completion", async () => {
+  const traces = [];
+  let calls = 0;
+  const tools = durableEnvelopeTools({ effect({ value }, context) {
+    assert.equal(context.actor.id, "captured");
+    return { prompt: `Result ${value}` };
+  }, save(records) { traces.push(records.map(record => record.status)); } });
+  const result = await envelopeLoop({ async complete(prompt, options) {
+    assert.equal(prompt, "Product-owned prompt");
+    assert.equal(options.timeoutMs, 90_000);
+    const properties = options.outputSchema.properties;
+    assert.equal(properties.text.maxLength, 16000);
+    assert.equal(properties.toolName.maxLength, 256);
+    assert.equal(properties.arguments.maxLength, 262144);
+    if (++calls === 1) {
+      assert.equal(options.previousResponse, undefined);
+      return { text: envelopeTool(), tools };
+    }
+    assert.equal(options.previousResponse.kind, "tool");
+    assert.equal(options.previousResponse.arguments, '{"value":"1"}');
+    assert.equal(options.previousResponse.result.ok, true);
+    assert.equal(options.previousResponse.result.result.prompt, "Result 1");
+    return { text: envelopeReply("Done") };
+  } });
+  assert.equal(result, "Done");
+  assert.deepEqual(traces, [["running"], ["complete"]]);
+});
+
+test("fixed envelope response 24 executes its effect before the exact limit error and never starts response 25", async () => {
+  let responses = 0;
+  let effects = 0;
+  const limitError = new Error("Original limit");
+  await assert.rejects(envelopeLoop({ limitError, async complete() {
+    responses++;
+    return { text: envelopeTool(), tools: durableEnvelopeTools({ effect() { effects++; return { prompt: "Done" }; } }) };
+  } }), error => error === limitError);
+  assert.equal(responses, 24);
+  assert.equal(effects, 24);
+});
+
+test("superseded malformed completed responses consume response slots before parsing without spending invalid allowance", async () => {
+  let responses = 0;
+  let effects = 0;
+  const limitError = new Error("Original limit");
+  await assert.rejects(envelopeLoop({ limitError, settle: () => "continue", async complete() {
+    responses++;
+    return { text: "malformed obsolete response", tools: durableEnvelopeTools({ effect() { effects++; } }) };
+  } }), error => error === limitError);
+  assert.equal(responses, 24);
+  assert.equal(effects, 0);
+});
+
+test("invalid allowance is cumulative across valid effects and discarded pending responses", async () => {
+  const replies = ["malformed", envelopeTool(), "obsolete malformed", "malformed again", envelopeTool(), "third malformed"];
+  let responses = 0;
+  let effects = 0;
+  const invalidResponseError = new Error("Original third-invalid failure");
+  await assert.rejects(envelopeLoop({ invalidResponseError,
+    settle: ({ phase }) => phase === "before-parse" && responses === 3 ? "continue" : "use",
+    async complete(_prompt, options) {
+      if ([2, 5].includes(responses + 1)) assert.deepEqual(options.previousResponse, { kind: "invalid", nativeToolAttempt: false });
+      return { text: replies[responses++], tools: durableEnvelopeTools({ effect() { effects++; return { prompt: "Verified" }; } }) };
+    }
+  }), error => error === invalidResponseError);
+  assert.equal(responses, 6);
+  assert.equal(effects, 2);
+});
+
+test("native application-tool misroutes invalidate replies but permit corrected completed tool envelopes and StructuredOutput replies", async () => {
+  let responses = 0;
+  let effects = 0;
+  const result = await envelopeLoop({ async complete(_prompt, options) {
+    responses++;
+    if (responses === 1) return { text: envelopeReply("False outage"), nativeToolAttempt: true };
+    if (responses === 2) {
+      assert.deepEqual(options.previousResponse, { kind: "invalid", nativeToolAttempt: true });
+      return { text: envelopeTool(), nativeToolAttempt: true,
+        tools: durableEnvelopeTools({ effect() { effects++; return { prompt: "Verified" }; } }) };
+    }
+    return { text: envelopeReply("Verified answer"), nativeToolAttempt: false };
+  } });
+  assert.equal(result, "Verified answer");
+  assert.equal(effects, 1);
+  assert.equal(responses, 3);
+});
+
+test("late pending admission after decoded final persistence continues inside the same response budget", async t => {
+  const admission = Promise.withResolvers();
+  const entered = Promise.withResolvers();
+  t.after(() => admission.resolve());
+  const saved = [];
+  let responses = 0;
+  const run = envelopeLoop({ async complete() {
+    return { text: envelopeReply(++responses === 1 ? "First answer" : "Latest answer") };
+  }, async settle({ phase, response }) {
+    if (phase === "before-parse") return "use";
+    saved.push(response.text);
+    if (saved.length === 1) { entered.resolve(); await admission.promise; return "continue"; }
+    return "end";
+  } });
+  await entered.promise;
+  assert.equal(responses, 1, "The next native response waits for the original app admission tail");
+  admission.resolve();
+  assert.equal(await run, "Latest answer");
+  assert.equal(responses, 2);
+  assert.deepEqual(saved, ["First answer", "Latest answer"]);
+});
+
+test("settlement refuses unknown decisions before effects and final return", async () => {
+  for (const final of [false, true]) {
+    let effects = 0;
+    await assert.rejects(envelopeLoop({ async complete() {
+      return { text: final ? envelopeReply("Do not finish") : envelopeTool(),
+        tools: durableEnvelopeTools({ effect() { effects++; } }) };
+    }, settle: ({ phase }) => final && phase === "before-parse" ? "use" : "unexpected" }), /Invalid completed-response settlement/u);
+    assert.equal(effects, 0);
+  }
+});
+
+test("completed envelope mode preserves abort before settlement and effects", async () => {
+  for (const stage of ["completion", "settlement"]) {
+    const controller = new AbortController();
+    const reason = new Error("Original cancellation");
+    let effects = 0;
+    await assert.rejects(envelopeLoop({ signal: controller.signal, async complete() {
+      if (stage === "completion") controller.abort(reason);
+      return { text: envelopeTool(), tools: durableEnvelopeTools({ effect() { effects++; } }) };
+    }, settle() {
+      assert.equal(stage, "settlement", "Completion cancellation precedes any settlement");
+      controller.abort(reason);
+      return "use";
+    } }), error => error === reason);
+    assert.equal(effects, 0);
+  }
+});
+
+test("completed operations require supplied tools and retain sealed request refusal without effect or new reservation", async () => {
+  await assert.rejects(envelopeLoop({ async complete() { return { text: envelopeTool() }; } }), /current durable tools/u);
+  const retired = new Error("The original request is sealed");
+  let effects = 0;
+  let saves = 0;
+  const tools = durableEnvelopeTools({ prepareContext() { throw retired; }, effect() { effects++; }, save() { saves++; } });
+  await assert.rejects(envelopeLoop({ async complete() { return { text: envelopeTool(), tools }; } }), error => error === retired);
+  assert.equal(effects, 0);
+  assert.equal(saves, 0);
+});
+
+test("completed effect preserves the original host error and rechecks fresh authorization after durable reservation", async () => {
+  const failure = new Error("Original effect error");
+  await assert.rejects(envelopeLoop({ async complete() {
+    return { text: envelopeTool(), tools: durableEnvelopeTools({ effect() { throw failure; }, propagateErrors: true }) };
+  } }), error => error === failure);
+  const revoked = new Error("Original actor no longer authorized");
+  let eligible = true;
+  let effects = 0;
+  const statuses = [];
+  const tools = durableEnvelopeTools({ authorize() { if (!eligible) throw revoked; }, effect() { effects++; },
+    save(records) { statuses.push(records.at(-1).status); eligible = false; } });
+  await assert.rejects(envelopeLoop({ async complete() { return { text: envelopeTool(), tools }; } }), error => error === revoked);
+  assert.equal(effects, 0);
+  assert.deepEqual(statuses, ["running", "not-executed"]);
+});
+
+test("unknown completed effect stops the bounded loop and its durable receipt cannot replay the effect", async () => {
+  let responses = 0;
+  let effects = 0;
+  const tools = durableEnvelopeTools({ effect() {
+    effects++;
+    throw Object.assign(new Error("Receipt was lost after execution"), { statusCode: 503 });
+  } });
+  await assert.rejects(envelopeLoop({ async complete() { responses++; return { text: envelopeTool(), tools }; } }),
+    error => error.code === "conversation_tool_outcome_unknown");
+  assert.equal(responses, 1);
+  assert.equal(effects, 1);
+  const receipt = tools.records()[0];
+  assert.equal(receipt.status, "unknown");
+  await assert.rejects(tools.execute({ id: receipt.id, name: receipt.name, arguments: receipt.arguments }),
+    error => error.code === "conversation_tool_outcome_unknown");
+  assert.equal(effects, 1);
+});
+
+
+test("oversized completed tool progress is corrected before any reservation and valid progress executes once", async () => {
+  let responses = 0;
+  let effects = 0;
+  let reservations = 0;
+  const result = await envelopeLoop({ async complete(_prompt, options) {
+    responses++;
+    if (responses === 3) return { text: envelopeReply("Done") };
+    if (responses === 2) assert.deepEqual(options.previousResponse, { kind: "invalid", nativeToolAttempt: false });
+    return { text: envelopeTool("x".repeat(responses === 1 ? 281 : 280)),
+      tools: durableEnvelopeTools({ effect() { effects++; return { prompt: "Verified" }; },
+        save(records) { if (records.at(-1).status === "running") reservations++; } }) };
+  } });
+  assert.equal(result, "Done");
+  assert.equal(effects, 1);
+  assert.equal(reservations, 1);
+});
+
+
+test("third invalid envelope selects the product error from the current native fact only once", async () => {
+  const malformed = new Error("Original malformed-response failure");
+  const misrouted = new Error("Original native-tool-response failure");
+  for (const nativeToolAttempt of [false, true]) {
+    let responses = 0;
+    const selectedFacts = [];
+    await assert.rejects(envelopeLoop({ invalidResponseError(fact) {
+      selectedFacts.push(fact);
+      return fact.nativeToolAttempt ? misrouted : malformed;
+    }, async complete() {
+      responses++;
+      return responses === 3
+        ? { text: nativeToolAttempt ? envelopeReply("False outage") : "malformed", nativeToolAttempt }
+        : { text: "malformed", nativeToolAttempt: !nativeToolAttempt };
+    } }), error => error === (nativeToolAttempt ? misrouted : malformed));
+    assert.equal(responses, 3);
+    assert.deepEqual(selectedFacts, [{ nativeToolAttempt }]);
+  }
+});
+
+test("opt-in third-invalid error factory must return an Error", async () => {
+  let calls = 0;
+  await assert.rejects(envelopeLoop({ invalidResponseError() { calls++; return "not an Error"; },
+    async complete() { return { text: "malformed" }; } }), /Invalid response error must be an Error/u);
+  assert.equal(calls, 1);
+});
+
+
+test("completed application operations refuse absent or invalid verified response call ids before reservation", async () => {
+  for (const toolCallId of [undefined, "", "x".repeat(257), 42]) {
+    let effects = 0;
+    let saves = 0;
+    const tools = durableEnvelopeTools({ effect() { effects++; }, save() { saves++; } });
+    await assert.rejects(envelopeLoop({ async complete() { return { text: envelopeTool(), tools, toolCallId }; } }),
+      /verified response call id/u);
+    assert.equal(effects, 0);
+    assert.equal(saves, 0);
+  }
+});
+
+test("recovered completed response reuses its restored durable call id without repeating the effect or accepting changed arguments", async () => {
+  const toolCallId = "verified-native-response-1:application-operation";
+  let effects = 0;
+  const initialTools = durableEnvelopeTools({ effect() { effects++; return { prompt: "Verified once" }; } });
+  const run = tools => {
+    let responses = 0;
+    return envelopeLoop({ async complete() {
+      return ++responses === 1 ? { text: envelopeTool(), tools, toolCallId } : { text: envelopeReply("Done") };
+    } });
+  };
+  assert.equal(await run(initialTools), "Done");
+  const previousCalls = initialTools.records();
+  assert.equal(previousCalls[0].id, toolCallId);
+  assert.equal(previousCalls[0].status, "complete");
+  const restoredTools = durableEnvelopeTools({ previousCalls,
+    effect() { assert.fail("Recovery must use the saved verified result"); } });
+  assert.equal(await run(restoredTools), "Done");
+  assert.equal(effects, 1);
+  const changedTools = durableEnvelopeTools({ previousCalls,
+    effect() { assert.fail("A response id cannot authorize changed arguments"); } });
+  const changed = JSON.stringify({ kind: "tool", text: "", toolName: "bounded_read", arguments: '{"value":"2"}' });
+  await assert.rejects(envelopeLoop({ async complete() { return { text: changed, tools: changedTools, toolCallId }; } }),
+    /already belongs to different arguments/u);
+  assert.equal(effects, 1);
+});

package/test/assistantScroll.browser.test.js

@@ -1149,3 +1149,154 @@ test("pending history keeps following the reader when a new reply changes transc
     await stopProcess(vite);
   }
 });
+
+
+test("connection warnings keep avatar controls and Reload reachable without replacing history", {
+  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 [320, 800]) {
+      const page = await browser.newPage({ viewport: { width, height: 1000 } });
+      await page.goto(`${vite.baseURL}/?conversation=1&avatar=1&avatarTools=1&update-errors=1`);
+      const external = name => page.getByRole("button", { name, exact: true }).evaluate(element => element.click());
+      await external("Resize height");
+      const conversation = page.locator(".assistant-conversation");
+      const avatar = page.locator(".assistant-conversation__avatar");
+      const body = page.locator(".assistant-transcript__body");
+      const draft = page.getByRole("textbox", { name: "Message AI assistant", exact: true });
+      const banner = page.locator(".assistant-transcript__error");
+      const reload = banner.getByRole("button", { name: "Reload chat", exact: true });
+      await draft.fill("Keep this draft and the loaded history.");
+      await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeLessThan(2);
+      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.errorAvatarBody = element; });
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+      const history = await body.locator(".assistant-transcript__turn").allTextContents();
+      let reloads = 0;
+      for (const size of ["standard", "large", "hidden"]) {
+        await page.getByRole("combobox", { name: "Avatar preference", exact: true }).selectOption(size);
+        await external("Show update error");
+        await expect(conversation).toHaveClass(/assistant-conversation--error/u);
+        await expect(avatar).toHaveCSS("position", "relative");
+        await expect(banner).toContainText("Conversation updates are temporarily unavailable.");
+        await expect(reload).toBeVisible();
+        const avatarBox = await avatar.boundingBox();
+        const bannerBox = await banner.boundingBox();
+        assert.ok(avatarBox.y + avatarBox.height <= bannerBox.y, "The entire avatar and its controls stay above the warning");
+        const controls = size === "hidden"
+          ? [page.getByRole("button", { name: "Retained avatar control", exact: true }), page.getByRole("button", { name: "Show avatar", exact: true })]
+          : [page.getByRole("button", { name: "Avatar tool", exact: true }), page.getByRole("button", { name: "Minimise avatar", exact: true })];
+        for (const target of [reload, ...controls]) {
+          await expect(target).toBeVisible();
+          assert.equal(await target.evaluate(element => {
+            const rect = element.getBoundingClientRect();
+            return element.contains(document.elementFromPoint(rect.x + rect.width / 2, rect.y + rect.height / 2));
+          }), true, "The ordinary pointer reaches each recovery and avatar control");
+        }
+        assert.equal(await body.evaluate(element => element === window.errorAvatarBody), true);
+        assert.deepEqual(await body.locator(".assistant-transcript__turn").allTextContents(), history);
+        await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+        await expect(draft).toHaveValue("Keep this draft and the loaded history.");
+        assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+        await reload.click();
+        await expect(banner).toHaveCount(0);
+        await expect(avatar).toHaveCSS("position", "absolute");
+        await expect(page.getByText(`Error reloads: ${++reloads}`, { exact: true })).toBeVisible();
+        assert.equal(await body.evaluate(element => element === window.errorAvatarBody), true);
+        assert.deepEqual(await body.locator(".assistant-transcript__turn").allTextContents(), history);
+        await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+        await expect(draft).toHaveValue("Keep this draft and the loaded history.");
+      }
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});
+
+
+test("short connection warnings preserve full text and recovery targets at phone widths", {
+  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 [320, 390]) {
+      const page = await browser.newPage({ viewport: { width, height: 768 } });
+      await page.goto(`${vite.baseURL}/?conversation=1&avatar=1&avatarTools=1&update-errors=1`);
+      await page.locator(".fixture").evaluate(element => {
+        element.style.height = "368px";
+        element.style.width = "100%";
+      });
+      await page.getByRole("combobox", { name: "Avatar preference", exact: true }).selectOption("standard");
+      const conversation = page.locator(".assistant-conversation");
+      const body = page.locator(".assistant-transcript__body");
+      const draft = page.getByRole("textbox", { name: "Message AI assistant", exact: true });
+      const banner = page.locator(".assistant-transcript__error");
+      const reload = banner.getByRole("button", { name: "Reload chat", exact: true });
+      await draft.fill("Keep this short-view draft.");
+      const originalBody = await body.elementHandle();
+      const history = await body.locator(".assistant-transcript__turn").allTextContents();
+      await page.getByRole("button", { name: "Show update error", exact: true }).evaluate(element => element.click());
+      await expect(banner).toContainText("the assistant may still be working.");
+      const bounds = await banner.evaluate(element => {
+        const box = node => {
+          const rect = node.getBoundingClientRect();
+          return { top: rect.top, bottom: rect.bottom, left: rect.left, right: rect.right };
+        };
+        return { banner: box(element), content: box(element.querySelector(".v-alert__content")),
+          words: box(element.querySelector(".assistant-transcript__error-content > span")),
+          button: box(element.querySelector("button")) };
+      });
+      for (const target of [bounds.words, bounds.button]) {
+        assert.ok(target.top >= bounds.content.top - 1 && target.bottom <= bounds.content.bottom + 1,
+          "The error content reserves the full wrapped text and Reload height");
+        assert.ok(target.top >= bounds.banner.top - 1 && target.bottom <= bounds.banner.bottom + 1,
+          "The warning does not clip its text or recovery button");
+      }
+      const transcriptBounds = await page.locator(".assistant-transcript").evaluate(element => ({
+        top: element.getBoundingClientRect().top,
+        bottom: element.getBoundingClientRect().bottom,
+        scrollTop: element.scrollTop
+      }));
+      assert.ok(bounds.banner.top >= transcriptBounds.top - 1 && bounds.banner.bottom <= transcriptBounds.bottom + 1,
+        "The parent allocates the complete warning height instead of clipping its own error row");
+      assert.equal(transcriptBounds.scrollTop, 0, "Reading the warning does not require scrolling the hidden transcript container");
+      await expect(conversation).toHaveCSS("overflow-y", "auto");
+      await reload.scrollIntoViewIfNeeded();
+      assert.equal(await page.locator(".assistant-transcript").evaluate(element => element.scrollTop), 0,
+        "The ordinary recovery target scrolls through the error conversation, not its clipped transcript");
+      assert.equal(await reload.evaluate(element => {
+        const rect = element.getBoundingClientRect();
+        return [2, rect.height / 2, rect.height - 2].every(offset =>
+          element.contains(document.elementFromPoint(rect.x + rect.width / 2, rect.y + offset)));
+      }), true, "The pointer reaches the top, centre and bottom of Reload");
+      await reload.focus();
+      await reload.press("Tab");
+      assert.equal(await body.evaluate(element => document.activeElement === element), true,
+        "The original transcript remains keyboard reachable after Reload");
+      await draft.focus();
+      assert.equal(await draft.evaluate(element => document.activeElement === element), true);
+      await expect(draft).toHaveValue("Keep this short-view draft.");
+      assert.equal(await body.evaluate((element, original) => element === original, originalBody), true);
+      assert.deepEqual(await body.locator(".assistant-transcript__turn").allTextContents(), history);
+      await reload.click();
+      await expect(banner).toHaveCount(0);
+      await expect(conversation).not.toHaveClass(/assistant-conversation--error/u);
+      await expect(page.getByText("Error reloads: 1", { exact: true })).toBeVisible();
+      assert.equal(await body.evaluate((element, original) => element === original, originalBody), true);
+      assert.deepEqual(await body.locator(".assistant-transcript__turn").allTextContents(), history);
+      await expect(draft).toHaveValue("Keep this short-view draft.");
+      assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});