@jskit-ai/assistant-core 0.1.234 → 0.1.236

package/examples/conversation/package.json

@@ -8,7 +8,7 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.234",
+    "@jskit-ai/assistant-core": "0.1.236",
     "@jskit-ai/http-runtime": "0.1.242",
     "@jskit-ai/kernel": "0.1.244",
     "@mdi/js": "^7.4.47",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.1.234",
+  "version": "0.1.236",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"

package/src/server/conversation/claudeTurn.js

@@ -1408,6 +1408,10 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       }
       active = true;
       if (!wasActive) await publish({ type: "continued", source: frame.type });
+      if (phase === "background") {
+        phase = "";
+        await publish({ type: "phase", phase });
+      }
     }
     if (frame.type === "command_lifecycle" || frame.type === "user") {
       const uuid = frame.type === "user" ? frame.uuid : frame.command_uuid;
@@ -1443,7 +1447,8 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
     } else if (frame.type === "system") {
       if (active && ["status", "compact_boundary"].includes(frame.subtype)) {
         const nextPhase = frame.subtype === "status" && frame.status === "compacting" ? "compacting" : "";
-        if (nextPhase !== phase) {
+        // An idle status does not end a wait that only background tasks own.
+        if (nextPhase !== phase && (nextPhase || phase !== "background")) {
           phase = nextPhase;
           await publish({ type: "phase", phase });
         }
@@ -1466,6 +1471,10 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       // response to it. A foreground result written while that worker was live
       // cannot complete this follow-up or retire its admitted application tools.
       if (tasks.size < previousTaskCount) outcome = null;
+      if (phase === "background" && !outcome) {
+        phase = "";
+        await publish({ type: "phase", phase });
+      }
       if (["background_tasks_changed", "task_started", "task_notification", "task_updated"].includes(frame.subtype)) {
         if (tasks.size && turnId && !active && !cancelling) {
           generation++;
@@ -1556,6 +1565,12 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       }
       if (cancelling) return;
       outcome = { status: interrupted ? "interrupted" : failed ? "failed" : "completed", error: message };
+      // The reply is final, but native background tasks still own the turn
+      // (and may continue it). Keep it active and say what it is waiting for.
+      if (active && tasks.size && !inFlight.size && phase !== "background") {
+        phase = "background";
+        await publish({ type: "phase", phase });
+      }
       await publish({ type: "diagnostic", stage: "native_result", status: outcome.status,
         terminalReason: frame.terminal_reason, active, pendingCommands: inFlight.size, backgroundTasks: tasks.size });
     }

package/src/server/conversation/providers/claudeDriver.js

@@ -171,7 +171,7 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
         else if (event.type === "message-complete") await current.onEvent(event);
         else if ((event.type === "admitted" && current.goal) || event.type === "settled") {
           await current.onEvent({ type: "goal", goal: claudeGoalValue(await entry.goals.read(), entry.id) });
-        } else if (event.type === "phase") await current.onEvent({ type: "phase", phase: event.phase === "compacting" ? "compacting" : "working" });
+        } else if (event.type === "phase") await current.onEvent({ type: "phase", phase: ["compacting", "background"].includes(event.phase) ? event.phase : "working" });
       }
     });
     return standalone;

package/src/server/conversation/runtime.js

@@ -142,7 +142,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
   }
 
   async function setPhase(entry, phase, turnId) {
-    if (!["", "preparing", "working", "compacting", "retrying"].includes(phase)) throw new Error("Invalid conversation phase from the engine adapter.");
+    if (!["", "preparing", "working", "compacting", "retrying", "background"].includes(phase)) throw new Error("Invalid conversation phase from the engine adapter.");
     if ((entry.phase || "") === phase) return;
     entry.phase = phase;
     await emit(entry, { type: "phase", phase, turnId });
@@ -239,7 +239,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
         reason: metadata.runtime.replacement.reason, segmentId: metadata.runtime.replacement.segmentId } : null,
       status: logical ? logical.status : entry.storageFailure || entry.executionFailure ? "unavailable" : entry.active || nativeTurn?.active ? "working" : metadata.runtime.replacement ? "replacement-pending"
         : metadata.runtime.request && (entry.engine === "api" || metadata.runtime.request.attempted || metadata.runtime.request.inspectionOnly) ? "unconfirmed" : "ready",
