@jskit-ai/assistant-core 0.2.9 → 0.2.11

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.9",
-    "@jskit-ai/http-runtime": "0.2.4",
-    "@jskit-ai/kernel": "0.2.4",
+    "@jskit-ai/assistant-core": "0.2.11",
+    "@jskit-ai/http-runtime": "0.2.5",
+    "@jskit-ai/kernel": "0.2.5",
     "@mdi/js": "^7.4.47",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.2.5",
-    "@jskit-ai/connectors-catalog": "0.2.5"
+    "@jskit-ai/connectors-core": "0.2.6",
+    "@jskit-ai/connectors-catalog": "0.2.6"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.7",

package/locales/en.json

@@ -333,6 +333,7 @@
         "compactWhileWorking": "Claude is still working. Wait for it to finish before freeing its context.",
         "noActiveTurn": "Claude has no active turn for this message.",
         "steeringUnavailable": "This Claude turn cannot accept steering now.",
+        "settingsChangeWhileWorking": "Stop the current Claude turn before changing its settings.",
         "notConnected": "Claude Code is not connected.",
         "accountStatusInvalid": "Claude Code returned an invalid account status."
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -51,8 +51,8 @@
     "@ai-sdk/togetherai": "^3.0.49",
     "@ai-sdk/xai": "^4.0.58",
     "@jskit-ai/agent": "0.1.0",
-    "@jskit-ai/resource-core": "0.1.195",
-    "@jskit-ai/resource-crud-core": "0.1.195",
+    "@jskit-ai/resource-core": "0.1.196",
+    "@jskit-ai/resource-crud-core": "0.1.196",
     "@mdi/js": "^7.4.47",
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.152",
@@ -61,8 +61,8 @@
     "ws": "^8.20.1"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.2.4",
-    "@jskit-ai/kernel": "0.2.4",
+    "@jskit-ai/http-runtime": "0.2.5",
+    "@jskit-ai/kernel": "0.2.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"
   },

package/src/server/conversation/claudePromptDelivery.js

