@jskit-ai/assistant-core 0.2.8 → 0.2.10

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.8",
+    "@jskit-ai/assistant-core": "0.2.10",
     "@jskit-ai/http-runtime": "0.2.4",
     "@jskit-ai/kernel": "0.2.4",
     "@mdi/js": "^7.4.47",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.2.4",
-    "@jskit-ai/connectors-catalog": "0.2.4"
+    "@jskit-ai/connectors-core": "0.2.5",
+    "@jskit-ai/connectors-catalog": "0.2.5"
   },
   "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.8",
+  "version": "0.2.10",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"

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/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" };