@jskit-ai/assistant-runtime 0.1.197 → 0.1.198

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.1.197",
+  "version": "0.1.198",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -12,19 +12,19 @@
     "./server": "./src/server/index.js"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.204",
+    "@jskit-ai/assistant-core": "0.1.205",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.224",
-    "@jskit-ai/http-web": "0.1.71",
-    "@jskit-ai/kernel": "0.1.226",
-    "@jskit-ai/realtime": "0.1.223",
-    "@jskit-ai/shell-web": "0.1.230",
+    "@jskit-ai/http-runtime": "0.1.225",
+    "@jskit-ai/http-web": "0.1.72",
+    "@jskit-ai/kernel": "0.1.227",
+    "@jskit-ai/realtime": "0.1.224",
+    "@jskit-ai/shell-web": "0.1.231",
     "@tanstack/vue-query": "^5.90.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/database-runtime": "0.1.226"
+    "@jskit-ai/database-runtime": "0.1.227"
   },
   "description": "Capability-based assistant runtime with per-surface chat, transcripts, settings, and action tools.",
   "jskit": {

package/src/client/composables/useAssistantConversation.js

@@ -31,7 +31,7 @@ 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_invalid_goal", "conversation_goal_changed"
+  "conversation_invalid_message", "conversation_busy", "conversation_not_steerable", "conversation_invalid_goal", "conversation_goal_changed"
 ]);
 
 function isQuestionConfiguration(value) {
@@ -46,7 +46,7 @@ function draftAfterAcceptedSubmission(currentDraft = "", submittedDraft = "") {
   return submitted && current.startsWith(submitted) ? current.slice(submitted.length) : current;
 }
 
-function createConversation(identity, { api, socket, actorKey, placement, readers, queueWhileSending, draftStorage, application, goalReadEnabled }) {
+function createConversation(identity, { api, socket, actorKey, placement, readers, queueWhileSending, deferWhileWorking, draftStorage, application, goalReadEnabled }) {
   const disposed = ref(false);
   const placementRevision = ref(0);
   const stopPlacement = placement.subscribe(() => { placementRevision.value += 1; });
@@ -90,8 +90,8 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   const editable = computed(() => active.value && !accessDenied.value);
   const available = computed(() => active.value && !loading.value && !accessDenied.value && Boolean(snapshot.value));
   const steerable = computed(() => snapshot.value?.status === "working" && snapshot.value?.capabilities?.steering === true);
-  const queueing = computed(() => queueWhileSending !== false && steerable.value);
-  const canSubmit = computed(() => available.value && (snapshot.value.status === "ready" || steerable.value) &&
+  const queueing = computed(() => queueWhileSending !== false && (steerable.value || deferWhileWorking));
+  const canSubmit = computed(() => available.value && (snapshot.value.status === "ready" || steerable.value || deferWhileWorking && snapshot.value.status === "working") &&
     (queueWhileSending !== false || !delivery.state.sending) &&
     !delivery.state.messages.some(message => message.status === "uncertain"));
   const savedDraft = toValue(draftStorage);
@@ -109,9 +109,11 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     const messages = Array.isArray(saved?.messages) ? saved.messages.filter(message =>
       typeof message?.id === "string" && typeof message.text === "string" &&
       typeof message.payload?.message === "string") : [];
-    const restoredMessages = messages.filter(message => !delivery.find(message.id))
-      .map(message => ({ ...message, status: "failed", error: message.error ||
-        "Delivery was not confirmed before this page closed. Check the conversation before retrying." }));
+    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" ? "" :
+        "Delivery was not confirmed before this page closed. Check the conversation before retrying.") };
+    });
     delivery.state.messages = unmatchedOptimisticMessages(turns.value, [...delivery.state.messages, ...restoredMessages], { receiptsOnly: true });
   } catch {
     draft.value = "";
@@ -232,6 +234,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   }, { immediate: true, flush: "sync" });
   watch(current, value => {
     if (value) return;
+    for (const pending of pendingMessages.values()) if (!pending.dispatched) pending.controller.abort();
     delivery.reset();
     snapshot.value = null;
     olderPages.value = [];
@@ -251,7 +254,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     disposed.value = true;
     subscription?.();
     stopPlacement();
-    for (const controller of pendingMessages.values()) controller.abort();
+    for (const pending of pendingMessages.values()) pending.controller.abort();
     pendingMessages.clear();
     goalReadController?.abort();
     globalThis.removeEventListener?.("focus", refreshVisibleGoal);
@@ -268,7 +271,8 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     const requestedSteering = request?.steer === true;
     if (requestedSteering && snapshot.value.capabilities?.steering !== true) return false;
     const steering = requestedSteering || steerable.value;
-    if ((snapshot.value.status === "working" || delivery.state.sending) && !steering) return false;
+    const deferred = deferWhileWorking && !retry && !steering;
+    if ((snapshot.value.status === "working" || delivery.state.sending) && !steering && !deferred) return false;
     if ((retry?.payload || payload).displayAttachments?.length && snapshot.value.capabilities?.attachments !== true) return false;
     const captured = retry?.payload?.request ? retry.payload : { ...(retry?.payload || payload), request: payload.request || {
       text: String(payload.message || ""),
@@ -276,7 +280,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       ...(payload.displayAttachments?.length ? { attachmentIds: payload.displayAttachments.map(file => file.attachmentId) } : {}),
       ...(steerable.value ? { steer: true } : {})
     } };
-    return submitRequest(captured, { messageId, onAccepted, queue: queueWhileSending !== false && steering });
+    return submitRequest(captured, { messageId, onAccepted, queue: queueWhileSending !== false && (steering || deferred), deferred });
   }
   function submitPrepared(payload, { messageId = crypto.randomUUID(), onAccepted, prepare } = {}) {
     if (typeof prepare !== "function") throw new TypeError("Prepared submission requires application preparation.");
@@ -315,16 +319,50 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     }
     return result;
   }
