@jskit-ai/assistant-core 0.2.1 → 0.2.3

package/src/server/conversation/providers/opencodeDriver.js

@@ -76,10 +76,10 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
     return { text: prepared, content: input.content };
   }
 
-  async function nativeStorageTarget({ native, context }) {
+  function withNativeStorageTarget({ native, context }, operation) {
     const prepared = native.preparation.storage(context);
-    return native.owner.ensure(null, async () =>
-      native.owner.startPreparedProcess(await prepared.process())).catch(prepared.failure);
+    return native.owner.withStorageProcess(async () =>
+      native.owner.startPreparedProcess(await prepared.process()), operation, prepared.failure);
   }
 
   async function disposeNative({ native, options }) {
@@ -127,17 +127,18 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
       const prepared = await native.preparation.existing(input, context, { operation: "delete" });
       return native.owner.deletePreparedConversation(prepared, input);
     },
-    async listConversationStorage(prepared) {
-      const target = await nativeStorageTarget(prepared);
+    listConversationStorage(prepared) {
       const { binding, context } = prepared;
-      return (await target.server.client.listConversationsForDirectory(binding.workdir, { signal: context.signal }))
-        .map((row) => ({ ...binding, conversationId: row.id }));
+      return withNativeStorageTarget(prepared, async target =>
+        (await target.server.client.listConversationsForDirectory(binding.workdir, { signal: context.signal }))
+          .map((row) => ({ ...binding, conversationId: row.id })));
     },
-    async retireConversationHistory(prepared) {
-      const target = await nativeStorageTarget(prepared);
-      // Native status is scoped to the saved project instance, not the control server.
-      const client = openCodeServerForDirectory(target.server, prepared.binding.workdir).client;
-      return retireOpenCodeConversationHistory(target.server.client, client, prepared.binding, prepared.context);
+    retireConversationHistory(prepared) {
+      return withNativeStorageTarget(prepared, target => {
+        // Native status is scoped to the saved project instance, not the control server.
+        const client = openCodeServerForDirectory(target.server, prepared.binding.workdir).client;
+        return retireOpenCodeConversationHistory(target.server.client, client, prepared.binding, prepared.context);
+      });
     },
     closeProject({ native, input }) {
       return native.owner.closeProject(input, native.preparation.projectCleanup());
@@ -489,13 +490,15 @@ export function createOpenCodeConversationDriver({ connections, host = {}, limit
           const start = host.opencode
             ? async () => facilities.runtime.startPreparedProcess(await facilities.prepareServer())
             : () => facilities.start({ signal, connection });
+          // A managed host's saved connections reach its running server in place.
+          const savedConnections = host.opencode ? async () => (await facilities.prepareServer()).connections : null;
           if (!native) {
             native = await facilities.runtime.acquire(binding.directory, async () => {
-              const shared = await facilities.runtime.ensure(facilities.selected, start);
+              const shared = await facilities.runtime.ensure(facilities.selected, start, savedConnections);
               return { key: binding.directory, workdir: binding.workdir, upstreamSessionId: binding.sessionId,
                 abortController: new AbortController(), server: openCodeServerForDirectory(shared.server, binding.workdir) };
             });
-          } else await facilities.runtime.ensure(facilities.selected, start);
+          } else await facilities.runtime.ensure(facilities.selected, start, savedConnections);
           signal.throwIfAborted();
           await updateBinding({ executionId: native.server.executionId, processDirectory: native.server.privateRoot || "" });
           const catalogue = await native.server.client.providers({ signal });

package/src/server/conversation/providers/scoped.js

@@ -320,7 +320,7 @@ export async function inspectPersistentConversationAdmission(options) {
   if (!record.providerConversationId) return { admission: "unknown", turnId: "" };
   const state = requireSuccess(await operations.readConversation(sessionId,
     inputFor(record, { messageId: input.messageId }), options.context));
-  return { admission: state.admitted ? "accepted" : "unknown", turnId: state.runId };
+  return { admission: state.admitted ? "accepted" : state.notAdmitted ? "not-admitted" : "unknown", turnId: state.runId };
 }
 
 export async function preparePersistentConversationChangeover(options) {
@@ -353,7 +353,10 @@ export async function inspectPersistentConversationDelivery(options) {
     const result = await createConversationChangeover({ ...continuity, agent: {
       inspectMessageAdmission: request => inspectMessageAdmission(sessionId, request, context),
       sendMessage() { throw new Error("Receipt inspection cannot submit another native prompt."); }
-    } }).send({ engineId, messages, input: { messageId: input.messageId }, turnMetadata });
+    } }).send({ engineId, messages, input: { messageId: input.messageId }, turnMetadata, inspectOnly: true });
+    if (result?.notSent) return { status: "not-sent", messageId: input.messageId,
+      error: "This message was not sent. Review it before sending a new message.",
+      messageCode: "assistant.conversation.messageNotSent", messageParams: {} };
     accepted = result?.delivered === true;
   } else if (!accepted) {
     if (row && row.user?.receipt !== false) return { status: "accepted", messageId: input.messageId, turnId: row.turnId, duplicate: true };

package/src/server/conversation/runtime.js

@@ -28,6 +28,9 @@ function failure(message, code, statusCode = 409, { messageCode, messageParams }
   return Object.assign(new Error(message), { code, statusCode }, messageCode ? { messageCode, messageParams: messageParams || {} } : {});
 }
 
+// The newest messages cancelled in one open conversation, refused if sent again.
+const MAX_CANCELLED_MESSAGES = 100;
+
 // A native delivery result keeps its own sentence and messageCode when it has one.
 function deliveryFailure(delivered) {
   const code = delivered?.code || "conversation_delivery_uncertain";
@@ -1558,6 +1561,10 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     deliveryTiming?.("preparation-started");
     const operation = goal ? "goal" : input?.steer === true ? "steer" : origin === "application" ? "wake" : "send";
     await access(context, entry.id, operation, entry, grant);
+    if (entry.cancelledMessages.has(input?.messageId)) {
+      throw Object.assign(failure("This message was cancelled. Send it again as a new message.", "conversation_message_cancelled", 409,
+        { messageCode: "assistant.conversation.messageCancelled" }), { delivery: "not-sent" });
+    }
     await entry.conversation?.admission(context, operation);
     deliveryTiming?.("authorized");
     if (goal) context?.signal?.throwIfAborted();
@@ -1738,6 +1745,34 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     return { stopped: true };
   }
 
+  // Cancel of one message in a runtime-owned conversation never waits for the
+  // conversation queue. The message is recorded as cancelled at once, so a send
+  // of it still queued, or arriving later, is refused as not sent; its own
+  // submission stops, ending any turn it started. Its unconfirmed request or
+  // pending native attempt is discarded afterwards, in queue order. A message
+  // already accepted stays history.
+  async function cancelDelivery(entry, context, messageId, representation) {
+    entry.cancelledMessages.delete(messageId);
+    entry.cancelledMessages.add(messageId);
+    if (entry.cancelledMessages.size > MAX_CANCELLED_MESSAGES) entry.cancelledMessages.delete(entry.cancelledMessages.values().next().value);
+    const interrupted = Boolean(entry.active?.requests.has(messageId));
+    if (interrupted) await stop(entry, context, undefined, representation);
+    void serial(entry, async () => {
+      await access(context, entry.id, "cancel", entry);
+      if (entry.conversation) {
+        await nativeChangeover(entry, context, null, () => { throw new Error("Cancel never sends a message."); }).discard({ messageId });
+        return;
+      }
+      await storage.write(entry.id, async transaction => {
+        const metadata = await transaction.readMetadata();
+        if (metadata.runtime.request?.messageId !== messageId) return;
+        delete metadata.runtime.request;
+        await transaction.writeMetadata(metadata);
+      });
+    }).catch(() => {});
+    return { ok: true, cancelled: true, messageId, interrupted };
+  }
+
   async function readGoal(entry, context, representation) {
     await access(context, entry.id, "readGoal", entry);
     if (!capabilities(entry).goals) return null;
@@ -1892,6 +1927,11 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     return { saved: true };
   }
 
+  function notSentReceipt(messageId) {
+    return { status: "not-sent", messageId, error: "This message was not sent. Review it before sending a new message.",
+      messageCode: "assistant.conversation.messageNotSent", messageParams: {} };
+  }
+
   async function recoverDelivery(entry, context, messageId, { observation: suppliedObservation, allowActive = false } = {}) {
     await access(context, entry.id, "inspectDelivery", entry);
     if (entry.active && !allowActive) throw failure("Wait for the current submission before checking delivery.", "conversation_busy", 409, { messageCode: "assistant.conversation.waitForSubmission" });
@@ -1920,8 +1960,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       ["codex", "claude", "opencode"].includes(segment.engine) && segment.request.attempted === false && !segment.request.inspectionOnly &&
       isDeepStrictEqual(segment.request, savedRequests[0].request))) {
       await access(context, entry.id, "inspectDelivery", entry);
-      return { status: "not-sent", messageId, error: "This message was not sent. Review it before sending a new message.",
-        messageCode: "assistant.conversation.messageNotSent", messageParams: {} };
+      return notSentReceipt(messageId);
     }
     const request = existing ? submittedMessage(existing) : metadata.runtime.request;
     if (!request || request.messageId !== messageId || !entry.provider.inspectAdmission) return receipt || { status: "unknown", messageId };
@@ -1930,6 +1969,17 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     const observation = suppliedObservation || await entry.provider.inspectAdmission({ ...request, nativeTurnId: existing?.metadata?.runtime?.nativeTurnId,
       context, configuration: metadata.runtime.configuration });
     await access(context, entry.id, "inspectDelivery", entry);
+    // The engine proved it never admitted this saved request. Record that it
+    // was not sent, as a definite rejection would, so Retry may send it.
+    if (!existing && observation.notAdmitted && pending && !pending.inspectionOnly && !entry.active) {
+      await storage.write(entry.id, async transaction => {
+        const current = await transaction.readMetadata();
+        if (current.runtime.request?.messageId !== messageId) return;
+        current.runtime.request.attempted = false;
+        await transaction.writeMetadata(current);
+      });
+      return notSentReceipt(messageId);
+    }
     if (!observation.accepted) return { ...(receipt || { status: "unknown", messageId }),
       ...(observation.recoveryLimitation ? { recoveryLimitation: observation.recoveryLimitation } : {}) };
     if (entry.driver.canonicalTranscript) {
@@ -2046,7 +2096,8 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
           throw new Error("Receipt inspection cannot submit another native prompt.");
         });
         const delivered = await sender.send({ engineId: entry.engine,
-          messages: await entry.conversation.transcript.history(), input: { messageId } });
+          messages: await entry.conversation.transcript.history(), input: { messageId }, inspectOnly: true });
+        if (delivered?.notSent) return notSentReceipt(messageId);
         if (!delivered?.delivered) throw deliveryFailure(delivered);
       }
       const row = (await readTranscript(entry)).find(turn => submittedMessage(turn)?.messageId === messageId);
