@jskit-ai/assistant-runtime 0.2.1 → 0.2.3

package/src/server/services/chatService.js

@@ -215,6 +215,34 @@ function createChatService({
     return { conversationId: response.meta?.conversationId, messageId: request.messageId, status: record.status };
   }
 
+  // Turns on one conversation share its runtime entry. The last of them to
+  // settle disposes it, so a finished chat keeps no runtime state; a turn that
+  // starts while that disposal runs waits for it and opens the entry again.
+  const conversationTurns = new Map();
+  async function openConversationTurn(conversationId, open) {
+    while (conversationTurns.get(conversationId)?.releasing) await conversationTurns.get(conversationId).releasing;
+    const turns = conversationTurns.get(conversationId) || { count: 0, handle: null, releasing: null };
+    conversationTurns.set(conversationId, turns);
+    turns.count += 1;
+    try {
+      turns.handle = await open();
+      return turns.handle;
+    } catch (error) {
+      await releaseConversationTurn(conversationId);
+      throw error;
+    }
+  }
+  async function releaseConversationTurn(conversationId) {
+    const turns = conversationTurns.get(conversationId);
+    turns.count -= 1;
+    if (turns.count > 0) return;
+    // A failed disposal keeps the entry, as before: the next turn reuses it and
+    // runtime close retries its save.
+    turns.releasing = Promise.resolve(turns.handle?.dispose()).catch(() => {})
+      .finally(() => conversationTurns.delete(conversationId));
+    await turns.releasing;
+  }
+
   async function streamChat(payload = {}, options = {}) {
     const assistantSurface = requireAssistantSurface(appConfig, payload?.targetSurfaceId);
     const context = normalizeObject(options.context);
@@ -320,85 +348,91 @@ function createChatService({
       const runtimeContext = { ...assistantContext, assistantRequest: {
         conversation, workspace, history: source.history, resolvedAttachments
       } };
-      let handle;
-      try { handle = await conversationRuntime.open({ id: conversationId, context: runtimeContext, configuration }); }
-      catch (error) {
-        if (error.code !== "conversation_configuration_mismatch") throw error;
-        handle = await conversationRuntime.open({ id: conversationId, context: runtimeContext });
-        await handle.configure(configuration);
-      }
-      let turnId = null;
-      let displayedId = null;
-      let displayedText = "";
-      const release = await handle.subscribe(event => {
-        if (event.type === "accepted" && event.messageId === source.messageId) turnId = event.turnId;
-        if (!turnId || event.turnId !== turnId) return;
-        if (event.type === "message" && ["assistant", "commentary"].includes(event.role)) {
-          if (displayedId !== event.messageId) {
-            if (displayedText) streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text: "", status: "streaming" });
-            displayedId = event.messageId;
-            displayedText = "";
-          }
-          if (event.text === displayedText) return;
-          if (event.text.startsWith(displayedText)) streamWriter.sendAssistantDelta({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_DELTA, delta: event.text.slice(displayedText.length) });
-          else streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text: event.text, status: "streaming" });
-          displayedText = event.text;
-        } else if (event.type === "tool") {
-          const call = event.call;
-          if (call.status === "running") streamWriter.sendToolCall({ type: ASSISTANT_STREAM_EVENT_TYPES.TOOL_CALL,
-            toolCallId: call.id, name: call.name, arguments: call.arguments });
-          else if (call.result) streamWriter.sendToolResult({ type: ASSISTANT_STREAM_EVENT_TYPES.TOOL_RESULT,
-            toolCallId: call.id, name: call.name, ok: call.result.ok === true,
-            ...(call.result.ok ? { result: call.result.result } : { error: call.result.error }) });
+      const handle = await openConversationTurn(conversationId, async () => {
+        try { return await conversationRuntime.open({ id: conversationId, context: runtimeContext, configuration }); }
+        catch (error) {
+          if (error.code !== "conversation_configuration_mismatch") throw error;
+          const opened = await conversationRuntime.open({ id: conversationId, context: runtimeContext });
+          await opened.configure(configuration);
+          return opened;
         }
       });
-      let cancellation;
-      const cancel = () => { cancellation ||= handle.cancel(); cancellation.catch(() => {}); };
-      let streamed = false;
       try {
-        const meta = { type: ASSISTANT_STREAM_EVENT_TYPES.META, messageId: source.messageId, conversationId,
-          provider: aiClient.provider, model: aiClient.defaultModel };
-        await turnRequests.update(claim, { meta });
-        streamWriter.sendMeta(meta);
-        streamed = true;
-        options.abortSignal?.addEventListener("abort", cancel, { once: true });
-        options.abortSignal?.throwIfAborted();
-        const receipt = await handle.send({ messageId: source.messageId, text: source.input,
-          ...(source.attachmentIds !== undefined ? { attachmentIds: source.attachmentIds } : {}) });
-        turnId = receipt.turnId;
-        const snapshot = await handle.wait();
-        const turn = snapshot.conversationLog.find(entry => entry.turnId === turnId);
-        const status = turn?.metadata?.runtime?.status;
-        if (status !== "complete") {
-          const reason = turn?.metadata?.runtime?.error || snapshot.error;
-          const error = reason ? new Error(reason) : Object.assign(new Error("Assistant request failed."), {
-            messageCode: "assistant.runtime.request.failed", messageParams: {} });
-          if (status === "cancelled") error.name = "AbortError";
-          throw error;
+        let turnId = null;
+        let displayedId = null;
+        let displayedText = "";
+        const release = await handle.subscribe(event => {
+          if (event.type === "accepted" && event.messageId === source.messageId) turnId = event.turnId;
+          if (!turnId || event.turnId !== turnId) return;
+          if (event.type === "message" && ["assistant", "commentary"].includes(event.role)) {
+            if (displayedId !== event.messageId) {
+              if (displayedText) streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text: "", status: "streaming" });
+              displayedId = event.messageId;
+              displayedText = "";
+            }
+            if (event.text === displayedText) return;
+            if (event.text.startsWith(displayedText)) streamWriter.sendAssistantDelta({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_DELTA, delta: event.text.slice(displayedText.length) });
+            else streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text: event.text, status: "streaming" });
+            displayedText = event.text;
+          } else if (event.type === "tool") {
+            const call = event.call;
+            if (call.status === "running") streamWriter.sendToolCall({ type: ASSISTANT_STREAM_EVENT_TYPES.TOOL_CALL,
+              toolCallId: call.id, name: call.name, arguments: call.arguments });
+            else if (call.result) streamWriter.sendToolResult({ type: ASSISTANT_STREAM_EVENT_TYPES.TOOL_RESULT,
+              toolCallId: call.id, name: call.name, ok: call.result.ok === true,
+              ...(call.result.ok ? { result: call.result.result } : { error: call.result.error }) });
+          }
+        });
+        let cancellation;
+        const cancel = () => { cancellation ||= handle.cancel(); cancellation.catch(() => {}); };
+        let streamed = false;
+        try {
+          const meta = { type: ASSISTANT_STREAM_EVENT_TYPES.META, messageId: source.messageId, conversationId,
+            provider: aiClient.provider, model: aiClient.defaultModel };
+          await turnRequests.update(claim, { meta });
+          streamWriter.sendMeta(meta);
+          streamed = true;
+          options.abortSignal?.addEventListener("abort", cancel, { once: true });
+          options.abortSignal?.throwIfAborted();
+          const receipt = await handle.send({ messageId: source.messageId, text: source.input,
+            ...(source.attachmentIds !== undefined ? { attachmentIds: source.attachmentIds } : {}) });
+          turnId = receipt.turnId;
+          const snapshot = await handle.wait();
+          const turn = snapshot.conversationLog.find(entry => entry.turnId === turnId);
+          const status = turn?.metadata?.runtime?.status;
+          if (status !== "complete") {
+            const reason = turn?.metadata?.runtime?.error || snapshot.error;
+            const error = reason ? new Error(reason) : Object.assign(new Error("Assistant request failed."), {
+              messageCode: "assistant.runtime.request.failed", messageParams: {} });
+            if (status === "cancelled") error.name = "AbortError";
+            throw error;
+          }
+          const text = normalizeText(turn.assistant?.text);
+          if (!text) throw new AppError(502, "Assistant returned no output.", { code: "assistant.runtime.request.noOutput" });
+          await transcriptService.completeConversation(assistantSurface, conversationId,
+            { status: "completed", metadata: turn.metadata?.completion || {} }, { context: assistantContext, workspace });
+          streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text });
+          streamWriter.sendDone({ type: ASSISTANT_STREAM_EVENT_TYPES.DONE, messageId: source.messageId, status: "completed" });
+          return { conversationId, messageId: source.messageId, status: "completed" };
+        } catch (error) {
+          const aborted = isAbortError(error) || options.abortSignal?.aborted;
+          const status = aborted ? "aborted" : "failed";
+          if (!streamed) throw error;
+          await transcriptService.completeConversation(assistantSurface, conversationId, { status }, { context: assistantContext, workspace });
+          streamWriter.sendError({ type: ASSISTANT_STREAM_EVENT_TYPES.ERROR, messageId: source.messageId,
+            code: aborted ? "assistant_stream_aborted" : String(error?.code || "assistant_stream_failed"),
+            message: aborted ? "Assistant request was cancelled." : String(error?.message || "Assistant request failed."),
+            ...streamErrorMessageFields(error, aborted),
+            status: aborted ? 499 : errorStatus(error) });
+          streamWriter.sendDone({ type: ASSISTANT_STREAM_EVENT_TYPES.DONE, messageId: source.messageId, status });
+          return { conversationId, messageId: source.messageId, status };
+        } finally {
+          options.abortSignal?.removeEventListener("abort", cancel);
+          release();
+          await cancellation;
         }
