@jskit-ai/assistant-runtime 0.2.2 → 0.2.3

package/fixtures/canonical-conversation/vite.config.mjs

@@ -9,7 +9,7 @@ export default defineConfig({
   plugins: [vue(), {
     name: "controlled-canonical-assistant-api",
     configureServer(server) {
-      let states, requests, held, mode, denied;
+      let states, requests, held, mode, denied, holdCancels, heldCancels;
       const pageLimits = new Map();
       // Exercise the existing page reader over this fixture's controlled rows.
       const transcript = createConversationTranscript({ storage: {
@@ -27,6 +27,7 @@ export default defineConfig({
             streaming: { revision: 0, messages: [] }, capabilities: { steering: false, goals: false, attachments: true } }];
         }));
         requests = []; held = []; mode = "accepted"; denied = false; pageLimits.clear();
+        holdCancels = false; heldCancels = [];
       }
       reset();
       function accept(state, input) {
@@ -60,6 +61,8 @@ export default defineConfig({
         if (url.pathname === "/fixture/reset") { reset(); return json({ ok: true }); }
         if (url.pathname === "/fixture/state") return json({ requests, states: Object.fromEntries(states), held: held.length });
         if (url.pathname === "/fixture/mode") { mode = input.mode; return json({ ok: true }); }
+        if (url.pathname === "/fixture/hold-cancels") { holdCancels = input.hold; return json({ ok: true }); }
+        if (url.pathname === "/fixture/answer-cancels") { for (const agree of heldCancels.splice(0)) agree(); return json({ ok: true }); }
         if (url.pathname === "/fixture/deny") { denied = input.denied; return json({ ok: true }); }
         if (url.pathname === "/fixture/error") { states.get(input.id).error = input.error; return json({ ok: true }); }
         if (url.pathname === "/fixture/interim-reply") { states.get(input.id).interimReply = input.reply; return json({ ok: true }); }
@@ -168,10 +171,27 @@ export default defineConfig({
           return json(accept(state, input), 202);
         }
         if (match[2] === "/cancel") { state.status = "ready"; return json({ stopped: true }); }
+        // The server always records a cancel and drops the unconfirmed request.
+        if (match[2].startsWith("/deliveries/") && match[2].endsWith("/cancel")) {
+          const messageId = decodeURIComponent(match[2].split("/")[2]);
+          const agree = () => {
+            state.cancelled = [...state.cancelled || [], messageId];
+            if (state.pendingRequest?.messageId === messageId) { state.pendingRequest = null; state.status = "ready"; }
+            json({ ok: true, cancelled: true, messageId });
+          };
+          if (holdCancels) heldCancels.push(agree);
+          else agree();
+          return;
+        }
         if (match[2].startsWith("/deliveries/") && match[2].endsWith("/inspect")) {
           const messageId = decodeURIComponent(match[2].split("/")[2]);
+          if (state.cancelled?.includes(messageId)) return json({ status: "cancelled", messageId });
           const receipt = state.conversationLog.find(turn => turn.user?.messageId === messageId);
-          if (!receipt && mode === "not-sent") return json({ status: "not-sent", messageId, error: "This message was not sent. Review it before sending a new message." });
+          if (!receipt && mode === "not-sent") {
+            // Like the runtime, record the proven request as unattempted: reads stop reporting it unconfirmed.
+            if (state.pendingRequest?.messageId === messageId) Object.assign(state, { status: "ready", pendingRequest: null });
+            return json({ status: "not-sent", messageId, error: "This message was not sent. Review it before sending a new message." });
+          }
           return json(receipt ? { status: "accepted", messageId, turnId: receipt.turnId } : { status: "unknown", messageId });
         }
         return json({ error: "Unknown fixture operation" }, 404);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -13,19 +13,19 @@
     "./locales/en.json": "./locales/en.json"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.2",
+    "@jskit-ai/assistant-core": "0.2.3",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.2.0",
-    "@jskit-ai/http-web": "0.2.1",
-    "@jskit-ai/kernel": "0.2.0",
-    "@jskit-ai/realtime": "0.2.0",
-    "@jskit-ai/shell-web": "0.2.0",
+    "@jskit-ai/http-runtime": "0.2.1",
+    "@jskit-ai/http-web": "0.2.2",
+    "@jskit-ai/kernel": "0.2.1",
+    "@jskit-ai/realtime": "0.2.1",
+    "@jskit-ai/shell-web": "0.2.1",
     "@tanstack/vue-query": "^5.90.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/database-runtime": "0.1.249"
+    "@jskit-ai/database-runtime": "0.1.250"
   },
   "description": "Capability-based assistant runtime with per-surface chat, transcripts, settings, and action tools.",
   "jskit": {

package/src/client/composables/useAssistantConversation.js

@@ -42,7 +42,8 @@ function configureAssistantConversations(app, { actorKey, api = null, request, c
 // occur after dispatch and must retain an uncertain receipt.
 const SEND_REJECTIONS = new Set([
   "ACTION_VALIDATION_FAILED", "ACTION_PERMISSION_DENIED", "ACTION_SURFACE_FORBIDDEN",
-  "conversation_invalid_message", "conversation_busy", "conversation_not_steerable", "conversation_invalid_goal", "conversation_goal_changed"
+  "conversation_invalid_message", "conversation_busy", "conversation_not_steerable", "conversation_invalid_goal", "conversation_goal_changed",
+  "conversation_message_cancelled"
 ]);
 
 function isQuestionConfiguration(value) {
@@ -116,6 +117,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   const accessDenied = ref(false);
   const delivery = createAssistantMessageDelivery();
   const pendingMessages = new Map();
+  const deliveryChecks = new Map();
   const olderPages = ref([]);
   let historyRevision = 0;
   let deniedHistoryRevision = 0;
@@ -158,10 +160,14 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       typeof message.payload?.message === "string") : [];
     const restoredMessages = messages.filter(message => !delivery.find(message.id)).map(message => {
       const status = ["failed", "accepted"].includes(message.status) ? message.status : "uncertain";
-      return { ...message, status, checking: false, error: message.error || (status === "accepted" ? "" :
+      return { ...message, status, checking: false, cancelling: false, error: message.error || (status === "accepted" ? "" :
         t("jskit.assistant.runtime.delivery.unconfirmedBeforeClose")) };
     });
     delivery.state.messages = unmatchedOptimisticMessages(turns.value, [...delivery.state.messages, ...restoredMessages], { receiptsOnly: true });
+    // A cancel the server had not agreed to before this page closed is retried.
+    for (const message of messages) {
+      if (message.cancelling || message.cancelError) delivery.cancelFailed(message.id, message.cancelError);
+    }
   } catch {
     draft.value = "";
     draftAttachments.value = [];
@@ -239,6 +245,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     accessDenied.value = false;
     delivery.reconcile(state.turns);
     if (state.status === "unconfirmed" && state.pendingRequest) delivery.restoreUncertain(state.pendingRequest, state.turns);
+    retryCancels();
     if (state.segmentId !== goalSegment) {
       // Keep the open goal menu while its first native identity arrives. The
       // pending read disables commands until it supplies the new exact target.
@@ -374,6 +381,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     stopPlacement();
     for (const pending of pendingMessages.values()) pending.controller.abort();
     pendingMessages.clear();
+    for (const check of deliveryChecks.values()) check.abort();
     goalReadController?.abort();
     delivery.reset();
   });
@@ -561,11 +569,32 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       if (current.value) subscription?.reload();
     }
   }
-  function cancelMessage(messageId) {
-    const pending = pendingMessages.get(messageId);
-    if (!pending) return false;
-    pending.controller.abort();
-    return true;
+  // Cancel means cancel, and the server decides. Cancel ends the message's
+  // unsent request and running delivery check, then asks the server, which
+  // always records the cancel. The message stays, shown as cancelling, until
+  // the server agrees; when the server cannot be reached it stays with Cancel
+  // again, and the next snapshot after reconnecting retries it.
+  async function cancelMessage(messageId) {
+    pendingMessages.get(messageId)?.controller.abort();
+    deliveryChecks.get(messageId)?.abort();
+    if (!available.value || !delivery.cancel(messageId)) return false;
+    try {
+      const result = await api.cancelConversationDelivery(identity.conversationId, messageId);
+      if (result?.ok === false) throw Object.assign(new Error(resultError(result)), { status: 409 });
+      if (!current.value) return false;
+      delivery.remove(messageId);
+      subscription?.reload();
+      return true;
+    } catch (failure) {
+      // The server's own refusal names itself; anything else did not reach it.
+      if (current.value) delivery.cancelFailed(messageId, Number.isInteger(failure?.status) && failure.status > 0 ? failureMessage(failure) : "");
+      return false;
+    }
+  }
+  function retryCancels() {
+    for (const message of delivery.state.messages) {
+      if (message.cancelError && !message.cancelling) void cancelMessage(message.id);
+    }
   }
 
   // The original history control keeps older pages separate from the live page.
@@ -653,14 +682,18 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     const view = goalView.value;
     const target = view?.target;
     const command = target?.capabilities?.goalCommands?.[action];
+    // Pause and Cancel never depend on chat delivery: each is pinned to the goal
+    // it stops and goes straight to the goal operation, even while a message is
+    // sending or its receipt is unknown. Set and Resume wait for those.
+    const stopping = action === "pause" || action === "cancel";
     if (!available.value || view?.status !== "available" || goalLoadError.value || goalAction.value || !goalTargetCurrent.value ||
         !["message", "control"].includes(command?.delivery) ||
-        delivery.state.messages.some(message => message.status === "uncertain")) return false;
+        !stopping && delivery.state.messages.some(message => message.status === "uncertain")) return false;
     if (input.tokenBudget != null && !target.capabilities.goalBudgets) {
       goalError.value = t("jskit.assistant.runtime.goal.budgetsUnsupported");
       return false;
     }
-    const retry = delivery.find(messageId);
+    const retry = stopping ? null : delivery.find(messageId);
     if (retry && retry.status !== "failed") return false;
     const request = retry?.payload.goalRequest || { action, expectedSegmentId: target.segmentId,
       expectedGoalId: view.goal?.id || null,
@@ -669,7 +702,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     goalAction.value = action;
     goalError.value = "";
     try {
-      if (retry || command.delivery === "message") {
+      if (retry || !stopping && command.delivery === "message") {
         const result = await submitRequest(retry?.payload || {
           message: action === "set" ? request.objective
             : t(action === "resume" ? "jskit.assistant.runtime.goal.resumeMessage" : "jskit.assistant.runtime.goal.cancelMessage"),
@@ -683,7 +716,8 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
         }
         return result;
       }
-      const result = await api.updateConversationGoal(identity.conversationId, request);
+      const result = await api.updateConversationGoal(identity.conversationId,
+        command.delivery === "message" ? { ...request, messageId } : request);
       if (result?.ok === false) throw new Error(resultError(result) || t("jskit.assistant.runtime.goal.changeFailed"));
       return result;
     } catch (failure) {
@@ -719,6 +753,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
         sampledAt: Date.parse(view.goal.updatedAt) } : null,
       pending: Boolean(goalAction.value) || !goalAvailable || !available.value || delivery.state.sending ||
         delivery.state.messages.some(message => message.status === "uncertain"),
+      stopPending: Boolean(goalAction.value) || !goalAvailable || !available.value,
       error: goalError.value || goalLoadError.value || view?.error || "",
       pauseInterruptsTurn: commands.pause?.interruptsTurn === true,
       cancelInterruptsTurn: commands.cancel?.interruptsTurn === true,
@@ -740,14 +775,18 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     if (!available.value) return false;
     const message = delivery.find(messageId);
     if (message?.checking) return false;
+    const check = new AbortController();
+    deliveryChecks.set(messageId, check);
     if (message) message.checking = true;
     try {
-      const receipt = await api.inspectConversationDelivery(identity.conversationId, messageId);
-      if (!current.value) return false;
+      const receipt = await api.inspectConversationDelivery(identity.conversationId, messageId, { signal: check.signal });
+      if (!current.value || check.signal.aborted) return false;
       if (receipt.status === "accepted") {
         delivery.accept(messageId);
         if (receipt.messageId === messageId && message?.payload.goalRequest) goalError.value = "";
       }
+      // The server recorded this message as cancelled, perhaps from another tab.
+      else if (receipt.status === "cancelled" && receipt.messageId === messageId) delivery.remove(messageId);
       else if (receipt.status === "not-sent" && receipt.messageId === messageId) delivery.rejectUnsent(messageId, resultError(receipt));
       else if (receipt.status === "unknown" && message?.status === "uncertain") {
         message.error = t("jskit.assistant.runtime.delivery.stillUnknown");
@@ -755,11 +794,15 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       subscription?.reload();
       return receipt;
     } catch (failure) {
+      if (check.signal.aborted) return false;
       if (current.value && message?.status === "uncertain") message.error = failureMessage(failure, t("jskit.assistant.runtime.delivery.checkFailed"));
       receiveError(failure);
       return false;
     }
-    finally { if (message) message.checking = false; }
+    finally {
+      if (deliveryChecks.get(messageId) === check) deliveryChecks.delete(messageId);
+      if (message) message.checking = false;
+    }
   }
 
   const runtime = { identity, current, active, editable, available, canSubmit, steerable, queueWhileSending: queueing,
@@ -1054,6 +1097,8 @@ function createConversationBinding({ conversationId, endpoint = "", surfaceId =
         hasMoreBefore: current?.hasMoreBefore.value || false,
         loadingMore: current?.loadingMore.value || false, loadMoreError: current?.loadMoreError.value || "",
         loading: current?.loading.value || false, working: !current?.error.value && state?.status === "working" && !current.delivery.state.sending,
+        // The server cancels any unconfirmed message, so its Cancel is offered.
+        cancellableDelivery: true,
         assistantLabel: display.assistantLabel || t("jskit.assistant.runtime.conversation.assistantLabel"),
         welcomeMessage: display.welcomeMessage ?? t("jskit.assistant.runtime.conversation.welcomeMessage"),
         systemLabel: display.systemLabel, variant: display.variant, visible: display.visible, retainWhenHidden: display.retainWhenHidden,
@@ -1075,6 +1120,7 @@ function createConversationBinding({ conversationId, endpoint = "", surfaceId =
         else if (canDraftWhileLoading.value) initialDraft.value = value;
       }, submit,
         resend: messageId => submit({ retryMessageId: messageId }), stop: () => current?.cancel(),
+        cancel: messageId => current?.cancelMessage(messageId),
         checkDelivery: messageId => current?.inspectDelivery(messageId), loadMore: input => current?.loadMore(input), reload: () => current?.reload() }
     };
   });

package/src/server/actionIds.js

@@ -5,6 +5,7 @@ const actionIds = Object.freeze({
   conversationCancel: "assistant.conversation.cancel",
   conversationSubscribe: "assistant.conversation.subscribe",
   conversationInspectDelivery: "assistant.conversation.delivery.inspect",
+  conversationCancelDelivery: "assistant.conversation.delivery.cancel",
   conversationGoalRead: "assistant.conversation.goal.read",
   conversationGoalUpdate: "assistant.conversation.goal.update",
   conversationConfigure: "assistant.conversation.configure",

package/src/server/actions.js

@@ -225,6 +225,21 @@ function createConversationActions({ conversationRuntime, conversationDataSchema
         return conversation.inspectDelivery({ messageId: input.messageId });
       }
     },
+    {
+      id: actionIds.conversationCancelDelivery,
+      version: 1,
+      kind: "command",
+      channels: ["api", "internal"],
+      surfaces: runtimeSurfaces,
+      permission: { require: "authenticated" },
+      input: conversationInspectInputValidator,
+      output: null,
+      idempotency: "none",
+      async execute(input, context) {
+        const conversation = await openConversation(input, context);
+        return conversation.cancelDelivery({ messageId: input.messageId });
+      }
+    },
     {
       id: actionIds.conversationGoalRead,
       version: 1,

package/src/server/registerRoutes.js

@@ -385,6 +385,25 @@ function registerConversationRoutes(
     reply.code(200).send(response);
   });
 
+  router.register("POST", `${routeBase}/deliveries/:messageId/cancel`, {
+    auth: "required", visibility,
+    params: composeSchemaDefinitions([params, assistantConversationMessageIdInputValidator], {
+      mode: "patch", context: "assistant-runtime conversation delivery cancel route params"
+    }),
+    meta: { tags: ["assistant"], summary: "Cancel one unsent or unconfirmed assistant message." }
+  }, async function assistantConversationCancelDeliveryRoute(request, reply) {
+    const routeState = resolveRouteRequestState(request, {
+      resolveCurrentAppConfig, requiresWorkspace, workspaceScopeSupport
+    });
+    const response = await request.executeAction({
+      actionId: actionIds.conversationCancelDelivery,
+      surface: routeState.hostSurfaceId,
+      input: { ...routeState.actionInput, conversationId: request.input.params.conversationId,
+        messageId: request.input.params.messageId }
+    });
+    reply.code(200).send(response);
+  });
+
   for (const method of ["GET", "POST"]) {
     router.register(method, `${routeBase}/goal`, {
       auth: "required", visibility, params,

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);
@@ -2329,9 +2493,25 @@ test("prepared Retry sends an uncertain message again only after the server prov
   assert.equal(unknown.status, "uncertain");
   assert.equal((await f.sent()).length, 1);
   await f.command("mode", { mode: "not-sent" });
-  const retried = await f.page.evaluate(() => window.provenBinding.submitPrepared({ message: "Do not recapture." },
+  // 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 }));
-  assert.equal(retried.ok, true);
+  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");
@@ -2394,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);
@@ -2500,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);
@@ -2522,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]);
@@ -2533,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]);

package/test/assistantConversationOperations.test.js

@@ -36,12 +36,18 @@ async function fixture(t, { workspace = false, conversationDataSchema = null, ap
   const dispatched = [Promise.withResolvers(), Promise.withResolvers()];
   const scopeInputs = [];
   const knownIds = new Set(["chat:one", "chat:two"]);
-  const access = { allowed: true };
+  const access = { allowed: true, authorized: [], hold: null };
   const storage = createFileConversationStorage({ directory });
   const runtime = createConversationRuntime({
     storage,
-    authorize: ({ context: actor, conversationId }) => access.allowed && actor?.actor?.id === "owner" && knownIds.has(conversationId) &&
-      (!workspace || actor.workspace?.id === trustedWorkspace.id),
+    async authorize({ context: actor, conversationId, operation }) {
+      access.authorized.push(operation);
+      // A test can hold one operation's authorization, and with it the conversation queue.
+      const hold = access.hold?.operation === operation && access.hold;
+      if (hold) { access.hold = null; hold.entered.resolve(); await hold.release; }
+      return access.allowed && actor?.actor?.id === "owner" && knownIds.has(conversationId) &&
+        (!workspace || actor.workspace?.id === trustedWorkspace.id);
+    },
     connections: {
       async resolve({ context: actor }) {
         assert.equal(actor.actor.id, "owner");
@@ -215,9 +221,9 @@ test("file-backed conversation routes return admission receipts and cancel one c
   const f = await fixture(t);
   assert.deepEqual(f.catalogue.listDefinitions().map(({ id }) => id), [
     actionIds.conversationRead, actionIds.conversationSend, actionIds.conversationCancel, actionIds.conversationSubscribe,
-    actionIds.conversationInspectDelivery, actionIds.conversationGoalRead, actionIds.conversationGoalUpdate
+    actionIds.conversationInspectDelivery, actionIds.conversationCancelDelivery, actionIds.conversationGoalRead, actionIds.conversationGoalUpdate
   ]);
-  assert.equal(f.routes.length, 6, "A supplied runtime does not register the old chat or optional settings routes");
+  assert.equal(f.routes.length, 7, "A supplied runtime does not register the old chat or optional settings routes");
   const initial = await f.invoke("GET");
   assert.equal(initial.status, 200);
   assert.equal(initial.payload.id, "chat:one");
@@ -255,11 +261,62 @@ test("file-backed conversation routes return admission receipts and cancel one c
   assert.equal((await readdir(f.directory)).length, 2, "Only the host's two conversation records are persisted");
 });
 
+test("Cancel of one message stops its own submission and always answers", async t => {
+  const f = await fixture(t);
+  const first = await f.invoke("POST", "/messages", { body: { messageId: "first", text: "First question" } });
+  assert.equal(first.payload.status, "accepted");
+  await f.dispatched[0].promise;
+  const cancelled = await f.invoke("POST", "/deliveries/:messageId/cancel", { messageId: "first" });
+  assert.equal(cancelled.status, 200);
+  assert.deepEqual(cancelled.payload, { ok: true, cancelled: true, messageId: "first", interrupted: true });
+  assert.equal(f.requests[0].signal.aborted, true, "the turn this message started stops");
+  const never = await f.invoke("POST", "/deliveries/:messageId/cancel", { messageId: "never-sent" });
+  assert.deepEqual(never.payload, { ok: true, cancelled: true, messageId: "never-sent", interrupted: false });
+  assert.equal((await f.invoke("GET")).payload.status, "ready");
+  assert.equal(f.requests.length, 1, "Cancel never submits a model request");
+});
+
+test("Cancel answers while earlier work holds the conversation queue and the queued send is refused as not sent", async t => {
+  const f = await fixture(t);
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  f.access.hold = { operation: "inspectDelivery", entered, release: release.promise };
+  const inspecting = f.invoke("POST", "/deliveries/:messageId/inspect", { messageId: "earlier" });
+  inspecting.catch(() => {});
+  let sending;
+  let cancelling;
+  let timer;
+  try {
+    await entered.promise;
+    sending = f.invoke("POST", "/messages", { body: { messageId: "queued", text: "Queued question" } });
+    sending.catch(() => {});
+    // The send is authorized and waits in the queue behind the held inspection.
+    while (!f.access.authorized.includes("send")) await new Promise(resolve => setImmediate(resolve));
+    await new Promise(resolve => setImmediate(resolve));
+    cancelling = f.invoke("POST", "/deliveries/:messageId/cancel", { messageId: "queued" });
+    const answer = await Promise.race([cancelling,
+      new Promise(resolve => { timer = setTimeout(() => resolve(null), 2_000); })]);
+    assert.notEqual(answer, null, "Cancel answered while earlier work held the conversation queue");
+    assert.deepEqual(answer.payload, { ok: true, cancelled: true, messageId: "queued", interrupted: false });
+  } finally {
+    clearTimeout(timer);
+    release.resolve();
+  }
+  await inspecting.catch(() => {});
+  await cancelling;
+  await assert.rejects(sending, { code: "conversation_message_cancelled", statusCode: 409 });
+  await assert.rejects(f.invoke("POST", "/messages", { body: { messageId: "queued", text: "Queued question" } }),
+    { code: "conversation_message_cancelled" }, "a later send of the cancelled message is refused too");
+  assert.equal(f.requests.length, 0, "the cancelled message never reaches the model");
+  const next = await f.invoke("POST", "/messages", { body: { messageId: "next", text: "Next question" } });
+  assert.equal(next.payload.status, "accepted", "the conversation stays usable");
+});
+
 test("conversation routes keep authenticated ownership and reject unknown identities", async t => {
   const f = await fixture(t);
   const other = { ...f.context, actor: { id: "other-user" } };
   for (const [method, suffix] of [["GET", ""], ["POST", "/messages"], ["POST", "/cancel"],
-    ["POST", "/deliveries/:messageId/inspect"], ["GET", "/goal"], ["POST", "/goal"]]) {
+    ["POST", "/deliveries/:messageId/inspect"], ["POST", "/deliveries/:messageId/cancel"], ["GET", "/goal"], ["POST", "/goal"]]) {
     await assert.rejects(f.invoke(method, suffix, { actor: other, body: {
       action: "set", expectedSegmentId: "segment", objective: "A goal", messageId: "forged", text: "A forged request", actor: f.context.actor, context: f.context,
       host: { nativeTools: true }, configuration: { systemPrompt: "Override" }, engine: "codex"
@@ -296,7 +353,7 @@ test("workspace conversation actions use the host's resolved workspace and optio
   const options = { ...f.options, assistantConfigService: { getSettings() {}, updateSettings() {} } };
   assert.deepEqual(createAssistantActions(options).map(({ id }) => id), [
     actionIds.conversationRead, actionIds.conversationSend, actionIds.conversationCancel, actionIds.conversationSubscribe,
-    actionIds.conversationInspectDelivery, actionIds.conversationGoalRead, actionIds.conversationGoalUpdate,
+    actionIds.conversationInspectDelivery, actionIds.conversationCancelDelivery, actionIds.conversationGoalRead, actionIds.conversationGoalUpdate,
     actionIds.settingsRead, actionIds.settingsUpdate
   ]);
   const router = createRouter();
@@ -414,10 +471,10 @@ test("the supplied runtime route/action path imports without SQL or the old chat
     const { registerRoutes } = await import(${JSON.stringify(new URL("../src/server/registerRoutes.js", import.meta.url).href)});
     const conversationRuntime = { async open() { throw new Error("Registration cannot open conversations."); } };
     const options = { config: ${JSON.stringify(config)}, conversationRuntime };
-    assert.equal(createAssistantActions(options).length, 7);
+    assert.equal(createAssistantActions(options).length, 8);
     const routes = [];
     registerRoutes({ register(...args) { routes.push(args); } }, options);
-    assert.equal(routes.length, 6);
+    assert.equal(routes.length, 7);
   `], { encoding: "utf8" });
   assert.equal(result.status, 0, result.stderr);
 });

package/test/assistantConversationSubscriptions.test.js

@@ -162,6 +162,9 @@ async function fixture(t, { diagnostics = false, onSetup } = {}) {
     stopSubscriptions();
     stopProbe();
     await transport.shutdown();
+    // Realtime closes only Socket.IO; the fixture owns its HTTP server.
+    http.closeAllConnections();
+    await new Promise((resolve) => http.close(resolve));
     await runtime.close();
     await rm(directory, { recursive: true, force: true });
   });
@@ -908,6 +911,8 @@ async function hostSubscriptionFixture(t, authService = null, conversationRuntim
     for (const client of clients) client.disconnect();
     release();
     await transport.shutdown();
+    http.closeAllConnections();
+    await new Promise((resolve) => http.close(resolve));
   });
   http.listen(0, "127.0.0.1");
   await once(http, "listening");

package/test/chatServiceLifecycle.test.js

@@ -73,7 +73,7 @@ async function* completionStream(completion = {}) {
   yield { choices: [{ delta: {}, finish_reason: completion.toolCall ? "tool_calls" : "stop" }] };
 }
 
-function createHarness(completions, { executeToolCall = null, tools: configuredTools = null, attachments, supportsAttachments = true } = {}) {
+function createHarness(completions, { executeToolCall = null, tools: configuredTools = null, attachments, supportsAttachments = true, wrapRuntime = (runtime) => runtime } = {}) {
   const pendingCompletions = [...completions];
   const completionRequests = [];
   const transcriptMessages = [];
@@ -165,7 +165,7 @@ function createHarness(completions, { executeToolCall = null, tools: configuredT
     ...createMemoryAssistantRows({ messages: transcriptMessages }),
     aiClientFactory: dependencies.aiClientFactory, toolCatalog: dependencies.serviceToolCatalog, attachments
   });
-  const chatService = createChatService({ ...dependencies, conversationRuntime });
+  const chatService = createChatService({ ...dependencies, conversationRuntime: wrapRuntime(conversationRuntime) });
 
   const streamWriter = {};
   for (const method of [
@@ -555,3 +555,49 @@ test("attachment identifiers use the conversation runtime's shape before any fil
   }
   assert.deepEqual(calls, []);
 });
+
+function countDisposals(runtime) {
+  const counts = { opened: 0, disposed: 0 };
+  return { counts, runtime: { ...runtime, async open(input) {
+    const handle = await runtime.open(input);
+    counts.opened += 1;
+    return { ...handle, async dispose(options) { counts.disposed += 1; return handle.dispose(options); } };
+  } } };
+}
+
+test("each settled turn releases its conversation, and a later turn opens it again", async () => {
+  const counted = {};
+  const harness = createHarness([textCompletion("First answer."), textCompletion("Second answer.")], {
+    wrapRuntime(runtime) { Object.assign(counted, countDisposals(runtime)); return counted.runtime; }
+  });
+
+  assert.equal((await harness.run("First question", { messageId: "message_1" })).status, "completed");
+  assert.deepEqual(counted.counts, { opened: 1, disposed: 1 }, "a finished turn keeps no runtime conversation open");
+  assert.equal((await harness.run("Second question", { messageId: "message_2" })).status, "completed");
+  assert.deepEqual(counted.counts, { opened: 2, disposed: 2 });
+  assert.deepEqual(assistantMessages(harness.streamEvents), ["First answer.", "Second answer."]);
+});
+
+test("a conversation stays open until the last of its overlapping turns settles", async () => {
+  const counted = {};
+  const firstChunk = Promise.withResolvers();
+  const continueResponse = Promise.withResolvers();
+  async function* held() {
+    yield { choices: [{ delta: { content: "Held answer." } }] };
+    firstChunk.resolve();
+    await continueResponse.promise;
+    yield { choices: [{ delta: {}, finish_reason: "stop" }] };
+  }
+  const harness = createHarness([held()], {
+    wrapRuntime(runtime) { Object.assign(counted, countDisposals(runtime)); return counted.runtime; }
+  });
+
+  const first = harness.run("First question", { messageId: "message_1" });
+  await firstChunk.promise;
+  // A second tab sends while the first answer is still running; the runtime refuses it.
+  assert.equal((await harness.run("Second question", { messageId: "message_2" })).status, "failed");
+  assert.equal(counted.counts.disposed, 0, "the refused turn must not close the conversation the first turn still uses");
+  continueResponse.resolve();
+  assert.equal((await first).status, "completed");
+  assert.deepEqual(counted.counts, { opened: 2, disposed: 1 });
+});

package/test/featureRuntime.test.js

@@ -229,11 +229,11 @@ test("one AssistantFeature composes host access and declared data while settings
   await host.start();
   try {
     assert.equal(registrations, 1);
-    assert.equal(wrapped.length, 10);
+    assert.equal(wrapped.length, 11);
     assert.ok(wrapped.includes(access.subscribeActionId));
     assert.ok(!wrapped.includes(actionIds.conversationSubscribe));
-    assert.equal(actions.listDefinitions().length, 12);
-    assert.equal(routes.length, 11);
+    assert.equal(actions.listDefinitions().length, 13);
+    assert.equal(routes.length, 12);
     assert.ok(routes.filter(route => route.path.endsWith("/settings")).every(route => route.contract.auth === "required"));
     assert.ok(routes.filter(route => !route.path.endsWith("/settings")).every(route => route.contract.auth === "public"));
     assert.equal(actions.getDefinition(actionIds.settingsRead).permission.require, "authenticated");