-      phase: logical ? logical.phase || "" : entry.phase || (nativeTurn?.active && nativeTurn.status !== "observation_lost" ? nativeTurn.phase === "compacting" ? "compacting" : "working" : ""),
+      phase: logical ? logical.phase || "" : entry.phase || (nativeTurn?.active && nativeTurn.status !== "observation_lost" ? ["compacting", "background"].includes(nativeTurn.phase) ? nativeTurn.phase : "working" : ""),
       error: logical ? logical.error || "" : entry.error || nativeTurn?.error || request?.error || last?.error || "",
       goal: entry.goal || null,
       pendingRequest: logical ? logical.pendingRequest || null : pendingRequest,
@@ -309,7 +309,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     const nativeTurn = payload.agentSession?.turn;
     if (nativeTurn) {
       entry.nativePhase = nativeTurn.active
-        ? ["preparing", "compacting", "retrying"].includes(nativeTurn.phase) ? nativeTurn.phase : "working"
+        ? ["preparing", "compacting", "retrying", "background"].includes(nativeTurn.phase) ? nativeTurn.phase : "working"
         : "";
       const request = entry.active?.request;
       if (!entry.active || request.accepted) {
@@ -442,13 +442,19 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
         : Math.max(0, initialWindow - (request?.input.origin === "user" ? 1 : 0)),
       maximumInitialMessageCharacters: limits.maxInitialNativeHistoryMessageCharacters,
       ...(budget ? { maximumHistoryBytes: async options => {
-        await access(context, entry.id, request.operation, entry);
-        signal.throwIfAborted();
-        // A host may free native context first; show that as compacting.
-        const bytes = await budget({ ...options, context, signal,
-          setPhase: phase => setPhase(entry, phase === "compacting" ? "compacting" : "preparing") });
-        signal.throwIfAborted();
-        return bytes;
+        try {
+          await access(context, entry.id, request.operation, entry);
+          signal.throwIfAborted();
+          // A host may free native context first; show that as compacting.
+          const bytes = await budget({ ...options, context, signal,
+            setPhase: phase => setPhase(entry, phase === "compacting" ? "compacting" : "preparing") });
+          signal.throwIfAborted();
+          return bytes;
+        } catch (error) {
+          // Sizing missed history precedes native dispatch, so this message
+          // was definitely not sent. Hosts and clients report it as such.
+          throw Object.assign(error, { delivery: "not-sent" });
+        }
       } } : {}),
       presentation: entry.conversation?.presentation || { unconfirmedCode: "conversation_delivery_uncertain",
         unconfirmedMessage: "The previous submission has uncertain delivery. Retry this message to check its native receipt; it will not be resent automatically." },

package/src/server/conversation/storage.js

@@ -186,12 +186,16 @@ export function createConversationStorage({ readRecord, writeRecord, deleteRecor
           const find = (role) => turn.messages.find((message) => message.role === role) || null;
           const thinking = turn.messages.filter((message) => message.role === "thinking");
           const commentary = turn.messages.filter((message) => message.role === "commentary");
-          const activity = [...thinking, ...commentary].sort((a, b) => a.at.localeCompare(b.at));
+          // Native continuations (for example Claude background-task notifications)
+          // can add later replies to the same request turn. Every saved reply stays
+          // in the ordered message list; the latest one still closes it.
+          const replies = turn.messages.filter((message) => message.role === "assistant");
+          const activity = [...thinking, ...commentary, ...replies.slice(0, -1)].sort((a, b) => a.at.localeCompare(b.at));
           const system = find("system"), user = find("user"), assistant = find("assistant");
           return structuredClone({
             turnId: id, user, assistant, thinking, commentary,
             ...(system ? { system } : {}), ...(turn.metadata ? { metadata: turn.metadata } : {}),
-            messages: [system, user, ...activity, assistant].filter(Boolean)
+            messages: [system, user, ...activity, replies.at(-1)].filter(Boolean)
           });
         },
         async appendMessage(id, { turnMetadata, ...message }) {

package/src/shared/conversation/patches.js

@@ -108,11 +108,20 @@ function applyConversationLogPatch(payload = {}, patch = null, options = {}) {
       }
       updated[role] = chronologicalConversationActivity([...messages.values()]);
     }
+    // A request turn can hold several saved replies (native continuations).
+    // Keep each one; the latest reply still closes the message list.
+    const replies = new Map();
+    for (const message of [existing, patch.turn].flatMap(turn => Array.isArray(turn.messages)
+      ? turn.messages.filter(message => message?.role === "assistant") : [turn.assistant].filter(Boolean))) {
+      replies.set(message.messageId || JSON.stringify(message.at ? [message.at] : ["", message.text]), message);
+    }
+    if (!replies.size && updated.assistant) replies.set("", updated.assistant);
+    const orderedReplies = chronologicalConversationActivity([...replies.values()]);
     updated.messages = [
       updated.system,
       updated.user,
-      ...chronologicalConversationActivity([...updated.thinking, ...updated.commentary]),
-      updated.assistant
+      ...chronologicalConversationActivity([...updated.thinking, ...updated.commentary, ...orderedReplies.slice(0, -1)]),
+      orderedReplies.at(-1)
     ].filter(Boolean);
   }
   const nextTurns = (existingIndex >= 0

package/test/claudeTurn.test.js

@@ -422,6 +422,29 @@ test("Claude authoritative task snapshots repair membership and ignore ambient w
   assert.equal(turn.read().active, false);
 });
 
+test("Claude reports a final reply that waits only for background tasks as the background phase", async () => {
+  const { turn, send, events } = fixture();
+  const phases = () => events.filter(event => event.type === "phase").map(event => event.phase);
+  await send();
+  await turn.receive({ type: "system", subtype: "task_started", task_id: "build", task_type: "local_bash" });
+  await turn.receive({ type: "system", subtype: "task_started", task_id: "helper", task_type: "local_bash" });
+  await turn.receive({ type: "result", subtype: "success", result: "Started" });
+  assert.deepEqual([turn.read().active, turn.read().phase], [true, "background"]);
+  await turn.receive({ type: "system", subtype: "status", status: null });
+  assert.equal(turn.read().phase, "background", "An idle status keeps the background wait");
+  await turn.receive({ type: "system", subtype: "task_notification", task_id: "build", status: "completed" });
+  assert.equal(turn.read().phase, "", "A finished task means Claude is working on it again");
+  await turn.receive({ type: "stream_event", event: { type: "message_start", message: { id: "report" } } });
+  await turn.receive({ type: "result", subtype: "success", result: "Report" });
+  assert.deepEqual([turn.read().active, turn.read().phase, turn.read().text], [true, "background", "Report"]);
+  await turn.receive({ type: "system", subtype: "task_notification", task_id: "helper", status: "killed" });
+  await turn.receive({ type: "user", uuid: "notice", origin: { kind: "task-notification" } });
+  assert.equal(turn.read().phase, "");
+  await turn.receive({ type: "result", subtype: "success", result: "Helper stopped" });
+  assert.deepEqual([turn.read().active, turn.read().phase], [false, ""]);
+  assert.deepEqual(phases(), ["background", "", "background", ""]);
+});
+
 test("Claude can steer background-only work without waiting for an already completed generation", async () => {
   const { turn, send, client } = fixture();
   await send();
@@ -2338,7 +2361,8 @@ test("bound Main cannot dispatch or retain a pending prompt when its history bud
   f.binding.transcript.history = async () => [{ id: "earlier", version: "v1", role: "user", text: "Earlier work." }];
   await f.binding.state.write({ lastEngine: "codex", engines: { codex: { seen: {} } } });
   f.binding.maximumHistoryBytes = async () => { throw new Error("Current native context usage unavailable"); };
-  await assert.rejects(f.conversation.send({ messageId: "no-budget", text: "Continue" }), /Current native context usage unavailable/u);
+  await assert.rejects(f.conversation.send({ messageId: "no-budget", text: "Continue" }), error =>
+    /Current native context usage unavailable/u.test(error.message) && error.delivery === "not-sent");
   assert.equal(f.processes.length, 0);
   assert.equal(f.messages.length, 0);
   assert.equal((await f.binding.state.read())?.engines?.claude?.pending, undefined);

package/test/conversation.test.js

@@ -319,3 +319,39 @@ test("reasoning-only histories remain readable without creating phantom message
   assert.equal(page.pagination.hasMoreBefore, false);
   assert.equal(page.pagination.nextBeforeTurnId, "");
 });
+
+test("native continuation replies in one request turn all stay in saved and patched history", async () => {
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  const request = await transcript.writeConversationUserMessage("chat", { messageId: "request", text: "Write a report" });
+  const write = (role, messageId, outputId, at, text) => transcript[{
+    thinking: "writeConversationThinkingMessage", commentary: "writeConversationCommentaryMessage",
+    assistant: "writeConversationAssistantMessage"
+  }[role]]("chat", { messageId, outputId, at, text, turnId: request.turnId });
+  await write("thinking", "t1", "api_a_0", "2026-10-01T01:00:01.000Z", "Planning the query");
+  await write("commentary", "c1", "api_a_1", "2026-10-01T01:00:02.000Z", "Running the query");
+  // A text-only API message ends one native run while a background task continues.
+  await write("assistant", "interim", "api_b_0", "2026-10-01T01:00:03.000Z", "The query is still running.");
+  // The task notification continues the same request: thinking and the report share one API message.
+  await write("thinking", "t2", "api_c_0", "2026-10-01T01:00:04.000Z", "Time for the report");
+  await write("assistant", "report", "api_c_1", "2026-10-01T01:00:05.000Z", "| Group | Share |\n| --- | --- |\n| A | 60% |");
+  const beforeFollowUp = await transcript.readConversationLogPage("chat", { limit: 12, presentation: true });
+  // An unsolicited later notification adds a short follow-up to the same request turn.
+  await write("thinking", "t3", "api_d_0", "2026-10-01T01:00:40.000Z", "That helper was stale");
+  const followUp = await write("assistant", "follow-up", "api_d_1", "2026-10-01T01:00:41.000Z", "The stale helper stopped.");
+  const ids = turn => turn.messages.map(message => message.messageId);
+  const expected = ["request", "t1", "c1", "interim", "t2", "report", "t3", "follow-up"];
+  const [saved] = await transcript.readConversationLog("chat", { presentation: true });
+  assert.equal(saved.turnId, request.turnId);
+  assert.deepEqual(ids(saved), expected, "every saved reply is presented in order, after its own progress");
+  assert.equal(saved.assistant.messageId, "interim", "the turn's first reply keeps its existing field identity");
+  assert.deepEqual(ids(followUp), expected);
+  // A live upsert from the late follow-up must not hide the report already shown.
+  const patched = applyConversationLogPatch(beforeFollowUp, { type: "upsert-turn", turn: followUp }, { limit: 12 });
+  assert.deepEqual(ids(patched.conversationLog[0]), expected);
+  const partial = applyConversationLogPatch(beforeFollowUp, { type: "upsert-turn", turn: {
+    turnId: request.turnId, assistant: followUp.messages.at(-1), messages: [followUp.messages.at(-1)]
+  } }, { limit: 12 });
+  assert.deepEqual(ids(partial.conversationLog[0]).filter(id => ["interim", "report", "follow-up"].includes(id)),
+    ["interim", "report", "follow-up"], "a partial patch adds its reply without dropping earlier ones");
+});