-        const text = normalizeText(turn.assistant?.text);
-        if (!text) throw new AppError(502, "Assistant returned no output.", { code: "assistant.runtime.request.noOutput" });
-        await transcriptService.completeConversation(assistantSurface, conversationId,
-          { status: "completed", metadata: turn.metadata?.completion || {} }, { context: assistantContext, workspace });
-        streamWriter.sendAssistantMessage({ type: ASSISTANT_STREAM_EVENT_TYPES.ASSISTANT_MESSAGE, text });
-        streamWriter.sendDone({ type: ASSISTANT_STREAM_EVENT_TYPES.DONE, messageId: source.messageId, status: "completed" });
-        return { conversationId, messageId: source.messageId, status: "completed" };
-      } catch (error) {
-        const aborted = isAbortError(error) || options.abortSignal?.aborted;
-        const status = aborted ? "aborted" : "failed";
-        if (!streamed) throw error;
-        await transcriptService.completeConversation(assistantSurface, conversationId, { status }, { context: assistantContext, workspace });
-        streamWriter.sendError({ type: ASSISTANT_STREAM_EVENT_TYPES.ERROR, messageId: source.messageId,
-          code: aborted ? "assistant_stream_aborted" : String(error?.code || "assistant_stream_failed"),
-          message: aborted ? "Assistant request was cancelled." : String(error?.message || "Assistant request failed."),
-          ...streamErrorMessageFields(error, aborted),
-          status: aborted ? 499 : errorStatus(error) });
-        streamWriter.sendDone({ type: ASSISTANT_STREAM_EVENT_TYPES.DONE, messageId: source.messageId, status });
-        return { conversationId, messageId: source.messageId, status };
       } finally {
-        options.abortSignal?.removeEventListener("abort", cancel);
-        release();
-        await cancellation;
+        await releaseConversationTurn(conversationId);
       }
     }
   }