@@ -2057,7 +2108,8 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       await access(context, entry.id, "inspectDelivery", entry);
       // Native-only acceptance is evidence of delivery, not permission to
       // manufacture an authored row or use a native turn ID as its receipt.
-      return observation.accepted ? { status: "accepted", messageId, duplicate: true } : { status: "unknown", messageId };
+      if (observation.accepted) return { status: "accepted", messageId, duplicate: true };
+      return observation.notAdmitted && !entry.active ? notSentReceipt(messageId) : { status: "unknown", messageId };
     }
     const result = await recoverDelivery(entry, context, messageId);
     if (result.status !== "accepted" || entry.engine === "api") return result;
@@ -2299,7 +2351,10 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
   function retireEntry(entry) {
     entry.disposed = true;
     entry.listeners.clear();
-    streams.clear(entry.id);
+    // Live streams are kept per conversation id. A logical conversation streams
+    // through its own owner, so the stream under its id belongs to another entry
+    // with the same id, such as its session's Main conversation.
+    if (!entry.conversation?.commands) streams.clear(entry.id);
     if (entries.get(entry.key) === entry) entries.delete(entry.key);
   }
 
@@ -2553,7 +2608,8 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       const key = conversation?.namespace || id;
       let entry = entries.get(key);
       if (!entry) {
-        entry = { id, key, conversation, host: selectedHost, pending: Promise.resolve(), active: null, listeners: new Set(), error: "" };
+        entry = { id, key, conversation, host: selectedHost, pending: Promise.resolve(), active: null, listeners: new Set(), error: "",
+          cancelledMessages: new Set() };
         entries.set(key, entry);
         entry.initializing = initialize(entry, configuration, engine).catch(error => {
           if (entries.get(key) === entry) entries.delete(key);
@@ -2606,6 +2662,20 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
           await access(context, id, "read", entry);
           return read(entry);
         },
+        // Cancel of one unsent or unconfirmed message always records it; an
+        // application conversation supplies its own operation for that.
+        async cancelDelivery({ messageId } = {}) {
+          if (typeof messageId !== "string" || !messageId) throw new TypeError("A message id is required.");
+          await access(context, id, "cancel", entry);
+          if (entry.conversation?.commands) {
+            if (typeof entry.conversation.commands.cancelDelivery !== "function") {
+              throw failure("This conversation cannot cancel one message.", "conversation_unsupported", 400,
+                { messageCode: "assistant.conversation.messageCancelUnsupported" });
+            }
+            return entry.conversation.commands.cancelDelivery({ messageId }, context);
+          }
+          return cancelDelivery(entry, context, messageId, representation);
+        },
         async cancel(input) {
           await access(context, id, "cancel", entry);
           if (entry.conversation?.commands) return entry.conversation.commands.cancel(input, context);
@@ -2830,6 +2900,23 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       });
       return retained || cleanupUnopened();
     },
