@jskit-ai/assistant-core 0.1.228 → 0.1.230

package/examples/conversation/package.json

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

package/src/server/conversation/claudeProcess.js

@@ -10,6 +10,21 @@ import { CLAUDE_APPLICATION_TOOL_SERVER } from "./claudeTools.js";
 import { nativeCommandHook, validateCommandWrapper } from "./commandWrapper.js";
 
 const statusReads = new WeakMap();
+const CLAUDE_EXIT_WAIT_MS = 5_000;
+
+/** Person-facing cause for a Claude process that ended without being stopped. */
+export function claudeUnexpectedExitMessage(processExit = {}) {
+  const resume = "The conversation so far is saved; send a message to continue.";
+  if (Number(processExit?.taskLimit?.count) > 0) {
+    return "Claude stopped unexpectedly: the server refused to create more processes or threads for it " +
+      `(process/thread limit reached). ${resume}`;
+  }
+  if (processExit?.signal) return `Claude stopped unexpectedly: it was terminated by ${processExit.signal}. ${resume}`;
+  if (Number.isInteger(processExit?.code)) {
+    return `Claude stopped unexpectedly with exit code ${processExit.code}. ${resume}`;
+  }
+  return `Claude stopped unexpectedly. ${resume}`;
+}
 
 export async function readClaudeCodeAuthStatus({
   env = process.env, credentialHome = { home: env.HOME || homedir() }, command = "claude", commandRunner, signal
@@ -347,7 +362,20 @@ export async function createClaudeCodeProcess({
     await onStarted?.(native.id, stop);
     signal?.throwIfAborted();
     const stream = Duplex.from({ readable: native.stdout, writable: native.stdin });
-    client = createClaudeJsonClient({ stream, onEvent, onFailure,
+    // A lost stream usually means the process ended. Its exit details arrive
+    // separately, so wait briefly for them before reporting the cause.
+    const exited = native.exited;
+    const describeFailure = async (failure) => {
+      if (failure?.code === "assistant_claude_observation_lost" && exited && !stopped && !stopping) {
+        const processExit = failure.processExit || await Promise.race([
+          exited.catch(() => null),
+          new Promise((resolve) => setTimeout(resolve, CLAUDE_EXIT_WAIT_MS, null).unref?.())
+        ]);
+        if (processExit) Object.assign(failure, { processExit, message: claudeUnexpectedExitMessage(processExit) });
+      }
+      return onFailure?.(failure);
+    };
+    client = createClaudeJsonClient({ stream, onEvent, onFailure: describeFailure,
       onControlRequest(request, context) {
         if (request.subtype === "hook_callback" && commandWrapper && request.callback_id === "jskit-command-wrapper") {
           return nativeCommandHook(commandWrapper, request.input);

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

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import path from "node:path";
 import { realpath } from "node:fs/promises";
+import { isDeepStrictEqual } from "node:util";
 import { bindClaudeConversationAccount, claudeConnectionIdentity, claudeFlagSettings, claudeModelConfiguration, readClaudeCodeAuthStatus } from "../claudeProcess.js";
 import { nativeAiModel, nativeAiProvider } from "../../../shared/nativeProviders.js";
 import { requireClaudeSessionId, listClaudeConversationStorage } from "../claudeHistory.js";
@@ -107,7 +108,13 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
     const store = {
       read(context) { return JSON.stringify({ executionId: context.binding.executionId, sent: context.binding.sent, pausedGoal: context.binding.pausedGoal, blockedGoal: context.binding.blockedGoal }); },
       async save(entry, { execution = false } = {}) {
-        await entry.context.updateBinding({ pausedGoal: entry.pausedGoal, blockedGoal: entry.blockedGoal, ...(execution ? { executionId: entry.executionId } : {}) });
+        // Only execution and retained-goal changes belong to the binding. An
+        // unchanged save (such as opening a replacement successor before its
+        // owner commits) must not write through the provider's binding fence.
+        const { binding } = entry.context;
+        const goals = { pausedGoal: entry.pausedGoal ?? null, blockedGoal: entry.blockedGoal ?? null };
+        if (!execution && isDeepStrictEqual(goals, { pausedGoal: binding.pausedGoal ?? null, blockedGoal: binding.blockedGoal ?? null })) return;
+        await entry.context.updateBinding({ ...goals, ...(execution ? { executionId: entry.executionId } : {}) });
       },
       async releaseExecution(entry) {
         await entry.context.updateBinding({ executionId: "" });

package/test/claudeConversationSession.test.js

@@ -1550,6 +1550,18 @@ for (const saveFails of [false, true]) test(`Claude retains failed-start custody
   }
 });
 
+test("opening an inert Claude successor binding does not write through the provider fence", async t => {
+  const f = await fixture(t);
+  await f.first.close();
+  const driver = createClaudeConversationDriver(f.driverOptions);
+  // A replacement opens its successor before the runtime commits the new owner.
+  const writeBinding = () => { throw new Error("A retired provider cannot change a native binding."); };
+  for (const binding of [await driver.createBinding(), { ...await driver.createBinding(), pausedGoal: null, blockedGoal: null }]) {
+    const provider = await driver.open({ binding, writeBinding, onFailure() {} });
+    await provider.dispose();
+  }
+});
+
 test("original scoped Claude history resumes from the authorized credential home while retaining its private scope", async t => {
   const f = await fixture(t);
   await f.first.close();

package/test/claudeProcess.test.js

@@ -299,10 +299,35 @@ test("Claude observes parent exit after initialization even while a child retain
   const error = await failed.promise;
   assert.equal(error.code, "assistant_claude_observation_lost");
   assert.deepEqual(error.processExit, { code: 1, signal: null });
+  assert.match(error.message, /^Claude stopped unexpectedly with exit code 1\. .*send a message to continue/u);
   await native.client.completion;
   assert.equal(failures, 1);
 });
 
+test("Claude reports a task-limit exit that arrives after its stream ended", { timeout: 3_000 }, async t => {
+  const { PassThrough, Writable } = await import("node:stream");
+  const exited = Promise.withResolvers();
+  const failed = Promise.withResolvers();
+  const stdout = new PassThrough();
+  const stdin = new Writable({ write(chunk, _encoding, done) {
+    const frame = JSON.parse(String(chunk));
+    stdout.write(JSON.stringify({ type: "control_response", response: { subtype: "success", request_id: frame.request_id, response: {} } }) + "\n");
+    done();
+  } });
+  const native = await createClaudeCodeProcess({ execution: {
+    async start() { return { id: "task-limit", stdin, stdout, exited: exited.promise }; },
+    async stop() { return { scopeEmpty: true }; }
+  }, onFailure(error) { failed.resolve(error); } });
+  t.after(() => native.stop());
+  stdout.end();
+  const taskLimit = { source: "cgroup-pids-events", count: 3 };
+  setTimeout(() => exited.resolve({ code: 1, signal: null, taskLimit }), 50);
+  const error = await failed.promise;
+  assert.equal(error.code, "assistant_claude_observation_lost");
+  assert.deepEqual(error.processExit, { code: 1, signal: null, taskLimit });
+  assert.match(error.message, /process\/thread limit reached/u);
+});
+
 test("Claude host startup budget allows slow initialization and still bounds failed startup", async t => {
   t.mock.timers.enable({ apis: ["setTimeout"] });
   const { PassThrough, Writable } = await import("node:stream");