@@ -56,9 +56,11 @@ export function createClaudePromptDelivery({
     }
     let native;
     try {
-      if (!command && entry.main && entry.turn?.active && entry.process) {
-        // Main steering keeps the active instruction installation, just like
-        // command steering. Refresh guidance on the next idle admission.
+      if (!command && entry.turn?.active && entry.process) {
+        // Steering keeps the active instruction installation, just like command
+        // steering, in Main and in every other conversation: guidance changed
+        // by the running work (a repair editing the project's Genesis files)
+        // applies at the next idle admission and never refuses the message.
         // Account replacement must still confirm cleanup before any new send.
         if (preparation.account) await bindAccount(entry);
         native = entry.process || await ensureProcess(entry, input);

package/src/server/conversation/codexTurnState.js

@@ -163,7 +163,14 @@ export function codexAppServerProcessedResultEvent(session = {}, threadId = "",
   )) || null;
 }
 
-export function codexAppServerTurnStateFromAgentRun(run = {}, normalizeRunState = normalizeCodexAppServerRunState) {
+/**
+ * The turn a saved Codex run reports. No saved run (null or undefined) is no turn: it is idle. A saved run
+ * whose state is not written yet is starting, which counts as active.
+ * @param {object | null | undefined} run
+ * @param {(state: unknown) => string} [normalizeRunState]
+ */
+export function codexAppServerTurnStateFromAgentRun(run, normalizeRunState = normalizeCodexAppServerRunState) {
+  if (run == null) return codexAppServerIdleTurnState();
   const runState = normalizeRunState(run.state);
   const active = codexAppServerRunStateIsActive(runState);
   const state = runState === CODEX_APP_SERVER_RUN_STATE.FINALIZING
@@ -194,10 +201,11 @@ export function codexAppServerTurnStateFromAgentRun(run = {}, normalizeRunState
 }
 
 export function codexAppServerTurnState(session = {}, normalizeRunState = normalizeCodexAppServerRunState) {
-  const run = codexAppServerAgentRun(session);
-  if (run) {
-    return codexAppServerTurnStateFromAgentRun(run, normalizeRunState);
-  }
+  return codexAppServerTurnStateFromAgentRun(codexAppServerAgentRun(session), normalizeRunState);
+}
+
+/** The turn of a session or binding that has no saved Codex run. */
+function codexAppServerIdleTurnState() {
   return {
     active: false,
     completedAt: "",

package/src/server/conversation/continuity.js

@@ -4,6 +4,7 @@ import { isCompletedEnvelopeTurn } from "./transcript.js";
 import { ignorePromptRejection, ignorePromptSending } from "./nativeCommandCallbacks.js";
 
 // A final answer keeps its identity when an application edits its visible text.
+// A turn's later replies repeat it here; distinctMessages tells them apart.
 export function conversationMessageIdentity(turnId, message) {
   return `${turnId}/${message.role}/${["user", "assistant", "system"].includes(message.role)
     ? "" : message.messageId || message.at}`;
@@ -16,6 +17,24 @@ export function conversationMessageVersion(message, { includeData = false } = {}
   })).digest("hex");
 }
 
+/**
+ * Native continuations add later replies to a turn, and those repeat its identity. The first keeps
+ * it, because saved cursors and an edited final answer use it, and each later one adds its own id.
+ * The original version saved for a repeated identity names only the last reply written, so it is dropped.
+ * @param {object[]} messages
+ * @returns {object[]}
+ */
+function distinctMessages(messages) {
+  const repeats = Map.groupBy(messages, message => message.id);
+  return messages.map(message => {
+    const repeated = repeats.get(message.id);
+    if (repeated.length === 1) return message;
+    const { originalVersion: _lastWritten, ...distinct } = message;
+    const position = repeated.indexOf(message);
+    return position ? { ...distinct, id: `${message.id}${message.messageId || position + 1}` } : distinct;
+  });
+}
+
 // A changeover whose owner keeps no delivery log.
 function logNothing() {}
 
@@ -70,7 +89,7 @@ export function createConversationChangeover({ state, transcript, agent, identit
       lastEngine: engineId,
       engines: {
         [engineId]: {
-          seen: Object.fromEntries(messages.map((message) => [message.id, message.originalVersion || message.version]))
+          seen: Object.fromEntries(distinctMessages(messages).map((message) => [message.id, message.originalVersion || message.version]))
         }
       }
     };
@@ -81,7 +100,7 @@ export function createConversationChangeover({ state, transcript, agent, identit
     const seen = value.engines[engineId].seen;
     // New replies from the last engine are already in that native conversation.
     // Preserve old fingerprints: an edited bubble still needs to be delivered.
-    for (const message of messages) {
+    for (const message of distinctMessages(messages)) {
       if (message.engineId === engineId && !Object.hasOwn(seen, message.id)) {
         seen[message.id] = message.originalVersion || message.version;
       }
@@ -146,16 +165,17 @@ export function createConversationChangeover({ state, transcript, agent, identit
       code: unconfirmedCode, messageId, threadId, error: unconfirmedMessage };
   }
 
-  async function send({ engineId, messages, input, turnMetadata, completedEnvelope = false, excludedMessageIds = [], inspectOnly = false }) {
+  async function send({ engineId, messages: written, input, turnMetadata, completedEnvelope = false, excludedMessageIds = [], inspectOnly = false }) {
     if (typeof completedEnvelope !== "boolean" || !Array.isArray(excludedMessageIds) ||
         excludedMessageIds.some(id => typeof id !== "string" || !id.trim() || id.length > 128) ||
         new Set(excludedMessageIds).size !== excludedMessageIds.length || excludedMessageIds.length && !completedEnvelope) {
       throw new TypeError("Native history exclusions require a tracked completed envelope and exact message IDs.");
     }
     const excluded = new Set(excludedMessageIds);
-    const value = await readState({ engineId, messages });
+    const value = await readState({ engineId, messages: written });
     const binding = value.engines[engineId] ||= { seen: {} };
-    rememberReplies(value, engineId, messages);
+    rememberReplies(value, engineId, written);
+    const messages = distinctMessages(written);
     const persist = () => state.write(value);
     async function markDelivered(seen) {
       const replacement = value.replacement;
@@ -383,7 +403,7 @@ function writtenMessages(history, native = false) {
 export const conversationNativeMessages = history => writtenMessages(history, true);
 
 export function conversationHistoryVersions(history) {
-  return Object.fromEntries(writtenMessages(history).map(message => [message.id, message.version]));
+  return Object.fromEntries(distinctMessages(writtenMessages(history)).map(message => [message.id, message.version]));
 }
 
 export function conversationRequestText({ text, origin, data }) {

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

@@ -1,3 +1,4 @@
+import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
 import { createConversationSystemPrompt } from "../systemPrompt.js";
 
 /**
@@ -44,7 +45,12 @@ export function createClaudeConversationAdapter({ getProcess, isActive, startPro
       const canUpdate = getProcess() && installedPrompt === systemPrompt && installedMode === instructionMode &&
         liveUpdateIdentity !== undefined && updateIdentity === liveUpdateIdentity;
       if (getProcess() && isActive() && !canUpdate && !instructions.isCurrent({ systemPrompt, contextIdentity })) {
-        throw new Error("Stop the current Claude turn before changing its settings.");
+        // Steering never gets here: it keeps the running installation. This is an
+        // explicit settings or command preparation while work is running.
+        throw new AppError(409, "Stop the current Claude turn before changing its settings.", {
+          code: "conversation_claude_settings_change_while_working",
+          messageCode: "assistant.claude.settingsChangeWhileWorking"
+        });
       }
       return instructions.ensure({
         systemPrompt,

package/test/claudeTurn.test.js

@@ -949,6 +949,36 @@ test("Claude status retains active instructions and applies changed guidance onc
   assert.equal(f.processes.length, 2, "Idle readiness installs the changed instructions");
 });
 
+// A repair chat edits the project's Genesis files while it works, so its
+// composed instructions change mid-turn. A message typed then is steering.
+for (const main of [true, false]) test(`Claude steering keeps the running instructions after guidance changed mid-turn and idle admission applies them, main=${main}`, async t => {
+  const f = await publishedClaudeFixture(t);
+  const entry = main ? f.entry : await f.owner.open(f.context, {
+    conversationId: "87654321-4321-4321-8321-cba987654321", mainId: f.conversationId, create: true
+  });
+  assert.equal(entry.main, main);
+  await f.owner.startTurn(entry, { message: "Repair the setup", messageId: "repair", persistent: true });
+  const running = entry.process;
+  f.behavior.systemPrompt = "Guidance the repair changed during its own turn.";
+  const steered = await f.owner.startTurn(entry, { message: "The saved version already has this", messageId: "midturn", steer: true });
+  assert.deepEqual([steered.ok, entry.nativeTurn.read().active], [true, true]);
+  assert.equal(entry.process, running, "the steer keeps the running process and its instructions");
+  assert.equal(f.processes.length, 1);
+  assert.equal(f.behavior.nativeInputs.at(-1), "The saved version already has this", "the steer reached the running Claude");
+  await entry.process.options.onEvent({ session_id: entry.id, type: "result", subtype: "success", result: "Done" });
+  await f.owner.startTurn(entry, { message: "Next request", messageId: "next" });
+  assert.equal(f.processes.length, 2, "the next idle admission installs the changed guidance");
+});
+
+test("an explicit Claude settings change while work runs is refused with its own code", async t => {
+  const f = await publishedClaudeFixture(t);
+  await f.send();
+  await assert.rejects(f.entry.nativeTurn.prepare({ systemPrompt: "Changed guidance", settings: {}, model: "sonnet" }), error =>
+    error.code === "conversation_claude_settings_change_while_working" && error.statusCode === 409 &&
+    error.messageCode === "assistant.claude.settingsChangeWhileWorking");
+  assert.equal(f.processes.length, 1);
+});
+
 test("Claude active status keeps a running turn across an account change; idle admission applies it", async t => {
   const f = await publishedClaudeFixture(t);
   await f.send();

package/test/codexConversationSession.test.js

@@ -1740,6 +1740,28 @@ test("Codex cancellation drains owned work, and a deadline saves a failed turn",
   assert.equal(trace.filter(row => row.args).length, 1);
 });
 
+// An upgraded binding keeps its native thread but has no saved Codex run. With
+// its Codex account gone, reading, Stop and selection still start nothing.
+test("a Codex binding with no saved run reads ready, and Stop and selection start no Codex work", async t => {
+  const f = await fixture(t, apiOptions());
+  await f.first.close();
+  await f.storage.write("conversation", async transaction => {
+    const metadata = await transaction.readMetadata();
+    assert.equal(Object.hasOwn(metadata.runtime.binding, "codexAppServerRun"), false);
+    metadata.runtime.binding = { ...metadata.runtime.binding, threadId: "imported-thread", processInstanceId: "" };
+    await transaction.writeMetadata(metadata);
+  });
+  await rm(f.account);
+  const conversation = await f.runtime().open({ id: "conversation" });
+  const state = await conversation.read();
+  assert.equal(state.status, "ready");
+  assert.equal(state.phase, "");
+  assert.deepEqual(await conversation.cancel(), { stopped: false });
+  await select(conversation, "api", "imported-to-api");
+  assert.equal((await conversation.read()).engine, "api");
+  await assert.rejects(f.trace(), { code: "ENOENT" }, "No Codex process was started");
+});
+
 test("lost Codex acknowledgement stays uncertain until native history proves the exact message", async t => {
   const f = await fixture(t);
   const lost = { messageId: "lost-id", text: "lost" };

package/test/codexTurn.test.js

@@ -19,6 +19,7 @@ import {
   codexAppServerAgentRunPatch,
   codexAppServerPendingUserMessageOwnership,
   codexAppServerTurnState,
+  codexAppServerTurnStateFromAgentRun,
   CODEX_APP_SERVER_RUN_STATE
 } from "../src/server/conversation/codexTurn.js";
 
@@ -563,6 +564,18 @@ test("original pending ownership and terminal outer identity are preserved witho
     error => error === hostError);
 });
 
+test("no saved Codex run is no turn, while a saved run without a state is starting", () => {
+  for (const run of [undefined, null]) {
+    const turn = codexAppServerTurnStateFromAgentRun(run);
+    assert.equal(turn.active, false);
+    assert.equal(turn.state, "idle");
+    assert.deepEqual(turn, codexAppServerTurnState({ agentRuns: [] }));
+  }
+  const starting = codexAppServerTurnStateFromAgentRun({});
+  assert.equal(starting.active, true);
+  assert.equal(starting.state, "starting");
+});
+
 test("native notification queues merge only waiting stream deltas and retain receipt order", async () => {
   const owner = createCodexAppServerNotificationQueue();
   const context = { sessionId: "session-1", sessionKey: "session-1", threadId: "thread-1", turnId: "turn-1" };
@@ -3672,6 +3685,160 @@ test("native history budget resolves only for new catch-up and preserves the ret
   assert.equal(sent[2].message, "Just these words");
 });
 
+// One saved turn that native continuations can add replies to, delivered through a changeover.
+async function continuedConversation() {
+  const { createConversationChangeover, conversationNativeMessages, conversationHistoryVersions } = await import("../src/server/conversation/continuity.js");
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  const { turnId } = await transcript.writeConversationUserMessage("chat", { messageId: "request", text: "Write a report",
+    at: "2026-10-01T01:00:00.000Z", turnMetadata: { runtime: { engine: "claude" } } });
+  let saved = { lastEngine: "claude", engines: { claude: { seen: {} } } };
+  let sends = 0;
+  let prompt = "";
+  const changeover = createConversationChangeover({
+    state: { async read() { return structuredClone(saved); }, async write(next) { saved = structuredClone(next); } },
+    transcript: { async hasMessage() { return false; } },
+    agent: { async sendMessage(input) { prompt = input.message; return { ok: true, delivered: true }; } }
+  });
+  const turns = () => transcript.readConversationLog("chat");
+  let written = 0;
+  return {
+    transcript, turnId, turns,
+    reply: (messageId, text) => transcript.writeConversationAssistantMessage("chat", { messageId, text, turnId,
+      at: `2026-10-01T01:00:0${++written}.000Z` }),
+    edit: (messageId, text) => storage.write("chat", async tx => {
+      const message = (await tx.readTurn(turnId)).messages.find(row => row.messageId === messageId);
+      await tx.appendMessage(turnId, { ...message, text });
+    }),
+    history: async () => conversationNativeMessages(await turns()),
+    versions: async () => conversationHistoryVersions(await turns()),
+    save(value) { saved = value; },
+    seen: (engineId = "claude") => saved.engines[engineId].seen,
+    async send(engineId = "claude", messages) {
+      await changeover.send({ engineId, messages: messages || conversationNativeMessages(await turns()),
+        input: { messageId: `follow-up-${++sends}`, message: "Next" } });
+      return prompt;
+    }
+  };
+}
+
+// What a changeover preamble carried: each message's id, text and correction mark, and the removals.
+function carriedHistory(prompt) {
+  const { messages, removedMessageIds } = JSON.parse(prompt.split("\n").find(line => line.startsWith('{"messages"')));
+  return { messages: messages.map(message => [message.messageId, message.text, message.corrected]), removedMessageIds };
+}
+
+test("replies that share a turn are each remembered, so later messages carry no changeover preamble", async () => {
+  const f = await continuedConversation();
+  await f.reply("interim", "The query is still running.");
+  await f.reply("report", "The report.");
+  assert.equal(await f.send(), "Next");
+  assert.equal(await f.send(), "Next");
+  // A native continuation after that delivery is already in the engine's own conversation.
+  await f.reply("late", "The stale helper stopped.");
+  assert.equal(await f.send(), "Next");
+  assert.deepEqual(f.seen(), await f.versions());
+  assert.deepEqual(Object.keys(f.seen()), ["000001/user/", "000001/assistant/", "000001/assistant/report", "000001/assistant/late"]);
+});
+
+test("replies without message ids keep separate identities in one turn", async () => {
+  const f = await continuedConversation();
+  await f.transcript.writeConversationAssistantMessage("chat", { text: "First", turnId: f.turnId, at: "2026-10-01T01:00:01.000Z" });
+  await f.transcript.writeConversationAssistantMessage("chat", { text: "Second", turnId: f.turnId, at: "2026-10-01T01:00:02.000Z" });
+  assert.equal(await f.send(), "Next");
+  assert.equal(await f.send(), "Next");
+  assert.deepEqual(Object.keys(f.seen()), ["000001/user/", "000001/assistant/", "000001/assistant/2"]);
+});
+
+test("a corrected reply in a shared turn is delivered alone, and merged replies are reported removed", async () => {
+  const f = await continuedConversation();
+  await f.reply("interim", "The query is still running.");
+  await f.reply("report", "The report.");
+  assert.equal(await f.send(), "Next");
+  await f.edit("report", "The corrected report.");
+  assert.deepEqual(carriedHistory(await f.send()),
+    { messages: [["report", "The corrected report.", true]], removedMessageIds: [] });
+  assert.equal(await f.send(), "Next");
+  await f.edit("interim", "The corrected status.");
+  assert.deepEqual(carriedHistory(await f.send()),
+    { messages: [["interim", "The corrected status.", true]], removedMessageIds: [] });
+  assert.equal(await f.send(), "Next");
+  // An application's edit replaces every reply in the turn and keeps the first one's identity.
+  await f.transcript.upsertConversationAssistantMessage("chat", { turnId: f.turnId, text: "One merged answer." });
+  assert.deepEqual(carriedHistory(await f.send()),
+    { messages: [["interim", "One merged answer.", true]], removedMessageIds: ["000001/assistant/report"] });
+  assert.equal(await f.send(), "Next");
+});
+
+test("a cursor saved while replies shared one identity delivers one correction, then none", async () => {
+  const f = await continuedConversation();
+  await f.reply("interim", "The query is still running.");
+  await f.reply("report", "The report.");
+  const [user, first, last] = await f.history();
+  f.save({ lastEngine: "claude", engines: { claude: { seen: { [user.id]: user.version, [first.id]: last.version } } } });
+  assert.deepEqual(carriedHistory(await f.send()),
+    { messages: [["interim", "The query is still running.", true]], removedMessageIds: [] });
+  assert.deepEqual(f.seen(), await f.versions());
+  assert.equal(await f.send(), "Next");
+});
+
+test("a cursor saved with a turn's first reply is already current", async () => {
+  const f = await continuedConversation();
+  await f.reply("interim", "The query is still running.");
+  await f.reply("report", "The report.");
+  const [user, first] = await f.history();
+  f.save({ lastEngine: "claude", engines: { claude: { seen: { [user.id]: user.version, [first.id]: first.version } } } });
+  assert.equal(await f.send(), "Next");
+  assert.deepEqual(f.seen(), await f.versions());
+  assert.equal(await f.send(), "Next");
+});
+
+test("a cursor saved while replies shared one identity delivers a returning engine's turn once", async () => {
+  const f = await continuedConversation();
+  await f.reply("interim", "The query is still running.");
+  await f.reply("report", "The report.");
+  const [user, first, last] = await f.history();
+  await f.reply("late", "The stale helper stopped.");
+  f.save({ lastEngine: "claude", engines: { codex: { seen: { [user.id]: user.version, [first.id]: last.version } } } });
+  assert.deepEqual(carriedHistory(await f.send("codex")), { messages: [
+    ["interim", "The query is still running.", true], ["report", "The report.", undefined],
+    ["late", "The stale helper stopped.", undefined]], removedMessageIds: [] });
+  assert.deepEqual(f.seen("codex"), await f.versions());
+  assert.equal(await f.send("codex"), "Next");
+});
+
+test("a cursor saved while replies shared one identity keeps real corrections", async () => {
+  const shared = await continuedConversation();
+  await shared.reply("interim", "The query is still running.");
+  await shared.reply("report", "The report.");
+  const [user, first] = await shared.history();
+  shared.save({ lastEngine: "claude", engines: { claude: { seen: { [user.id]: user.version, [first.id]: "before-the-edit" } } } });
+  assert.deepEqual(carriedHistory(await shared.send()),
+    { messages: [["interim", "The query is still running.", true]], removedMessageIds: [] });
+  assert.equal(await shared.send(), "Next");
+
+  const merged = await continuedConversation();
+  await merged.reply("interim", "The query is still running.");
+  await merged.reply("report", "The report.");
+  const [mergedUser, , reportBeforeEdit] = await merged.history();
+  merged.save({ lastEngine: "claude", engines: { claude: { seen: { [mergedUser.id]: mergedUser.version,
+    [reportBeforeEdit.id]: reportBeforeEdit.version } } } });
+  await merged.transcript.upsertConversationAssistantMessage("chat", { turnId: merged.turnId, text: "One merged answer." });
+  assert.deepEqual(carriedHistory(await merged.send()),
+    { messages: [["interim", "One merged answer.", true]], removedMessageIds: [] });
+  assert.equal(await merged.send(), "Next");
+});
+
+test("a host's history may repeat a turn's identity and its last written original version", async () => {
+  const f = await continuedConversation();
+  const reply = { id: "000001/assistant/", role: "assistant", engineId: "claude", originalVersion: "report-version" };
+  const messages = [{ ...reply, messageId: "interim", text: "Running.", version: "interim-version" },
+    { ...reply, messageId: "report", text: "The report.", version: "report-version" }];
+  assert.equal(await f.send("claude", messages), "Next");
+  assert.deepEqual(f.seen(), { "000001/assistant/": "interim-version", "000001/assistant/report": "report-version" });
+  assert.equal(await f.send("claude", messages), "Next");
+});
+
 test("native history budget rejects unavailable dynamic limits before pending delivery", async () => {
   const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
   for (const budget of [0, -1, NaN, Infinity, "4096", undefined]) {