package/test/actionDefinitions.test.js

@@ -117,7 +117,8 @@ test("host access wraps only canonical conversation definitions and receives the
   });
   assert.deepEqual(wrapped.map(({ id }) => id), [
     actionIds.conversationRead, actionIds.conversationSend, actionIds.conversationCancel, subscribeActionId,
-    actionIds.conversationInspectDelivery, actionIds.conversationGoalRead, actionIds.conversationGoalUpdate
+    actionIds.conversationInspectDelivery, actionIds.conversationCancelDelivery, actionIds.conversationGoalRead,
+    actionIds.conversationGoalUpdate
   ]);
   assert.equal(findDefinition(definitions, actionIds.conversationSubscribe), undefined);
   for (const definition of wrapped) {

package/test/assistantConversationBinding.browser.test.js

@@ -33,7 +33,14 @@ async function fixture(t, width = 1280, { acceptedDraft = false, draftWhileLoadi
   const state = async () => (await page.request.get(`${vite.baseURL}/fixture/state`)).json();
   const sent = async () => (await state()).requests.filter(request => request.suffix === "/messages");
   const notify = id => page.evaluate(id => window.conversationFixture.socket.notify(id), id);
-  return { page, primary, input, command, state, sent, notify };
+  // An unknown delivery check rereads the conversation. A receipt confirmed
+  // before the server serves that read would settle it from canonical history.
+  const inspectionReread = id => expect.poll(async () => {
+    const { requests } = await state();
+    const inspection = requests.findLastIndex(request => request.id === id && request.suffix.endsWith("/inspect"));
+    return inspection >= 0 && requests.slice(inspection + 1).some(request => request.method === "GET" && request.id === id && !request.suffix);
+  }).toBe(true);
+  return { page, primary, input, command, state, sent, notify, inspectionReread };
 }
 
 test("inspecting a restored no-admission request releases Send while preserving newer draft and uploads", options, async t => {
@@ -180,6 +187,142 @@ test("optional goal controls follow declared command semantics and budgets witho
   assert.equal((await f.sent()).length, 0, "Goal commands use the existing goal operation, not ordinary send");
 });
 
+test("a paused goal stays cancellable while a message is sending or its delivery is unknown", options, async t => {
+  const f = await fixture(t);
+  await f.command("goals", { id: "chat:1", budgets: false, commands: {
+    set: { delivery: "message", interruptsTurn: false }, resume: { delivery: "message", interruptsTurn: false },
+    pause: { delivery: "control", interruptsTurn: true }, cancel: { delivery: "message", interruptsTurn: true }
+  } });
+  await f.notify("chat:1");
+  const goals = async () => (await f.state()).requests.filter(request => request.suffix === "/goal" && request.method === "POST").map(request => request.input);
+  const pausedGoal = async objective => {
+    await f.primary.getByRole("button", { name: "Set goal", exact: true }).click();
+    await f.page.getByRole("textbox", { name: "Goal objective" }).fill(objective);
+    await f.page.getByRole("button", { name: "Start goal", exact: true }).click();
+    await f.primary.getByRole("button", { name: "Goal running", exact: true }).click();
+    await f.page.getByRole("button", { name: "Pause goal", exact: true }).click();
+    await expect(f.primary.getByRole("button", { name: "Goal paused", exact: true })).toBeVisible();
+    await f.page.keyboard.press("Escape");
+    await expect(f.page.getByRole("button", { name: "Resume goal", exact: true })).toHaveCount(0);
+  };
+  const cancelPausedGoal = async () => {
+    await f.primary.getByRole("button", { name: "Goal paused", exact: true }).click();
+    await expect(f.page.getByRole("button", { name: "Resume goal", exact: true })).toBeDisabled();
+    const cancel = f.page.getByRole("button", { name: "Cancel goal", exact: true });
+    await expect(cancel).toBeEnabled();
+    await cancel.click();
+    await expect(f.primary.getByRole("button", { name: "Set goal", exact: true })).toBeVisible();
+    await f.page.keyboard.press("Escape");
+    await expect(f.page.getByRole("textbox", { name: "Goal objective" })).toHaveCount(0);
+    const sent = await goals();
+    assert.equal(sent.at(-1).action, "cancel");
+    assert.ok(sent.at(-1).messageId, "A message-delivered Cancel keeps its receipt identity");
+    assert.equal(sent.at(-1).expectedGoalId, sent.at(-2).expectedGoalId);
+  };
+
+  await pausedGoal("Finish while a message is sending");
+  await f.command("mode", { mode: "hold" });
+  await f.input.fill("Still sending");
+  await f.input.press("Enter");
+  await expect.poll(async () => (await f.state()).held).toBe(1);
+  await f.command("mode", { mode: "accepted" });
+  await cancelPausedGoal();
+  assert.equal((await f.state()).held, 1, "Cancel did not wait for the message still sending");
+  await f.command("accept");
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().delivery.state.sending)).toBe(false);
+
+  await pausedGoal("Finish while a delivery is unknown");
+  await f.command("mode", { mode: "uncertain" });
+  await f.input.fill("Deslop");
+  await f.input.press("Enter");
+  await expect(f.primary.getByRole("button", { name: "Retry delivery check", exact: true })).toBeVisible();
+  await f.command("mode", { mode: "accepted" });
+  await cancelPausedGoal();
+  assert.deepEqual((await goals()).map(command => command.action), ["set", "pause", "cancel", "set", "pause", "cancel"]);
+});
+
+test("Cancel ends a running delivery check, keeps the message until the server agrees and retries after the server was unreachable", options, async t => {
+  const f = await fixture(t);
+  await f.command("mode", { mode: "uncertain" });
+  await f.input.fill("Say OK and just that");
+  await f.input.press("Enter");
+  const check = f.primary.getByRole("button", { name: "Retry delivery check", exact: true });
+  await expect(check).toBeVisible();
+  const [original] = await f.sent();
+  const message = f.primary.getByText("Say OK and just that", { exact: true });
+  const cancelling = f.primary.getByRole("status").filter({ hasText: "Cancelling…" });
+  const cancel = f.primary.getByRole("button", { name: "Cancel", exact: true });
+  const cancels = async () => (await f.state()).requests.filter(request => request.suffix.endsWith("/cancel")).length;
+
+  // The server cannot be reached: the message stays, with Cancel again.
+  await f.page.route("**/deliveries/*/cancel", route => route.abort("internetdisconnected"));
+  const result = await f.page.evaluate(async messageId => {
+    const runtime = window.conversationFixture.current();
+    const checking = runtime.inspectDelivery(messageId);
+    const wasChecking = runtime.delivery.find(messageId)?.checking === true;
+    const cancelled = runtime.cancelMessage(messageId);
+    const whileWaiting = runtime.delivery.find(messageId)?.cancelling === true;
+    return { wasChecking, whileWaiting, receipt: await checking, cancelled: await cancelled };
+  }, original.input.messageId);
+  assert.deepEqual(result, { wasChecking: true, whileWaiting: true, receipt: false, cancelled: false });
+  await expect(f.primary.getByText("Couldn't reach the server — Cancel again", { exact: true })).toBeVisible();
+  await expect(message).toBeVisible();
+  await expect(cancel).toBeEnabled();
+  await f.page.unroute("**/deliveries/*/cancel");
+
+  // Reconnecting retries the cancel; the message stays, cancelling, until the
+  // server answers, and an unconfirmed snapshot meanwhile does not change that.
+  await f.command("hold-cancels", { hold: true });
+  await f.notify("chat:1");
+  await expect(cancelling).toBeVisible();
+  await expect.poll(cancels).toBe(1);
+  await expect(message).toBeVisible();
+  assert.equal((await f.state()).states["chat:1"].pendingRequest.messageId, original.input.messageId);
+  await f.command("answer-cancels");
+  await expect(message).toHaveCount(0);
+  await expect(check).toHaveCount(0);
+
+  // The server dropped the request, so neither a snapshot nor a reload brings it back.
+  assert.equal((await f.state()).states["chat:1"].pendingRequest, null);
+  await f.notify("chat:1");
+  await f.page.reload();
+  await expect(f.input).toBeEnabled();
+  await expect(message).toHaveCount(0);
+  assert.equal(await cancels(), 1);
+});
+
+test("a Cancel the server never received is retried after a page reload", options, async t => {
+  const f = await fixture(t);
+  const attach = async () => {
+    await f.page.evaluate(() => {
+      window.savedBinding = window.conversationFixture.acquireConversation({
+        conversationId: "chat:2", draftStorage: { storage: sessionStorage, key: "unfinished-cancel" }
+      });
+      window.conversationFixture.target("chat:2");
+    });
+    await expect.poll(() => f.page.evaluate(() => window.savedBinding.runtime.value?.available.value)).toBe(true);
+  };
+  await attach();
+  await f.command("mode", { mode: "uncertain" });
+  await f.input.fill("Cancel me across a reload");
+  await f.input.press("Enter");
+  await expect(f.primary.getByRole("button", { name: "Retry delivery check", exact: true })).toBeVisible();
+  await f.page.route("**/deliveries/*/cancel", route => route.abort("internetdisconnected"));
+  await f.primary.getByRole("button", { name: "Cancel", exact: true }).click();
+  await expect(f.primary.getByText("Couldn't reach the server — Cancel again", { exact: true })).toBeVisible();
+  await f.page.unroute("**/deliveries/*/cancel");
+  await f.command("hold-cancels", { hold: true });
+  await f.page.reload();
+  await attach();
+  const message = f.primary.getByText("Cancel me across a reload", { exact: true });
+  await expect(f.primary.getByRole("status").filter({ hasText: "Cancelling…" })).toBeVisible();
+  await expect(message).toBeVisible();
+  await f.command("answer-cancels");
+  await expect(message).toHaveCount(0);
+  const cancels = (await f.state()).requests.filter(request => request.suffix.endsWith("/cancel"));
+  assert.deepEqual(cancels.map(request => request.id), ["chat:2"]);
+});
+
 test("the first native goal preserves absent identity and later controls capture its actual thread", options, async t => {
   const f = await fixture(t);
   await f.input.fill("Keep this ordinary draft");
@@ -413,6 +556,7 @@ test("explicit delivery inspection acknowledges uncertain attachments without cl
   await check.click();
   await expect(check).toBeVisible();
   assert.deepEqual((await attachments()).acknowledged, [], "An unknown receipt does not accept the upload");
+  await f.inspectionReread("chat:1");
   await f.command("confirm", { id: "chat:1" });
   await check.click();
   await expect(check).toHaveCount(0);
@@ -639,7 +783,9 @@ test("canonical receipts settle a held response and uncertain delivery stays ins
   const check = f.primary.getByRole("button", { name: "Retry delivery check", exact: true });
   await expect(check).toBeVisible();
   await expect(f.primary.getByText("Keep this exact uncertain request", { exact: true })).toHaveCount(1);
-  await expect(f.primary.getByRole("button", { name: /^(Retry|Edit|Cancel)$/u })).toHaveCount(0);
+  // Never resent or edited while unknown; only the server's Cancel is offered.
+  await expect(f.primary.getByRole("button", { name: /^(Retry|Edit)$/u })).toHaveCount(0);
+  await expect(f.primary.getByRole("button", { name: "Cancel", exact: true })).toBeEnabled();
   const checkBox = await check.boundingBox();
   assert.ok(checkBox.width >= 48 && checkBox.height >= 48);
   await f.input.fill("Preserve the newer draft");
@@ -731,7 +877,17 @@ for (const status of ["uncertain", "pending", "accepted", "failed", "unrecognise
     assert.equal(restored.id, saved.messages[0].id);
     assert.deepEqual(restored.payload, saved.messages[0].payload);
     assert.equal((await f.sent()).length, 1, "restoration never dispatches a saved request");
-    assert.equal(await f.page.evaluate(() => window.savedBinding.runtime.value.canSubmit.value), !unconfirmed);
+    // The server is ready, so a different authored draft may proceed; only the
+    // restored uncertain words themselves stay blocked until inspection settles them.
+    assert.equal(await f.page.evaluate(() => window.savedBinding.runtime.value.canSubmit.value), true);
+    if (unconfirmed) {
+      assert.equal(await f.page.evaluate(() => {
+        const runtime = window.savedBinding.runtime.value;
+        runtime.draft.value = "Exact original saved words";
+        return runtime.canSubmit.value;
+      }), false, "the uncertain request's own words cannot be sent again");
+      await f.page.evaluate(draft => { window.savedBinding.runtime.value.draft.value = draft; }, saved.draft);
+    }
     if (unconfirmed) {
       const check = f.primary.getByRole("button", { name: "Retry delivery check", exact: true });
       try { await expect(check).toBeEnabled(); }
@@ -746,9 +902,9 @@ for (const status of ["uncertain", "pending", "accepted", "failed", "unrecognise
         await f.page.screenshot({ path: `/tmp/jskit-saved-delivery-reload-${status}-20261006.png` });
         throw failure;
       }
-      for (const action of ["Retry", "Cancel", "Edit"]) {
-        await expect(f.primary.getByRole("button", { name: action, exact: true })).toHaveCount(0);
-      }
+      // Never resent or edited while unknown; only the server's Cancel is offered.
+      await expect(f.primary.getByRole("button", { name: /^(Retry|Edit)$/u })).toHaveCount(0);
+      await expect(f.primary.getByRole("button", { name: "Cancel", exact: true })).toBeEnabled();
       // The fixture's original inspector matches any same-ID row. Keep the
       // nonreceipt projection proof above, then inspect genuine absence.
       await f.command("history", { id: "chat:2", turns: [], limit: 20 });
@@ -833,7 +989,7 @@ test("a finished-turn error without a definite rejection status remains uncertai
   assert.equal((await f.sent()).length, 1);
 });
 
-for (const code of ["ACTION_VALIDATION_FAILED", "conversation_not_steerable"]) {
+for (const code of ["ACTION_VALIDATION_FAILED", "conversation_not_steerable", "conversation_message_cancelled"]) {
 test(`an explicit pre-admission rejection retains original retry identity and the newer draft: ${code}`, options, async t => {
   const f = await fixture(t);
   await f.command("mode", { mode: "rejected" });
@@ -842,6 +998,8 @@ test(`an explicit pre-admission rejection retains original retry identity and th
     await f.command("question", { id: "chat:1", text: "An earlier answer is still finishing.", pending: true });
     await f.notify("chat:1");
     await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().steerable.value)).toBe(true);
+  }
+  if (code !== "ACTION_VALIDATION_FAILED") {
     await f.page.route("**/messages", async route => {
       const response = await route.fetch();
       await route.fulfill(response.status() === 400
@@ -887,7 +1045,8 @@ test(`an explicit pre-admission rejection retains original retry identity and th
       await f.input.fill("Keep my newer draft");
       await f.primary.getByRole("button", { name: action, exact: true }).click();
       await expect(f.primary.getByText("Failed: The message was rejected before admission.", { exact: true })).toHaveCount(0);
-      assert.equal(await f.page.evaluate(id => window.conversationFixture.current().delivery.find(id), request.input.messageId), null);
+      // Cancel removes the message once the server agrees.
+      await expect.poll(() => f.page.evaluate(id => window.conversationFixture.current().delivery.find(id), request.input.messageId)).toBe(null);
       await expect(f.input).toHaveValue(action === "Edit" ? `${text}\n\nKeep my newer draft` : "Keep my newer draft");
     }
     assert.equal((await f.sent()).length, 4, "Cancel and Edit do not dispatch another prompt");
@@ -1557,13 +1716,18 @@ test("a voice preview cannot acknowledge sending or uncertain delivery and dedup
   const second = (await f.sent())[1].input.messageId;
   await preview(second, "An uncertain preview is not an acknowledgement.");
   await expect(f.primary.getByText("An uncertain preview is not an acknowledgement.", { exact: true })).toHaveCount(0);
-  await expect(f.primary.getByText("Vibe64", { exact: true })).toBeVisible();
+  // The uncertain notice stays attached to the user's own bubble, not a system row.
+  const uncertainBubble = f.primary.locator(".assistant-transcript__message--user").filter({ hasText: "Keep this uncertain request." });
+  await expect(uncertainBubble.locator(".assistant-transcript__optimistic-failure")).toBeVisible();
+  await expect(uncertainBubble.getByRole("button", { name: "Retry delivery check", exact: true })).toBeVisible();
+  await expect(f.primary.locator(".assistant-transcript__system")).toHaveCount(0);
   assert.deepEqual((await delivery()).messages, [{ id: second, status: "uncertain" }]);
   assert.equal((await delivery()).history.length, 1);
   await check.click();
   await expect(check).toBeEnabled();
   assert.deepEqual((await delivery()).messages, [{ id: second, status: "uncertain" }]);
   await expect(f.input).toHaveValue("Keep this uncertain request.");
+  await f.inspectionReread("chat:1");
   await f.command("confirm", { id: "chat:1" });
   await check.click();
   await expect(check).toHaveCount(0);
@@ -2311,6 +2475,50 @@ test("prepared binding preserves retry identity, newer composer input and inspec
   assert.deepEqual(await f.page.evaluate(() => window.taskClearedFiles), [["original-file"]]);
 });
 
+test("prepared Retry sends an uncertain message again only after the server proves it was never sent", options, async t => {
+  const f = await fixture(t);
+  await f.page.evaluate(() => {
+    window.provenBinding = window.conversationFixture.acquireConversation({ conversationId: "chat:3", active: false });
+    window.provenReader = window.conversationFixture.acquireConversation({ conversationId: "chat:3" });
+  });
+  await expect.poll(() => f.page.evaluate(() => window.provenReader.runtime.value.available.value)).toBe(true);
+  await f.command("mode", { mode: "uncertain" });
+  const uncertain = await f.page.evaluate(() => window.provenBinding.submitPrepared({ message: "Send me once." },
+    { messageId: "proven-retry", prepare: captured => captured.request }));
+  assert.equal(uncertain.status, "uncertain");
+  assert.equal((await f.sent()).length, 1);
+  // An unknown receipt still never resends.
+  const unknown = await f.page.evaluate(() => window.provenBinding.submitPrepared({ message: "Do not recapture." },
+    { retryMessageId: "proven-retry", prepare: captured => captured.request }));
+  assert.equal(unknown.status, "uncertain");
+  assert.equal((await f.sent()).length, 1);
+  await f.command("mode", { mode: "not-sent" });
+  // Hold the resend until a read after the not-sent proof has arrived: the
+  // proven request is saved as unattempted, so it no longer reads as unconfirmed.
+  const sendGate = Promise.withResolvers();
+  t.after(() => sendGate.resolve());
+  let sendHeld = false;
+  await f.page.route("**/messages", async route => {
+    sendHeld = true;
+    await sendGate.promise;
+    await route.continue().catch(() => {});
+  });
+  const retrying = f.page.evaluate(() => window.provenBinding.submitPrepared({ message: "Do not recapture." },
+    { retryMessageId: "proven-retry", prepare: captured => captured.request }));
+  await expect.poll(() => sendHeld).toBe(true);
+  await f.page.evaluate(() => window.provenBinding.runtime.value.reload());
+  sendGate.resolve();
+  const retried = await retrying;
+  await f.page.unroute("**/messages");
+  // Acceptance is the HTTP receipt or the canonical row, whichever arrives first.
+  assert.ok(retried && retried.ok !== false, JSON.stringify(retried));
+  const sent = await f.sent();
+  assert.equal(sent.length, 2);
+  assert.equal(sent[1].input.messageId, "proven-retry");
+  assert.equal(sent[1].input.text, "Send me once.");
+  assert.equal(await f.page.evaluate(() => window.provenBinding.runtime.value.delivery.find("proven-retry")?.status ?? "accepted"), "accepted");
+});
+
 test("acceptance settles a voice-retained conversation after its text view retargets without clearing the next composer", options, async t => {
   const f = await fixture(t, 1280, { acceptedDraft: true });
   await f.page.evaluate(() => window.conversationFixture.attachments(true));
@@ -2366,7 +2574,8 @@ test("transient subscription errors keep loaded history and recover through the
     user: { messageId: `question-${index}`, role: "user", text: `Private saved question ${index}. ` + "Keep the original discussion. ".repeat(8) },
     assistant: { messageId: `answer-${index}`, role: "assistant", text: `Private saved answer ${index}. ` + "Read the saved answer without losing your place. ".repeat(8) }
   }));
-  await f.command("history", { id: "chat:1", turns, limit: 30 });
+  // History pages count real messages: load all 30 turns' questions and answers.
+  await f.command("history", { id: "chat:1", turns, limit: turns.length * 2 });
   await f.notify("chat:1");
   const body = f.primary.locator(".assistant-transcript__body");
   await expect(body.locator(".assistant-transcript__turn")).toHaveCount(turns.length * 2);
@@ -2472,7 +2681,25 @@ for (const width of [390, 768, 1280]) {
     await body.hover();
     await f.page.mouse.wheel(0, -300);
     await expect.poll(() => body.evaluate(element => element.scrollTop)).toBeLessThan(previousScroll);
-    await body.evaluate(element => { window.atomicHistoryBody = element; element.scrollTop = 420; });
+    // The reader looks at question 13. The refresh removes saved turns 7 and 10
+    // and shortens answer 11 above it, so the reader's rows must stay where they
+    // are on screen, whatever scrollTop that takes at this width.
+    const reader = body.locator(".assistant-transcript__turn").filter({ hasText: "Atomic saved question 13." });
+    await reader.evaluate(row => {
+      const scroller = row.closest(".assistant-transcript__body");
+      window.atomicHistoryBody = scroller;
+      scroller.scrollTop += row.getBoundingClientRect().top - scroller.getBoundingClientRect().top;
+    });
+    // Rows near the new position replace their size estimates on later frames.
+    const readerTop = () => reader.evaluate(async row => {
+      const scroller = row.closest(".assistant-transcript__body");
+      const top = () => row.getBoundingClientRect().top - scroller.getBoundingClientRect().top;
+      const before = [top(), scroller.scrollTop];
+      await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+      return before[0] === top() && before[1] === scroller.scrollTop ? Math.round(top()) : NaN;
+    });
+    await expect.poll(readerTop).not.toBeNaN();
+    const readerOffset = await readerTop();
     await f.input.fill("Unsent while history refreshes");
     await f.input.evaluate(element => { element.focus({ preventScroll: true }); element.setSelectionRange(3, 8); });
     const previousIds = turns.slice(6).map(turn => turn.turnId);
@@ -2494,7 +2721,7 @@ for (const width of [390, 768, 1280]) {
     await expect.poll(() => Boolean(release)).toBe(true);
     assert.deepEqual(await f.page.evaluate(() => window.conversationFixture.current().turns.value.map(turn => turn.turnId)), previousIds);
     assert.equal(await body.evaluate(element => element === window.atomicHistoryBody), true);
-    await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+    await expect.poll(async () => Math.abs(await readerTop() - readerOffset)).toBeLessThanOrEqual(1);
     await expect(f.input).toHaveValue("Unsent while history refreshes");
     await expect(f.input).toBeFocused();
     assert.deepEqual(await f.input.evaluate(element => [element.selectionStart, element.selectionEnd]), [3, 8]);
@@ -2505,7 +2732,7 @@ for (const width of [390, 768, 1280]) {
     await expect(f.primary.getByText("Authoritatively replaced saved answer", { exact: true })).toHaveCount(1);
     await expect(f.primary.getByText(/Atomic saved question (7|10)\./)).toHaveCount(0);
     assert.equal(await body.evaluate(element => element === window.atomicHistoryBody), true);
-    await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+    await expect.poll(async () => Math.abs(await readerTop() - readerOffset)).toBeLessThanOrEqual(1);
     await expect(f.input).toHaveValue("Unsent while history refreshes");
     await expect(f.input).toBeFocused();
     assert.deepEqual(await f.input.evaluate(element => [element.selectionStart, element.selectionEnd]), [3, 8]);