@jskit-ai/assistant-runtime 0.1.218 → 0.1.220

package/README.md

@@ -0,0 +1,29 @@
+
+With the existing realtime diagnostic option (`JSKIT_REALTIME_DEBUG=1`, or
+`config.realtime.debug=true`), conversation subscriptions emit one `pending`
+warning if admission/snapshot reading has not returned within the client's
+10-second acknowledgement budget. The warning names the current stage and the
+server-generated epoch; a conversation identity is included only after its
+successful authorized open. Observer release also records the current stage and
+reason. While diagnostics are enabled, every stage transition is recorded at
+warning level with its duration and total elapsed time, so warning-only logs
+retain the earlier admission costs as well as the step pending at timeout.
+Timers are removed on acknowledgement, failure, replacement, unsubscribe
+and connection close. Diagnostics contain no request body or conversation text,
+and do not change authorization, subscription deadlines or model work.
+
+Released subscriptions stop setup at the next completed phase. The existing
+socket owner supplies its current subscription identity to the subscribe action;
+an obsolete open cannot attach a new observer, and a late observer is detached
+without starting a snapshot. Reads already in progress may finish, but cannot
+acknowledge into a replacement view. Reload performs fresh authorization, and
+releasing a view never stops its model turn.
+
+Prepared application submissions may explicitly enable `queueWhileSending` to
+reuse the binding's serial delivery queue while application preparation is still
+running. Each queued request retains its captured payload and receipt identity.
+Stop and conversation retirement cancel queued preparation through the existing
+owner. A typed, definite ended-turn rejection may become one ordinary Send with
+the same identity, without repeating preparation; uncertain delivery never
+permits replay. With the option absent or false, prepared submissions retain
+their existing non-queueing behavior.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.1.218",
+  "version": "0.1.220",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -12,7 +12,7 @@
     "./server": "./src/server/index.js"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.225",
+    "@jskit-ai/assistant-core": "0.1.227",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {

package/src/client/composables/useAssistantConversation.js

@@ -390,7 +390,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       throw new TypeError("Prepared submission requires an authored conversation request.");
     }
     if (!current.value || accessDenied.value || retry && retry.status !== "failed") return Promise.resolve(false);
-    return submitRequest(captured, { messageId, onAccepted, prepare });
+    return submitRequest(captured, { messageId, onAccepted, prepare, queue: queueWhileSending === true });
   }
   async function submitDraft(payload, { messageId = crypto.randomUUID(), submissionKind = steerable.value ? "steer" : "send",
     questionText = "", onAccepted } = {}) {
@@ -463,7 +463,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
                 return { ok: false, error: "This conversation no longer accepts attachments." };
               }
             }
-            const request = prepare ? await prepare(submission, { signal: controller.signal }) : submission.request;
+            let request = prepare ? await prepare(submission, { signal: controller.signal }) : submission.request;
             if (prepare) {
               if (!current.value || accessDenied.value || controller.signal.aborted || request === false) return false;
               if (!request || typeof request !== "object" || Array.isArray(request)) {
@@ -471,9 +471,31 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
               }
             }
             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 }));
