@jskit-ai/assistant-runtime 0.2.7 → 0.2.9

package/fixtures/canonical-conversation/App.vue

@@ -121,6 +121,8 @@ onMounted(() => {
   window.conversationFixture = {
     socket,
     acquireConversation,
+    // A reader's own visibility, as when an application hides a retained view.
+    activity(value) { return ref(value); },
     releaseFactory() { factoryScope.stop(); },
     target(id) { conversationId.value = id; },
     show(value) { visible.value = value; },

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

@@ -110,6 +110,12 @@ export default defineConfig({
           for (const pending of held.splice(0)) pending.respond(pending.receipt);
           return json({ ok: true });
         }
+        if (url.pathname === "/fixture/start-queued-goal") {
+          const state = states.get(input.id);
+          changeGoal(state, state.queuedGoal);
+          state.queuedGoal = null;
+          return json({ ok: true });
+        }
         if (url.pathname === "/fixture/finish") {
           const state = states.get(input.id);
           state.status = "ready";
@@ -145,6 +151,11 @@ export default defineConfig({
           }
           const receipt = command.delivery === "message" ? accept(state, { messageId: input.messageId,
             text: input.objective || (input.action === "resume" ? "Resume the goal." : "Cancel the goal.") }) : null;
+          // The command is accepted behind the running turn; its goal changes later.
+          if (receipt && mode === "queue-goal") {
+            state.queuedGoal = input;
+            return json(receipt);
+          }
           changeGoal(state, input);
           const result = receipt || state.goal || null;
           return json(result, result === null ? 204 : 200);

package/locales/en.json

@@ -74,6 +74,7 @@
         "goal": {
           "budgetsUnsupported": "This conversation does not support goal token budgets.",
           "changeFailed": "Could not change the goal.",
+          "notStarted": "The goal did not start. Check the chat before starting it again.",
           "unavailable": "Goal status is unavailable.",
           "resumeMessage": "Resume the goal.",
           "cancelMessage": "Cancel the goal."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "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.5",
+    "@jskit-ai/assistant-core": "0.2.7",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.2.2",
-    "@jskit-ai/http-web": "0.2.6",
-    "@jskit-ai/kernel": "0.2.2",
-    "@jskit-ai/realtime": "0.2.5",
-    "@jskit-ai/shell-web": "0.2.2",
+    "@jskit-ai/http-runtime": "0.2.3",
+    "@jskit-ai/http-web": "0.2.7",
+    "@jskit-ai/kernel": "0.2.3",
+    "@jskit-ai/realtime": "0.2.6",
+    "@jskit-ai/shell-web": "0.2.3",
     "@tanstack/vue-query": "^5.90.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/database-runtime": "0.1.251"
+    "@jskit-ai/database-runtime": "0.1.252"
   },
   "description": "Capability-based assistant runtime with per-surface chat, transcripts, settings, and action tools.",
   "jskit": {

package/src/client/composables/useAssistantConversation.js

@@ -110,6 +110,8 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   const loading = ref(true);
   const stopping = ref(false);
   const goalAction = ref("");
+  // An accepted Set or Resume waiting for its goal keeps Pause and Cancel usable.
+  const goalSettling = ref(false);
   const goalTargetCurrent = ref(false);
   const goalError = ref("");
   const goalView = shallowRef(null);
@@ -136,6 +138,11 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   const hasMoreBefore = computed(() => normalizeConversationLogPagination(oldestLoadedPage.value?.pagination).hasMoreBefore);
   const editable = computed(() => active.value && !accessDenied.value);
   const available = computed(() => active.value && !loading.value && !accessDenied.value && Boolean(snapshot.value));
+  // A deferred message keeps the subscription while its view is hidden, so it
+  // is admitted against live state. A failed read leaves that state stale.
+  const deferredWaits = ref(0);
+  const listening = computed(() => active.value || current.value && deferredWaits.value > 0);
+  const admissible = computed(() => listening.value && !loading.value && !accessDenied.value && !error.value && Boolean(snapshot.value));
   const steerable = computed(() => snapshot.value?.status === "working" && snapshot.value?.capabilities?.steering === true);
   const workingPolicy = computed(() => resolveWorkingPolicy(snapshot.value, { deferWhileWorking, admitWhileWorking }));
   const queueing = computed(() => queueWhileSending !== false && (steerable.value || workingPolicy.value.deferWhileWorking || workingPolicy.value.admitWhileWorking));
@@ -215,6 +222,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   let goalSegment = null;
   let goalReadController = null;
   let goalReadQueued = false;
+  let goalCommandSequence = 0;
   const readsGoals = computed(() => goalReadEnabled || snapshot.value?.capabilities?.goals === true ||
     [...readers.values()].some(reader => toValue(reader.goal) === true));
   watch(readsGoals, enabled => { if (enabled) void refreshGoal(); });
@@ -305,7 +313,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       if (denial !== deniedHistoryRevision) {
         throw Object.assign(new Error("Access denied."), { status: 403, messageCode: "assistant.runtime.accessDenied" });
       }
-      return current.value && active.value && subscriptionCurrent();
+      return current.value && listening.value && subscriptionCurrent();
     };
     // A concurrent Load older operation extends the desired span. Retry one
     // refresh in this same read, rather than dropping that newly loaded page.
@@ -354,7 +362,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     }
     return null;
   }
-  watch(active, enabled => {
+  watch(listening, enabled => {
     subscription?.();
     subscription = null;
     historyRevision += 1;
@@ -372,6 +380,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     for (const pending of pendingMessages.values()) if (!pending.dispatched) pending.controller.abort();
     clearConversationView();
     goalAction.value = "";
+    goalSettling.value = false;
     goalReadQueued = false;
     questions.reset();
   }, { flush: "sync" });
@@ -450,6 +459,9 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   }
   // A deferred message waits only while the working turn cannot take it. It
   // steers as soon as that turn accepts steering, or sends once it is ready.
+  // Its view may be hidden. While loading or after a failed read there is no
+  // current state to admit it against, so the unsent message keeps waiting;
+  // only Stop, Cancel, retirement or lost access end it.
   function waitForAdmission({ controller }) {
     return new Promise(resolve => {
       let stop;
@@ -459,12 +471,13 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
         resolve(admission);
       };
       const check = () => {
-        if (controller.signal.aborted || !available.value) finish(false);
+        if (controller.signal.aborted || accessDenied.value) finish(false);
+        else if (!admissible.value) return;
         else if (snapshot.value.status === "ready") finish("send");
         else if (steerable.value) finish("steer");
         else if (snapshot.value.status !== "working") finish(false);
       };
-      stop = watch([available, snapshot, steerable], check, { flush: "sync" });
+      stop = watch([admissible, snapshot, steerable], check, { flush: "sync" });
       controller.signal.addEventListener("abort", check, { once: true });
       check();
     });
@@ -477,10 +490,13 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     const pending = { controller: new AbortController(), started: false, dispatched: false };
     const { controller } = pending;
     pendingMessages.set(messageId, pending);
+    if (deferred) deferredWaits.value += 1;
     try {
       const result = await delivery.send(payload, {
+        // A goal command settles on the server's goal answer, not on its
+        // transcript turn, which can arrive while its goal is still changing.
         messageId, queue, isCurrent: () => current.value, onAccepted,
-        receiptTurns: turns, uncertainOnError: true,
+        receiptTurns: payload.goalRequest ? null : turns, uncertainOnError: true,
         async deliver(submission) {
           pending.started = true;
           let admission = null;
@@ -490,13 +506,12 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
               // Refresh through the same subscription after a queued predecessor;
               // its receipt may have arrived before the working snapshot.
               await subscription?.reload();
-              if (error.value) return false;
-              if (snapshot.value.status === "working" && !steerable.value) {
+              if (snapshot.value?.status === "working" && !steerable.value) {
                 delivery.wait(messageId, t("jskit.assistant.runtime.delivery.waitingForStep"));
               }
               admission = await waitForAdmission(pending);
               delivery.wait(messageId, "");
-              if (!admission || controller.signal.aborted || !available.value ||
+              if (!admission || controller.signal.aborted || !admissible.value ||
                   snapshot.value.status !== (admission === "steer" ? "working" : "ready")) return false;
               if (submission.displayAttachments?.length && snapshot.value.capabilities?.attachments !== true) {
                 return { ok: false, error: t("jskit.assistant.runtime.attachments.noLongerAccepted") };
@@ -566,6 +581,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       return false;
     } finally {
       if (!pending.started && pendingMessages.get(messageId) === pending) pendingMessages.delete(messageId);
+      if (deferred) deferredWaits.value -= 1;
       if (current.value) subscription?.reload();
     }
   }
@@ -686,7 +702,8 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     // 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 ||
+    if (!available.value || view?.status !== "available" || goalLoadError.value ||
+        goalAction.value && !(stopping && goalSettling.value) || !goalTargetCurrent.value ||
         !["message", "control"].includes(command?.delivery) ||
         !stopping && delivery.state.messages.some(message => message.status === "uncertain")) return false;
     if (input.tokenBudget != null && !target.capabilities.goalBudgets) {
@@ -699,11 +716,16 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       expectedGoalId: view.goal?.id || null,
       ...(action === "set" ? { objective: String(input.objective || "").trim(),
         ...(input.tokenBudget == null ? {} : { tokenBudget: input.tokenBudget }) } : {}) };
+    const before = view.goal ? { id: view.goal.id, status: view.goal.status } : null;
+    const sequence = ++goalCommandSequence;
+    let accepted = false;
     goalAction.value = action;
+    goalSettling.value = false;
     goalError.value = "";
     try {
+      let result;
       if (retry || !stopping && command.delivery === "message") {
-        const result = await submitRequest(retry?.payload || {
+        result = await submitRequest(retry?.payload || {
           message: action === "set" ? request.objective
             : t(action === "resume" ? "jskit.assistant.runtime.goal.resumeMessage" : "jskit.assistant.runtime.goal.cancelMessage"),
           goalRequest: request
@@ -714,11 +736,12 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
           }
           return false;
         }
-        return result;
+      } else {
+        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"));
       }
-      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"));
+      accepted = true;
       return result;
     } catch (failure) {
       if (current.value) {
@@ -727,13 +750,43 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       }
       return false;
     } finally {
-      if (current.value) {
-        goalAction.value = "";
+      // The command stays Starting, Resuming, Pausing or Cancelling until a goal
+      // read made after the server's answer arrives; until then the control
+      // shows no stale goal or enabled form. An accepted Set or Resume also
+      // waits while its goal waits behind the running turn.
+      if (current.value && goalCommandSequence === sequence) {
         await goalRead;
         await refreshGoal();
+        if (accepted && !stopping) await awaitGoalChange(before, sequence);
         subscription?.reload();
       }
+      if (goalCommandSequence === sequence) {
+        goalAction.value = "";
+        goalSettling.value = false;
+      }
+    }
+  }
+  // An accepted Set or Resume changes the server's goal, now or once the turn
+  // it waits behind has ended. When the conversation stops working without
+  // that change, a fresh read decides and the reason is shown. A later Pause
+  // or Cancel ends the wait.
+  const goalChangedFrom = before => {
+    const goal = goalView.value?.goal;
+    return Boolean(goal) && (goal.id !== before?.id || goal.status !== before?.status);
+  };
+  async function awaitGoalChange(before, sequence) {
+    const settled = () => !current.value || goalCommandSequence !== sequence || goalChangedFrom(before);
+    await subscription?.reload();
+    if (!settled()) goalSettling.value = true;
+    while (!settled() && snapshot.value?.status === "working") {
+      await new Promise(resolve => {
+        const stop = watch([goalView, () => snapshot.value?.status, current, goalAction], () => { stop(); resolve(); });
+      });
     }
+    if (settled()) return;
+    await goalRead;
+    await refreshGoal();
+    if (!settled()) goalError.value = t("jskit.assistant.runtime.goal.notStarted");
   }
   const goalState = computed(() => {
     const view = goalView.value;
@@ -742,7 +795,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     const commands = capabilities.goalCommands || {};
     const loading = !goalTargetCurrent.value && !goalLoadError.value;
     const goalAvailable = goalTargetCurrent.value && view?.status === "available" && !goalLoadError.value;
-    const stopPending = Boolean(goalAction.value) || !goalAvailable || !available.value;
+    const stopPending = Boolean(goalAction.value) && !goalSettling.value || !goalAvailable || !available.value;
     return {
       enabled: active.value && Boolean(loading || (view?.status === "available" && !goalLoadError.value) || goalError.value || goalLoadError.value),
       loading,
@@ -752,7 +805,8 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       tokenBudgetSupported: capabilities.goalBudgets === true,
       goal: goalAvailable && view?.goal ? { ...view.goal, elapsedSeconds: view.goal.timeUsedSeconds,
         sampledAt: Date.parse(view.goal.updatedAt) } : null,
-      pending: stopPending || delivery.state.sending || delivery.state.messages.some(message => message.status === "uncertain"),
+      pending: Boolean(goalAction.value) || stopPending || delivery.state.sending ||
+        delivery.state.messages.some(message => message.status === "uncertain"),
       stopPending,
       error: goalError.value || goalLoadError.value || view?.error || "",
       pauseInterruptsTurn: commands.pause?.interruptsTurn === true,

package/test/assistantConversationBinding.browser.test.js

@@ -393,6 +393,117 @@ test("a lost goal receipt uses the same inspection-only ledger and never starts
   assert.equal((await requests()).length, 1, "An undeclared goal command is not exposed or dispatched");
 });
 
+test("Start goal stays Starting… until the goal is read after the server's answer, and no second start is sent", options, async t => {
+  const f = await fixture(t);
+  await f.command("goals", { id: "chat:1", budgets: false, commands: {
+    set: { delivery: "message", interruptsTurn: false }, pause: { delivery: "control", interruptsTurn: true }
+  } });
+  await f.notify("chat:1");
+  const starts = async () => (await f.state()).requests.filter(request => request.suffix === "/goal" && request.method === "POST");
+  await f.primary.getByRole("button", { name: "Set goal", exact: true }).click();
+  const objective = f.page.getByRole("textbox", { name: "Goal objective" });
+  const start = f.page.locator(".assistant-goal__form button[type=submit]");
+  await objective.fill("Finish while the goal read is slow");
+  // Goal reads made after Start wait, as a slow server read does.
+  const reads = Promise.withResolvers();
+  let heldReads = 0;
+  await f.page.route("**/conversations/*/goal", async route => {
+    if (route.request().method() === "GET") {
+      heldReads += 1;
+      await reads.promise;
+    }
+    await route.continue();
+  });
+  await start.click();
+  await expect.poll(async () => (await starts()).length).toBe(1);
+  await expect.poll(() => heldReads).toBeGreaterThan(0);
+  // The server has answered; the control has not yet read the goal it started.
+  await expect(start).toHaveText("Starting…");
+  await expect(start).toBeDisabled();
+  await expect(objective).toHaveValue("Finish while the goal read is slow");
+  assert.equal(await f.page.evaluate(() => window.conversationFixture.current().changeGoal("set", { objective: "A second start" })), false);
+  reads.resolve();
+  await expect(f.primary.getByRole("button", { name: "Goal running", exact: true })).toHaveAttribute("aria-expanded", "false");
+  assert.equal((await starts()).length, 1, "One Start sends one goal command");
+});
+
+test("a Start accepted behind the running turn stays Starting… until its goal runs, and says so when it never starts", options, async t => {
+  const f = await fixture(t);
+  await f.command("goals", { id: "chat:1", budgets: false, commands: {
+    set: { delivery: "message", interruptsTurn: false }, cancel: { delivery: "control", interruptsTurn: false }
+  } });
+  await f.notify("chat:1");
+  const starts = async () => (await f.state()).requests.filter(request =>
+    request.suffix === "/goal" && request.method === "POST" && request.input.action === "set");
+  const control = name => f.primary.getByRole("button", { name, exact: true });
+  const objective = f.page.getByRole("textbox", { name: "Goal objective" });
+  const start = f.page.locator(".assistant-goal__form button[type=submit]");
+  await f.command("mode", { mode: "queue-goal" });
+  await control("Set goal").click();
+  await objective.fill("Start after the current turn");
+  await start.click();
+  await expect.poll(async () => (await starts()).length).toBe(1);
+  await f.notify("chat:1");
+  // Accepted, but its goal waits behind the running turn.
+  await expect(start).toHaveText("Starting…");
+  await expect(start).toBeDisabled();
+  await expect(objective).toHaveValue("Start after the current turn");
+  await f.page.keyboard.press("Escape");
+  await expect(control("Starting…")).toBeVisible();
+  assert.equal(await f.page.evaluate(() => window.conversationFixture.current().changeGoal("set", { objective: "A second start" })), false);
+  await f.command("start-queued-goal", { id: "chat:1" });
+  await f.notify("chat:1");
+  await expect(control("Goal running")).toBeVisible();
+  assert.equal((await starts()).length, 1);
+
+  // A Start the conversation finishes without says so and keeps its objective.
+  await control("Goal running").click();
+  await f.page.getByRole("button", { name: "Cancel goal", exact: true }).click();
+  await expect(control("Set goal")).toBeVisible();
+  await objective.fill("Never takes effect");
+  await start.click();
+  await expect.poll(async () => (await starts()).length).toBe(2);
+  await f.notify("chat:1");
+  await expect(start).toBeDisabled();
+  await f.command("finish", { id: "chat:1" });
+  await f.notify("chat:1");
+  await expect(f.page.getByRole("alert").filter({ hasText: "The goal did not start. Check the chat before starting it again." })).toBeVisible();
+  await expect(objective).toHaveValue("Never takes effect");
+  await expect(start).toBeEnabled();
+  assert.equal((await starts()).length, 2);
+});
+
+test("Cancel stays available while a Resume waits behind the running turn and ends that wait", 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: false }, cancel: { delivery: "control", interruptsTurn: false }
+  } });
+  await f.notify("chat:1");
+  const control = name => f.primary.getByRole("button", { name, exact: true });
+  const menu = name => f.page.getByRole("button", { name, exact: true });
+  await control("Set goal").click();
+  await f.page.getByRole("textbox", { name: "Goal objective" }).fill("Resume after the current turn");
+  await f.page.locator(".assistant-goal__form button[type=submit]").click();
+  await expect(control("Goal running")).toHaveAttribute("aria-expanded", "false");
+  await control("Goal running").click();
+  await menu("Pause goal").click();
+  await expect(control("Goal paused")).toBeVisible();
+  await f.command("mode", { mode: "queue-goal" });
+  await menu("Resume goal").click();
+  await expect(menu("Resuming…")).toBeDisabled();
+  await f.notify("chat:1");
+  await expect(menu("Cancel goal")).toBeEnabled();
+  await expect(menu("Resuming…")).toBeDisabled();
+  await menu("Cancel goal").click();
+  await expect(control("Set goal")).toBeVisible();
+  await f.command("finish", { id: "chat:1" });
+  await f.notify("chat:1");
+  await expect(f.page.getByRole("alert")).toHaveCount(0);
+  const commands = (await f.state()).requests.filter(request => request.suffix === "/goal" && request.method === "POST");
+  assert.deepEqual(commands.map(request => request.input.action), ["set", "pause", "resume", "cancel"]);
+});
+
 test("a supplied goal view keeps its pinned target and refreshes through the retained binding without polling", options, async t => {
   const f = await fixture(t);
   const goal = { id: "retained-goal", objective: "The plain product objective", status: "paused",
@@ -1135,6 +1246,85 @@ test("a deferred follow-up explains its wait and steers once the working turn ac
   await expect(f.primary.getByText(/^Pending/)).toHaveCount(0);
 });
 
+// An application keeps a retained view mounted but inactive while another
+// conversation is shown. A message waiting for admission there was never sent:
+// hiding its view must not fail it as "Message could not be sent.", and the
+// person who moved on must not have to return before it is sent.
+test("a deferred message sends while its view is hidden once the session admits it", options, async t => {
+  const f = await fixture(t);
+  await f.page.evaluate(() => {
+    window.readerActive = window.conversationFixture.activity(true);
+    window.deferredBinding = window.conversationFixture.acquireConversation({
+      conversationId: "chat:2", deferWhileWorking: true, queueWhileSending: true, active: window.readerActive
+    });
+  });
+  const deferred = () => f.page.evaluate(() => {
+    const runtime = window.deferredBinding.runtime.value;
+    const { id, status, error, waiting } = runtime.delivery.state.messages.find(message => message.text === "Queued while working") || {};
+    return { available: runtime.available.value, status: runtime.snapshot.value?.status, message: { id, status, error, waiting },
+      subscriptions: window.conversationFixture.socket.inspect().active };
+  });
+  await expect.poll(async () => (await deferred()).available).toBe(true);
+  const { subscriptions } = await deferred();
+  await f.page.evaluate(() => { window.original = window.deferredBinding.runtime.value.send({ message: "Original nonsteerable request" }); });
+  await expect.poll(async () => (await deferred()).status).toBe("working");
+  await f.page.evaluate(() => { window.queued = window.deferredBinding.runtime.value.send({ message: "Queued while working" }); });
+  await expect.poll(async () => (await deferred()).message.waiting).toBe("Waiting for the assistant to finish this step");
+  await f.page.evaluate(() => { window.readerActive.value = false; });
+  await expect.poll(async () => (await deferred()).available).toBe(false);
+  const hidden = await deferred();
+  assert.equal(hidden.message.status, "pending", `hiding the view is not a failed delivery: ${hidden.message.error}`);
+  assert.equal(hidden.subscriptions, subscriptions, "the waiting message keeps its live state");
+  assert.equal((await f.sent()).length, 1, "the working turn still cannot take the message");
+  await f.command("finish", { id: "chat:2" });
+  await f.notify("chat:2");
+  await expect.poll(async () => (await f.sent()).length).toBe(2);
+  const [, followUp] = await f.sent();
+  assert.deepEqual([followUp.input.messageId, followUp.input.text], [hidden.message.id, "Queued while working"]);
+  assert.equal((await f.page.evaluate(() => window.queued)).status, "accepted");
+  const sent = await deferred();
+  assert.equal(sent.available, false, "the message was sent while its view stayed hidden");
+  await expect.poll(async () => (await deferred()).subscriptions, { message: "an empty queue releases the hidden view's subscription" }).toBe(subscriptions - 1);
+  await f.page.evaluate(() => { window.readerActive.value = true; });
+  await expect.poll(async () => (await deferred()).available).toBe(true);
+  assert.equal((await f.sent()).length, 2, "the queued message is sent once");
+});
+
+// A lost subscription leaves the last snapshot shown with its error while it
+// retries. Its refresh then reads nothing, so that stale error says nothing
+// about the unsent message: it waits for the recovered state and sends once.
+test("a deferred message waits through a failing resubscription instead of failing", options, async t => {
+  const f = await fixture(t);
+  await f.page.evaluate(() => {
+    window.deferredBinding = window.conversationFixture.acquireConversation({
+      conversationId: "chat:2", deferWhileWorking: true, queueWhileSending: true
+    });
+  });
+  const deferred = () => f.page.evaluate(() => {
+    const runtime = window.deferredBinding.runtime.value;
+    const { id, status, error } = runtime.delivery.state.messages.find(message => message.text === "Sent while reconnecting") || {};
+    return { available: runtime.available.value, error: runtime.error.value, message: { id, status, error } };
+  });
+  await expect.poll(async () => (await deferred()).available).toBe(true);
+  let failing = true;
+  await f.page.route(url => url.pathname.endsWith("/conversations/chat%3A2"), route => failing && route.request().method() === "GET"
+    ? route.fulfill({ status: 503, contentType: "application/json", body: JSON.stringify({ error: "Conversation temporarily unavailable." }) })
+    : route.continue());
+  await f.page.evaluate(() => window.conversationFixture.socket.reconnect());
+  await expect.poll(async () => (await deferred()).error).toBe("Conversation temporarily unavailable.");
+  assert.equal((await deferred()).available, true, "the last snapshot stays shown");
+  await f.page.evaluate(() => { window.queued = window.deferredBinding.runtime.value.send({ message: "Sent while reconnecting" }); });
+  await expect.poll(async () => (await deferred()).message.status).toBe("pending");
+  const waiting = await deferred();
+  assert.equal((await f.sent()).length, 0, "nothing is admitted against the stale snapshot");
+  failing = false;
+  // The subscription's own retry, not the message, recovers the state.
+  await expect.poll(async () => (await f.sent()).length, { timeout: 15_000 }).toBe(1);
+  const [sent] = await f.sent();
+  assert.deepEqual([sent.input.messageId, sent.input.text], [waiting.message.id, "Sent while reconnecting"]);
+  assert.equal((await f.page.evaluate(() => window.queued)).status, "accepted");
+});
+
 for (const steer of [false, true]) {
   test(`Stop cancels locally queued native ${steer ? "steering" : "startup"} follow-ups`, options, async t => {
     const f = await fixture(t);
@@ -3293,10 +3483,13 @@ test("a background goal read keeps current pinned controls available and seriali
     await expect(f.page.getByRole("button", { name: "Cancel goal", exact: true })).toBeDisabled();
     assert.equal(await f.page.evaluate(() => window.conversationFixture.current().changeGoal("cancel")), false);
     releaseCommand();
-    await expect(pause).toBeEnabled();
+    // The answered Pause stays Pausing… until a goal read made after its answer
+    // lands, so the stale goal never offers its controls again.
+    await expect(f.page.getByRole("button", { name: "Pausing…", exact: true })).toBeDisabled();
     assert.equal(commands.length, 1, "Only the actual Pause command was admitted");
     holdRead = false;
     releaseRead();
+    await expect(pause).toBeEnabled();
     await f.page.evaluate(() => window.fixtureBackgroundGoalRead);
     assert.deepEqual(await f.sent(), []);
   } finally {

package/test/assistantConversationSubscriptions.test.js

@@ -342,6 +342,7 @@ test("a real subscription slower than ten seconds keeps its observer, says it is
   const barrier = f.holdNextRead(id);
   const view = f.view(socket, id);
   await until(f.changes, () => barrier.started);
+  const readStartedAt = performance.now();
   const subscriptionEpoch = f.subscriptionTimings.at(-1).subscriptionEpoch;
   while (!view.errors.length) await once(f.changes, "change", { signal: AbortSignal.timeout(12_000) });
   assert.equal(view.errors[0].message, "Chat is still loading. Waiting for the server; Reload chat to try now.");
@@ -350,6 +351,9 @@ test("a real subscription slower than ten seconds keeps its observer, says it is
   assert.equal(socket.id, socketId);
   assert.equal(socket.connected, true);
   assert.equal(view.states.length, 0);
+  // The client's ten-second wait starts before the server's clock does, so the
+  // read is held until the server has also waited ten seconds.
+  await new Promise(resolve => setTimeout(resolve, Math.max(0, 10_001 - (performance.now() - readStartedAt))));
   barrier.resolve();
   await until(f.changes, () => view.states.length === 1);
   assert.equal(view.states[0].conversationLog[0].user.messageId, "survives-wait");