@jskit-ai/assistant-runtime 0.1.212 → 0.1.213

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-runtime",
-  "version": "0.1.212",
+  "version": "0.1.213",
   "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.219",
+    "@jskit-ai/assistant-core": "0.1.220",
     "json-rest-schema": "^1.0.17"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.239",
-    "@jskit-ai/http-web": "0.1.86",
-    "@jskit-ai/kernel": "0.1.241",
-    "@jskit-ai/realtime": "0.1.238",
-    "@jskit-ai/shell-web": "0.1.245",
+    "@jskit-ai/http-runtime": "0.1.240",
+    "@jskit-ai/http-web": "0.1.87",
+    "@jskit-ai/kernel": "0.1.242",
+    "@jskit-ai/realtime": "0.1.239",
+    "@jskit-ai/shell-web": "0.1.246",
     "@tanstack/vue-query": "^5.90.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/database-runtime": "0.1.241"
+    "@jskit-ai/database-runtime": "0.1.242"
   },
   "description": "Capability-based assistant runtime with per-surface chat, transcripts, settings, and action tools.",
   "jskit": {

package/src/client/support/subscribeAssistantConversation.js

@@ -148,6 +148,10 @@ function subscribeAssistantConversation({
         changedPresentation = true;
       }
     } else if (event.type === "message" || event.type === "message-complete") {
+      // A saved turn can be outside the loaded page. Its transcript patch owns
+      // presentation; the following completion must not recreate it at the tail.
+      const persisted = event.type === "message" && event.status === "complete" && event.persisted === true;
+      if (persisted) changedPresentation = completed.delete(event.messageId) || changedPresentation;
       // A later initial read can already contain the result of buffered events.
       const older = streaming && event.streaming?.revision < streaming.revision;
       const completedWhileRunning = event.type === "message" && event.status === "complete" &&
@@ -155,13 +159,13 @@ function subscribeAssistantConversation({
       if (!older || completedWhileRunning) {
         const previous = streaming?.messages?.find(message => message.messageId === event.messageId);
         const changed = receiveStreaming(event.streaming);
-        if (event.type === "message" && event.status === "complete" && event.text) {
+        if (event.type === "message" && event.status === "complete" && event.text && !persisted) {
           completed.set(event.messageId, { turnId: event.turnId, message: {
             messageId: event.messageId, role: event.role, text: event.text, status: "complete",
             ...(event.outputId ? { outputId: event.outputId } : {}),
             ...(event.turnId ? { turnId: event.turnId } : {}),
             ...(event.origin ? { origin: event.origin } : {}),
-            ...(previous?.at ? { at: previous.at } : {})
+            ...((event.at || previous?.at) ? { at: event.at || previous.at } : {})
           } });
         }
         changedPresentation ||= changed || event.status === "complete";

package/test/assistantConversationBinding.browser.test.js

@@ -2435,6 +2435,39 @@ test("canonical rewind replaces the loaded saved window without retaining remove
 });
 
 
+test("saved history replay stays off the live tail and loads once with its timestamp", options, async t => {
+  const f = await fixture(t, 390);
+  const progress = { role: "commentary", messageId: "replayed-progress", text: "Earlier saved progress",
+    at: "2026-10-13T15:50:59.328Z" };
+  const answer = { role: "assistant", messageId: "replayed-answer", text: "Earlier saved answer",
+    at: "2026-10-13T15:52:58.929Z" };
+  const turns = Array.from({ length: 37 }, (_, index) => {
+    const user = { role: "user", messageId: `replay-question-${index}`, text: `Replay question ${index + 1}` };
+    return { turnId: String(2485 + index).padStart(6, "0"), user,
+      ...(index === 0 ? { commentary: [progress], assistant: answer, messages: [user, progress, answer] } : {}) };
+  });
+  await f.command("history", { id: "chat:1", turns, limit: 20 });
+  await f.notify("chat:1");
+  await expect.poll(() => f.page.evaluate(() => window.conversationFixture.current().turns.value.length)).toBe(20);
+  await f.page.evaluate(turn => {
+    const socket = window.conversationFixture.socket;
+    socket.notify("chat:1", { type: "transcript", patch: { type: "upsert-turn", turn } });
+    for (const message of turn.messages.filter(message => message.role !== "user")) {
+      socket.notify("chat:1", { type: "message", ...message, turnId: turn.turnId, status: "complete",
+        persisted: true, streaming: { revision: 1, messages: [] } });
+    }
+  }, turns[0]);
+  await expect(f.primary.getByText(answer.text, { exact: true })).toHaveCount(0);
+  assert.equal(await f.page.evaluate(() => window.conversationFixture.current().turns.value.length), 20);
+  assert.equal(await f.page.evaluate(() => window.conversationFixture.current().loadMore()), true);
+  await expect(f.primary.getByText(answer.text, { exact: true })).toHaveCount(1);
+  const saved = await f.page.evaluate(() => window.conversationFixture.current().turns.value.find(turn => turn.turnId === "002485"));
+  assert.equal(saved.user.text, "Replay question 1");
+  assert.equal(saved.assistant.at, answer.at);
+  assert.equal(saved.commentary[0].at, progress.at);
+  assert.deepEqual(await f.sent(), [], "Reading replayed history cannot send another request");
+});
+
 test("canonical loaded-history replay retains older completed output and its authored row", options, async t => {
   const f = await fixture(t, 390);
   const turns = Array.from({ length: 25 }, (_, index) => ({

package/test/assistantConversationSubscriptions.test.js

@@ -570,6 +570,52 @@ test("stream snapshots preserve completed commentary and coalesce lifecycle read
   assert.deepEqual(errors, []);
 });
 
+test("replayed saved completions outside the history page never become live tail rows", async t => {
+  const socket = new EventEmitter();
+  socket.connected = true;
+  const states = [], events = [];
+  const latest = Array.from({ length: 20 }, (_, index) => {
+    const turnId = String(2502 + index).padStart(6, "0");
+    const user = { messageId: `question-${turnId}`, role: "user", text: `Question ${turnId}` };
+    return { turnId, user, messages: [user] };
+  });
+  const initial = { id: "chat", status: "working", conversationLog: latest,
+    pagination: { limit: 20, hasMoreBefore: true }, streaming: { revision: 0, messages: [] } };
+  let subscriptionId, revision = 0;
+  socket.timeout = () => ({ emit(_name, input, acknowledge) {
+    subscriptionId = input.subscriptionId;
+    acknowledge(null, { ok: true, streamEpoch: "epoch", state: initial });
+  } });
+  const dispose = subscribeAssistantConversation({ socket, conversationId: "chat", targetSurfaceId: "home", hostSurfaceId: "home",
+    read: async () => initial, onState: state => states.push(state), onEvent: event => events.push(event) });
+  t.after(dispose);
+  function deliver(event) {
+    socket.emit(ASSISTANT_CONVERSATION_EVENT, { subscriptionId, conversationId: "chat", streamEpoch: "epoch",
+      streamRevision: ++revision, event });
+  }
+  const messages = [
+    { messageId: "old-progress", role: "commentary", text: "Earlier progress", at: "2026-10-13T15:50:59.328Z" },
+    { messageId: "old-answer", role: "assistant", text: "Earlier answer", at: "2026-10-13T15:52:58.929Z" }
+  ];
+  // Native history reconciliation first publishes the saved turn, then its
+  // completion notifications. Paging deliberately excludes this older turn.
+  const turn = { turnId: "002485", commentary: [messages[0]], assistant: messages[1], messages };
+  deliver({ type: "transcript", patch: { type: "upsert-turn", turn } });
+  for (const message of messages) deliver({ type: "message", ...message, turnId: turn.turnId,
+    status: "complete", persisted: true, streaming: initial.streaming });
+  assert.deepEqual(states.at(-1).turns, latest, "Saved replay cannot append a synthetic old turn after the current request");
+  await dispose.reload();
+  assert.deepEqual(states.at(-1).turns, latest, "Ordinary canonical refresh does not revive completed replay entries");
+  assert.equal(events.filter(event => event.type === "message").length, 2, "Notifications still reach non-transcript consumers");
+
+  const live = { messageId: "live-progress", turnId: "002521", role: "commentary", text: "New progress",
+    at: "2026-10-13T16:13:22.233Z", status: "complete" };
+  deliver({ type: "message", ...live, streaming: { revision: 1, messages: [] } });
+  assert.equal(states.at(-1).turns.at(-1).commentary[0].text, live.text);
+  assert.equal(states.at(-1).turns.at(-1).commentary[0].at, live.at,
+    "A completed message without an earlier partial retains its supplied timestamp");
+});
+
 test("original transcript patches survive a read already in flight and the next canonical read remains authoritative", async t => {
   const changes = new EventEmitter();
   const socket = new EventEmitter();