@jskit-ai/assistant-core 0.1.223 → 0.1.225

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

@@ -26,7 +26,7 @@ const goalCapabilities = Object.freeze({ goals: true, goalBudgets: true,
   goalCommands: Object.freeze({
     set: Object.freeze({ delivery: "control", interruptsTurn: false }),
     resume: Object.freeze({ delivery: "control", interruptsTurn: false }),
-    pause: Object.freeze({ delivery: "control", interruptsTurn: false }),
+    pause: Object.freeze({ delivery: "control", interruptsTurn: true }),
     cancel: Object.freeze({ delivery: "control", interruptsTurn: false })
   }) });
 const nativeInput = input => [
@@ -216,6 +216,12 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
     async ensureConversation({ sessionId, native }) {
       return native.runOwner.ensureSessionReadiness(sessionId, await native.preparation.readiness());
     },
+    async updateConversationSettings({ sessionId, native, context, input }) {
+      const acquired = await native.runOwner.conversationContext(sessionId, { conversationId: input.threadId }, context);
+      if (acquired.ok === false) return acquired;
+      await acquired.provider.updateThreadSettings(input.threadId, { model: input.model, effort: input.effort });
+      return { ok: true };
+    },
     async createConversation({ sessionId, native, input, context }) {
       return native.runOwner.createConversation(sessionId, input, context);
     },
@@ -931,6 +937,12 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
               });
               if (result.ok !== false) binding.goal = result.goal || null;
             } finally { admission.release(); }
+            if (result.ok !== false && input.action === "pause") {
+              // Pause keeps the goal and uses the original verified Stop owner
+              // to stop its current conversation turn as well as scheduling.
+              const stopped = await interrupt({ configuration, context });
+              if (stopped?.ok === false) throw Object.assign(new Error(stopped.error), stopped, { cleanupFailed: true });
+            }
             if (nativeContext.completeResult) await nativeContext.completeResult(result);
             return { goal: goalValue(result.goal), nativeResult: result };
           }
@@ -949,6 +961,7 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
             prepareConversation: () => goalContext(configuration, context, signal, { prepareThread: true, tools })
           });
           if (result.ok === false) throw new Error(result.error);
+          if (input.action === "pause") await interrupt({ configuration, context });
           return goalValue(result.goal);
         },
         async inspectAdmission({ messageId, threadId, nativeTurnId, configuration, context, goal: command, representation, verifyAccount = false, receiptBinding }) {

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

@@ -107,12 +107,48 @@ function streamMessage({ sessionId, store, projection, publish }, context, recor
   }).catch(() => {});
 }
 
