@jskit-ai/assistant-core 0.1.227 → 0.1.229

package/examples/conversation/package.json

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

package/fixtures/responsive-assistant/ConversationFixture.vue

@@ -70,7 +70,7 @@ const models = reactive({
 const goalEnabled = ref(new URLSearchParams(location.search).has("goal"));
 const goal = ref(null);
 const goalState = reactive({
-  enabled: goalEnabled, goal, working: computed(() => phase.value === "active"),
+  enabled: goalEnabled, goal, pauseBlocked: true, working: computed(() => phase.value === "active"),
   set(input) { phase.value = "active"; goal.value = { ...input, status: "active", elapsedSeconds: 0, sampledAt: Date.now() }; },
   pause() { goal.value = { ...goal.value, status: "paused", elapsedSeconds: goal.value.elapsedSeconds + (Date.now() - goal.value.sampledAt) / 1000, sampledAt: Date.now() }; },
   resume() { phase.value = "active"; goal.value = { ...goal.value, status: "active", reason: "", sampledAt: Date.now() }; },

package/package.json

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

package/src/client/conversation/AssistantGoalControl.vue

@@ -64,8 +64,8 @@ async function setGoal() {
     </template>
     <v-card class="assistant-goal__details pa-3" max-width="360">
       <strong role="status">{{ label }}</strong>
-      <v-btn v-if="running && state.pause" size="small" :disabled="state.pending" @click="state.pause()">{{ state.action === 'pause' ? 'Pausing…' : 'Pause goal' }}</v-btn>
-      <v-btn v-else-if="['paused', 'blocked', 'usageLimited'].includes(goal?.status) && state.resume" size="small" :disabled="state.pending" @click="state.resume()">{{ state.action === 'resume' ? 'Resuming…' : 'Resume goal' }}</v-btn>
+      <v-btn v-if="(running || (state.pauseBlocked && goal?.status === 'blocked')) && state.pause" size="small" :disabled="state.pending" @click="state.pause()">{{ state.action === 'pause' ? 'Pausing…' : 'Pause goal' }}</v-btn>
+      <v-btn v-if="['paused', 'blocked', 'usageLimited'].includes(goal?.status) && state.resume" size="small" :disabled="state.pending" @click="state.resume()">{{ state.action === 'resume' ? 'Resuming…' : 'Resume goal' }}</v-btn>
       <v-btn v-if="goal && goal.status !== 'complete' && state.cancel" color="error" size="small" variant="text" :disabled="state.pending" @click="state.cancel()">{{ state.action === 'cancel' ? 'Cancelling…' : 'Cancel goal' }}</v-btn>
       <p v-if="goal" class="my-2">{{ goal.objective }}</p>
       <p v-if="goal?.reason" class="text-body-small my-2">{{ goal.reason }}</p>

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/test/assistantScroll.browser.test.js

@@ -816,12 +816,14 @@ test("optional goals show running and paused lights, count only active time, and
     await expect(light).toHaveCSS("animation-name", "none");
     await page.getByRole("button", { name: "Goal blocked", exact: true }).click();
     await page.clock.runFor(250);
-    for (const name of ["Resume goal", "Cancel goal"]) {
+    for (const name of ["Pause goal", "Resume goal", "Cancel goal"]) {
       const button = page.getByRole("button", { name, exact: true });
       await expect(button).toBeInViewport();
       const bounds = await button.boundingBox();
       assert.ok(bounds.y >= 0 && bounds.y + bounds.height <= 577, `${name} is fully visible without scrolling`);
     }
+    await page.getByRole("button", { name: "Pause goal", exact: true }).click();
+    await expect(page.getByRole("button", { name: "Goal paused", exact: true })).toBeVisible();
     await page.getByRole("button", { name: "Resume goal", exact: true }).click();
     await expect(page.getByRole("button", { name: "Pause goal", exact: true })).toBeVisible();
     await page.getByRole("button", { name: "Toggle goals" }).evaluate(element => element.click());

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");

package/test/claudeTurn.test.js

@@ -2528,3 +2528,14 @@ test("Claude Block refuses absent reasons and stale identity before interrupting
     assert.equal(f.entry.blockedGoal, null);
   }
 });
+
+
+test("Claude explicitly pauses a blocked goal without resuming native work", async t => {
+  const f = await publishedClaudeFixture(t);
+  f.entry.blockedGoal = { threadId: f.entry.id, createdAt: 123, objective: "Finish checks", status: "blocked", reason: "Native loop stopped" };
+  const result = await f.owner.updateGoal(f.entry, { action: "pause", threadId: f.entry.id, createdAt: 123, objective: "Finish checks" });
+  assert.equal(result.goal.status, "paused");
+  assert.equal(f.entry.blockedGoal, null);
+  assert.equal(f.entry.pausedGoal.status, "paused");
+  assert.equal(f.processes.length, 0);
+});