+    // Trusted server lifecycle: the application deleted or archived a logical
+    // conversation that it binds through its own commands. Its open entry, if
+    // any, leaves memory and its handles close. Nothing is opened; native and
+    // storage-owned conversations keep their own disposal.
+    async retireOpenConversation({ namespace, sessionId }) {
+      const entry = entries.get(namespace);
+      if (!entry || entry.id !== sessionId) return { retired: false };
+      if (!entry.conversation?.commands) {
+        throw new TypeError("Only a logical conversation bound through its commands retires without disposal.");
+      }
+      await entry.initializing.catch(() => {});
+      return serial(entry, async () => {
+        if (entry.disposed || entries.get(namespace) !== entry) return { retired: false };
+        retireEntry(entry);
+        return { retired: true };
+      });
+    },
     // Host publication from the same native owner, through the existing entry.
     // This does not subscribe to a provider or retain another observer registry.
     async publishNative({ namespace, sessionId, event }) {

package/src/server/hosts/codexConfiguration.js

@@ -20,3 +20,7 @@ export {
   createCodexAppServerIsolation,
   readCodexToolFreeConfiguration
 } from "../conversation/codexConfiguration.js";
+export {
+  codexDisabledProcessFeatureArguments,
+  codexHomeDisposablePaths
+} from "../conversation/codexHomeStorage.js";

package/test/assistantScroll.browser.test.js

@@ -26,6 +26,31 @@ async function settleReaderAt(body, scrollTop) {
   }, scrollTop)).toBe(true);
 }
 
