@jskit-ai/assistant-core 0.1.225 → 0.1.226

package/examples/conversation/package.json

@@ -8,7 +8,7 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.225",
+    "@jskit-ai/assistant-core": "0.1.226",
     "@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.225",
+  "version": "0.1.226",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"

package/src/server/conversation/claudeProcess.js

@@ -180,13 +180,15 @@ export async function stopClaudeCodeProcess({ process: native, executionId, stop
   return { ...proof, exited: true };
 }
 
-export async function bindClaudeConversationAccount(entry, { identity, providerId, stop, save }) {
+export async function bindClaudeConversationAccount(entry, { identity, providerId, allowAccountChange = false, stop, save }) {
   entry.accountIdentities ||= {};
   if (!nativeAiProvider(providerId) && entry.accountIdentities[providerId] && entry.accountIdentities[providerId] !== identity) {
     await stop(entry, "The signed-in Claude account changed.");
-    throw Object.assign(new Error("This conversation belongs to another Claude account. Reconnect that account or start a new session."), {
-      code: "claude_account_changed"
-    });
+    if (!allowAccountChange) {
+      throw Object.assign(new Error("This conversation belongs to another Claude account. Reconnect that account or start a new session."), {
+        code: "claude_account_changed"
+      });
+    }
   }
   if (entry.accountIdentity !== identity) {
     entry.accountIdentity = identity;

package/src/server/conversation/claudeTurn.js

@@ -126,8 +126,8 @@ export function createClaudeConversationGoals({ conversationId, readHistory, rea
       if (!objective || objective.length > 4000 || /^(clear|stop|off|reset|none|cancel)$/iu.test(objective)) {
         throw goalError("Enter a goal condition of up to 4,000 characters.");
       }
-      if (readState().active || (action === "set" && goal && goal.status !== "complete")) {
-        throw goalError("Stop the current turn and cancel the existing goal before setting another.");
+      if (action === "set" && goal && goal.status !== "complete") {
+        throw goalError("Cancel the existing goal before setting another.");
       }
       await sendGoal({ message: `/goal ${objective}` });
     } else throw goalError("Unknown Claude goal action.");
@@ -264,7 +264,7 @@ export function createClaudeConversationOwner({
     const providerId = account.providerId;
     if (entry.accountIdentity !== identity) entry.nativeTurn.invalidateFinalAssistantResult();
     try {
-      await bindClaudeConversationAccount(entry, { identity, providerId,
+      await bindClaudeConversationAccount(entry, { identity, providerId, allowAccountChange: account.allowAccountChange === true,
         stop: (entry, reason) => entry.nativeTurn.stopProcess(reason, { preparing: true }), save: saveAccount });
     } catch (failure) {
       if (failure.code !== "claude_account_changed") throw failure;
@@ -1434,6 +1434,11 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       // A completed main loop can still own background work. There is no
       // generation left to interrupt or second terminal result to wait for.
       if (outcome && inFlight.size === 0) {
+        // The next input owns completion now. A task finishing during host
+        // preparation must not settle this turn using the previous result.
+        outcome = null;
+        acceptedInput = null;
+        clearFinalAssistantResult();
         await publish({ type: "diagnostic", stage: "steering_background_only", backgroundTasks: tasks.size });
         return;
       }

package/test/claudeConversationSession.test.js

@@ -1059,6 +1059,25 @@ test("Claude native goal commands use ordinary admission, pause retains the goal
   await assert.rejects(f.conversation.updateGoal({ ...start, messageId: "budget", tokenBudget: 100 }), /token budget/u);
 });
 
+test("Claude accepts a goal during an active turn through the existing steering path", async t => {
+  const f = await fixture(t);
+  await f.conversation.send({ messageId: "working", text: "wait" });
+  const { segmentId } = await f.conversation.read();
+  assert.equal(await f.conversation.readGoal(), null);
+  const command = { action: "set", objective: "Finish the current work", messageId: "working-goal", expectedSegmentId: segmentId };
+  assert.equal((await f.conversation.updateGoal(command)).status, "accepted");
+  const goal = await f.conversation.readGoal();
+  assert.equal(goal.objective, command.objective);
+  assert.equal(goal.status, "active");
+  assert.equal((await f.conversation.updateGoal(command)).duplicate, true);
+  await assert.rejects(f.conversation.updateGoal({ ...command, messageId: "another-goal", objective: "Replace it" }), /cancel the existing goal/i);
+  const trace = await f.trace();
+  assert.equal(trace.filter(row => row.args?.includes("--print")).length, 1);
+  assert.deepEqual(trace.filter(row => row.frame?.type === "user").map(row => row.frame.message.content),
+    ["wait", "/goal Finish the current work"]);
+  assert.equal(trace.filter(row => row.frame?.request?.subtype === "interrupt").length, 1);
+});
+
 test("Claude rejects reserved goals and waits for ordinary Send to deliver a replacement briefing", async t => {
   const f = await fixture(t);
   let state = await f.conversation.read();

package/test/claudeTurn.test.js

@@ -135,6 +135,21 @@ test("interruption does not claim process exit or complete work on a control ack
   assert.equal(turn.read().text, "Resumed");
 });
 
+test("Claude steering survives background completion while the follow-up is being prepared", async () => {
+  const { turn, send, client, events } = fixture();
+  await send();
+  await turn.receive({ type: "system", subtype: "task_started", task_id: "build", task_type: "local_bash" });
+  await turn.receive({ type: "result", subtype: "success", result: "Build started" });
+  client.interrupt = () => assert.fail("The generation has already completed");
+  await turn.interruptGeneration(client);
+  await turn.receive({ type: "system", subtype: "task_notification", task_id: "build", status: "completed" });
+  assert.equal(events.some(event => event.type === "settled"), false, "The reserved steering input still needs admission");
+  await send("follow-up");
+  await turn.receive({ type: "result", subtype: "success", result: "Revised answer" });
+  assert.equal(turn.read().status, "completed");
+  assert.equal(turn.read().text, "Revised answer");
+});
+
 test("lost acknowledgement stays uncertain and stop rejects pending admission", async () => {
   const { turn, client, send } = fixture();
   client.send = async () => {};