@jskit-ai/assistant-runtime 0.1.215 → 0.1.217

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

@@ -122,6 +122,7 @@ export default defineConfig({
         if (denied || !state) return json({ error: "Access denied.", code: "conversation_forbidden" }, 403);
         if (request.method === "GET" && !match[2]) {
           return json(pageLimits.has(id) ? { ...state, ...await transcript.readConversationLogPage(id, {
+            pageUnit: "messages",
             beforeTurnId: url.searchParams.get("beforeTurnId") || "",
             limit: url.searchParams.get("limit") || pageLimits.get(id)
           }) } : state);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.1.215",
+  "version": "0.1.217",
   "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.222",
+    "@jskit-ai/assistant-core": "0.1.224",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {

package/src/client/composables/useAssistantConversation.js

@@ -84,7 +84,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   const error = ref("");
   const loading = ref(true);
   const stopping = ref(false);
-  const goalPending = ref(false);
+  const goalAction = ref("");
   const goalTargetCurrent = ref(false);
   const goalError = ref("");
   const goalView = shallowRef(null);
@@ -115,7 +115,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
   const steerable = computed(() => snapshot.value?.status === "working" && snapshot.value?.capabilities?.steering === true);
   const workingPolicy = computed(() => resolveWorkingPolicy(snapshot.value, { deferWhileWorking, admitWhileWorking }));
   const queueing = computed(() => queueWhileSending !== false && (steerable.value || workingPolicy.value.deferWhileWorking || workingPolicy.value.admitWhileWorking));
-  const canSubmit = computed(() => available.value && (snapshot.value.status === "ready" || steerable.value || (workingPolicy.value.deferWhileWorking || workingPolicy.value.admitWhileWorking) && snapshot.value.status === "working") &&
+  const canSubmit = computed(() => available.value && !stopping.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" &&
       (snapshot.value.status !== "ready" || !message.payload || text(message.payload.draft ?? message.payload.message) === text(draft))));
@@ -221,6 +221,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       // 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;
+      goalLoadError.value = "";
       goalReadController?.abort();
     }
     if (readsGoals.value && (initial || goalChanged || state.segmentId !== goalSegment)) void refreshGoal();
@@ -274,7 +275,9 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     // refresh in this same read, rather than dropping that newly loaded page.
     while (valid()) {
       const revision = historyRevision;
-      const oldest = olderPages.value[0]?.conversationLog?.[0]?.turnId;
+      const oldestTurn = olderPages.value[0]?.conversationLog?.[0];
+      const oldest = oldestTurn?.turnId;
+      const oldestCursor = olderPages.value[0]?.pagination?.nextBeforeTurnId || oldest;
       const latest = await api.readConversation(identity.conversationId);
       if (!valid()) return latest;
       const pages = [];
@@ -282,7 +285,9 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       const cursors = new Set();
       while (oldest && page.pagination.hasMoreBefore) {
         const cursor = page.pagination.nextBeforeTurnId || page.pagination.oldestTurnId;
-        if (cursor && compareTurnIds(cursor, oldest) <= 0) break;
+        const reachedFullOldestTurn = page.pagination.oldestTurnId === oldest && !page.conversationLog[0]?.paginationPartial;
+        const passedOldestTurn = compareTurnIds(page.pagination.oldestTurnId, oldest) < 0;
+        if (cursor && (cursor === oldestCursor || passedOldestTurn || reachedFullOldestTurn)) break;
         if (!cursor || cursors.has(cursor)) throw new Error("Older conversation history could not be refreshed. Reload chat to try again.");
         cursors.add(cursor);
         page = normalizeConversationLogPage(await api.readConversation(identity.conversationId, {
@@ -291,7 +296,14 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
         if (!valid()) return latest;
         // A removed oldest row can make this page reach farther back than the
         // reader loaded. Keep the original visible boundary and page metadata.
-        const saved = page.conversationLog.filter(turn => compareTurnIds(turn.turnId, oldest) >= 0);
+        const saved = page.conversationLog.filter(turn => compareTurnIds(turn.turnId, oldest) >= 0).map(turn => {
+          if (turn.turnId !== oldest || !oldestTurn.paginationPartial) return turn;
+          const roles = ["system", "user", "assistant"];
+          const excluded = roles.slice(0, roles.findIndex(role => oldestTurn[role]));
+          return { ...turn, paginationPartial: true,
+            ...Object.fromEntries(excluded.map(role => [role, null])),
+            messages: turn.messages?.filter(message => !excluded.includes(message.role)) };
+        });
         pages.unshift(normalizeConversationLogPage({ ...page, conversationLog: saved, pagination: {
           ...page.pagination, count: saved.length, oldestTurnId: saved[0]?.turnId || "",
           hasMoreBefore: page.pagination.hasMoreBefore || saved.length < page.conversationLog.length
@@ -327,7 +339,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     draftAttachments.value = [];
     draftRetry.value = null;
     goalError.value = "";
-    goalPending.value = false;
+    goalAction.value = "";
     goalView.value = null;
     goalLoadError.value = "";
     goalReadQueued = false;
@@ -430,7 +442,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     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, appAdmission };
+    const pending = { controller: new AbortController(), started: false, dispatched: false };
     const { controller } = pending;
     pendingMessages.set(messageId, pending);
     try {
@@ -501,7 +513,8 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     const finish = (result) => {
       if (typeof complete === "function") complete(result);
     };
-    const beforeTurnId = normalizeConversationLogPagination(oldestLoadedPage.value?.pagination).oldestTurnId ||
+    const pagination = normalizeConversationLogPagination(oldestLoadedPage.value?.pagination);
+    const beforeTurnId = pagination.nextBeforeTurnId || pagination.oldestTurnId ||
       String(turns.value[0]?.turnId || "").trim();
     if (!available.value || !hasMoreBefore.value || loadingMore.value || !beforeTurnId) {
       finish({ changed: false, loaded: false });
@@ -519,10 +532,13 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
         return false;
       }
       const previousOldestTurnId = String(turns.value[0]?.turnId || "").trim();
+      const previousMessageCount = turns.value.reduce((count, turn) => count + (turn.messages?.length || 0), 0);
       historyRevision += 1;
       olderPages.value = [normalizeConversationLogPage(page), ...olderPages.value];
       const nextOldestTurnId = String(turns.value[0]?.turnId || "").trim();
-      const changed = Boolean(nextOldestTurnId && nextOldestTurnId !== previousOldestTurnId);
+      const nextMessageCount = turns.value.reduce((count, turn) => count + (turn.messages?.length || 0), 0);
+      const changed = Boolean(nextOldestTurnId && (nextOldestTurnId !== previousOldestTurnId ||
+        nextMessageCount !== previousMessageCount));
       finish({ changed, loaded: true });
       return true;
     } catch (failure) {
@@ -577,7 +593,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 || !goalTargetCurrent.value ||
+    if (!available.value || view?.status !== "available" || goalLoadError.value || goalAction.value || !goalTargetCurrent.value ||
         !["message", "control"].includes(command?.delivery) ||
         delivery.state.messages.some(message => message.status === "uncertain")) return false;
     if (input.tokenBudget != null && !target.capabilities.goalBudgets) {
@@ -590,7 +606,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       expectedGoalId: view.goal?.id || null,
       ...(action === "set" ? { objective: String(input.objective || "").trim(),
         ...(input.tokenBudget == null ? {} : { tokenBudget: input.tokenBudget }) } : {}) };
-    goalPending.value = true;
+    goalAction.value = action;
     goalError.value = "";
     try {
       if (retry || command.delivery === "message") {
@@ -615,7 +631,7 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
       return false;
     } finally {
       if (current.value) {
-        goalPending.value = false;
+        goalAction.value = "";
         await goalRead;
         await refreshGoal();
         subscription?.reload();
@@ -627,14 +643,19 @@ function createConversation(identity, { api, socket, actorKey, placement, reader
     if (!readsGoals.value) return null;
     const capabilities = view?.target?.capabilities || {};
     const commands = capabilities.goalCommands || {};
+    const loading = !goalTargetCurrent.value && !goalLoadError.value;
+    const goalAvailable = goalTargetCurrent.value && view?.status === "available" && !goalLoadError.value;
     return {
-      enabled: active.value && Boolean((view?.status === "available" && !goalLoadError.value) || goalError.value),
+      enabled: active.value && Boolean(loading || (view?.status === "available" && !goalLoadError.value) || goalError.value || goalLoadError.value),
+      loading,
+      available: Boolean(goalAvailable),
+      action: goalAction.value,
       tokenBudgetSupported: capabilities.goalBudgets === true,
-      goal: view?.goal ? { ...view.goal, elapsedSeconds: view.goal.timeUsedSeconds,
+      goal: goalAvailable && view?.goal ? { ...view.goal, elapsedSeconds: view.goal.timeUsedSeconds,
         sampledAt: Date.parse(view.goal.updatedAt) } : null,
-      pending: goalPending.value || !goalTargetCurrent.value || !available.value || delivery.state.sending ||
+      pending: Boolean(goalAction.value) || !goalAvailable || !available.value || delivery.state.sending ||
         delivery.state.messages.some(message => message.status === "uncertain"),
-      error: goalError.value,
+      error: goalError.value || goalLoadError.value,
       pauseInterruptsTurn: commands.pause?.interruptsTurn === true,
       cancelInterruptsTurn: commands.cancel?.interruptsTurn === true,
       ...Object.fromEntries(["set", "resume", "pause", "cancel"].filter(action =>
@@ -645,7 +666,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.appAdmission) && !pending.dispatched) pending.controller.abort();
+      if (!pending.dispatched) pending.controller.abort();
     }
     try { return await api.cancelConversation(identity.conversationId); }
     catch (failure) { receiveError(failure); return false; }

package/test/assistantConversationBinding.browser.test.js

@@ -295,6 +295,12 @@ test("a supplied goal view keeps its pinned target and refreshes through the ret
   failedRead = true;
   await f.page.evaluate(() => window.conversationFixture.current().refreshGoal());
   await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().goalLoadError.value)).toBe("Goal status is unavailable.");
+  await expect(f.primary.getByRole("button", { name: "Goal unavailable", exact: true })).toBeVisible();
+  assert.deepEqual(await f.page.evaluate(() => {
+    const state = window.conversationFixture.current().goalState.value;
+    return { available: state.available, goal: state.goal, pending: state.pending };
+  }), { available: false, goal: null, pending: true });
+  await expect(f.page.getByRole("button", { name: "Resume goal", exact: true })).toHaveCount(0);
   assert.equal(await f.page.evaluate(() => window.conversationFixture.current().error.value), "",
     "Passive goal failure does not enter conversation or app-wide request recovery");
   await expect(f.input).toBeEnabled();
@@ -877,6 +883,41 @@ test("opted-in nonsteerable follow-ups use the original serial queue and dispatc
   assert.equal((await f.sent()).at(-1).input.steer, true);
 });
 
+for (const steer of [false, true]) {
+  test(`Stop cancels locally queued native ${steer ? "steering" : "startup"} follow-ups`, options, async t => {
+    const f = await fixture(t);
+    await f.command("steering", { id: "chat:1", enabled: true });
+    await f.command("mode", { mode: "hold" });
+    await f.page.evaluate(() => {
+      window.firstNative = window.conversationFixture.current().send({ message: "First held instruction" });
+    });
+    await expect.poll(async () => (await f.state()).held).toBe(1);
+    await f.command("question", { id: "chat:1", text: "Starting native work", pending: true });
+    await f.notify("chat:1");
+    await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().steerable.value)).toBe(true);
+    await f.page.evaluate(steer => {
+      window.queuedNative = window.conversationFixture.current().send({ message: "Queued native follow-up",
+        request: { text: "Queued native follow-up", steer } });
+    }, steer);
+    assert.equal((await f.sent()).length, 1);
+    const stopGate = Promise.withResolvers();
+    t.after(() => stopGate.resolve());
+    await f.page.route("**/cancel", async route => { await stopGate.promise; await route.continue(); });
+    await f.page.evaluate(() => { window.stoppingNative = window.conversationFixture.current().cancel(); });
+    await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().stopping.value)).toBe(true);
+    const canSendDuringStop = await f.page.evaluate(() => window.conversationFixture.current().canSubmit.value);
+    stopGate.resolve();
+    await f.page.evaluate(() => window.stoppingNative);
+    await f.command("mode", { mode: "accepted" });
+    await f.command("accept");
+    await f.page.evaluate(() => window.firstNative);
+    const queuedResult = await f.page.evaluate(() => window.queuedNative);
+    assert.equal((await f.sent()).length, 1, "Stop must prevent a local follower from dispatching after the first receipt");
+    assert.equal(queuedResult, false);
+    assert.equal(canSendDuringStop, false, "new sends wait for Stop confirmation");
+  });
+}
+
 for (const action of ["stop", "actor", "denied"]) {
   test(`opted-in local followers cannot dispatch after ${action}`, options, async t => {
     const f = await fixture(t);
@@ -1628,7 +1669,7 @@ test("paged history uses the original page reader and keeps older messages throu
     user: { role: "user", messageId: `history-${index + 1}`, text: `Saved question ${index + 1}` },
     ...(index < 4 ? { assistant: { role: "assistant", messageId: `answer-${index + 1}`, text: `Saved answer ${index + 1}` } } : {})
   }));
-  await f.command("history", { id: "chat:1", turns, limit: 2 });
+  await f.command("history", { id: "chat:1", turns, limit: 4 });
   await f.notify("chat:1");
   await expect(f.primary.getByText("Saved question 5", { exact: true })).toHaveCount(1);
   await expect(f.primary.getByText("Saved question 1", { exact: true })).toHaveCount(0);
@@ -1639,7 +1680,7 @@ test("paged history uses the original page reader and keeps older messages throu
   assert.deepEqual(await f.page.evaluate(() => window.historyCompletion), { changed: true, loaded: true });
   await expect(f.primary.getByText("Saved question 2", { exact: true })).toHaveCount(1);
   const paged = (await f.state()).requests.filter(request => request.query.beforeTurnId);
-  assert.deepEqual(paged.map(request => request.query), [{ beforeTurnId: "000004", limit: "2" }]);
+  assert.deepEqual(paged.map(request => request.query), [{ beforeTurnId: 'message:["000003","assistant"]', limit: "4" }]);
   await f.page.evaluate(() => window.conversationFixture.socket.notify("chat:1", {
     type: "message", turnId: "000005", messageId: "live-answer", role: "assistant", status: "inProgress", text: "Live answer",
     streaming: { revision: 1, messages: [{ turnId: "000005", messageId: "live-answer", role: "assistant", status: "inProgress", text: "Live answer" }] }
@@ -2230,7 +2271,7 @@ test("canonical incoming messages preserve paged history and the scrolled-up rea
     user: { messageId: `loaded-user-${index}`, role: "user", text: `Loaded question ${index + 1}. ` + "Keep the earlier discussion. ".repeat(6) },
     assistant: { messageId: `loaded-answer-${index}`, role: "assistant", text: `Loaded answer ${index + 1}. ` + "Keep the earlier answer. ".repeat(6) }
   }));
-  await f.command("history", { id: "chat:1", turns, limit: 6 });
+  await f.command("history", { id: "chat:1", turns, limit: 12 });
   await f.notify("chat:1");
   await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().turns.value.length)).toBe(6);
   assert.equal(await f.page.evaluate(() => window.conversationFixture.current().loadMore()), true);
@@ -2246,7 +2287,7 @@ test("canonical incoming messages preserve paged history and the scrolled-up rea
   await f.input.fill("Keep this unsent draft");
   await f.input.evaluate(element => { element.focus({ preventScroll: true }); element.setSelectionRange(2, 7); });
   turns.push({ turnId: "000025", user: { messageId: "incoming-user", role: "user", text: "New incoming question" } });
-  await f.command("history", { id: "chat:1", turns, limit: 6 });
+  await f.command("history", { id: "chat:1", turns, limit: 12 });
   await f.notify("chat:1");
   await expect(f.primary.getByText("New incoming question", { exact: true })).toHaveCount(1);
   const ids = await f.page.evaluate(() => window.conversationFixture.current().turns.value.map(turn => turn.turnId));
@@ -2267,7 +2308,7 @@ for (const width of [390, 768, 1280]) {
       user: { role: "user", messageId: `atomic-user-${index}`, text: `Atomic saved question ${index + 1}. ` + "Retain visible discussion. ".repeat(8) },
       assistant: { role: "assistant", messageId: `atomic-answer-${index}`, text: `Atomic saved answer ${index + 1}. ` + "Retain visible answer. ".repeat(8) }
     }));
-    await f.command("history", { id: "chat:1", turns, limit: 6 });
+    await f.command("history", { id: "chat:1", turns, limit: 12 });
     await f.notify("chat:1");
     await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().turns.value.length)).toBe(6);
     assert.equal(await f.page.evaluate(() => window.conversationFixture.current().loadMore()), true);
@@ -2284,7 +2325,7 @@ for (const width of [390, 768, 1280]) {
     const fresh = turns.filter(turn => !["000007", "000010"].includes(turn.turnId));
     fresh[8] = { ...fresh[8], assistant: { ...fresh[8].assistant, text: "Authoritatively replaced saved answer" } };
     fresh.push({ turnId: "000025", user: { role: "user", messageId: "atomic-incoming", text: "Atomic new question" } });
-    await f.command("history", { id: "chat:1", turns: fresh, limit: 6 });
+    await f.command("history", { id: "chat:1", turns: fresh, limit: 12 });
     let release;
     let held = false;
     const reads = "**/api/assistant/home/conversations/chat%3A1?**";
@@ -2912,6 +2953,11 @@ test("changing the observed native segment blocks cached goal controls until the
     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().goalState.value.loading), true);
+    assert.equal(await f.page.evaluate(() => window.conversationFixture.current().goalState.value.goal), null);
+    await expect(f.primary.getByRole("button", { name: "Loading goal…", exact: true })).toBeVisible();
+    await expect(f.page.getByRole("button", { name: "Pause goal", exact: true })).toHaveCount(0);
+    await expect(f.page.getByRole("button", { name: "Resuming…", exact: true })).toHaveCount(0);
     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";
@@ -2971,3 +3017,71 @@ test("unknown delivery reports its current result and allows different idle inpu
   assert.equal(await f.page.evaluate(id => window.conversationFixture.current().delivery.find(id).status,
     old.input.messageId), "uncertain");
 });
+
+
+for (const width of [1280, 390]) test(`ten real messages per history load across split turns at ${width}px`, options, async t => {
+  const f = await fixture(t, width);
+  const turns = [];
+  let id = 0;
+  for (let index = 1; index <= 16; index++) {
+    const user = { role: "user", messageId: `ten-user-${index}`, text: `Ten question ${index}` };
+    const assistant = index < 16 ? { role: "assistant", messageId: `ten-answer-${index}`, text: `Ten answer ${index}` } : null;
+    turns.push({ turnId: String(++id).padStart(6, "0"), user, assistant, messages: [user, assistant].filter(Boolean) });
+    for (let reasoning = 0; reasoning < 4; reasoning++) {
+      const thought = { role: "thinking", messageId: `ten-thought-${index}-${reasoning}`, text: `Reasoning ${index} ${reasoning}` };
+      turns.push({ turnId: String(++id).padStart(6, "0"), thinking: [thought], messages: [thought] });
+    }
+  }
+  await f.command("history", { id: "chat:1", turns, limit: 10 });
+  await f.notify("chat:1");
+  const messageCount = () => f.page.evaluate(() => window.conversationFixture.current().turns.value
+    .reduce((count, turn) => count + [turn.system, turn.user, turn.assistant].filter(Boolean).length, 0));
+  await expect.poll(messageCount).toBe(10);
+  await expect(f.primary.getByText("Ten question 11", { exact: true })).toHaveCount(0);
+  await expect(f.primary.getByText("Ten answer 11", { exact: true })).toHaveCount(1);
+  assert.equal(await f.page.evaluate(() => window.conversationFixture.current().loadMore()), true);
+  await expect.poll(messageCount).toBe(20);
+  await f.page.evaluate(() => { window.beforeTenMessageRefresh = window.conversationFixture.current().snapshot.value; });
+  await f.notify("chat:1");
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().snapshot.value !== window.beforeTenMessageRefresh)).toBe(true);
+  await expect.poll(messageCount).toBe(20);
+  assert.equal(await f.page.evaluate(() => window.conversationFixture.current().loadMore()), true);
+  await expect.poll(messageCount).toBe(30);
+  await expect(f.primary.getByText("Ten question 1", { exact: true })).toHaveCount(0);
+  assert.equal(await f.page.evaluate(() => window.conversationFixture.current().loadMore({
+    complete: result => { window.tenMessageCompletion = result; }
+  })), true);
+  await expect.poll(messageCount).toBe(31);
+  assert.deepEqual(await f.page.evaluate(() => window.tenMessageCompletion), { changed: true, loaded: true });
+  await expect(f.primary.getByText("Ten question 1", { exact: true })).toHaveCount(1);
+  await expect(f.primary.getByRole("button", { name: "Load older messages", exact: true })).toHaveCount(0);
+  assert.deepEqual(await f.sent(), []);
+});
+
+
+test("initial goal loading shows no goal commands until the empty goal is confirmed", options, async t => {
+  const f = await fixture(t);
+  const waiting = Promise.withResolvers();
+  const entered = Promise.withResolvers();
+  await f.page.route("**/conversations/*/goal", async route => {
+    entered.resolve();
+    await waiting.promise;
+    return route.fulfill({ json: { status: "available", goal: null, target: { segmentId: "empty-goal",
+      capabilities: { goals: true, goalBudgets: false, goalCommands: {
+        set: { delivery: "message", interruptsTurn: false }, resume: { delivery: "message", interruptsTurn: false }
+      } } } } });
+  });
+  try {
+    await f.page.evaluate(() => window.conversationFixture.eventReaders([{ id: "goal-reader", goal: true }]));
+    await entered.promise;
+    const loading = f.primary.getByRole("button", { name: "Loading goal…", exact: true });
+    await expect(loading).toBeVisible();
+    await loading.click();
+    await expect(f.page.getByRole("button", { name: "Start goal", exact: true })).toHaveCount(0);
+    await expect(f.page.getByRole("button", { name: "Resume goal", exact: true })).toHaveCount(0);
+    waiting.resolve();
+    await expect(f.primary.getByRole("button", { name: "Set goal", exact: true })).toBeVisible();
+    await expect(f.page.getByRole("button", { name: "Start goal", exact: true })).toBeVisible();
+    await expect(f.page.getByRole("button", { name: "Resume goal", exact: true })).toHaveCount(0);
+  } finally { waiting.resolve(); }
+});