+// Prepended history starts at those estimates and materializes on a later frame,
+// when scroll anchoring moves scrollTop. Read positions only once that settles.
+async function settleLayout(body) {
+  await expect.poll(() => body.evaluate(async element => {
+    const [top, height] = [element.scrollTop, element.scrollHeight];
+    await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+    return element.scrollTop === top && element.scrollHeight === height;
+  })).toBe(true);
+}
+
+// A gesture's scroll ends after its last input event; a touch drag ends with
+// its fling. A scrollend still queued from earlier scrolling must not count, or
+// the reader is measured while the fling keeps moving it.
+async function scrollGesture(body, lastEventType, perform) {
+  await body.evaluate((element, type) => {
+    element.gestureScrollEnded = new Promise(resolve => {
+      element.addEventListener(type, () => {
+        element.addEventListener("scrollend", () => resolve(), { once: true });
+      }, { once: true, passive: true });
+    });
+  }, lastEventType);
+  await perform();
+  await body.evaluate(element => element.gestureScrollEnded);
+}
+
 const VIEWPORTS = Object.freeze([
   Object.freeze({ name: "phone", width: 390, height: 844 }),
   Object.freeze({ name: "compact", width: 800, height: 900 }),
@@ -266,10 +291,12 @@ test("conversation scrolling preserves history anchors and resets expansion on s
     await page.getByRole("button", { name: "Read more", exact: true }).click();
     await expect(page.getByRole("button", { name: "Show less", exact: true })).toBeVisible();
     const original = page.getByText("Conversation line 1:", { exact: false }).first();
+    await settleLayout(body);
     const originalTop = (await original.boundingBox()).y;
     // Measure history anchoring without Playwright first scrolling to the button.
     await page.getByRole("button", { name: "Load older messages", exact: true }).evaluate(element => element.click());
-    await expect.poll(async () => Math.abs((await original.boundingBox()).y - originalTop)).toBeLessThan(2);
+    await settleLayout(body);
+    expect(Math.abs((await original.boundingBox()).y - originalTop)).toBeLessThan(2);
     const before = await body.evaluate((element) => element.scrollTop);
     await page.getByRole("button", { name: "Append reply", exact: true }).click();
     await expect(page.getByText("New reply.", { exact: false })).toBeAttached();
@@ -370,20 +397,18 @@ test("upward scrolling loads older history once and preserves retry and selectio
         const cdp = await page.context().newCDPSession(page);
         const x = bounds.x + bounds.width / 2;
         const y = bounds.y + 40;
-        const stopped = body.evaluate(element => new Promise(resolve => {
-          element.addEventListener("scrollend", () => resolve(), { once: true });
-        }));
-        await cdp.send("Input.dispatchTouchEvent", { type: "touchStart", touchPoints: [{ x, y }] });
-        for (let offset = 20; offset <= 380; offset += 20) {
-          await cdp.send("Input.dispatchTouchEvent", { type: "touchMove", touchPoints: [{ x, y: y + offset }] });
-          await page.evaluate(() => new Promise(requestAnimationFrame));
-        }
-        await cdp.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] });
-        await stopped;
+        await scrollGesture(body, "touchend", async () => {
+          await cdp.send("Input.dispatchTouchEvent", { type: "touchStart", touchPoints: [{ x, y }] });
+          for (let offset = 20; offset <= 380; offset += 20) {
+            await cdp.send("Input.dispatchTouchEvent", { type: "touchMove", touchPoints: [{ x, y: y + offset }] });
+            await page.evaluate(() => new Promise(requestAnimationFrame));
+          }
+          await cdp.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] });
+        });
         await cdp.detach();
       } else {
         await body.hover();
-        await page.mouse.wheel(0, -380);
+        await scrollGesture(body, "wheel", () => page.mouse.wheel(0, -380));
       }
       const pending = page.getByRole("button", { name: "Loading older messages…", exact: true });
       await expect(pending).toBeDisabled();