-  async function submitRequest(payload, { messageId, onAccepted, queue = false, prepare }) {
+  function waitUntilReady({ controller }) {
+    return new Promise(resolve => {
+      let stop;
+      const finish = ready => {
+        stop?.();
+        controller.signal.removeEventListener("abort", check);
+        resolve(ready);
+      };
+      const check = () => {
+        if (controller.signal.aborted || !available.value) finish(false);
+        else if (snapshot.value.status === "ready") finish(true);
+        else if (snapshot.value.status !== "working") finish(false);
+      };
+      stop = watch([available, snapshot], check, { flush: "sync" });
+      controller.signal.addEventListener("abort", check, { once: true });
+      check();
+    });
+  }
+
+  async function submitRequest(payload, { messageId, onAccepted, queue = false, prepare, deferred = false }) {
+    if (pendingMessages.has(messageId)) return false;
+    // Register before the original serial tail so Stop/retirement also reaches
+    // a local follower whose deliver callback has not started yet.
+    const pending = { controller: new AbortController(), started: false, dispatched: false, deferred };
+    const { controller } = pending;
+    pendingMessages.set(messageId, pending);
     try {
       const result = await delivery.send(payload, {
         messageId, queue, isCurrent: () => current.value, onAccepted,
         receiptTurns: turns, uncertainOnError: true,
         async deliver(submission) {
-          const controller = new AbortController();
-          pendingMessages.set(messageId, controller);
-          let dispatched = false;
+          pending.started = true;
           try {
+            if (controller.signal.aborted) return false;
+            if (deferred) {
+              // Refresh through the same subscription after a queued predecessor;
+              // its receipt may have arrived before the working snapshot.
+              await subscription?.reload();
+              if (error.value || !await waitUntilReady(pending)) return false;
+              if (controller.signal.aborted || !available.value || snapshot.value.status !== "ready") return false;
+              if (submission.displayAttachments?.length && snapshot.value.capabilities?.attachments !== true) {
+                return { ok: false, error: "This conversation no longer accepts attachments." };
+              }
+            }
             const request = prepare ? await prepare(submission, { signal: controller.signal }) : submission.request;
             if (prepare) {
               if (!current.value || accessDenied.value || controller.signal.aborted || request === false) return false;
@@ -332,20 +370,20 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
                 throw new TypeError("Application preparation must return its conversation request or false.");
               }
             }
-            dispatched = true;
+            pending.dispatched = true;
             return await (submission.goalRequest
               ? api.updateConversationGoal(identity.conversationId, { ...submission.goalRequest, messageId }, { signal: controller.signal })
               : api.sendConversationMessage(identity.conversationId, { ...request, messageId }, { signal: controller.signal }));
           }
           catch (failure) {
             if (controller.signal.aborted) return false;
-            if (prepare && !dispatched) return { ok: false, error: failure.message,
+            if (prepare && !pending.dispatched) return { ok: false, error: failure.message,
               ...(failure.code ? { code: failure.code } : {}) };
             if (SEND_REJECTIONS.has(failure.code)) return { ok: false, error: failure.message,
               ...(prepare && failure.code ? { code: failure.code } : {}) };
             throw failure;
           } finally {
-            if (pendingMessages.get(messageId) === controller) pendingMessages.delete(messageId);
+            if (pendingMessages.get(messageId) === pending) pendingMessages.delete(messageId);
           }
         }
       });
@@ -355,13 +393,15 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       if (prepare) return { ok: false, status: "uncertain", error: failure.message,
         ...(failure.code ? { code: failure.code } : {}) };
       return false;
-    } finally { if (current.value) subscription?.reload(); }
+    } finally {
+      if (!pending.started && pendingMessages.get(messageId) === pending) pendingMessages.delete(messageId);
+      if (current.value) subscription?.reload();
+    }
   }
   function cancelMessage(messageId) {
-    const controller = pendingMessages.get(messageId);
-    if (!controller) return false;
-    controller.abort();
-    pendingMessages.delete(messageId);
+    const pending = pendingMessages.get(messageId);
+    if (!pending) return false;
+    pending.controller.abort();
     return true;
   }
 
