@jskit-ai/assistant-runtime 0.1.205 → 0.1.207

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.1.205",
+  "version": "0.1.207",
   "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.212",
+    "@jskit-ai/assistant-core": "0.1.214",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.232",
-    "@jskit-ai/http-web": "0.1.79",
-    "@jskit-ai/kernel": "0.1.234",
-    "@jskit-ai/realtime": "0.1.231",
-    "@jskit-ai/shell-web": "0.1.238",
+    "@jskit-ai/http-runtime": "0.1.234",
+    "@jskit-ai/http-web": "0.1.81",
+    "@jskit-ai/kernel": "0.1.236",
+    "@jskit-ai/realtime": "0.1.233",
+    "@jskit-ai/shell-web": "0.1.240",
     "@tanstack/vue-query": "^5.90.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/database-runtime": "0.1.234"
+    "@jskit-ai/database-runtime": "0.1.236"
   },
   "description": "Capability-based assistant runtime with per-surface chat, transcripts, settings, and action tools.",
   "jskit": {

package/src/client/composables/useAssistantConversation.js

@@ -47,7 +47,19 @@ function draftAfterAcceptedSubmission(currentDraft = "", submittedDraft = "") {
   return submitted && current.startsWith(submitted) ? current.slice(submitted.length) : current;
 }
 
-function createConversation(identity, { api, socket, actorKey, placement, readers, queueWhileSending, deferWhileWorking, draftStorage, application, goalReadEnabled }) {
+function resolveWorkingPolicy(snapshot, { deferWhileWorking, admitWhileWorking }) {
+  const resolve = (name, option) => {
+    const value = typeof option === "function" ? option(snapshot) : option;
+    if (typeof value !== "boolean") throw new TypeError(`${name} must return a boolean.`);
+    return value;
+  };
+  const deferred = resolve("deferWhileWorking", deferWhileWorking);
+  const admitted = resolve("admitWhileWorking", admitWhileWorking);
+  if (deferred && admitted) throw new TypeError("Choose either admitWhileWorking or deferWhileWorking.");
+  return { deferWhileWorking: deferred, admitWhileWorking: admitted };
+}
+
+function createConversation(identity, { api, socket, actorKey, placement, readers, queueWhileSending, deferWhileWorking, admitWhileWorking, draftStorage, application, goalReadEnabled }) {
   const disposed = ref(false);
   const placementRevision = ref(0);
   const stopPlacement = placement.subscribe(() => { placementRevision.value += 1; });
@@ -73,7 +85,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   const loading = ref(true);
   const stopping = ref(false);
   const goalPending = ref(false);
-  const goalLoading = ref(false);
+  const goalTargetCurrent = ref(false);
   const goalError = ref("");
   const goalView = shallowRef(null);
   const goalLoadError = ref("");
@@ -101,8 +113,9 @@ 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 || deferWhileWorking));
-  const canSubmit = computed(() => available.value && (snapshot.value.status === "ready" || steerable.value || deferWhileWorking && snapshot.value.status === "working") &&
+  const workingPolicy = computed(() => resolveWorkingPolicy(snapshot.value, { deferWhileWorking, admitWhileWorking }));
+  const queueing = computed(() => queueWhileSending !== false && (steerable.value || workingPolicy.value.deferWhileWorking || workingPolicy.value.admitWhileWorking));
+  const canSubmit = computed(() => available.value && (snapshot.value.status === "ready" || steerable.value || (workingPolicy.value.deferWhileWorking || workingPolicy.value.admitWhileWorking) && snapshot.value.status === "working") &&
     (queueWhileSending !== false || !delivery.state.sending) &&
     !delivery.state.messages.some(message => message.status === "uncertain"));
   const savedDraft = toValue(draftStorage);
@@ -206,6 +219,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     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.
+      goalTargetCurrent.value = false;
       goalReadController?.abort();
     }
     if (readsGoals.value && (initial || goalChanged || state.segmentId !== goalSegment)) void refreshGoal();
@@ -228,6 +242,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       delivery.reset();
       goalError.value = "";
       goalView.value = null;
+      goalTargetCurrent.value = false;
       goalLoadError.value = "";
       goalReadController?.abort();
     }
@@ -339,8 +354,12 @@ 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;
-    const deferred = deferWhileWorking && !retry && !steering;
-    if ((snapshot.value.status === "working" || delivery.state.sending) && !steering && !deferred) return false;
+    const policy = workingPolicy.value;
+    const deferred = policy.deferWhileWorking && !retry && !steering;
+    // An application queue can admit ordinary messages without native steering
+    // or waiting for ready. It still owns admission, permissions and receipts.
+    const appAdmission = policy.admitWhileWorking && !steering;
+    if ((snapshot.value.status === "working" || delivery.state.sending) && !steering && !deferred && !appAdmission) 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 || ""),
@@ -348,7 +367,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 || deferred), deferred });
+    return submitRequest(captured, { messageId, onAccepted, queue: queueWhileSending !== false && (steering || deferred || appAdmission), deferred, appAdmission });
   }
   function submitPrepared(payload, { messageId = crypto.randomUUID(), onAccepted, prepare } = {}) {
     if (typeof prepare !== "function") throw new TypeError("Prepared submission requires application preparation.");
@@ -406,11 +425,11 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     });
   }
 
