@jskit-ai/assistant-core 0.1.230 → 0.1.232

package/examples/conversation/package.json

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

package/src/server/conversation/claudeTurn.js

@@ -391,8 +391,8 @@ export function createClaudeConversationOwner({
     if (options && typeof options.then === "function") options = await options;
     assertPreparing();
     let startupCleanup;
-    let retainedGoalClear;
     let startedExecutionId;
+    const processToken = {};
     try { entry.process = await createProcess({ ...options,
       workdir: entry.nativeWorkdir, sessionId: entry.id, resume: entry.sent,
       onStarted: async (executionId, stop) => {
@@ -417,12 +417,13 @@ export function createClaudeConversationOwner({
           // on its event reader: interrupt/exit also needs that reader to drain.
           pending.stop();
         }
-        // A retained Pause disarms only the native goal hook before a new
-        // authored input is admitted. This local command is not an AI turn.
-        if (retainedGoalClear) {
-          if (frame.type === "result" && frame.user_message_uuid === retainedGoalClear.id) {
-            if (frame.local_command === "goal" && frame.is_error !== true && frame.subtype === "success") retainedGoalClear.resolve();
-            else retainedGoalClear.reject(createError("Claude could not suspend its retained goal checker."));
+        // Local commands (retained goal clear, compaction) are not AI turns.
+        // Their frames stay out of the turn view until their own result.
+        const local = entry.localCommand;
+        if (local?.processToken === processToken) {
+          if (frame.type === "result" && frame.user_message_uuid === local.id) {
+            if (frame.local_command === local.name && frame.is_error !== true && frame.subtype === "success") local.resolve();
+            else local.reject(createError(local.failureMessage));
           }
           return;
         }
@@ -469,7 +470,7 @@ export function createClaudeConversationOwner({
         }
       } : {}),
       onFailure: async error => {
-        retainedGoalClear?.reject(error);
+        if (entry.localCommand?.processToken === processToken) entry.localCommand.reject(error);
         if (store.releaseExecution) {
           entry.nativeTurn.invalidateInstructions();
           try { await entry.nativeTurn.stopProcess(error.message); }
@@ -505,30 +506,55 @@ export function createClaudeConversationOwner({
       throw error;
     }
     if (entry.startupCleanup?.executionId === entry.executionId) entry.startupCleanup = null;
+    entry.processToken = processToken;
     if (entry.pausedGoal || entry.blockedGoal) {
-      const completion = Promise.withResolvers();
-      completion.promise.catch(() => {});
-      retainedGoalClear = { ...completion, id: randomUUID() };
-      const timer = setTimeout(() => completion.reject(createError("Claude timed out suspending its retained goal checker.")), 30_000);
       try {
-        await entry.process.client.send("/goal clear", { messageId: retainedGoalClear.id, sessionId: entry.id });
-        await completion.promise;
+        const id = await runLocalCommand(entry, "/goal clear", { name: "goal", timeoutMs: 30_000,
+          failureMessage: "Claude could not suspend its retained goal checker.",
+          timeoutMessage: "Claude timed out suspending its retained goal checker." });
         const cleared = await readHistory(entry);
-        if (cleared.goal || cleared.goalCommandId !== retainedGoalClear.id) {
+        if (cleared.goal || cleared.goalCommandId !== id) {
           throw createError("Claude has not saved the retained goal's native clear receipt.");
         }
         assertPreparing();
       } catch (error) {
         await entry.nativeTurn.stopProcess(error.message);
         throw Object.assign(error, { delivery: "not-sent" });
-      } finally {
-        clearTimeout(timer);
-        retainedGoalClear = null;
       }
     }
     return entry.process;
   }
 
+  async function runLocalCommand(entry, command, { name, timeoutMs, failureMessage, timeoutMessage }) {
+    const completion = Promise.withResolvers();
+    completion.promise.catch(() => {});
+    const local = { ...completion, id: randomUUID(), name, failureMessage, processToken: entry.processToken };
+    entry.localCommand = local;
+    const timer = setTimeout(() => completion.reject(createError(timeoutMessage)), timeoutMs);
+    try {
+      await entry.process.client.send(command, { messageId: local.id, sessionId: entry.id });
+      await completion.promise;
+      return local.id;
+    } finally {
+      clearTimeout(timer);
+      if (entry.localCommand === local) entry.localCommand = null;
+    }
+  }
+
+  // Native /compact summarises Claude's own history in place, exactly like its
+  // automatic compaction. It is not an AI turn and adds no chat message.
+  async function compactContext(entry, input = {}) {
+    input.signal?.throwIfAborted();
+    if (entry.turn?.active || entry.nativeTurn.read().active) {
+      throw Object.assign(createError("Claude is still working. Wait for it to finish before freeing its context."), { statusCode: 409 });
+    }
+    await ensureProcess(entry, input);
+    input.signal?.throwIfAborted();
+    await runLocalCommand(entry, "/compact", { name: "compact", timeoutMs: 15 * 60_000,
+      failureMessage: "Claude could not summarise its context.",
+      timeoutMessage: "Claude timed out summarising its context." });
+  }
+
   async function send(entry, input = {}, { renewal = false, command, applicationCommand } = {}) {
     const message = command ? input.text : text(input.message || input.prompt);
     if (!command && !message) throw createError("Enter a message for Claude.");
@@ -1090,7 +1116,7 @@ export function createClaudeConversationOwner({
     if (!binding) return { value: delivered.value };
   }
 
-  return Object.freeze({ applicationToolsSupported: true, entries, closingSessions, get closing() { return closing; }, createAccountQueries, open, acquire, createConversation, snapshot, readRetainedTurn, readFinalAssistantResult, readHistory, ensureReady, ensureProcess, readContextUsage, stopForTerminal, prepareTerminal, send, startTurn,
+  return Object.freeze({ applicationToolsSupported: true, entries, closingSessions, get closing() { return closing; }, createAccountQueries, open, acquire, createConversation, snapshot, readRetainedTurn, readFinalAssistantResult, readHistory, ensureReady, ensureProcess, readContextUsage, compactContext, stopForTerminal, prepareTerminal, send, startTurn,
     interrupt, read, inspectAdmission, hasActiveTemporaryConversation, hasActiveConversation, retireConversationHistory, reconcileSessions, restoreSessionEntries, closeSession, closeProject, invalidateRuntimes, drain, forget, close, deleteConversation, recover, stopSelected, wait, stopConversation,
     readGoal, updateGoal, renewal, run, steer, cancel });
 }

package/src/server/conversation/runtime.js

@@ -418,7 +418,9 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       ...(budget ? { maximumHistoryBytes: async options => {
         await access(context, entry.id, request.operation, entry);
         signal.throwIfAborted();
-        const bytes = await budget({ ...options, context, signal });
+        // A host may free native context first; show that as compacting.
+        const bytes = await budget({ ...options, context, signal,
+          setPhase: phase => setPhase(entry, phase === "compacting" ? "compacting" : "preparing") });
         signal.throwIfAborted();
         return bytes;
       } } : {}),

package/test/claudeTurn.test.js

@@ -2242,6 +2242,53 @@ test("Claude context inspection refuses unavailable usage and honours cancellati
   assert.equal(f.messages.length, 0);
 });
 
+test("Claude context compaction runs native /compact as a local command without a chat turn", async t => {
+  const f = await publishedClaudeFixture(t);
+  let usage = { model: "claude-opus", totalTokens: 946000, maxTokens: 1000000, autoCompactThreshold: 967000 };
+  f.behavior.initialize = native => {
+    native.client.request = async request => request.subtype === "get_context_usage" ? usage : {};
+    const send = native.client.send;
+    native.client.send = async (message, input) => {
+      if (message !== "/compact") return send(message, input);
+      (f.behavior.nativeInputs ||= []).push(message);
+      for (const frame of [{ type: "user", uuid: input.messageId }, { type: "system", subtype: "status", status: "compacting" },
+        { type: "system", subtype: "compact_boundary", compact_metadata: { trigger: "manual" } },
+        { type: "user", uuid: "summary", message: { content: "This session is being continued..." } }]) {
+        await native.options.onEvent({ ...frame, session_id: native.options.sessionId });
+      }
+      usage = { ...usage, totalTokens: 40000 };
+      await native.options.onEvent({ type: "result", subtype: "success", result: "", local_command: "compact",
+        user_message_uuid: input.messageId, session_id: native.options.sessionId });
+    };
+  };
+  await f.owner.compactContext(f.entry);
+  assert.deepEqual(f.behavior.nativeInputs, ["/compact"]);
+  assert.equal((await f.owner.readContextUsage(f.entry)).usedTokens, 40000);
+  assert.equal(f.entry.turn, null);
+  assert.equal(f.entry.localCommand, null);
+  assert.equal(f.messages.length, 0);
+  assert.equal(f.processes.length, 1);
+  await f.send("after-compaction");
+  assert.deepEqual(f.behavior.nativeInputs.slice(-1), ["Explain"]);
+  assert.equal(f.entry.turn.active, true);
+});
+
+test("Claude context compaction reports native failure and refuses an active turn", async t => {
+  const f = await publishedClaudeFixture(t);
+  f.behavior.initialize = native => {
+    const send = native.client.send;
+    native.client.send = async (message, input) => {
+      if (message !== "/compact") return send(message, input);
+      await native.options.onEvent({ type: "result", subtype: "error_during_execution", is_error: true,
+        local_command: "compact", user_message_uuid: input.messageId, session_id: native.options.sessionId });
+    };
+  };
+  await assert.rejects(f.owner.compactContext(f.entry), /could not summarise its context/);
+  assert.equal(f.entry.localCommand, null);
+  await f.send("working");
+  await assert.rejects(f.owner.compactContext(f.entry), error => error.statusCode === 409 && /still working/.test(error.message));
+});
+
 
 test("bound Main history budget transfers more than 30 complete messages through the original Claude sender", { timeout: 10_000 }, async t => {
   const f = await suppliedCommonFixture(t, { tools: false, representation: "native" });
@@ -2251,8 +2298,14 @@ test("bound Main history budget transfers more than 30 complete messages through
   f.binding.transcript.history = async () => history;
   await f.binding.state.write({ lastEngine: "codex", engines: { codex: { seen: {} } } });
   let reads = 0;
-  f.binding.maximumHistoryBytes = async ({ engineId, returning, context, signal, input }) => {
+  const phases = [];
+  const canonical = await f.runtime.open({ id: "lesson", context: f.toolContext });
+  f.binding.maximumHistoryBytes = async ({ engineId, returning, context, signal, input, setPhase }) => {
     reads++;
+    await setPhase("compacting");
+    phases.push((await canonical.read()).phase);
+    await setPhase("preparing");
+    phases.push((await canonical.read()).phase);
     assert.equal(engineId, "claude");
     assert.equal(returning, false);
     assert.equal(context.actor.id, "owner");
@@ -2267,6 +2320,7 @@ test("bound Main history budget transfers more than 30 complete messages through
   };
   await sendCommon(f, "full-history");
   assert.equal(reads, 1);
+  assert.deepEqual(phases, ["compacting", "preparing"], "a host freeing native context reports it as compacting");
   assert.ok(sent[0].length > 128_000);
   for (const message of history) assert.ok(sent[0].includes(JSON.stringify(message.text)), message.id);
   await f.frame({ type: "result", subtype: "success", result: "Received." });