+// Saved transcript projection is also used while a host's source lease is busy.
+// Keep provider observation and transcript writes in readPersistentConversation.
+async function projectPersistentConversation(options, context, record, response, turns) {
+  const { sessionId, store, projection, receipts, includeAccess = false, transcriptQuery } = options;
+  const scope = { sessionId, conversationId: record.conversationId };
+  const messages = turns.flatMap((turn) => turn.messages.map((message) => ({
+    ...message,
+    id: message.messageId || `${turn.turnId}:${message.role}:${message.at}`,
+    ...(message.role === "user" ? { attachments: turn.user?.attachments || [] } : {}),
+    ...(message.role === "user" && !receipts.persisted(turn) &&
+      !(response.admitted === true && message.messageId === record.messageId) ? { receipt: false } : {}),
+    status: "completed",
+    ...projection.messageMetadata(turn)
+  })));
+  for (const message of response.messages || []) {
+    if (message.complete === false && !messages.some((saved) => saved.id === message.id)) {
+      const projected = projection.message(message, record, "incomplete");
+      if (projected) messages.push({ ...projected, status: response.status });
+    }
+  }
+  return projection.snapshot({ context, record, response, messages, includeAccess,
+    readPage: transcriptQuery ? async () => {
+      const page = await store.readConversationLogPage(scope, transcriptQuery);
+      return { ...page, conversationLog: qualifyTranscript(page.conversationLog, record, response, receipts) };
+    } : null
+  });
+}
+
+export async function projectStoredPersistentConversation(options) {
+  const { sessionId, store, record, projection } = options;
+  const context = projection.context(options.context, record);
+  const turns = await store.readConversationLog({ sessionId, conversationId: record.conversationId });
+  return projectPersistentConversation(options, context, record, {
+    status: record.status, runId: record.runId, error: record.error
+  }, turns);
+}
+
 // These original persistent-conversation operations run inside the host's
 // existing write lease. Their record, transcript and native operations are the
 // same facilities used by its retained conversation; no state is copied here.
 export async function readPersistentConversation(options) {
-  const { sessionId, operations, store, records, projection, receipts, publish,
-    includeAccess = false, transcriptQuery } = options;
+  const { sessionId, operations, store, records, projection, publish } = options;
   let { record } = options;
   const context = projection.context(options.context, record);
   const scope = { sessionId, conversationId: record.conversationId };
@@ -154,27 +190,7 @@ export async function readPersistentConversation(options) {
       store.readConversationStream(scope).messages.length) {
     await publish(context, record.conversationId, { payload: { conversationStream: store.clearConversationStream(scope) } });
   }
-  const messages = turns.flatMap((turn) => turn.messages.map((message) => ({
-    ...message,
-    id: message.messageId || `${turn.turnId}:${message.role}:${message.at}`,
-    ...(message.role === "user" ? { attachments: turn.user?.attachments || [] } : {}),
-    ...(message.role === "user" && !receipts.persisted(turn) &&
-      !(response.admitted === true && message.messageId === record.messageId) ? { receipt: false } : {}),
-    status: "completed",
-    ...projection.messageMetadata(turn)
-  })));
-  for (const message of response.messages || []) {
-    if (message.complete === false && !messages.some((saved) => saved.id === message.id)) {
-      const projected = projection.message(message, record, "incomplete");
-      if (projected) messages.push({ ...projected, status: response.status });
-    }
-  }
-  return projection.snapshot({ context, record, response, messages, includeAccess,
-    readPage: transcriptQuery ? async () => {
-      const page = await store.readConversationLogPage(scope, transcriptQuery);
-      return { ...page, conversationLog: qualifyTranscript(page.conversationLog, record, response, receipts) };
-    } : null
-  });
+  return projectPersistentConversation(options, context, record, response, turns);
 }
 
 export async function startPersistentConversationTurn(options) {

package/src/server/conversation/runtime.js

@@ -1,7 +1,7 @@
 import { createConversationProviderFactory } from "./provider.js";
 import { createConversationDeliveryTiming } from "./deliveryTiming.js";
 import { normalizeConversationConfiguration } from "./configuration.js";
-import { runScopedConversationTurn, readPersistentConversation, startPersistentConversationTurn,
+import { runScopedConversationTurn, readPersistentConversation, projectStoredPersistentConversation, startPersistentConversationTurn,
   inspectPersistentConversationAdmission, preparePersistentConversationChangeover,
   inspectPersistentConversationDelivery, stopPersistentConversation, deletePersistentConversation } from "./providers/scoped.js";
 import { isDeepStrictEqual } from "node:util";
@@ -2186,6 +2186,10 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
   return Object.freeze({
     // Internal host composition uses its existing admission/write lease. These
     // original coordinators share the scoped owner and introduce no entry or queue.
+    async projectStoredPersistentConversation(options) {
+      if (closed) throw failure("This conversation runtime is closed.", "conversation_closed");
+      return projectStoredPersistentConversation(options);
+    },
     async readPersistentConversation(options) {
       if (closed) throw failure("This conversation runtime is closed.", "conversation_closed");
       return readPersistentConversation(options);
@@ -2300,6 +2304,21 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       }
       return createDriver(prepared.engine, defaultHost).seedRenewalHandover(prepared);
     },
+    async updateNativeConversationSettings({ id, context, input = {} } = {}) {
+      if (typeof id !== "string" || !id.trim()) throw new TypeError("A conversation id is required.");
+      await access(context, id, "configure");
+      if (closed) throw failure("This conversation runtime is closed.", "conversation_closed");
+      const prepared = await defaultHost?.conversation?.({ id, context, input, operation: "updateSettings" });
+      if (prepared?.sessionId !== id || !prepared.native || !Object.hasOwn(prepared, "context")) {
+        throw new TypeError("Native settings require their authorized host preparation.");
+      }
+      const driver = createDriver(prepared.engine, defaultHost);
+      if (typeof driver.updateConversationSettings !== "function") {
+        throw failure("This provider does not support live native settings.", "conversation_unsupported");
+      }
+      if (closed) throw failure("This conversation runtime is closed.", "conversation_closed");
+      return driver.updateConversationSettings({ ...prepared, input });
+    },
     // Readiness uses the same authorized host and original native owner without
     // opening a retained handle or starting a conversational turn.
     async ensureNativeConversation({ id, context } = {}) {

package/src/server/conversation/runtimeStateUpgrade.js

@@ -1,4 +1,5 @@
 import { isAbsolute } from "node:path";
+import { prepareCopiedConversationAgentRun } from "./agentRun.js";
 
 const engines = new Set(["api", "claude", "codex", "opencode"]);
 const object = value => value !== null && typeof value === "object" && !Array.isArray(value);
@@ -198,3 +199,44 @@ export function upgradeConversationRuntimeState({ metadata, conversationLog, ret
   runtime.lastEngine = lastEngine;
   return { metadata: { ...metadata, runtime }, changed: true, warnings };
 }
+
+/** Explicit destination-only operation. The caller first stops all copied
+ * processes and pauses native goals through their owners; this makes their
+ * saved projections inert without opening a provider or replaying requests.
+ */
+export async function prepareConversationRuntimeCopy(transaction, { at }) {
+  if (typeof at !== "string" || !Number.isFinite(Date.parse(at))) throw new TypeError("A copy timestamp is required.");
+  const metadata = structuredClone(await transaction.readMetadata());
+  const turns = await Promise.all((await transaction.listTurnIds()).map(id => transaction.readTurn(id)));
+  const runtime = metadata.runtime;
+  if (runtime) {
+    if (runtime.version !== 3) invalid("Upgrade the parent conversation before copying its runtime state.");
+    upgradeConversationRuntimeState({ metadata, conversationLog: turns });
+    if (runtime.replacement) invalid("Finish the parent conversation changeover before copying it.");
+    for (const segment of [...runtime.predecessors, runtime]) {
+      if (segment.binding) {
+        // Native history identity and paths remain valid in the identical guest
+        // layout; process handles belong exclusively to the original machine.
+        if (Object.hasOwn(segment.binding, "executionId")) segment.binding.executionId = "";
+        if (Object.hasOwn(segment.binding, "processDirectory")) segment.binding.processDirectory = "";
+        if (segment.binding.codexAppServerRun) {
+          segment.binding.codexAppServerRun = prepareCopiedConversationAgentRun(segment.binding.codexAppServerRun, { at });
+        }
+      }
+      if (segment.nativeTurn) {
+        if (segment.nativeTurn.active) Object.assign(segment.nativeTurn, {
+          active: false, state: "interrupted", status: "interrupted", runState: "interrupted", phase: "", completedAt: at, updatedAt: at
+        });
+        if (segment.nativeTurn.goalStatus === "active") segment.nativeTurn.goalStatus = "paused";
+      }
+      if (segment.request) segment.request.error = "Copied pending input was not replayed. Check its delivery before submitting again.";
+    }
+    await transaction.writeMetadata(metadata);
+  }
+  for (const turn of turns) {
+    if (turn.metadata?.runtime?.status === "running") {
+      await transaction.updateTurnMetadata(turn.turnId, { runtime: { ...turn.metadata.runtime,
+        status: "interrupted", error: "Copied into a stopped development environment. This request was not replayed." } });
+    }
+  }
+}

package/test/claudeConversationSession.test.js

@@ -298,6 +298,7 @@ async function fixture(t, options = {}) {
       if (text === "steering") {
         answer.message.content[0].text = "Initial progress";
         answer.message.id = frame.uuid + "-before";
+        answer.message.stop_reason = "end_turn";
         record(answer); emit(answer); return;
       }
       if (text === "phases") {
@@ -434,7 +435,7 @@ test("Claude reports common work and compaction phases and clears phase after se
   assert.deepEqual(phases, ["preparing", "working", "compacting", "working", ""]);
 });
 
-test("Claude steering interrupts generation and admits a distinct message without replacing its process", async t => {
+test("Claude steering interrupts generation and admits a distinct message without replacing its process", { timeout: 30_000 }, async t => {
   const f = await fixture(t);
   const started = Promise.withResolvers();
   const events = [];
@@ -2097,7 +2098,7 @@ test("completed Claude native-tool tracking refuses steering a retained marked u
   } finally { await f.close(); }
 });
 
-test("completed Claude native-tool tracking preserves ordinary native steering in the opted runtime", async t => {
+test("completed Claude native-tool tracking preserves ordinary native steering in the opted runtime", { timeout: 30_000 }, async t => {
   const f = await completedEnvelopeFixture(t);
   const progress = Promise.withResolvers();
   await f.conversation.subscribe(event => {

package/test/claudeProcess.test.js

@@ -3,7 +3,7 @@ import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import os, { tmpdir } from "node:os";
 import path, { join } from "node:path";
 import { test } from "node:test";
-import { claudePlanUsage, claudeCodeArguments, claudeModelConfiguration, createClaudeCodeProcess, readClaudeCodeAuthStatus, stopClaudeCodeProcess } from "../src/server/conversation/claudeProcess.js";
+import { createClaudeAccountQueries, claudePlanUsage, claudeCodeArguments, claudeModelConfiguration, createClaudeCodeProcess, readClaudeCodeAuthStatus, stopClaudeCodeProcess } from "../src/server/conversation/claudeProcess.js";
 import { createLocalConversationExecution } from "../src/server/conversation/localExecution.js";
 
 test("native command construction preserves tool-free constraints without granting permissions by default", () => {
@@ -278,6 +278,31 @@ test("Claude handshake failure retains acquired execution custody when cleanup i
 });
 
 
+test("Claude observes parent exit after initialization even while a child retains stdout", { 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();
+  } });
+  let failures = 0;
+  const native = await createClaudeCodeProcess({ execution: {
+    async start() { return { id: "parent-exit", stdin, stdout, exited: exited.promise }; },
+    async stop() { return { scopeEmpty: true }; }
+  }, onFailure(error) { failures++; failed.resolve(error); } });
+  t.after(() => native.stop());
+  assert.equal(stdout.readableEnded, false);
+  exited.resolve({ code: 1, signal: null });
+  const error = await failed.promise;
+  assert.equal(error.code, "assistant_claude_observation_lost");
+  assert.deepEqual(error.processExit, { code: 1, signal: null });
+  await native.client.completion;
+  assert.equal(failures, 1);
+});
+
 test("Claude initialization rejects confirmed execution exit before half-open protocol EOF", async () => {
   const { PassThrough, Writable } = await import("node:stream");
   for (const cleanup of ["verified", "unconfirmed", "rejected"]) {
@@ -377,3 +402,116 @@ test("Claude supplied execution hosts retain initialization without an optional
   assert.equal(native.initialization.originalHost, true);
   assert.deepEqual(await native.stop(), { scopeEmpty: true, exited: true });
 });
+
+
+test("Claude account queries isolate concurrent identities and deduplicate each account", async () => {
+  for (const method of ["readCatalogue", "readPlanUsage"]) {
+    const pending = new Map(["first", "second"].map(id => [id, Promise.withResolvers()]));
+    const calls = [];
+    const queries = createClaudeAccountQueries({
+      accountIdentity: async context => context.id,
+      processes: () => [...pending].map(([id, held]) => ({ accountIdentity: id, process: {
+        get initialization() { calls.push(id); return held.promise; },
+        client: { request() { calls.push(id); return held.promise; } }
+      } })),
+      createProcess() { throw new Error("An owned account process should be reused."); }
+    });
+    const first = queries[method]({ id: "first" });
+    const duplicate = queries[method]({ id: "first" });
+    const second = queries[method]({ id: "second" });
+    // Finish in reverse order to expose cross-account sharing and cache races.
+    pending.get("second").resolve({ models: [{ value: "second" }], rate_limits_available: true,
+      rate_limits: { five_hour: { utilization: 20 } } });
+    pending.get("first").resolve({ models: [{ value: "first" }], rate_limits_available: true,
+      rate_limits: { five_hour: { utilization: 80 } } });
+    const [a, same, b] = await Promise.all([first, duplicate, second]);
+    assert.deepEqual(calls, ["first", "second"], method);
+    assert.deepEqual(same, a);
+    if (method === "readCatalogue") {
+      assert.equal(a.models[0].value, "first");
+      assert.equal(b.models[0].value, "second");
+    } else {
+      assert.equal(a.identity, "first");
+      assert.equal(b.identity, "second");
+      assert.equal(a.windows[0].remainingPercent, 20);
+      assert.equal(b.windows[0].remainingPercent, 80);
+    }
+    await queries.invalidate();
+  }
+});
+
+test("account invalidation cancels held startup and usage without stopping a borrowed conversation", async () => {
+  for (const phase of ["startup", "owned usage", "borrowed usage"]) {
+    const started = Promise.withResolvers();
+    let stops = 0;
+    const native = { client: { request() { started.resolve(); return new Promise(() => {}); } },
+      async stop() { stops++; return { scopeEmpty: true }; } };
+    const queries = createClaudeAccountQueries({ accountIdentity: async () => "account",
+      processes: () => phase === "borrowed usage" ? [{ accountIdentity: "account", process: native }] : [],
+      createProcess({ signal }) {
+        if (phase !== "startup") return native;
+        started.resolve();
+        return new Promise((_resolve, reject) => signal.addEventListener("abort", () => reject(signal.reason), { once: true }));
+      }
+    });
+    const pending = queries.readPlanUsage({});
+    const rejected = assert.rejects(pending, /cancelled for reconnection/);
+    await started.promise;
+    await queries.invalidate();
+    await rejected;
+    assert.equal(stops, phase === "owned usage" ? 1 : 0, phase);
+  }
+});
+
+for (const method of ["readCatalogue", "readPlanUsage"]) {
+  for (const phase of ["initial identity", "final identity", "retained cleanup"]) {
+    test(`${method} invalidation fences ${phase} before launching or caching a stale query`, { timeout: 2_000 }, async () => {
+      const entered = Promise.withResolvers();
+      const release = Promise.withResolvers();
+      let identities = 0;
+      let starts = 0;
+      let stops = 0;
+      const queries = createClaudeAccountQueries({
+        async accountIdentity() {
+          identities++;
+          if (identities === (phase === "initial identity" ? 1 : phase === "final identity" ? 2 : -1)) {
+            entered.resolve();
+            await release.promise;
+          }
+          return "account";
+        },
+        createProcess() {
+          starts++;
+          return {
+            initialization: { models: [{ value: `model-${starts}` }] },
+            client: { request: async () => ({ rate_limits_available: true, rate_limits: {} }) },
+            async stop() {
+              stops++;
+              if (phase === "retained cleanup" && stops === 1) return { scopeEmpty: false };
+              if (phase === "retained cleanup" && stops === 2) {
+                entered.resolve();
+                await release.promise;
+              }
+              return { scopeEmpty: true };
+            }
+          };
+        }
+      });
+      if (phase === "retained cleanup") await assert.rejects(queries[method]({}), /cleanup could not be confirmed/);
+      const pending = queries[method]({}).then(value => ({ value }), failure => ({ failure }));
+      await entered.promise;
+      const invalidating = queries.invalidate();
+      // Initial account lookup has not registered a process or pending query.
+      // Let invalidation finish to exercise an old read resuming after reconnect.
+      if (phase === "initial identity") await invalidating;
+      release.resolve();
+      const result = await pending;
+      await invalidating;
+      assert.match(result.failure?.message || "query unexpectedly succeeded", /cancelled for reconnection/);
+      assert.equal(starts, phase === "initial identity" ? 0 : 1, "invalidation must not launch a successor");
+      await queries[method]({});
+      assert.equal(starts, phase === "initial identity" ? 1 : 2, "a fresh request repopulates the invalidated cache");
+      await queries.invalidate();
+    });
+  }
+}