@@ -394,10 +419,12 @@ test("upward scrolling loads older history once and preserves retry and selectio
         element.dispatchEvent(new Event("scroll"));
       });
       const original = page.getByText("Conversation line 1:", { exact: false }).first();
+      await settleLayout(body);
       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 settleLayout(body);
+      expect(Math.abs((await original.boundingBox()).y - originalTop)).toBeLessThan(2);
       await expect(requests).toHaveText("History requests: 1");
 
       // Keyboard navigation also requests older history.
@@ -421,11 +448,7 @@ test("upward scrolling loads older history once and preserves retry and selectio
       // Removing the history control re-anchors the scroller, which would
       // cancel a keyboard scroll already in flight; press Home once it settles.
       await expect(page.getByRole("button", { name: "Load older messages", exact: true })).toHaveCount(0);
-      await expect.poll(() => body.evaluate(async element => {
-        const height = element.scrollHeight;
-        await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
-        return element.scrollHeight === height;
-      })).toBe(true);
+      await settleLayout(body);
       await expect.poll(async () => {
         await body.focus();
         return body.evaluate(element => document.activeElement === element);
@@ -443,6 +466,99 @@ test("upward scrolling loads older history once and preserves retry and selectio
   }
 });
 
+test("a reader's own upward scrolling leaves the latest message from its first frame", {
+  skip: !RUN_BROWSER_TEST,
+  timeout: 60_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: FIXTURE_ROOT });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    for (const width of [390, 1365]) {
+      const touch = width < 1000;
+      const page = await browser.newPage({ viewport: { width, height: 900 }, hasTouch: touch, isMobile: touch });
+      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 fromBottom = () => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop);
+      const appendReply = async () => {
+        const replies = page.getByText("New reply.", { exact: false });
+        const count = await replies.count();
+        await page.getByRole("button", { name: "Append reply", exact: true }).evaluate(element => element.click());
+        await expect(replies).toHaveCount(count + 1);
+        await settleLayout(body);
+      };
+      await expect(page.getByText("Conversation line 70:", { exact: false })).toBeVisible();
+      await page.getByRole("button", { name: "Exhaust history", exact: true }).evaluate(element => element.click());
+      await settleLayout(body);
+      expect(await fromBottom()).toBeLessThanOrEqual(1);
+      await expect.poll(async () => {
+        await body.focus();
+        return body.evaluate(element => document.activeElement === element);
+      }).toBe(true);
+
+      // A short upward wheel or touch scroll stays within the 48px follow
+      // threshold, and a touch fling ends without further input events.
+      if (touch) {
+        const bounds = await body.boundingBox();
+        const cdp = await page.context().newCDPSession(page);
+        const [x, y] = [bounds.x + bounds.width / 2, bounds.y + 100];
+        await cdp.send("Input.dispatchTouchEvent", { type: "touchStart", touchPoints: [{ x, y }] });
+        for (const offset of [10, 20, 30]) {
+          await cdp.send("Input.dispatchTouchEvent", { type: "touchMove", touchPoints: [{ x, y: y + offset }] });
+        }
+        await cdp.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] });
+        await cdp.detach();
+      } else {
+        await body.hover();
+        await page.mouse.wheel(0, -20);
+      }
+      await expect.poll(fromBottom).toBeGreaterThan(1);
+      await settleLayout(body);
+      await appendReply();
+      expect(await fromBottom()).toBeGreaterThan(1);
+
+      // Returning to the end resumes following new replies.
+      await body.press("End");
+      await expect.poll(fromBottom).toBeLessThanOrEqual(1);
+      await appendReply();
+      expect(await fromBottom()).toBeLessThanOrEqual(1);
+
+      // The first frame of an upward scroll lands inside the follow threshold;
+      // the rest of it (a fling or smooth scroll) moves the reader into history
+      // without further input events.
+      await body.press("ArrowUp");
+      await expect.poll(fromBottom).toBeGreaterThan(1);
+      await settleLayout(body);
+      expect(await fromBottom()).toBeLessThanOrEqual(48);
+      await body.evaluate(element => { element.scrollTop = Math.round(element.scrollTop / 2); });
+      await settleLayout(body);
+      await appendReply();
+      expect(await fromBottom()).toBeGreaterThan(1_000);
+      await body.press("End");
+      await expect.poll(fromBottom).toBeLessThanOrEqual(1);
+      await appendReply();
+      expect(await fromBottom()).toBeLessThanOrEqual(1);
+
+      // The scroll event of the transcript's own follow scroll can arrive after
+      // the key press, before the reader has moved; it must not cancel the
+      // reader's scroll.
+      await body.evaluate(element => {
+        element.addEventListener("keydown", () => element.dispatchEvent(new Event("scroll")), { once: true });
+      });
+      await body.press("Home");
+      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(0);
+      await appendReply();
+      expect(await body.evaluate(element => element.scrollTop)).toBe(0);
+      assert.deepEqual(errors, []);
+      await page.close();
+    }
+  } finally {
+    await browser.close();
+    await stopProcess(vite);
+  }
+});
+
 test("retained hidden transcripts preserve readers and follow only at the latest message", {
   skip: !RUN_BROWSER_TEST,
   timeout: 90_000

package/test/claudeConversationSession.test.js

@@ -265,7 +265,7 @@ async function fixture(t, options = {}) {
   await writeFile(account, "owner@example.test");
   await writeFile(command, `#!${process.execPath}
     import { createInterface } from "node:readline";
-    import { appendFileSync, mkdirSync, readFileSync } from "node:fs";
+    import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
     import path from "node:path";
     const args = process.argv.slice(2);
     const structuredResponse = ${JSON.stringify(options.structuredResponse || null)};
@@ -308,6 +308,12 @@ async function fixture(t, options = {}) {
         if (frame.request.subtype === "interrupt") emit({ type: "result", subtype: "success", terminal_reason: "aborted_streaming", result: "" });
         return;
       }
+      // A crash after reading the prompt but before recording it in history.
+      const dropped = path.join(process.env.CLAUDE_CONFIG_DIR, "dropped-once");
+      if (JSON.stringify(frame.message.content).includes("drop once") && !existsSync(dropped)) {
+        writeFileSync(dropped, "");
+        process.exit(1);
+      }
       record(frame);
       const text = typeof frame.message.content === "string" ? frame.message.content
         : frame.message.content.filter(part => part.type === "text").map(part => part.text).join(" ");
@@ -783,6 +789,25 @@ test("uncertain native delivery is reconciled from history without a second infe
   assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 1);
 });
 
+test("a Claude prompt missing from history after its process ended is not sent, and Retry sends it", async t => {
+  const f = await fixture(t);
+  const dropped = { messageId: "dropped-before-history", text: "drop once" };
+  await assert.rejects(f.conversation.send(dropped), error => error.delivery === "uncertain");
+  assert.equal((await f.conversation.wait()).status, "unconfirmed");
+  const receipt = await f.conversation.inspectDelivery({ messageId: dropped.messageId });
+  assert.equal(receipt.status, "not-sent");
+  assert.equal(receipt.messageCode, "assistant.conversation.messageNotSent");
+  // The proof is saved: a reload no longer restores an unconfirmed message.
+  assert.equal((await f.conversation.read()).status, "ready");
+  assert.equal((await f.conversation.inspectDelivery({ messageId: dropped.messageId })).status, "not-sent");
+  const sent = await f.conversation.send(dropped);
+  assert.equal(sent.messageId, dropped.messageId);
+  const finished = await f.conversation.wait();
+  assert.equal(finished.conversationLog.length, 1);
+  assert.equal(finished.conversationLog[0].assistant.text, "Answer: drop once");
+  assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 2);
+});
+
 test("inspecting an older accepted Claude message leaves a different pending receipt untouched", async t => {
   const f = await fixture(t);
   const first = await f.conversation.send(input);