+            for (let attempt = 0; ; attempt += 1) {
+              try {
+                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) {
+                // The server identifies this exact pre-admission race. Keep the
+                // same queued words/attachments/identity and try ordinary Send
+                // once. A timeout, generic rejection or uncertain send never
+                // grants another dispatch.
+                if (attempt !== 0 || submission.goalRequest || request.steer !== true ||
+                    failure.code !== "conversation_steer_turn_finished" || failure.status !== 409 ||
+                    failure.details?.delivery && (failure.details.delivery.status !== "not-sent" ||
+                      failure.details.delivery.messageId !== messageId)) throw failure;
+                const retained = delivery.find(messageId);
+                if (retained?.status === "accepted" || turns.value.some(turn => turn.user?.messageId === messageId && turn.user.receipt !== false)) return { ok: true };
+                if (!current.value || accessDenied.value || controller.signal.aborted || !retained || retained.status !== "pending") return false;
+                const { steer: _finishedTurn, ...nextRequest } = request;
+                request = nextRequest;
+                // Retain the new dispatch intent if Send itself fails; Retry
+                // must not loop back through the obsolete steering request.
+                retained.payload.request = nextRequest;
+                retained.payload.submissionKind = "send";
+              }
+            }
           }
           catch (failure) {
             if (controller.signal.aborted) return false;
@@ -482,7 +504,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
             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,
+            if (notSent || SEND_REJECTIONS.has(failure.code) || failure.code === "conversation_steer_turn_finished" && failure.status === 409 && !failure.details?.delivery) return { ok: false, error: failure.message,
               ...(prepare && failure.code ? { code: failure.code } : {}) };
             throw failure;
           } finally {
@@ -650,12 +672,13 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       loading,
       available: Boolean(goalAvailable),
       action: goalAction.value,
+      working: snapshot.value?.status === "working",
       tokenBudgetSupported: capabilities.goalBudgets === true,
       goal: goalAvailable && view?.goal ? { ...view.goal, elapsedSeconds: view.goal.timeUsedSeconds,
         sampledAt: Date.parse(view.goal.updatedAt) } : null,
       pending: Boolean(goalAction.value) || !goalAvailable || !available.value || delivery.state.sending ||
         delivery.state.messages.some(message => message.status === "uncertain"),
-      error: goalError.value || goalLoadError.value,
+      error: goalError.value || goalLoadError.value || view?.error || "",
       pauseInterruptsTurn: commands.pause?.interruptsTurn === true,
       cancelInterruptsTurn: commands.cancel?.interruptsTurn === true,
       ...Object.fromEntries(["set", "resume", "pause", "cancel"].filter(action =>
@@ -680,7 +703,10 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     try {
       const receipt = await api.inspectConversationDelivery(identity.conversationId, messageId);
       if (!current.value) return false;
-      if (receipt.status === "accepted") delivery.accept(messageId);
+      if (receipt.status === "accepted") {
+        delivery.accept(messageId);
+        if (receipt.messageId === messageId && message?.payload.goalRequest) goalError.value = "";
+      }
       else if (receipt.status === "not-sent" && receipt.messageId === messageId) delivery.rejectUnsent(messageId, receipt.error);
       else if (receipt.status === "unknown" && message?.status === "uncertain") {
         message.error = "Delivery is still unknown. Retry to check again.";

package/src/server/AssistantProvider.js

@@ -98,11 +98,12 @@ const AssistantFeature = defineFeature({
       config
     });
   },
-  boot({ conversationRuntime, conversationAccess, realtime, events, config, workspaces, logger }, { outputs }) {
+  boot({ conversationRuntime, conversationAccess, realtime, events, config, env, workspaces, logger }, { outputs }) {
     if (!conversationRuntime || !realtime) return;
     const state = subscriptionLifecycle.get(outputs.assistant);
     state.release = registerConversationSubscriptions({
       realtime, events, actions: state.actions, config, logger, workspaceScopeSupport: workspaces?.scope || null,
+      diagnostics: ["1", "true", "yes", "on"].includes(String(env?.JSKIT_REALTIME_DEBUG ?? config?.realtime?.debug ?? "").trim().toLowerCase()),
       ...(conversationAccess ? {
         subscribeActionId: conversationAccess.subscribeActionId,
         requestPolicy: conversationAccess.requestPolicy

package/src/server/actions.js

@@ -201,12 +201,15 @@ function createConversationActions({ conversationRuntime, conversationDataSchema
         if (typeof deps?.onEvent !== "function" || typeof deps?.onRelease !== "function") {
           throw new TypeError("Conversation subscriptions require their server-owned event and cleanup callbacks.");
         }
+        if (deps.isCurrent?.() === false) return null;
         deps.onStage?.("conversation-open");
         const conversation = await openConversation(input, context);
+        if (deps.isCurrent?.() === false) return null;
         deps.onStage?.("observer-attach");
         const release = await conversation.subscribe(deps.onEvent);
         try {
           deps.onRelease(release);
+          if (deps.isCurrent?.() === false) return null;
           deps.onStage?.("snapshot-read");
           return await conversation.read();
         } catch (error) {

package/src/server/registerConversationSubscriptions.js

@@ -31,7 +31,7 @@ function subscriptionError(error) {
 // A host may select its fixed action/request policy at composition; clients
 // never choose either. The selected action remains the authorization boundary.
 function registerConversationSubscriptions({ realtime, events, actions, config = {}, logger = null, workspaceScopeSupport = null,
-  subscribeActionId = actionIds.conversationSubscribe, requestPolicy = "authenticated" } = {}) {
+  subscribeActionId = actionIds.conversationSubscribe, requestPolicy = "authenticated", diagnostics = false } = {}) {
   if (typeof realtime?.onConnection !== "function" || typeof events?.publish !== "function") {
     throw new TypeError("Conversation subscriptions require the shared realtime connection and event runtime.");
   }
@@ -50,10 +50,11 @@ function registerConversationSubscriptions({ realtime, events, actions, config =
     const subscriptions = new Map();
     let closed = false;
 
-    function release(subscriptionId) {
+    function release(subscriptionId, reason = "unsubscribe") {
       const subscription = subscriptions.get(subscriptionId);
       if (!subscription) return;
       subscriptions.delete(subscriptionId);
+      subscription.diagnosticRelease?.(reason);
       clearTimeout(subscription.timer);
       subscription.pending.clear();
       subscription.release?.();
@@ -67,12 +68,25 @@ function registerConversationSubscriptions({ realtime, events, actions, config =
       let stageStartedAt = startedAt;
       let stage = "request-admission";
       let observedConversationId;
+      let diagnosticTimer;
+      function diagnostic(stageName, fields = {}) {
+        if (!diagnostics) return;
+        const now = performance.now();
+        try {
+          logger?.warn?.({ event: "assistant.conversation.subscription", subscriptionEpoch: subscription?.epoch,
+            ...(typeof observedConversationId === "string" ? { conversationId: observedConversationId } : {}),
+            stage: stageName, previousStage: stage, durationMs: now - stageStartedAt,
+            elapsedMs: now - startedAt, ...fields }, "Assistant conversation subscription diagnostic.");
+        } catch { /* Diagnostics never change admission or cleanup. */ }
+      }
       function onStage(next, fields = {}) {
         const now = performance.now();
         // Only a successfully opened, authorized conversation may enter diagnostics.
         if (next === "observer-attach") observedConversationId = input.conversationId;
         try {
-          logger?.info?.({ event: "assistant.conversation.subscription", subscriptionEpoch: subscription?.epoch,
+          const slowOutcome = now - startedAt >= 5_000 && ["acknowledgement", "abandoned"].includes(next);
+          const level = diagnostics || next === "failed" || slowOutcome ? "warn" : "info";
+          logger?.[level]?.({ event: "assistant.conversation.subscription", subscriptionEpoch: subscription?.epoch,
             ...(typeof observedConversationId === "string" ? { conversationId: observedConversationId } : {}),
             stage: next, previousStage: stage,
             durationMs: now - stageStartedAt, elapsedMs: now - startedAt, ...fields },
@@ -83,9 +97,17 @@ function registerConversationSubscriptions({ realtime, events, actions, config =
       }
       try {
         subscriptionId = requireSubscriptionId(input);
-        release(subscriptionId);
+        release(subscriptionId, "replacement");
         subscription = { pending: new Map(), revision: 0, epoch: randomUUID(), queue: Promise.resolve() };
         subscriptions.set(subscriptionId, subscription);
+        if (diagnostics) {
+          subscription.diagnosticRelease = reason => {
+            clearTimeout(diagnosticTimer);
+            diagnostic("released", { reason });
+          };
+          diagnosticTimer = setTimeout(() => diagnostic("pending", { acknowledgementBudgetMs: 10_000 }), 10_000);
+          diagnosticTimer.unref?.();
+        }
         const current = () => !closed && socket.connected && subscriptions.get(subscriptionId) === subscription;
         onStage("authentication");
         const request = await (requestPolicy === "host" ? readRequest() : authenticate());
@@ -148,6 +170,7 @@ function registerConversationSubscriptions({ realtime, events, actions, config =
           deps: {
             onEvent,
             onStage,
+            isCurrent: current,
             onRelease(detach) {
               if (!current()) detach();
               else subscription.release = detach;
@@ -167,6 +190,8 @@ function registerConversationSubscriptions({ realtime, events, actions, config =
           status: Number(error?.status || error?.statusCode || 500) });
         if (subscriptions.get(subscriptionId) === subscription) release(subscriptionId);
         if (!closed && socket.connected) acknowledge(subscriptionError(error));
+      } finally {
+        clearTimeout(diagnosticTimer);
       }
     }
 
@@ -184,7 +209,7 @@ function registerConversationSubscriptions({ realtime, events, actions, config =
       closed = true;
       socket.off(ASSISTANT_CONVERSATION_SUBSCRIBE, subscribe);
       socket.off(ASSISTANT_CONVERSATION_UNSUBSCRIBE, unsubscribe);
-      for (const subscriptionId of subscriptions.keys()) release(subscriptionId);
+      for (const subscriptionId of subscriptions.keys()) release(subscriptionId, "connection-closed");
     };
   });
 }

package/test/assistantConversationBinding.browser.test.js

@@ -147,6 +147,8 @@ test("optional goal controls follow declared command semantics and budgets witho
     await expect(start).toBeEnabled();
     await start.click();
     await expect(f.primary.getByRole("button", { name: "Goal running", exact: true })).toBeVisible();
+    await expect(f.primary.getByRole("button", { name: "Goal running", exact: true })).toHaveAttribute("aria-expanded", "false");
+    await f.primary.getByRole("button", { name: "Goal running", exact: true }).click();
     const pause = f.page.getByRole("button", { name: "Pause goal", exact: true });
     await expect(pause).toBeEnabled();
     await expect(f.page.getByText(budgets
@@ -191,6 +193,8 @@ test("the first native goal preserves absent identity and later controls capture
   await expect(start).toBeEnabled();
   await start.click();
   await expect(f.primary.getByRole("button", { name: "Goal running", exact: true })).toBeVisible();
+  await expect(f.primary.getByRole("button", { name: "Goal running", exact: true })).toHaveAttribute("aria-expanded", "false");
+  await f.primary.getByRole("button", { name: "Goal running", exact: true }).click();
   const pause = f.page.getByRole("button", { name: "Pause goal", exact: true });
   await expect(pause).toBeEnabled();
   await pause.click();
@@ -225,6 +229,7 @@ test("a lost goal receipt uses the same inspection-only ledger and never starts
   const check = f.primary.getByRole("button", { name: "Retry delivery check", exact: true });
   await expect(check).toBeVisible();
   await expect(f.primary.getByText("Finish the uncertain goal", { exact: true })).toHaveCount(1);
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().goalState.value.error)).toBe("The goal's receipt was lost.");
   const requests = async () => (await f.state()).requests.filter(request => request.suffix === "/goal" && request.method === "POST");
   const [original] = await requests();
   assert.ok(original.input.messageId);
@@ -235,6 +240,7 @@ test("a lost goal receipt uses the same inspection-only ledger and never starts
   await f.command("confirm", { id: "chat:1" });
   await check.click();
   await expect(check).toHaveCount(0);
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().goalState.value.error)).toBe("");
   await expect(f.primary.getByRole("button", { name: "Goal running", exact: true })).toBeVisible();
   await expect(f.primary.getByText("Finish the uncertain goal", { exact: true })).toHaveCount(1);
   assert.equal((await requests()).length, 1);
@@ -319,7 +325,7 @@ test("a supplied goal view keeps its pinned target and refreshes through the ret
   assert.equal(commands.length, 1, "Retired viewer controls cannot target the next viewer's goal");
 });
 
-test("a rejected message goal retry keeps its original UUID and exact read target", options, async t => {
+for (const rejection of ["conversation_goal_changed", "conversation_invalid_goal"]) test(`a rejected message goal retry keeps its original UUID and exact read target (${rejection})`, options, async t => {
   const f = await fixture(t);
   const commands = [];
   const view = { status: "available", goal: null, target: { segmentId: null,
@@ -328,8 +334,8 @@ test("a rejected message goal retry keeps its original UUID and exact read targe
     if (route.request().method() === "GET") return route.fulfill({ json: view });
     const input = route.request().postDataJSON();
     commands.push(input);
-    if (commands.length === 1) return route.fulfill({ status: 409,
-      json: { code: "conversation_goal_changed", error: "Goal changed before admission." } });
+    if (commands.length === 1) return route.fulfill({ status: rejection === "conversation_invalid_goal" ? 400 : 409,
+      json: { code: rejection, error: "Goal rejected before admission." } });
     return route.fulfill({ json: { status: "accepted", messageId: input.messageId, turnId: "original-goal-receipt" } });
   });
   await f.page.evaluate(() => window.conversationFixture.eventReaders([{ id: "goal-reader", goal: true }]));
@@ -337,6 +343,8 @@ test("a rejected message goal retry keeps its original UUID and exact read targe
   await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().goalState.value?.pending)).toBe(false);
   assert.equal(await f.page.evaluate(() => window.conversationFixture.current().changeGoal("set", { objective: "Original objective" })), false);
   assert.equal(commands.length, 1);
+  assert.equal(await f.page.evaluate(id => window.conversationFixture.current().delivery.find(id)?.status,
+    commands[0].messageId), "failed", "pre-dispatch validation is not an uncertain delivery");
   assert.ok(commands[0].messageId);
   assert.equal(commands[0].expectedSegmentId, null);
   assert.equal(commands[0].expectedGoalId, null);
@@ -764,6 +772,67 @@ for (const status of ["uncertain", "pending", "accepted", "failed", "unrecognise
   });
 }
 
+for (const ordinaryFails of [false, true]) {
+  test(`a finished-turn steer becomes one ordinary Send with its original identity (Send fails: ${ordinaryFails})`, options, async t => {
+    const f = await fixture(t);
+    await f.command("mode", { mode: "rejected" });
+    await f.command("steering", { id: "chat:1", enabled: true });
+    await f.command("question", { id: "chat:1", text: "Earlier work", pending: true });
+    await f.notify("chat:1");
+    await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().steerable.value)).toBe(true);
+    let calls = 0;
+    await f.page.route("**/messages", async route => {
+      calls += 1;
+      const response = await route.fetch();
+      if (calls === 1) {
+        if (!ordinaryFails) await f.command("mode", { mode: "accepted" });
+        await route.fulfill({ response, status: 409, json: {
+          error: "The turn finished before dispatch.", code: "conversation_steer_turn_finished"
+        } });
+      } else await route.fulfill({ response });
+    });
+    await f.input.fill("Keep exactly these words");
+    await f.input.press("Enter");
+    await expect.poll(async () => (await f.sent()).length).toBe(2);
+    const [steer, send] = await f.sent();
+    assert.equal(steer.input.steer, true);
+    const { steer: _oldIntent, ...ordinary } = steer.input;
+    assert.deepEqual(send.input, ordinary);
+    if (ordinaryFails) {
+      await expect(f.primary.getByText("Failed: The message was rejected before admission.", { exact: true })).toBeVisible();
+      assert.equal(await f.page.evaluate(id => window.conversationFixture.current().delivery.find(id).payload.request.steer,
+        steer.input.messageId), undefined);
+      await f.input.fill("Keep my newer draft");
+      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(3);
+      assert.deepEqual((await f.sent())[2].input, ordinary);
+      await expect(f.input).toHaveValue("Keep my newer draft");
+    }
+    await expect(f.primary.getByRole("button", { name: "Stop", exact: true })).toBeVisible();
+    await expect(f.primary.getByText("Keep exactly these words", { exact: true })).toHaveCount(1);
+  });
+}
+
+test("a finished-turn error without a definite rejection status remains uncertain and never auto-resends", options, async t => {
+  const f = await fixture(t);
+  await f.command("mode", { mode: "rejected" });
+  await f.command("steering", { id: "chat:1", enabled: true });
+  await f.command("question", { id: "chat:1", text: "Earlier work", 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: 503, json: { error: "Delivery unknown", code: "conversation_steer_turn_finished" } });
+  });
+  await f.input.fill("Retain uncertain words");
+  await f.input.press("Enter");
+  await expect.poll(async () => (await f.sent()).length).toBe(1);
+  const [request] = await f.sent();
+  await expect.poll(() => f.page.evaluate(id => window.conversationFixture.current().delivery.find(id).status, request.input.messageId)).toBe("uncertain");
+  assert.equal((await f.sent()).length, 1);
+});
+
 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);
@@ -1810,6 +1879,65 @@ test("dynamic acquisition keeps the original shared readers and releases only it
   assert.equal((await f.sent()).length, 0);
 });
 
+for (const stop of [false, true]) {
+  test(`prepared application queue retains followers until admission and respects Stop (${stop})`, options, async t => {
+    const f = await fixture(t);
+    await f.command("mode", { mode: "hold" });
+    await f.page.evaluate(() => {
+      window.preparedQueue = window.conversationFixture.acquireConversation({ conversationId: "chat:2", queueWhileSending: true });
+      window.preparedCalls = [];
+      const send = (id, text) => window.preparedQueue.runtime.value.submitPrepared({ message: text, request: { text } }, {
+        messageId: id, prepare(submission) { window.preparedCalls.push(id); return submission.request; }
+      });
+      window.preparedFirst = send("prepared-first", "First authored message");
+      window.preparedSecond = send("prepared-second", "Second authored message");
+    });
+    await expect.poll(async () => (await f.state()).held).toBe(1);
+    assert.deepEqual(await f.page.evaluate(() => window.preparedCalls), ["prepared-first"]);
+    assert.equal(await f.page.evaluate(() => window.preparedQueue.runtime.value.delivery.state.messages.length), 2);
+    if (stop) await f.page.evaluate(() => window.preparedQueue.runtime.value.cancel());
+    await f.command("mode", { mode: "accepted" });
+    await f.command("accept");
+    await f.page.evaluate(() => window.preparedFirst);
+    const result = await f.page.evaluate(() => window.preparedSecond);
+    assert.equal((await f.sent()).length, stop ? 1 : 2);
+    assert.deepEqual(await f.page.evaluate(() => window.preparedCalls), stop ? ["prepared-first"] : ["prepared-first", "prepared-second"]);
+    if (stop) assert.equal(result, false);
+    else assert.equal(result.status, "accepted");
+  });
+}
+
+test("prepared steering uses the definite finished-turn fallback without repeating preparation", options, async t => {
+  const f = await fixture(t);
+  await f.command("mode", { mode: "rejected" });
+  let calls = 0;
+  await f.page.route("**/messages", async route => {
+    const response = await route.fetch();
+    if (++calls === 1) {
+      await f.command("mode", { mode: "accepted" });
+      const input = route.request().postDataJSON();
+      await route.fulfill({ response, status: 409, json: {
+        error: "The turn finished before dispatch.", code: "conversation_steer_turn_finished",
+        details: { delivery: { status: "not-sent", messageId: input.messageId } }
+      } });
+    } else await route.fulfill({ response });
+  });
+  const result = await f.page.evaluate(async () => {
+    const binding = window.conversationFixture.acquireConversation({ conversationId: "chat:2", queueWhileSending: true });
+    window.prepareCount = 0;
+    return binding.runtime.value.submitPrepared({ message: "Keep these words", request: { text: "Keep these words", steer: true } }, {
+      messageId: "prepared-finished", prepare(submission) { window.prepareCount += 1; return submission.request; }
+    });
+  });
+  assert.equal(result.status, "accepted");
+  assert.equal(await f.page.evaluate(() => window.prepareCount), 1);
+  const sent = await f.sent();
+  assert.equal(sent.length, 2);
+  assert.equal(sent[0].input.steer, true);
+  const { steer: _ended, ...ordinary } = sent[0].input;
+  assert.deepEqual(sent[1].input, ordinary);
+});
+
 test("prepared submission keeps optimism before application creation and uses the same captured receipt owner", options, async t => {
   const f = await fixture(t);
   await f.command("mode", { mode: "hold" });
@@ -3085,3 +3213,31 @@ test("initial goal loading shows no goal commands until the empty goal is confir
     await expect(f.page.getByRole("button", { name: "Resume goal", exact: true })).toHaveCount(0);
   } finally { waiting.resolve(); }
 });
+
+
+test("host goal recovery errors remain visible while Resume uses the current goal target", options, async t => {
+  const f = await fixture(t);
+  const view = { status: "available", error: "Goal recovery stopped because its AI account changed. Resume with the intended account.",
+    goal: { id: "retained-goal", objective: "Finish the agreed work", status: "paused" },
+    target: { segmentId: "retained-native", capabilities: { goals: true,
+      goalCommands: { resume: { delivery: "control", interruptsTurn: false } } } } };
+  const commands = [];
+  await f.page.route("**/conversations/*/goal", async route => {
+    if (route.request().method() === "GET") return route.fulfill({ json: view });
+    commands.push(route.request().postDataJSON());
+    view.error = "";
+    view.goal.status = "active";
+    return route.fulfill({ json: { ok: true } });
+  });
+  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 paused", exact: true }).click();
+  await expect(f.page.getByRole("alert").filter({ hasText: "Goal recovery stopped" })).toBeVisible();
+  const resume = f.page.getByRole("button", { name: "Resume goal", exact: true });
+  await expect(resume).toBeEnabled();
+  await resume.click();
+  await expect.poll(() => commands.length).toBe(1);
+  assert.deepEqual(commands[0], { action: "resume", expectedSegmentId: "retained-native", expectedGoalId: "retained-goal" });
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().goalState.value.error)).toBe("");
+  assert.deepEqual(await f.sent(), []);
+});

package/test/assistantConversationSubscriptions.test.js

@@ -42,7 +42,7 @@ function requestSubscription(socket, input) {
   });
 }
 
-async function fixture(t) {
+async function fixture(t, { diagnostics = false, onSetup } = {}) {
   const directory = await mkdtemp(join(tmpdir(), "assistant-subscriptions-"));
   const changes = new EventEmitter();
   const notify = () => changes.emit("change");
@@ -86,13 +86,16 @@ async function fixture(t) {
     conversations.set(id, conversation);
   }
   let active = 0;
+  let snapshotReads = 0;
   const actions = createActionCatalogue();
   const contributor = createAuthActionContextContributor();
   actions.registerContextContributor({ id: contributor.contributorId, contribute: contributor.contribute });
   actions.register({ contributorId: "test.assistant", domain: "assistant", actions: createAssistantActions({ config,
     conversationRuntime: { async open(input) {
+      await onSetup?.("conversation-open");
       const conversation = await runtime.open(input);
       return { ...conversation, async read() {
+        snapshotReads += 1;
         const barrier = nextReadBarriers.get(input.id);
         if (barrier) {
           nextReadBarriers.delete(input.id);
@@ -106,6 +109,7 @@ async function fixture(t) {
         let released = false;
         active += 1;
         notify();
+        await onSetup?.("observer-attach");
         return () => {
           if (released) return;
           released = true;
@@ -141,8 +145,11 @@ async function fixture(t) {
     serverSockets.add(socket);
     return () => { serverSockets.delete(socket); notify(); };
   });
-  const stopSubscriptions = registerConversationSubscriptions({ realtime, events, actions, config,
-    logger: { info(record) { subscriptionTimings.push(record); notify(); } } });
+  const stopSubscriptions = registerConversationSubscriptions({ realtime, events, actions, config, diagnostics,
+    logger: {
+      info(record) { subscriptionTimings.push({ ...record, level: "info" }); notify(); },
+      warn(record) { subscriptionTimings.push({ ...record, level: "warn" }); notify(); }
+    } });
   const published = [];
   events.register({ id: "test.assistant.published", handle(event) { published.push(event); notify(); } });
   http.listen(0, "127.0.0.1");
@@ -204,7 +211,49 @@ async function fixture(t) {
   }
   return { ids, connect, view, changes, sessions, revoked, fetches, conversations, runtimeEvents,
     realtime, transport, serverSockets, published, events, stopSubscriptions, authRequests, subscriptionTimings,
-    holdNextRead, active: () => active };
+    holdNextRead, active: () => active, snapshotReads: () => snapshotReads };
+}
+
+for (const phase of ["conversation-open", "observer-attach"]) {
+  test(`released during ${phase} skips obsolete snapshot and preserves replacement observation`, async t => {
+    const entered = Promise.withResolvers();
+    const gate = Promise.withResolvers();
+    t.after(() => gate.resolve());
+    let held = false;
+    const f = await fixture(t, { diagnostics: true, async onSetup(stage) {
+      if (stage !== phase || held) return;
+      held = true;
+      entered.resolve();
+      await gate.promise;
+    } });
+    const socket = await f.connect();
+    const id = f.ids[0];
+    await f.conversations.get(id).send({ messageId: "survives-observer-release", text: "Keep working" });
+    await until(f.changes, () => f.fetches.length === 1);
+    const oldView = f.view(socket, id);
+    await entered.promise;
+    const epoch = f.subscriptionTimings.at(-1).subscriptionEpoch;
+    oldView.dispose();
+    await until(f.changes, () => f.subscriptionTimings.some(record =>
+      record.subscriptionEpoch === epoch && record.stage === "released"));
+    const replacement = f.view(socket, id);
+    await until(f.changes, () => replacement.states.length === 1);
+    assert.equal(f.snapshotReads(), 1);
+    gate.resolve();
+    await until(f.changes, () => f.subscriptionTimings.some(record =>
+      record.subscriptionEpoch === epoch && record.stage === "abandoned"));
+    assert.equal(f.snapshotReads(), 1, "Released setup cannot start a new snapshot");
+    assert.equal(f.subscriptionTimings.some(record =>
+      record.subscriptionEpoch === epoch && record.stage === "snapshot-read"), false);
+    assert.equal(f.active(), 1, "Late cleanup preserves the replacement observer");
+    assert.equal(oldView.states.length, 0);
+    assert.equal(f.fetches.length, 1);
+    assert.equal(f.fetches[0].signal.aborted, false, "View cancellation never stops the model");
+    f.fetches[0].text("Still working after view replacement.");
+    await until(f.changes, () => replacement.received.some(event => event.text?.includes("view replacement")));
+    replacement.dispose();
+    await until(f.changes, () => f.active() === 0);
+  });
 }
 
 test("subscription timings identify a blocked snapshot and abandoned observation without stopping work", { timeout: 20_000 }, async t => {
@@ -247,6 +296,7 @@ test("subscription timings identify a blocked snapshot and abandoned observation
   assert.ok(records.every(record => !Object.hasOwn(record, "subscriptionId")),
     "Correlation uses the server epoch rather than arbitrary client subscription text");
   assert.equal(records.find(record => record.stage === "acknowledgement").snapshotTurns, 1);
+  assert.ok(records.every(record => record.level === "info"), "Normal subscriptions do not produce warnings");
   assert.equal(recovered.states[0].conversationLog[0].user.messageId, "measured-once");
   assert.equal(f.active(), 1);
   assert.equal(f.fetches.length, 1);
@@ -255,6 +305,30 @@ test("subscription timings identify a blocked snapshot and abandoned observation
   await until(f.changes, () => f.active() === 0);
 });
 
+test("slow successful subscriptions warn once with the blocked stage and no conversation content", async t => {
+  const f = await fixture(t);
+  const socket = await f.connect();
+  const id = f.ids[0];
+  const barrier = f.holdNextRead(id);
+  const view = f.view(socket, id);
+  await until(f.changes, () => barrier.started);
+  const now = performance.now.bind(performance);
+  const clock = t.mock.method(performance, "now", () => now() + 6_000);
+  try {
+    barrier.resolve();
+    await until(f.changes, () => view.states.length === 1);
+  } finally { clock.mock.restore(); }
+  const warnings = f.subscriptionTimings.filter(record => record.level === "warn");
+  assert.equal(warnings.length, 1);
+  assert.equal(warnings[0].stage, "acknowledgement");
+  assert.equal(warnings[0].previousStage, "snapshot-read");
+  assert.ok(warnings[0].durationMs >= 6_000);
+  assert.ok(warnings[0].elapsedMs >= warnings[0].durationMs);
+  assert.equal(warnings[0].snapshotTurns, 0);
+  assert.equal(Object.hasOwn(warnings[0], "state"), false);
+  assert.equal(f.fetches.length, 0);
+});
+
 test("the real ten-second subscription deadline releases its late observer and Reload never repeats work", { timeout: 25_000 }, async t => {
   const f = await fixture(t);
   const socket = await f.connect();
@@ -282,6 +356,11 @@ test("the real ten-second subscription deadline releases its late observer and R
   barrier.resolve();
   await until(f.changes, () => f.subscriptionTimings.some(record =>
     record.subscriptionEpoch === firstSubscriptionEpoch && record.stage === "abandoned"));
+  const abandoned = f.subscriptionTimings.find(record =>
+    record.subscriptionEpoch === firstSubscriptionEpoch && record.stage === "abandoned");
+  assert.equal(abandoned.level, "warn", "A timed-out snapshot remains visible at the production warning level");
+  assert.equal(abandoned.previousStage, "snapshot-read");
+  assert.ok(abandoned.durationMs >= 5_000);
   assert.equal(view.states.length, statesBeforeLateRead, "The obsolete server read never acknowledges into the recovered view");
   assert.equal(f.active(), 1, "The late read cannot release the recovered observer");
   assert.equal(f.fetches.length, 1);
@@ -304,6 +383,7 @@ test("subscription diagnostics never serialize unvalidated client identifiers",
   assert.equal(result.status, 400);
   assert.equal(f.active(), 0);
   assert.equal(f.subscriptionTimings.at(-1).stage, "failed");
+  assert.equal(f.subscriptionTimings.at(-1).level, "warn");
   assert.ok(f.subscriptionTimings.every(record => /^[0-9a-f-]{36}$/.test(record.subscriptionEpoch)));
   assert.ok(f.subscriptionTimings.every(record => !Object.hasOwn(record, "conversationId") &&
     !Object.hasOwn(record, "subscriptionId")));
@@ -1148,3 +1228,47 @@ test("retargeting a retained logical observer uses the current engine namespace
   assert.equal(active, 0);
   assert.equal(sends, 0);
 });
+
+
+test("opt-in subscription watchdog identifies a pending snapshot before the await returns", async t => {
+  const f = await fixture(t, { diagnostics: true });
+  const socket = await f.connect();
+  const barrier = f.holdNextRead(f.ids[0]);
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  const view = f.view(socket, f.ids[0]);
+  await until(f.changes, () => barrier.started);
+  t.mock.timers.tick(10_000);
+  t.mock.timers.reset();
+  const pending = f.subscriptionTimings.find(record => record.stage === "pending");
+  const stages = f.subscriptionTimings.filter(record => record.stage !== "pending");
+  assert.deepEqual(stages.map(record => record.stage), ["authentication", "action-admission",
+    "conversation-open", "observer-attach", "snapshot-read"]);
+  assert.ok(stages.every(record => record.level === "warn"), "Opt-in stage timings survive a warning-only operational log");
+  assert.ok(stages.every(record => Number.isFinite(record.durationMs) && Number.isFinite(record.elapsedMs)));
+  assert.equal(pending.previousStage, "snapshot-read");
+  assert.equal(pending.conversationId, f.ids[0]);
+  assert.equal(pending.acknowledgementBudgetMs, 10_000);
+  assert.equal(pending.level, "warn");
+  assert.equal(Object.hasOwn(pending, "state"), false);
+  view.dispose();
+  await until(f.changes, () => f.subscriptionTimings.some(record => record.stage === "released"));
+  assert.equal(f.subscriptionTimings.find(record => record.stage === "released").previousStage, "snapshot-read");
+  barrier.resolve();
+  await until(f.changes, () => f.subscriptionTimings.some(record => record.stage === "abandoned"));
+  assert.equal(view.states.length, 0);
+  assert.equal(f.fetches.length, 0, "Diagnostics do not start or replay a model turn");
+});
+
+for (const diagnostics of [false, true]) test(`watchdog timer is removed after acknowledgement (diagnostics=${diagnostics})`, async t => {
+  const f = await fixture(t, { diagnostics });
+  const socket = await f.connect();
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  const view = f.view(socket, f.ids[0]);
+  await until(f.changes, () => view.states.length === 1);
+  t.mock.timers.tick(20_000);
+  t.mock.timers.reset();
+  view.dispose();
+  await until(f.changes, () => f.active() === 0);
+  assert.equal(f.subscriptionTimings.some(record => record.stage === "pending"), false);
+  assert.equal(f.subscriptionTimings.some(record => record.stage === "released"), diagnostics);
+});