@@ -515,6 +555,9 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   async function cancel() {
     if (!editable.value || stopping.value) return false;
     stopping.value = true;
+    for (const pending of pendingMessages.values()) {
+      if (pending.deferred && !pending.dispatched) pending.controller.abort();
+    }
     try { return await api.cancelConversation(identity.conversationId); }
     catch (failure) { receiveError(failure); return false; }
     finally { stopping.value = false; if (current.value) subscription?.reload(); }
@@ -610,7 +653,7 @@ function conversationBindingSetup({ socket, boundedTask = null } = {}) {
 
 function createConversationBinding({ conversationId, endpoint = "", surfaceId = "", hostSurfaceId = "", workspaceSlug,
   actorKey: suppliedActorKey, api: suppliedApi = null, socket: suppliedSocket = null, active = true, onEvent,
-  clearDraftOn: suppliedClearDraftOn, queueWhileSending, draftWhileLoading = false,
+  clearDraftOn: suppliedClearDraftOn, queueWhileSending, deferWhileWorking = false, draftWhileLoading = false,
   draftStorage = null, application = null, boundedTask = null,
   data, attachments = null, suggestions = null, models = null, questions = null, goal = null, presentation = {} } = {}, setup) {
   const { app, routeContext, placement, workspaceScope, socket: setupSocket, config, defaults = {} } = setup ||
@@ -622,6 +665,7 @@ function createConversationBinding({ conversationId, endpoint = "", surfaceId =
   });
   if (!["dispatch", "accepted"].includes(clearDraftOn)) throw new TypeError("clearDraftOn must be dispatch or accepted.");
   if (queueWhileSending !== undefined && typeof queueWhileSending !== "boolean") throw new TypeError("queueWhileSending must be a boolean.");
+  if (typeof deferWhileWorking !== "boolean") throw new TypeError("deferWhileWorking must be a boolean.");
   if (typeof draftWhileLoading !== "boolean") throw new TypeError("draftWhileLoading must be a boolean.");
   if (application !== null && typeof application !== "function") throw new TypeError("application must be a factory.");
   if (boundedTask !== null) return useBoundedTask(boundedTask, { active, data, presentation });
@@ -679,7 +723,7 @@ function createConversationBinding({ conversationId, endpoint = "", surfaceId =
     const key = JSON.stringify(["assistant", target.actorKey, target.endpoint, target.targetSurfaceId,
       target.hostSurfaceId, target.workspaceSlug, target.conversationId]);
     retained = retainAssistantConversation(app, key, readers => createConversation(target, {
-      readers, socket, actorKey, placement, queueWhileSending, draftStorage, application, goalReadEnabled: toValue(goal) === true,
+      readers, socket, actorKey, placement, queueWhileSending, deferWhileWorking, draftStorage, application, goalReadEnabled: toValue(goal) === true,
       api: suppliedApi || defaults.api || createAssistantApi({ request: defaults.request || assistantHttpClient.request,
         resolveBasePath: () => target.endpoint, resolveSurfaceId: () => target.hostSurfaceId })
     }), { active, questions, goal, onEvent });

package/test/assistantConversationBinding.browser.test.js

@@ -601,12 +601,140 @@ test("canonical receipts settle a held response and uncertain delivery stays ins
   await expect(f.primary.getByText("Keep this exact uncertain request", { exact: true })).toHaveCount(0);
 });
 
-test("an explicit pre-admission rejection retains original retry identity and the newer draft", options, async t => {
+for (const status of ["uncertain", "pending", "accepted", "failed", "unrecognised"]) {
+  test(`saved delivery preserves its actual admission fact through page reload: ${status}`, options, async t => {
+    const f = await fixture(t);
+    const messageId = `reload-${status}`;
+    const attach = async () => {
+      await f.page.evaluate(() => {
+        window.savedBinding = window.conversationFixture.acquireConversation({
+          conversationId: "chat:2", draftStorage: { storage: sessionStorage, key: "original-delivery-reload" }
+        });
+        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: status === "accepted" ? "product-native-duplicate"
+      : status === "failed" ? "rejected" : status === "pending" ? "hold" : "uncertain" });
+    await f.page.evaluate(messageId => {
+      const runtime = window.savedBinding.runtime.value;
+      runtime.draft.value = "Keep my separate newer draft";
+      window.savedSubmission = runtime.send({ message: "Exact original saved words",
+        data: { clientId: "original-client", focus: { project: "original-project" } } }, { messageId });
+    }, messageId);
+    await expect.poll(async () => (await f.sent()).length).toBe(1);
+    if (status !== "pending") await f.page.evaluate(() => window.savedSubmission);
+    const unconfirmed = ["uncertain", "pending", "unrecognised"].includes(status);
+    await f.command("question", { id: "chat:2", text: "An unrelated completed answer.", pending: false });
+    if (unconfirmed) {
+      await f.command("history", { id: "chat:2", limit: 20, turns: [{ turnId: messageId,
+        user: { messageId, role: "user", text: "Exact original saved words", receipt: false }
+      }] });
+    }
+    await f.notify("chat:2");
+    await expect.poll(() => f.page.evaluate(() => window.savedBinding.runtime.value.snapshot.value.status)).toBe("ready");
+    if (status === "unrecognised") {
+      await f.page.evaluate(() => {
+        const saved = JSON.parse(sessionStorage.getItem("original-delivery-reload"));
+        saved.messages[0].status = "unrecognised";
+        sessionStorage.setItem("original-delivery-reload", JSON.stringify(saved));
+      });
+    }
+    let releaseInspection;
+    if (status === "uncertain") {
+      const gate = Promise.withResolvers();
+      t.after(() => gate.resolve());
+      releaseInspection = gate.resolve;
+      await f.page.route("**/deliveries/**/inspect", async route => {
+        await gate.promise;
+        await route.fulfill({ json: { status: "unknown", messageId } }).catch(() => {});
+      });
+      await f.page.evaluate(messageId => { void window.savedBinding.runtime.value.inspectDelivery(messageId); }, messageId);
+      await expect.poll(() => f.page.evaluate(() => JSON.parse(sessionStorage.getItem("original-delivery-reload")).messages[0].checking)).toBe(true);
+    }
+    const saved = await f.page.evaluate(() => JSON.parse(sessionStorage.getItem("original-delivery-reload")));
+    assert.equal(saved.messages[0].status, status);
+    await f.page.reload();
+    releaseInspection?.();
+    if (releaseInspection) await f.page.unroute("**/deliveries/**/inspect");
+    await expect(f.input).toBeEnabled();
+    await attach();
+    await expect(f.input).toHaveValue(saved.draft);
+    const restored = await f.page.evaluate(messageId => window.savedBinding.runtime.value.delivery.find(messageId), messageId);
+    assert.equal(restored.status, unconfirmed ? "uncertain" : status);
+    assert.equal(restored.checking, false, "an inspector from the old page cannot disable recovery on the new page");
+    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);
+    if (unconfirmed) {
+      const check = f.primary.getByRole("button", { name: "Check delivery", exact: true });
+      try { await expect(check).toBeEnabled(); }
+      catch (failure) {
+        t.diagnostic(JSON.stringify(await f.page.evaluate(() => {
+          const saved = window.savedBinding.runtime.value;
+          const primary = window.conversationFixture.current();
+          return { shared: saved === primary, savedIdentity: saved.identity, primaryIdentity: primary.identity,
+            canonical: saved.turns.value, messages: saved.delivery.state.messages,
+            projected: saved.delivery.turns(saved.turns.value) };
+        })));
+        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);
+      }
+      // 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 });
+      await f.notify("chat:2");
+      await expect(check).toBeEnabled();
+      assert.equal(await f.page.evaluate(messageId => window.savedBinding.runtime.value.delivery.find(messageId).status, messageId), "uncertain",
+        "removing a nonreceipt row is not evidence of rejection or admission");
+      await check.click();
+      await expect(check).toBeEnabled();
+      assert.equal(await f.page.evaluate(messageId => window.savedBinding.runtime.value.delivery.find(messageId).status, messageId), "uncertain");
+      assert.equal((await f.sent()).length, 1, "unknown inspection cannot resend or acknowledge");
+      if (status === "pending") await f.command("accept");
+      else await f.command("confirm", { id: "chat:2" });
+      await f.notify("chat:2");
+      await expect(check).toHaveCount(0);
+      assert.equal((await f.sent()).length, 1, "only the actual canonical receipt settles the original identity");
+    } else {
+      await expect(f.primary.getByRole("button", { name: "Check delivery", exact: true })).toHaveCount(0);
+      await expect(f.primary.getByRole("button", { name: "Retry", exact: true })).toHaveCount(status === "failed" ? 1 : 0);
+    }
+  });
+}
+
+for (const code of ["ACTION_VALIDATION_FAILED", "conversation_not_steerable"]) {
+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" });
+  if (code === "conversation_not_steerable") {
+    await f.command("steering", { id: "chat:1", enabled: true });
+    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);
+    await f.page.route("**/messages", async route => {
+      const response = await route.fetch();
+      await route.fulfill(response.status() === 400
+        ? { response, status: 409, json: { error: "The message was rejected before admission.", code } }
+        : { response });
+    });
+  }
   await f.input.fill("Retry only this original message");
   await f.input.press("Enter");
   await expect(f.primary.getByText("Failed: The message was rejected before admission.", { exact: true })).toBeVisible();
+  const [rejected] = await f.sent();
+  assert.equal((await f.sent()).length, 1, "a definite rejection never silently resubmits steering as new work");
+  assert.equal(await f.page.evaluate(id => window.conversationFixture.current().delivery.find(id).status, rejected.input.messageId), "failed");
+  assert.equal(await f.page.evaluate(() => window.conversationFixture.current().canSubmit.value), true);
+  await expect(f.primary.getByRole("button", { name: "Check delivery", exact: true })).toHaveCount(0);
+  if (code === "conversation_not_steerable") {
+    assert.equal(rejected.input.steer, true);
+  }
   await f.input.fill("My newer draft");
   await f.command("mode", { mode: "accepted" });
   await f.primary.getByRole("button", { name: "Retry", exact: true }).click();
@@ -619,8 +747,119 @@ test("an explicit pre-admission rejection retains original retry identity and th
   await f.primary.getByRole("button", { name: "Stop", exact: true }).click();
   await expect(f.primary.getByRole("button", { name: "Stop", exact: true })).toHaveCount(0);
   assert.equal((await f.state()).requests.filter(request => request.suffix === "/cancel").length, 1);
+  if (code === "conversation_not_steerable") {
+    await f.command("mode", { mode: "rejected" });
+    for (const action of ["Cancel", "Edit"]) {
+      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);
+      const text = `Known rejected steer for ${action}`;
+      await f.input.fill(text);
+      await f.input.press("Enter");
+      await expect(f.primary.getByText("Failed: The message was rejected before admission.", { exact: true })).toBeVisible();
+      const request = (await f.sent()).at(-1);
+      assert.equal(request.input.steer, true);
+      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);
+      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");
+    assert.equal((await f.state()).requests.filter(request => request.suffix === "/cancel").length, 1, "failed-message recovery does not stop agent work");
+  }
+});
+}
+
+test("opted-in nonsteerable follow-ups use the original serial queue and dispatch only after ready", options, async t => {
+  const f = await fixture(t);
+  await f.page.evaluate(() => {
+    window.deferredBinding = window.conversationFixture.acquireConversation({
+      conversationId: "chat:2", deferWhileWorking: true, queueWhileSending: true
+    });
+    window.conversationFixture.target("chat:2");
+  });
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current()?.identity.conversationId)).toBe("chat:2");
+  await expect(f.input).toBeEnabled();
+  await f.input.fill("Original nonsteerable request");
+  await f.input.press("Enter");
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().snapshot.value.status)).toBe("working");
+  await f.page.evaluate(() => window.conversationFixture.data({ clientId: "typed", focus: { project: "captured" } }));
+  await f.input.fill("Typed follow-up while answering");
+  await f.input.press("Enter");
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().delivery.state.messages.length)).toBe(1);
+  const [typed] = await f.page.evaluate(() => window.conversationFixture.current().delivery.state.messages);
+  await f.page.evaluate(() => {
+    window.conversationFixture.retainVoice();
+    window.queuedSpeech = window.conversationFixture.sendVoice("Spoken follow-up while answering", {
+      clientId: "voice", focus: { project: "voice-captured" }
+    });
+    window.conversationFixture.changeFocus({ project: "later" });
+  });
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().delivery.state.messages.length)).toBe(2);
+  const [, spoken] = await f.page.evaluate(() => window.conversationFixture.current().delivery.state.messages);
+  await expect(f.primary.getByText(typed.text, { exact: true })).toHaveCount(1);
+  await expect(f.primary.getByText(spoken.text, { exact: true })).toHaveCount(1);
+  await expect(f.input).toBeEnabled();
+  assert.equal(await f.page.evaluate(() => window.conversationFixture.current().canSubmit.value), true);
+  assert.equal((await f.sent()).length, 1, "both authored follow-ups wait locally without HTTP");
+  await f.command("finish", { id: "chat:2" });
+  await f.notify("chat:2");
+  await expect.poll(async () => (await f.sent()).length).toBe(2);
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().snapshot.value.status)).toBe("working");
+  assert.deepEqual((await f.sent())[1].input, {
+    messageId: typed.id, text: typed.text, data: { clientId: "typed", focus: { project: "captured" } }
+  });
+  assert.equal((await f.sent()).length, 2, "the next follower waits for the first follow-up's real turn");
+  await f.command("finish", { id: "chat:2" });
+  await f.notify("chat:2");
+  await expect.poll(async () => (await f.sent()).length).toBe(3);
+  assert.deepEqual((await f.sent())[2].input, {
+    messageId: spoken.id, text: spoken.text, data: { clientId: "voice", focus: { project: "voice-captured" } }
+  });
+  assert.equal((await f.page.evaluate(() => window.queuedSpeech)).status, "accepted");
+  assert.equal((await f.state()).requests.some(request => request.suffix === "/cancel"), false,
+    "ordinary follow-ups never stop the original turn or output owner");
+  await f.command("steering", { id: "chat:2", enabled: true });
+  await f.notify("chat:2");
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().steerable.value)).toBe(true);
+  assert.equal((await f.page.evaluate(() => window.conversationFixture.sendVoice("Native steering remains immediate"))).status, "accepted");
+  assert.equal((await f.sent()).at(-1).input.steer, true);
 });
 