-  async function submitRequest(payload, { messageId, onAccepted, queue = false, prepare, deferred = false }) {
+  async function submitRequest(payload, { messageId, onAccepted, queue = false, prepare, deferred = false, appAdmission = 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 pending = { controller: new AbortController(), started: false, dispatched: false, deferred, appAdmission };
     const { controller } = pending;
     pendingMessages.set(messageId, pending);
     try {
@@ -420,7 +439,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
         async deliver(submission) {
           pending.started = true;
           try {
-            if (controller.signal.aborted) return false;
+            if (controller.signal.aborted || appAdmission && (!available.value || stopping.value || !workingPolicy.value.admitWhileWorking)) return false;
             if (deferred) {
               // Refresh through the same subscription after a queued predecessor;
               // its receipt may have arrived before the working snapshot.
@@ -447,7 +466,10 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
             if (controller.signal.aborted) return false;
             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,
+            const rejection = failure.details?.delivery;
+            const notSent = Number.isInteger(failure.status) && failure.status >= 400 && failure.status < 500 &&
+              rejection && !Array.isArray(rejection) && rejection.status === "not-sent" && rejection.messageId === messageId;
+            if (notSent || SEND_REJECTIONS.has(failure.code)) return { ok: false, error: failure.message,
               ...(prepare && failure.code ? { code: failure.code } : {}) };
             throw failure;
           } finally {
@@ -519,7 +541,6 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     const capabilities = snapshot.value.capabilities;
     const controller = new AbortController();
     goalReadController = controller;
-    goalLoading.value = true;
     const job = Promise.resolve().then(() => api.readConversationGoal(identity.conversationId, {
       signal: AbortSignal.any([controller.signal, AbortSignal.timeout(30_000)])
     })).then(result => {
@@ -529,6 +550,9 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       goalView.value = result && Object.hasOwn(result, "target") ? result : {
         status: "available", goal: result, target: { segmentId: segment, capabilities }
       };
+      // A background read does not invalidate this observation. Its supplied
+      // goal target may intentionally differ from the visible chat segment.
+      goalTargetCurrent.value = true;
       goalLoadError.value = "";
       return true;
     }).catch(failure => {
@@ -540,7 +564,6 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       if (goalRead !== job) return;
       goalRead = null;
       goalReadController = null;
-      goalLoading.value = false;
       if (goalReadQueued) {
         goalReadQueued = false;
         void refreshGoal();
@@ -558,7 +581,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     const view = goalView.value;
     const target = view?.target;
     const command = target?.capabilities?.goalCommands?.[action];
-    if (!available.value || view?.status !== "available" || goalLoadError.value || goalPending.value || goalLoading.value ||
+    if (!available.value || view?.status !== "available" || goalLoadError.value || goalPending.value || !goalTargetCurrent.value ||
         !["message", "control"].includes(command?.delivery) ||
         delivery.state.messages.some(message => message.status === "uncertain")) return false;
     if (input.tokenBudget != null && !target.capabilities.goalBudgets) {
@@ -613,7 +636,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       tokenBudgetSupported: capabilities.goalBudgets === true,
       goal: view?.goal ? { ...view.goal, elapsedSeconds: view.goal.timeUsedSeconds,
         sampledAt: Date.parse(view.goal.updatedAt) } : null,
-      pending: goalPending.value || goalLoading.value || !available.value || delivery.state.sending ||
+      pending: goalPending.value || !goalTargetCurrent.value || !available.value || delivery.state.sending ||
         delivery.state.messages.some(message => message.status === "uncertain"),
       error: goalError.value,
       pauseInterruptsTurn: commands.pause?.interruptsTurn === true,
@@ -626,7 +649,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     if (!editable.value || stopping.value) return false;
     stopping.value = true;
     for (const pending of pendingMessages.values()) {
-      if (pending.deferred && !pending.dispatched) pending.controller.abort();
+      if ((pending.deferred || pending.appAdmission) && !pending.dispatched) pending.controller.abort();
     }
     try { return await api.cancelConversation(identity.conversationId); }
     catch (failure) { receiveError(failure); return false; }
@@ -653,7 +676,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     error, accessDenied, loading, stopping, delivery, turns,
     hasMoreBefore, loadingMore, loadMoreError, loadMore,
     send, submitPrepared, submitDraft, cancel, cancelMessage, inspectDelivery, changeGoal, refreshGoal, goalState, goalView, goalLoadError, questions,
-    reload() { const job = subscription?.reload(); void refreshGoal(); return job; } };
+    reload(options) { const job = subscription?.reload(options); void refreshGoal(); return job; } };
   runtime.application = application ? application(runtime) : null;
   return runtime;
 }
@@ -724,7 +747,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, deferWhileWorking = false, draftWhileLoading = false,
+  clearDraftOn: suppliedClearDraftOn, queueWhileSending, deferWhileWorking = false, admitWhileWorking = 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 ||
@@ -736,7 +759,9 @@ 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 (!["boolean", "function"].includes(typeof deferWhileWorking)) throw new TypeError("deferWhileWorking must be a boolean.");
+  if (!["boolean", "function"].includes(typeof admitWhileWorking)) throw new TypeError("admitWhileWorking must be a boolean.");
+  resolveWorkingPolicy(null, { deferWhileWorking, admitWhileWorking });
   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 });
@@ -794,7 +819,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, deferWhileWorking, draftStorage, application, goalReadEnabled: toValue(goal) === true,
+      readers, socket, actorKey, placement, queueWhileSending, deferWhileWorking, admitWhileWorking, 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/src/client/support/subscribeAssistantConversation.js

@@ -65,9 +65,10 @@ function subscribeAssistantConversation({
   function receiveState(snapshot, options) {
     state = snapshot;
     receiveStreaming(snapshot.streaming);
-    publishState({ ...options, canonical: true });
+    publishState({ canonical: true, ...options });
   }
-  function reload() {
+  function reload({ resubscribe = false } = {}) {
+    if (resubscribe) return subscribe({ preserveHistory: true });
     if (!listening) return subscribe();
     if (reloadInFlight) {
       reloadQueued = true;
@@ -179,7 +180,7 @@ function subscribeAssistantConversation({
     if (epoch === null) pending.push(payload);
     else deliver(payload);
   }
-  function subscribe() {
+  function subscribe({ preserveHistory = false } = {}) {
     if (disposed || !socket.connected) return;
     const attempt = ++generation;
     epoch = null;
@@ -206,7 +207,7 @@ function subscribeAssistantConversation({
         return;
       }
       epoch = response.streamEpoch;
-      receiveState(response.state, { initial: true });
+      receiveState(response.state, { initial: !preserveHistory, canonical: !preserveHistory });
       for (const payload of pending.sort((left, right) => left.streamRevision - right.streamRevision)) deliver(payload);
       pending = [];
     });

package/src/server/services/chatService.js

@@ -218,7 +218,9 @@ function createChatService({
       writer.sendDone({ type: ASSISTANT_STREAM_EVENT_TYPES.DONE, messageId: request.messageId, status: "unconfirmed" });
       return { conversationId: response.meta?.conversationId, messageId: request.messageId, status: "unconfirmed" };
     }
-    if (response.failure && !response.meta) throw new AppError(response.failure.status, response.failure.message);
+    if (response.failure && !response.meta) throw new AppError(response.failure.status, response.failure.message, {
+      code: response.failure.code, details: response.failure.details
+    });
     if (response.meta) writer.sendMeta(response.meta);
     if (response.answer) writer.sendAssistantMessage(response.answer);
     if (response.error) writer.sendError(response.error);
@@ -268,7 +270,9 @@ function createChatService({
       result = await executeTurn();
     } catch (error) {
       response.failure = { message: String(error?.message || "Assistant request failed."),
-        status: Number(error?.status || error?.statusCode || 500) };
+        status: Number(error?.status || error?.statusCode || 500),
+        ...(error instanceof AppError ? { code: error.code,
+          ...(error.details && String(error.code).trim() !== "ACTION_PERMISSION_DENIED" ? { details: error.details } : {}) } : {}) };
       await turnRequests.update(claim, response, "failed");
       throw error;
     }

package/test/assistantConversationBinding.browser.test.js

@@ -2479,3 +2479,416 @@ test("canonical loaded-history replay retains older completed output and its aut
   assert.equal(display.assistant.text, "Live older completed reply");
   assert.deepEqual(await f.sent(), []);
 });
+
+
+test("an exact host pre-admission receipt preserves one manual retry and actor and draft guards", options, async t => {
+  const f = await fixture(t);
+  await f.command("mode", { mode: "rejected" });
+  await f.page.route("**/messages", async route => {
+    const response = await route.fetch();
+    const input = route.request().postDataJSON();
+    await route.fulfill({ response, status: 409, json: { code: "host_capture_rejected",
+      error: "The host refused this message before native admission.",
+      details: { delivery: { status: "not-sent", messageId: input.messageId } } } });
+  });
+  await f.page.evaluate(() => window.conversationFixture.data({ originId: "captured-tab", choice: "original" }));
+  await f.input.fill("Retain this exact original request");
+  await f.input.press("Enter");
+  await expect(f.primary.getByText("Failed: The host refused this message before native admission.", { exact: true })).toBeVisible();
+  const [original] = await f.sent();
+  assert.equal(await f.page.evaluate(id => window.conversationFixture.current().delivery.find(id).status, original.input.messageId), "failed");
+  await expect(f.primary.getByRole("button", { name: "Check delivery", exact: true })).toHaveCount(0);
+  await f.input.fill("Keep my newer draft");
+  await f.page.evaluate(() => window.conversationFixture.data({ originId: "newer-tab", choice: "newer" }));
+  assert.equal((await f.sent()).length, 1, "a rejection never retries automatically");
+  await f.page.unroute("**/messages");
+  await f.command("mode", { mode: "accepted" });
+  await f.primary.getByRole("button", { name: "Retry", exact: true }).click();
+  await expect.poll(async () => (await f.sent()).length).toBe(2);
+  const requests = await f.sent();
+  assert.deepEqual(requests[1].input, original.input, "manual Retry retains the ID, words and captured selection/data");
+  await expect(f.input).toHaveValue("Keep my newer draft");
+  await f.page.evaluate(() => {
+    window.rejectedActorRuntime = window.conversationFixture.current();
+    window.conversationFixture.actor("another-actor");
+  });
+  assert.equal(await f.page.evaluate(() => window.rejectedActorRuntime.send({ message: "Must not dispatch" },
+    { messageId: "foreign-actor" })), false);
+  assert.equal((await f.sent()).length, 2, "receipt metadata grants no authority to a retired actor");
+});
+
+for (const kind of ["mismatched-id", "malformed-status", "missing-marker", "post-routing-failure"]) {
+  test(`unconfirmed host delivery metadata remains inspection-only: ${kind}`, options, async t => {
+    const f = await fixture(t);
+    await f.command("mode", { mode: "rejected" });
+    await f.page.route("**/messages", async route => {
+      const response = await route.fetch();
+      const input = route.request().postDataJSON();
+      await route.fulfill({ response, status: kind === "post-routing-failure" ? 500 : 409,
+        json: { code: "host_dispatch_failed", error: "Delivery cannot be confirmed.", details: { delivery: kind === "missing-marker" ? null : {
+          status: kind === "malformed-status" ? "rejected" : "not-sent",
+          messageId: kind === "mismatched-id" ? "another-message" : input.messageId
+        } } } });
+    });
+    await f.input.fill("Do not resubmit unknown work");
+    await f.input.press("Enter");
+    const check = f.primary.getByRole("button", { name: "Check delivery", exact: true });
+    await expect(check).toBeVisible();
+    const [original] = await f.sent();
+    await check.click();
+    await expect.poll(() => f.page.evaluate(id => window.conversationFixture.current().delivery.find(id).checking,
+      original.input.messageId)).toBe(false);
+    assert.equal(await f.page.evaluate(id => window.conversationFixture.current().delivery.find(id).status,
+      original.input.messageId), "uncertain");
+    await expect(f.primary.getByRole("button", { name: "Retry", exact: true })).toHaveCount(0);
+    assert.equal((await f.sent()).length, 1, "missing native/canonical history never proves not-sent or resubmits");
+  });
+}
+
+for (const width of [390, 768, 1280]) {
+  test(`application admission accepts typed and spoken follow-ups during nonsteerable work at ${width}px`, options, async t => {
+    const f = await fixture(t, width);
+    await f.page.evaluate(() => {
+      window.admissionBinding = window.conversationFixture.acquireConversation({
+        conversationId: "chat:2", admitWhileWorking: true, queueWhileSending: true
+      });
+      window.conversationFixture.target("chat:2");
+    });
+    await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current()?.identity.conversationId)).toBe("chat:2");
+    await f.input.fill("Initial request remains working");
+    await f.input.press("Enter");
+    await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().snapshot.value.status)).toBe("working");
+    assert.equal(await f.page.evaluate(() => window.conversationFixture.current().steerable.value), false);
+    await f.command("mode", { mode: "hold" });
+    await f.page.evaluate(() => window.conversationFixture.data({ clientId: "typed", focus: { project: "captured" } }));
+    await f.input.fill("Typed clarification while answering");
+    await f.input.press("Enter");
+    await expect.poll(async () => (await f.state()).held).toBe(1);
+    const typed = (await f.sent())[1].input;
+    await f.page.evaluate(() => {
+      window.conversationFixture.retainVoice();
+      window.admittedSpeech = window.conversationFixture.sendVoice("Spoken clarification 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))[1];
+    assert.equal((await f.sent()).length, 2, "the voice follower waits for the preceding admission receipt");
+    await f.input.fill("Keep this newer draft");
+    await f.command("mode", { mode: "accepted" });
+    await f.command("accept", { holdResponse: true });
+    await f.notify("chat:2");
+    await expect.poll(async () => (await f.sent()).length).toBe(3);
+    assert.deepEqual(typed, {
+      messageId: typed.messageId, text: "Typed clarification while answering",
+      data: { clientId: "typed", focus: { project: "captured" } }
+    });
+    assert.deepEqual((await f.sent())[2].input, {
+      messageId: spoken.id, text: spoken.text, data: { clientId: "voice", focus: { project: "voice-captured" } }
+    });
+    assert.notEqual(typed.messageId, spoken.id);
+    assert.equal((await f.page.evaluate(() => window.admittedSpeech)).status, "accepted");
+    assert.equal((await f.state()).held, 1, "a real canonical receipt releases the queue before the old HTTP response");
+    await f.command("release-response");
+    await expect(f.input).toHaveValue("Keep this newer draft");
+    assert.equal((await f.state()).states["chat:2"].status, "working", "no ready transition is needed for app admission");
+    assert.equal((await f.state()).requests.some(request => request.suffix === "/cancel"), false);
+    assert.equal((await f.sent()).some(request => Object.hasOwn(request.input, "steer")), false);
+    const layout = await f.primary.evaluate(element => {
+      const rect = element.getBoundingClientRect();
+      return { right: rect.right, width: innerWidth, overflow: document.documentElement.scrollWidth > innerWidth };
+    });
+    assert.ok(layout.right <= layout.width + 1);
+    assert.equal(layout.overflow, false);
+  });
+}
+
+for (const action of ["stop", "actor", "denied"]) {
+  test(`application admission retains local-follower fences after ${action}`, options, async t => {
+    const f = await fixture(t);
+    await f.page.evaluate(() => {
+      window.admissionBinding = window.conversationFixture.acquireConversation({
+        conversationId: "chat:2", admitWhileWorking: 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.firstAdmission = window.admissionBinding.runtime.value.send({ message: "First held admission" }, { messageId: "first-app-held" });
+    });
+    await expect.poll(async () => (await f.state()).held).toBe(1);
+    await f.page.evaluate(() => {
+      window.localAdmission = window.admissionBinding.runtime.value.send({ message: "Undispatched follower" }, { messageId: "local-app-follower" });
+    });
+    assert.equal((await f.sent()).length, 1);
+    if (action === "stop") await f.page.evaluate(() => window.admissionBinding.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.admissionBinding.runtime.value.available.value)).toBe(false);
+    }
+    await f.command("accept");
+    assert.equal(await f.page.evaluate(() => window.localAdmission), false);
+    assert.equal((await f.sent()).length, 1, "local followers never dispatch after their scope is stopped or retired");
+    assert.equal((await f.state()).requests.filter(request => request.suffix === "/cancel").length, action === "stop" ? 1 : 0);
+  });
+}
+
+test("application admission keeps unknown delivery inspection-only and rejects conflicting policies", options, async t => {
+  const f = await fixture(t);
+  const invalid = await f.page.evaluate(() => [
+    { admitWhileWorking: "yes" }, { admitWhileWorking: true, deferWhileWorking: true }
+  ].map(options => {
+    try { window.conversationFixture.acquireConversation({ conversationId: "chat:2", ...options }); }
+    catch (failure) { return { name: failure.name, message: failure.message }; }
+    return null;
+  }));
+  assert.deepEqual(invalid, [
+    { name: "TypeError", message: "admitWhileWorking must be a boolean." },
+    { name: "TypeError", message: "Choose either admitWhileWorking or deferWhileWorking." }
+  ]);
+  await f.page.evaluate(() => {
+    window.admissionBinding = window.conversationFixture.acquireConversation({
+      conversationId: "chat:2", admitWhileWorking: 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("question", { id: "chat:2", text: "Still working", pending: true });
+  await f.notify("chat:2");
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().snapshot.value.status)).toBe("working");
+  await f.command("mode", { mode: "uncertain" });
+  await f.input.fill("Do not repeat unknown work");
+  await f.input.press("Enter");
+  const check = f.primary.getByRole("button", { name: "Check delivery", exact: true });
+  await expect(check).toBeVisible();
+  const [original] = await f.sent();
+  await f.input.fill("Keep my newer draft");
+  assert.equal(await f.page.evaluate(() => window.admissionBinding.runtime.value.send({ message: "Cannot bypass uncertainty" })), false);
+  await check.click();
+  await expect.poll(() => f.page.evaluate(id => window.admissionBinding.runtime.value.delivery.find(id).checking,
+    original.input.messageId)).toBe(false);
+  assert.equal((await f.sent()).length, 1);
+  await expect(f.primary.getByRole("button", { name: "Retry", exact: true })).toHaveCount(0);
+  await expect(f.input).toHaveValue("Keep my newer draft");
+});
+
+// Keep the original HTTP/browser fixture; its canonical read carries the real
+// engine independently of a native-looking product model-selection label.
+async function modeAwareAdmissionFixture(t) {
+  const f = await fixture(t, 390);
+  let engine;
+  await f.page.route(/\/api\/assistant\/home\/conversations\/chat%3A2(?:\?.*)?$/u, async route => {
+    const response = await route.fetch();
+    const state = await response.json();
+    await route.fulfill({ response, json: { ...state,
+      engine, assistantSelection: { engineId: "codex" } } });
+  });
+  await f.page.evaluate(() => {
+    const native = snapshot => ["codex", "claude", "opencode"].includes(snapshot?.engine);
+    window.modeBinding = window.conversationFixture.acquireConversation({ conversationId: "chat:2",
+      admitWhileWorking: native, deferWhileWorking: snapshot => !native(snapshot), queueWhileSending: true });
+    window.conversationFixture.target("chat:2");
+    window.modeRuntime = window.modeBinding.runtime.value;
+  });
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current()?.identity.conversationId)).toBe("chat:2");
+  await expect.poll(() => f.page.evaluate(() => window.modeRuntime.available.value)).toBe(true);
+  return { ...f, async engine(value) {
+    engine = value;
+    await f.notify("chat:2");
+    await expect.poll(() => f.page.evaluate(() => window.modeRuntime.snapshot.value?.engine || null)).toBe(value || null);
+  } };
+}
+
+test("mode-aware application admission retains typed and spoken native and API policies at one identity", options, async t => {
+  const f = await modeAwareAdmissionFixture(t);
+  await f.command("question", { id: "chat:2", text: "Unresolved backend is working", pending: true });
+  await f.notify("chat:2");
+  await expect.poll(() => f.page.evaluate(() => window.modeRuntime.snapshot.value.status)).toBe("working");
+  await f.page.evaluate(() => { window.unresolvedAdmission = window.modeRuntime.send({ message: "Wait for original readiness" }); });
+  await expect.poll(() => f.page.evaluate(() => window.modeRuntime.delivery.state.messages.length)).toBe(1);
+  assert.equal((await f.sent()).length, 0, "An unknown backend retains existing deferral");
+  await f.engine("codex");
+  assert.equal((await f.sent()).length, 0, "A captured deferred request is never promoted to native admission");
+  await f.command("question", { id: "chat:2", text: "Unresolved backend is working", pending: false });
+  await f.notify("chat:2");
+  await expect.poll(async () => (await f.sent()).length).toBe(1);
+  assert.equal((await f.page.evaluate(() => window.unresolvedAdmission)).status, "accepted");
+  await expect.poll(() => f.page.evaluate(() => window.modeRuntime.snapshot.value.status)).toBe("working");
+  await f.command("mode", { mode: "hold" });
+  await f.input.fill("Native typed clarification");
+  await f.input.press("Enter");
+  await expect.poll(async () => (await f.state()).held).toBe(1);
+  await f.page.evaluate(() => {
+    window.conversationFixture.retainVoice();
+    window.nativeVoiceAdmission = window.conversationFixture.sendVoice("Native spoken clarification");
+  });
+  await expect.poll(() => f.page.evaluate(() => window.modeRuntime.delivery.state.messages.length)).toBe(2);
+  assert.equal((await f.sent()).length, 2, "Voice waits for the same real predecessor receipt");
+  await f.input.fill("Retain my draft across backend selection");
+  await f.command("mode", { mode: "accepted" });
+  await f.command("accept", { holdResponse: true });
+  await f.notify("chat:2");
+  await expect.poll(async () => (await f.sent()).length).toBe(3);
+  assert.equal((await f.page.evaluate(() => window.nativeVoiceAdmission)).status, "accepted");
+  assert.equal((await f.state()).states["chat:2"].status, "working");
+  await f.command("release-response");
+  await f.command("finish", { id: "chat:2" });
+  await f.engine("api");
+  await expect(f.input).toHaveValue("Retain my draft across backend selection");
+  await f.command("question", { id: "chat:2", text: "API is still answering", pending: true });
+  await f.notify("chat:2");
+  await expect.poll(() => f.page.evaluate(() => window.modeRuntime.snapshot.value.status)).toBe("working");
+  await f.input.fill("API typed clarification");
+  await f.input.press("Enter");
+  await f.page.evaluate(() => { window.apiVoiceAdmission = window.conversationFixture.sendVoice("API spoken clarification"); });
+  await expect.poll(() => f.page.evaluate(() => window.modeRuntime.delivery.state.messages.length)).toBe(2);
+  assert.equal((await f.sent()).length, 3, "A native-looking label cannot bypass the real API mode's ready wait");
+  await f.command("question", { id: "chat:2", text: "API is still answering", pending: false });
+  await f.notify("chat:2");
+  await expect.poll(async () => (await f.sent()).length).toBe(4);
+  assert.equal((await f.sent())[3].input.text, "API typed clarification");
+  await expect.poll(() => f.page.evaluate(() => window.modeRuntime.snapshot.value.status)).toBe("working");
+  assert.equal((await f.sent()).length, 4, "The second API follower retains the preceding-turn barrier");
+  await f.command("finish", { id: "chat:2" });
+  await f.notify("chat:2");
+  await expect.poll(async () => (await f.sent()).length).toBe(5);
+  assert.equal((await f.page.evaluate(() => window.apiVoiceAdmission)).status, "accepted");
+  await f.command("finish", { id: "chat:2" });
+  await f.engine("opencode");
+  await f.command("question", { id: "chat:2", text: "Native work resumes", pending: true });
+  await f.notify("chat:2");
+  await expect.poll(() => f.page.evaluate(() => window.modeRuntime.snapshot.value.status)).toBe("working");
+  assert.equal((await f.page.evaluate(() => window.conversationFixture.sendVoice("Native admission after returning"))).status, "accepted");
+  assert.equal((await f.sent()).length, 6);
+  assert.equal(await f.page.evaluate(() => window.modeRuntime === window.modeBinding.runtime.value &&
+    window.modeRuntime === window.conversationFixture.current()), true);
+  assert.equal((await f.page.evaluate(() => window.conversationFixture.voiceState())).id, "chat:2");
+  assert.equal((await f.sent()).some(request => Object.hasOwn(request.input, "steer")), false);
+  assert.equal((await f.state()).requests.some(request => request.suffix === "/cancel"), false);
+});
+
+test("mode-aware application admission refuses a captured follower after the actual backend changes", options, async t => {
+  const f = await modeAwareAdmissionFixture(t);
+  await f.engine("claude");
+  await f.command("mode", { mode: "hold" });
+  await f.page.evaluate(() => { window.modeFirst = window.modeRuntime.send({ message: "Original in-flight admission" }); });
+  await expect.poll(async () => (await f.state()).held).toBe(1);
+  await f.page.evaluate(() => { window.modeFollower = window.modeRuntime.send({ message: "Local native follower" }); });
+  await expect.poll(() => f.page.evaluate(() => window.modeRuntime.delivery.state.messages.length)).toBe(2);
+  await f.engine("api");
+  await f.command("accept");
+  assert.equal(await f.page.evaluate(() => window.modeFollower), false);
+  assert.equal((await f.sent()).length, 1, "A captured native policy cannot dispatch into a changed API owner");
+  assert.equal((await f.state()).requests.some(request => request.suffix === "/cancel"), false);
+});
+
+test("mode-aware application admission rejects nonboolean asynchronous and conflicting predicates", options, async t => {
+  const f = await fixture(t);
+  const failures = await f.page.evaluate(() => [
+    { admitWhileWorking: () => "yes" },
+    { deferWhileWorking: () => Promise.resolve(true) },
+    { admitWhileWorking: () => true, deferWhileWorking: () => true }
+  ].map(policy => {
+    try { window.conversationFixture.acquireConversation({ conversationId: "chat:2", ...policy }); }
+    catch (error) { return { name: error.name, message: error.message }; }
+    return null;
+  }));
+  assert.deepEqual(failures, [
+    { name: "TypeError", message: "admitWhileWorking must return a boolean." },
+    { name: "TypeError", message: "deferWhileWorking must return a boolean." },
+    { name: "TypeError", message: "Choose either admitWhileWorking or deferWhileWorking." }
+  ]);
+  assert.deepEqual(await f.sent(), []);
+});
+
+test("a background goal read keeps current pinned controls available and serializes actual commands", options, async t => {
+  const f = await fixture(t);
+  const view = { status: "available", goal: { id: "current-goal", objective: "Keep working", status: "active" },
+    target: { segmentId: "pinned-native-goal", capabilities: { goals: true,
+      goalCommands: { pause: { delivery: "control", interruptsTurn: false }, cancel: { delivery: "control", interruptsTurn: false } } } } };
+  const commands = [];
+  let holdRead = false;
+  let releaseRead;
+  let releaseCommand;
+  await f.page.route("**/conversations/*/goal", async route => {
+    if (route.request().method() === "GET") {
+      if (holdRead) await new Promise(resolve => { releaseRead = resolve; });
+      return route.fulfill({ json: view });
+    }
+    commands.push(route.request().postDataJSON());
+    await new Promise(resolve => { releaseCommand = resolve; });
+    return route.fulfill({ json: { ok: true } });
+  });
+  try {
+    await f.page.evaluate(() => window.conversationFixture.eventReaders([{ id: "goal-reader", goal: true }]));
+    await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().goalState.value?.pending)).toBe(false);
+    await f.primary.getByRole("button", { name: "Goal running", exact: true }).click();
+    holdRead = true;
+    await f.page.evaluate(() => { window.fixtureBackgroundGoalRead = window.conversationFixture.current().refreshGoal(); });
+    await expect.poll(() => Boolean(releaseRead)).toBe(true);
+    const pause = f.page.getByRole("button", { name: "Pause goal", exact: true });
+    await expect(pause).toBeEnabled();
+    await pause.click();
+    await expect.poll(() => commands.length).toBe(1);
+    assert.deepEqual(commands[0], { action: "pause", expectedSegmentId: "pinned-native-goal", expectedGoalId: "current-goal" });
+    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();
+    assert.equal(commands.length, 1, "Only the actual Pause command was admitted");
+    holdRead = false;
+    releaseRead();
+    await f.page.evaluate(() => window.fixtureBackgroundGoalRead);
+    assert.deepEqual(await f.sent(), []);
+  } finally {
+    holdRead = false;
+    releaseCommand?.();
+    releaseRead?.();
+  }
+});
+
+test("changing the observed native segment blocks cached goal controls until the replacement read completes", options, async t => {
+  const f = await fixture(t);
+  const commands = [];
+  const view = { status: "available", goal: { id: "old-goal", objective: "Old goal", status: "active" },
+    target: { segmentId: "old-pinned-target", capabilities: { goals: true,
+      goalCommands: { pause: { delivery: "control", interruptsTurn: false } } } } };
+  let held = false;
+  let releaseRead;
+  await f.page.route("**/conversations/*/goal", async route => {
+    if (route.request().method() === "GET") {
+      if (held) await new Promise(resolve => { releaseRead = resolve; });
+      return route.fulfill({ json: view });
+    }
+    commands.push(route.request().postDataJSON());
+    return route.fulfill({ json: { ok: true } });
+  });
+  try {
+    await f.page.evaluate(() => window.conversationFixture.eventReaders([{ id: "goal-reader", goal: true }]));
+    await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().goalState.value?.pending)).toBe(false);
+    held = true;
+    await f.command("goals", { id: "chat:1", segmentId: "replacement-native-observation", budgets: false,
+      commands: view.target.capabilities.goalCommands });
+    await f.notify("chat:1");
+    await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().snapshot.value.segmentId)).toBe("replacement-native-observation");
+    await expect.poll(() => Boolean(releaseRead)).toBe(true);
+    assert.equal(await f.page.evaluate(() => window.conversationFixture.current().goalState.value.pending), true);
+    assert.equal(await f.page.evaluate(() => window.conversationFixture.current().changeGoal("pause")), false);
+    assert.deepEqual(commands, [], "A previous observation cannot authorize a command for the replacement thread");
+    view.goal.id = "replacement-goal";
+    view.target.segmentId = "replacement-pinned-target";
+    held = false;
+    releaseRead();
+    await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().goalState.value.pending)).toBe(false);
+    assert.deepEqual(await f.page.evaluate(() => window.conversationFixture.current().changeGoal("pause")), { ok: true });
+    assert.deepEqual(commands, [{ action: "pause", expectedSegmentId: "replacement-pinned-target", expectedGoalId: "replacement-goal" }]);
+    assert.deepEqual(await f.sent(), []);
+  } finally {
+    held = false;
+    releaseRead?.();
+  }
+});

package/test/assistantConversationSubscriptions.test.js

@@ -736,7 +736,7 @@ test("removing the integration releases every observer and callback while the sh
   assert.equal(f.serverSockets.size, 0, "Provider shutdown also runs unrelated connection cleanup");
 });
 
-async function hostSubscriptionFixture(t, authService = null) {
+async function hostSubscriptionFixture(t, authService = null, conversationRuntime = null) {
   const changes = new EventEmitter();
   const notify = () => changes.emit("change");
   const listeners = new Set();
@@ -753,7 +753,7 @@ async function hostSubscriptionFixture(t, authService = null) {
     notify();
     return () => { listeners.delete(listener); notify(); };
   } };
-  const definitions = createAssistantActions({ config, conversationRuntime: { async open() { return conversation; } } });
+  const definitions = createAssistantActions({ config, conversationRuntime: conversationRuntime || { async open() { return conversation; } } });
   const original = definitions.find(definition => definition.id === actionIds.conversationSubscribe);
   const hostActionId = "test.host.conversation.subscribe";
   actions.register({ contributorId: "test.host", domain: "assistant", actions: [...definitions, {
@@ -990,3 +990,115 @@ test("denied Reload before the initial acknowledgement retires only that pending
   assert.equal(reads, 1, "Recovery uses fresh subscription admission rather than repeating the old read or inference");
   assert.deepEqual(errors, [failure]);
 });
+
+
+test("retargeting a retained logical observer uses the current engine namespace and original same-ID subscription owner", { timeout: 20_000 }, async t => {
+  let selected = "opencode";
+  let allowed = true;
+  const states = new Map(["opencode", "codex"].map(engine => [engine, {
+    engine, configuration: {}, status: "ready", conversationLog: [], threadId: `${engine}-thread`
+  }]));
+  const oldMessage = { messageId: "old-overlay", role: "assistant", turnId: "old-turn", status: "inProgress", text: "Old engine overlay" };
+  const streams = new Map([["opencode", { revision: 100, messages: [oldMessage] }], ["codex", { revision: 0, messages: [] }]]);
+  const originalListeners = new Map();
+  let sends = 0;
+  let active = 0;
+  let maximum = 0;
+  const commands = { async send() { sends += 1; }, async cancel() {}, async select() {}, async inspectDelivery() {} };
+  const runtime = createConversationRuntime({ authorize: () => allowed, host: {
+    async conversation({ id, context }) {
+      const engine = context.selected;
+      return { namespace: `${engine}:${id}`, sessionId: id, engine, commands,
+        read: () => states.get(engine), readStream: () => streams.get(engine) };
+    }
+  } });
+  t.after(() => runtime.close());
+  async function current() { return runtime.open({ id: "host-conversation", context: { selected } }); }
+  const f = await hostSubscriptionFixture(t, null, { async open() {
+    return { read: async () => (await current()).read(), async subscribe(listener) {
+      const engine = selected;
+      const release = await (await current()).subscribe(listener);
+      originalListeners.set(engine, listener);
+      active += 1;
+      maximum = Math.max(maximum, active);
+      return () => { release(); active -= 1; };
+    } };
+  } });
+  f.registerHost();
+  const socket = await f.connect();
+  const requests = [];
+  const timeout = socket.timeout.bind(socket);
+  socket.timeout = milliseconds => {
+    const target = timeout(milliseconds);
+    return { emit(name, input, acknowledge) {
+      requests.push({ name, input });
+      return target.emit(name, input, acknowledge);
+    } };
+  };
+  const loaded = [];
+  const errors = [];
+  const updates = [];
+  const release = subscribeAssistantConversation({ socket, conversationId: "host-conversation",
+    targetSurfaceId: "home", hostSurfaceId: "home", read: async () => (await current()).read(),
+    onState(state, options) { loaded.push({ state, options }); f.changes.emit("change"); },
+    onEvent(event) { updates.push(event); f.changes.emit("change"); },
+    onError(error) { errors.push(error); f.changes.emit("change"); } });
+  t.after(release);
+  await until(f.changes, () => loaded.length === 1);
+  assert.equal(loaded[0].state.engine, "opencode");
+  assert.equal(loaded[0].options.initial, true);
+  assert.equal(loaded[0].state.streaming.revision, 100);
+  assert.ok(loaded[0].state.turns.some(turn => turn.assistant?.text === oldMessage.text));
+  selected = "codex";
+  await release.reload();
+  assert.equal(loaded.at(-1).state.engine, "codex", "A canonical read can already use the successor owner");
+  assert.equal(f.calls.length, 1, "Ordinary Reload does not retarget the original observer");
+  await runtime.publishNative({ namespace: "codex:host-conversation", sessionId: "host-conversation", event: { type: "phase", phase: "working" } });
+  assert.equal(updates.length, 0, "The new engine namespace has no observer before retargeting");
+
+  release.reload({ resubscribe: true });
+  await until(f.changes, () => loaded.length === 3);
+  assert.equal(f.calls.length, 2);
+  assert.equal(active, 1);
+  assert.equal(maximum, 1, "The original server releases the predecessor before attaching its successor");
+  assert.deepEqual(loaded.at(-1).options, { initial: false, canonical: false }, "Retarget snapshot preserves the mounted loaded history");
+  assert.equal(loaded.at(-1).state.streaming.revision, 0, "The original epoch transition resets the predecessor's high stream revision");
+  assert.equal(loaded.at(-1).state.turns.some(turn => turn.assistant?.text === oldMessage.text), false);
+  originalListeners.get("opencode")({ type: "phase", phase: "obsolete" });
+  originalListeners.get("opencode")({ type: "message", ...oldMessage, text: "Late foreign overlay",
+    streaming: { revision: 200, messages: [{ ...oldMessage, text: "Late foreign overlay" }] } });
+  const partial = { messageId: "answer", role: "assistant", turnId: "000001", status: "inProgress", text: "New engine partial" };
+  streams.set("codex", { revision: 1, messages: [partial] });
+  await runtime.publishNative({ namespace: "codex:host-conversation", sessionId: "host-conversation", event: {
+    payload: { conversationStream: streams.get("codex") }
+  } });
+  await until(f.changes, () => loaded.at(-1).state.turns.some(turn => turn.assistant?.text === partial.text));
+  assert.equal(loaded.at(-1).state.streaming.revision, 1);
+  assert.equal(loaded.at(-1).state.turns.some(turn => turn.assistant?.text === "Late foreign overlay"), false);
+  await runtime.publishNative({ namespace: "codex:host-conversation", sessionId: "host-conversation", event: { type: "phase", phase: "working" } });
+  await until(f.changes, () => updates.some(event => event.phase === "working"));
+  assert.equal(requests.length, 2);
+  assert.ok(requests.every(request => request.name === ASSISTANT_CONVERSATION_SUBSCRIBE));
+  assert.equal(requests[1].input.subscriptionId, requests[0].input.subscriptionId);
+  assert.equal(f.published.at(-1).realtime.payload.subscriptionId, requests[0].input.subscriptionId);
+  assert.equal(updates.some(event => event.phase === "obsolete"), false, "Late retired observer callbacks cannot publish");
+  const answer = { messageId: "answer", role: "assistant", text: "Final from the selected engine" };
+  states.set("codex", { ...states.get("codex"), status: "ready", conversationLog: [{ turnId: "000001", messages: [answer], assistant: answer }] });
+  streams.set("codex", { revision: 2, messages: [] });
+  await runtime.publishNative({ namespace: "codex:host-conversation", sessionId: "host-conversation", event: {
+    payload: { conversationLogPatch: { type: "upsert-turn", turn: states.get("codex").conversationLog[0] },
+      conversationStream: streams.get("codex"), agentSession: { turn: { active: false } } }
+  } });
+  await until(f.changes, () => loaded.at(-1).state.status === "ready" && loaded.at(-1).state.turns.some(turn => turn.assistant?.text === answer.text));
+  assert.equal(sends, 0, "Observer refresh and final-state recovery never admit inference");
+  assert.deepEqual(errors, []);
+  allowed = false;
+  release.reload({ resubscribe: true });
+  await until(f.changes, () => errors.length === 1);
+  assert.equal(active, 0, "Revoked access releases the predecessor and cannot attach another observer");
+  assert.equal(errors[0].statusCode, 403);
+  release();
+  release.reload({ resubscribe: true });
+  assert.equal(active, 0);
+  assert.equal(sends, 0);
+});

package/test/sqlConversationStorage.test.js

@@ -4,6 +4,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import knex from "knex";
+import { AppError } from "@jskit-ai/kernel/server/runtime";
 import { createConversationTranscript } from "@jskit-ai/assistant-core/server/conversation";
 import { verifyConversationStorageContract } from "@jskit-ai/assistant-core/testing/conversation-storage";
 import transcriptsMigration from "../migrations/assistant_transcripts_initial.cjs";
@@ -203,3 +204,221 @@ test("the SQL facade uses common inference and durable tool rows while supplied
     { code: "conversation_forbidden" });
   }
 });
+
+test("the SQL facade replays historical inspection failures with their exact public code and row IDs without executing work", async t => {
+  const f = await fixture(t);
+  const conversation = await f.conversation();
+  const first = await f.messagesRepository.create({ conversationId: conversation.id, role: "user",
+    clientMessageSid: "first-legacy-question", contentText: "First" });
+  const next = await f.messagesRepository.create({ conversationId: conversation.id, role: "user",
+    clientMessageSid: "next-legacy-question", contentText: "Next" });
+  await f.messagesRepository.create({ conversationId: conversation.id, role: "assistant", contentText: "Unknown owner" });
+  const unchanged = await rows(f.db);
+  let inference = 0;
+  let effects = 0;
+  const aiClientFactory = { resolveClient: () => ({ enabled: true, provider: "test", defaultModel: "test",
+    createChatCompletionStream() { inference++; assert.fail("Historical inspection cannot invoke inference"); } }) };
+  const catalog = { resolveToolSet: () => ({ tools: [] }),
+    executeToolCall() { effects++; assert.fail("Historical inspection cannot invoke application effects"); } };
+  const runtime = createAssistantConversationRuntime({ ...f, aiClientFactory, toolCatalog: catalog });
+  t.after(() => runtime.close());
+  const turnRequests = createTurnRequestsRepository(f.db);
+  const dependencies = { conversationRuntime: runtime, aiClientFactory, serviceToolCatalog: catalog,
+    transcriptService: createTranscriptService(f), turnRequests,
+    assistantConfigService: { resolveSystemPrompt: async () => "Read the supplied context" },
+    appConfig: { surfaceDefinitions: { assistant: { enabled: true, requiresWorkspace: false } },
+      assistantSurfaces: { assistant: { settingsSurfaceId: "assistant", configScope: "global" } } } };
+  const input = { targetSurfaceId: "assistant", conversationId: conversation.id,
+    messageId: "inspect-legacy-history", input: "Continue", history: [] };
+  const events = [];
+  const options = { context: { actor: { id: "1" } }, streamWriter: Object.fromEntries(
+    ["sendMeta", "sendAssistantDelta", "sendAssistantMessage", "sendToolCall", "sendToolResult", "sendError", "sendDone"]
+      .map(name => [name, event => events.push({ name, event })])) };
+  const expectedDetails = { issues: [{ code: "overlapping_historical_turns", rowIds: [first.id, next.id] }] };
+  const requireInspection = error => {
+    assert.equal(error instanceof AppError, true);
+    assert.equal(error.status, 409);
+    assert.equal(error.code, "assistant_history_inspection_required");
+    assert.deepEqual(error.details, expectedDetails);
+    return true;
+  };
+  await assert.rejects(createChatService(dependencies).streamChat(input, options), requireInspection);
+  const receipt = await f.db("assistant_turn_requests").first();
+  assert.equal(receipt.status, "failed");
+  const restarted = createChatService({ ...dependencies, turnRequests: createTurnRequestsRepository(f.db) });
+  await assert.rejects(restarted.streamChat(input, options), requireInspection);
+  assert.deepEqual(JSON.parse(receipt.response_json).failure, {
+    message: "This conversation has ambiguous historical SQL rows. Inspect the reported rows offline before using the common runtime; no history was changed.",
+    status: 409, code: "assistant_history_inspection_required", details: expectedDetails
+  });
+  assert.deepEqual(await f.db("assistant_turn_requests"), [receipt], "Replay preserves the original request claim");
+  assert.deepEqual(await rows(f.db), unchanged, "Inspection and replay leave historical rows and metadata untouched");
+  assert.deepEqual(events, [], "The refused request never starts a stream");
+  assert.equal(inference, 0);
+  assert.equal(effects, 0);
+
+  const oldFailure = { message: "Previously recorded failure", status: 409 };
+  const oldInput = { ...input, messageId: "old-failure-receipt" };
+  const oldClaim = await turnRequests.claim({ actorUserId: "1", surfaceId: "assistant", workspaceId: null },
+    { conversationId: conversation.id, messageId: oldInput.messageId, input: oldInput.input, history: [], integrationId: "" });
+  await turnRequests.update(oldClaim, { failure: oldFailure }, "failed");
+  await assert.rejects(restarted.streamChat(oldInput, options), error => {
+    assert.equal(error.status, oldFailure.status);
+    assert.equal(error.message, oldFailure.message);
+    assert.equal(error.code, "APP_ERROR");
+    assert.equal(error.details, undefined);
+    return true;
+  });
+  const oldSaved = await turnRequests.find({ actorUserId: "1", surfaceId: "assistant", workspaceId: null }, oldInput.messageId);
+  assert.deepEqual(oldSaved.response, { failure: oldFailure }, "Replay does not backfill historical failure receipts");
+
+  for (const [index, failure] of [
+    new AppError(403, "Permission denied", { code: "ACTION_PERMISSION_DENIED", details: { privateRule: "private-permission-probe" } }),
+    Object.assign(new Error("Request failed"), { status: 503, code: "PRIVATE_ENGINE_ERROR", details: { privateRule: "private-permission-probe" } })
+  ].entries()) {
+    const hiddenInput = { ...input, messageId: `private-failure-${index}` };
+    const denied = createChatService({ ...dependencies, assistantConfigService: {
+      resolveSystemPrompt() { throw failure; }
+    } });
+    await assert.rejects(denied.streamChat(hiddenInput, options), error => error === failure);
+    const saved = await turnRequests.find({ actorUserId: "1", surfaceId: "assistant", workspaceId: null }, hiddenInput.messageId);
+    assert.deepEqual(saved.response.failure, { message: failure.message, status: failure.status,
+      ...(failure instanceof AppError ? { code: "ACTION_PERMISSION_DENIED" } : {}) });
+    assert.doesNotMatch(JSON.stringify(saved.response), /private-permission-probe|PRIVATE_ENGINE_ERROR|stack/u);
+    await assert.rejects(restarted.streamChat(hiddenInput, options), error => {
+      assert.equal(error.status, failure.status);
+      assert.equal(error.code, failure instanceof AppError ? "ACTION_PERMISSION_DENIED" : "APP_ERROR");
+      assert.equal(error.details, undefined);
+      return true;
+    });
+  }
+  assert.equal(inference, 0);
+  assert.equal(effects, 0);
+  assert.deepEqual(await rows(f.db), unchanged);
+});
+
+for (const shape of ["orphan-output", "orphan-tool-result", "unconfirmed-tool"]) {
+  test(`the original SQL facade retains ${shape} history and admits only an authorized fresh conversation`, async t => {
+    const f = await fixture(t);
+    const conversation = await f.conversationsRepository.create({ createdByUserId: "1", surfaceId: "assistant",
+      workspaceId: "77", metadata: { retainedHistory: shape } });
+    const fields = { conversationId: conversation.id, workspaceId: "77", actorUserId: "1", role: "assistant", kind: "chat" };
+    if (shape !== "orphan-output") {
+      await f.messagesRepository.create({ ...fields, role: "user", clientMessageSid: "legacy-question", contentText: "Existing question" });
+    }
+    const offending = await f.messagesRepository.create({ ...fields,
+      ...(shape === "orphan-output" ? { contentText: "Answer without an authored row" }
+        : { kind: shape === "orphan-tool-result" ? "tool_result" : "tool_call",
+          contentText: shape === "orphan-tool-result" ? '{"ok":true,"result":{"found":1}}' : "{}",
+          metadata: { toolCallId: "legacy-operation", tool: "inventory_lookup" } }) });
+    const issueCode = { "orphan-output": "orphan_output", "orphan-tool-result": "orphan_tool_result",
+      "unconfirmed-tool": "unconfirmed_historical_tool" }[shape];
+    const expectedDetails = { issues: [{ code: issueCode, rowIds: [offending.id] }] };
+    const unchanged = await rows(f.db);
+    const historical = await f.messagesRepository.listByConversationScope(conversation.id, { workspaceId: "77" });
+    let allowFreshInference = false;
+    const requests = [];
+    let effects = 0;
+    const aiClientFactory = { resolveClient: () => ({ enabled: true, provider: "test", defaultModel: "fixture-model",
+      async createChatCompletionStream(request) {
+        assert.equal(allowFreshInference, true, "Historical refusal and foreign admission must not start inference");
+        requests.push(structuredClone(request.messages));
+        return (async function* () {
+          yield { choices: [{ delta: { content: "Fresh answer." }, finish_reason: "stop" }] };
+        })();
+      } }) };
+    const catalog = { limits: { maxToolArgumentBytes: 4096 }, resolveToolSet: () => ({ tools: [] }),
+      toOpenAiToolSchema: tool => ({ type: "function", function: tool }),
+      executeToolCall() { effects++; assert.fail("Retained history cannot repeat an application effect"); } };
+    const runtime = createAssistantConversationRuntime({ ...f, aiClientFactory, toolCatalog: catalog });
+    t.after(() => runtime.close());
+    const turnRequests = createTurnRequestsRepository(f.db);
+    const dependencies = { conversationRuntime: runtime, aiClientFactory, serviceToolCatalog: catalog,
+      transcriptService: createTranscriptService(f), turnRequests,
+      assistantConfigService: { resolveSystemPrompt: async () => "Read only the admitted request" },
+      workspaceScopeSupport: { resolveWorkspace: context => context.requestMeta.resolvedWorkspaceContext.workspace },
+      appConfig: { surfaceDefinitions: {
+        assistant: { enabled: true, requiresWorkspace: true }, other: { enabled: true, requiresWorkspace: true }
+      }, assistantSurfaces: {
+        assistant: { settingsSurfaceId: "assistant", configScope: "workspace" },
+        other: { settingsSurfaceId: "other", configScope: "workspace" }
+      } } };
+    const events = [];
+    const options = { input: { targetSurfaceId: "assistant" },
+      context: { actor: { id: "1" }, requestMeta: { resolvedWorkspaceContext: { workspace: { id: "77" } } } },
+      streamWriter: Object.fromEntries(
+        ["sendMeta", "sendAssistantDelta", "sendAssistantMessage", "sendToolCall", "sendToolResult", "sendError", "sendDone"]
+          .map(name => [name, event => events.push({ name, event })])) };
+    const input = { targetSurfaceId: "assistant", conversationId: conversation.id, messageId: "inspect-retained-history",
+      input: "Continue", history: [] };
+    const service = createChatService(dependencies);
+    await assert.rejects(service.streamChat(input, options), error => {
+      assert.equal(error instanceof AppError, true);
+      assert.equal(error.status, 409);
+      assert.equal(error.code, "assistant_history_inspection_required");
+      assert.deepEqual(error.details, expectedDetails);
+      return true;
+    });
+    const receipt = await f.db("assistant_turn_requests").first();
+    const restarted = createChatService({ ...dependencies, turnRequests: createTurnRequestsRepository(f.db) });
+    await assert.rejects(restarted.streamChat(input, options), error => {
+      assert.equal(error.status, 409);
+      assert.equal(error.code, "assistant_history_inspection_required");
+      assert.deepEqual(error.details, expectedDetails);
+      return true;
+    });
+    assert.deepEqual(await rows(f.db), unchanged, "Refusal and replay cannot repair or discard historical rows");
+    assert.deepEqual(await f.db("assistant_turn_requests"), [receipt], "Exact-ID replay preserves the failed claim");
+    assert.deepEqual(events, []);
+    assert.equal(requests.length, 0);
+    assert.equal(effects, 0);
+    const listed = await restarted.listConversations({}, options);
+    assert.equal(listed.items.some(entry => entry.id === conversation.id), true);
+    const loaded = await restarted.getConversationMessages(conversation.id, {}, options);
+    assert.deepEqual(loaded.entries, historical, "Authorized browsing reads original rows independently of common projection");
+
+    for (const [index, foreign] of [
+      { surface: "assistant", actor: "2", workspace: "77" },
+      { surface: "other", actor: "1", workspace: "77" },
+      { surface: "assistant", actor: "1", workspace: "78" }
+    ].entries()) {
+      const deniedOptions = { ...options, input: { targetSurfaceId: foreign.surface }, context: {
+        actor: { id: foreign.actor }, requestMeta: { resolvedWorkspaceContext: { workspace: { id: foreign.workspace } } }
+      } };
+      await assert.rejects(restarted.getConversationMessages(conversation.id, {}, deniedOptions), error => {
+        assert.equal(error.status, 404);
+        assert.equal(error.details, undefined, "Foreign readers cannot inspect row IDs");
+        return true;
+      });
+      assert.equal((await restarted.listConversations({}, deniedOptions)).items.some(entry => entry.id === conversation.id), false);
+      await assert.rejects(restarted.streamChat({ ...input, targetSurfaceId: foreign.surface,
+        messageId: `foreign-history-${index}` }, deniedOptions), error => {
+        assert.equal(error.status, 404);
+        assert.equal(error.details, undefined, "Foreign sends fail before historical inspection");
+        return true;
+      });
+      await assert.rejects(runtime.open({ id: conversation.id, context: { actor: { id: foreign.actor },
+        surface: foreign.surface, assistantRequest: { conversation, workspace: { id: foreign.workspace }, history: [] } } }),
+      { code: "conversation_forbidden" });
+    }
+    assert.deepEqual(await rows(f.db), unchanged);
+    assert.deepEqual(events, []);
+    assert.equal(requests.length, 0);
+    assert.equal(effects, 0);
+
+    allowFreshInference = true;
+    const fresh = await restarted.streamChat({ targetSurfaceId: "assistant", messageId: "fresh-after-inspection",
+      input: "A new independent request", history: [] }, options);
+    assert.equal(fresh.status, "completed", JSON.stringify(events));
+    assert.notEqual(fresh.conversationId, conversation.id);
+    assert.equal(requests.length, 1, "A fresh conversation uses one admitted model response");
+    assert.equal(requests[0].some(message => message.content === "Existing question" ||
+      message.content === "Answer without an authored row"), false, "Fresh admission does not reseed ambiguous history");
+    assert.equal(effects, 0, "Fresh recovery cannot replay an unconfirmed legacy effect");
+    assert.equal(events.at(-1).name, "sendDone");
+    assert.deepEqual(await f.db("assistant_messages").where({ conversation_id: conversation.id }).orderBy("id"), unchanged.messages);
+    assert.deepEqual(await f.db("assistant_conversations").where({ id: conversation.id }).orderBy("id"), unchanged.conversations);
+    assert.deepEqual(await f.db("assistant_turn_requests").where({ id: receipt.id }), [receipt]);
+    assert.deepEqual((await restarted.getConversationMessages(conversation.id, {}, options)).entries, historical);
+  });
+}