+for (const action of ["stop", "actor", "denied"]) {
+  test(`opted-in local followers cannot dispatch after ${action}`, options, async t => {
+    const f = await fixture(t);
+    await f.page.evaluate(() => {
+      window.deferredBinding = window.conversationFixture.acquireConversation({
+        conversationId: "chat:2", deferWhileWorking: true, queueWhileSending: true
+      });
+      window.conversationFixture.target("chat:2");
+    });
+    await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current()?.identity.conversationId)).toBe("chat:2");
+    await f.command("mode", { mode: "hold" });
+    await f.page.evaluate(() => {
+      window.firstDeferred = window.deferredBinding.runtime.value.send({ message: "First in-flight request" }, { messageId: "first-held" });
+    });
+    await expect.poll(async () => (await f.state()).held).toBe(1);
+    await f.page.evaluate(() => {
+      window.followerDeferred = window.deferredBinding.runtime.value.send({ message: "Local follower only" }, { messageId: "local-follower" });
+    });
+    assert.equal((await f.sent()).length, 1);
+    if (action === "stop") await f.page.evaluate(() => window.deferredBinding.runtime.value.cancel());
+    else if (action === "actor") await f.page.evaluate(() => window.conversationFixture.actor("different-actor"));
+    else {
+      await f.command("deny", { denied: true });
+      await f.notify("chat:2");
+      await expect.poll(() => f.page.evaluate(() => window.deferredBinding.runtime.value.available.value)).toBe(false);
+    }
+    await f.command("accept");
+    assert.equal(await f.page.evaluate(() => window.followerDeferred), false);
+    assert.equal((await f.sent()).length, 1, "a canceled local follower never reaches HTTP behind the original serial predecessor");
+    assert.equal((await f.state()).requests.filter(request => request.suffix === "/cancel").length, action === "stop" ? 1 : 0);
+  });
+}
+
 test("authored application data stays captured across retry, a lost receipt and changed focus", options, async t => {
   const f = await fixture(t);
   const originalData = { clientId: "typed-client", focus: { project: "first", session: "original" } };