@jskit-ai/assistant-core 0.1.222 → 0.1.224

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/transcript.js

@@ -1,4 +1,5 @@
 import { normalizeText } from "./normalize.js";
+import { conversationLogPage } from "../../shared/conversation/pagination.js";
 
 /** Conversation policy, independent of database, filesystem, identity and HTTP. */
 export function createConversationTranscript({ storage, clock = () => new Date(), applicationTurns = false } = {}) {
@@ -15,30 +16,43 @@ export function createConversationTranscript({ storage, clock = () => new Date()
     });
   }
 
-  async function readConversationLogPage(scope, { beforeTurnId = "", limit = 0, presentation = false } = {}) {
+  async function readConversationLogPage(scope, { beforeTurnId = "", limit = 0, presentation = false, pageUnit = "turns" } = {}) {
     if (typeof presentation !== "boolean") throw new TypeError("Transcript presentation requires an explicit boolean.");
+    if (!["turns", "messages"].includes(pageUnit)) throw new TypeError("Transcript pageUnit must be turns or messages.");
     return storage.read(scope, async (transaction) => {
       const allIds = await transaction.listTurnIds();
-      const visible = presentation ? (await Promise.all(allIds.map(id => transaction.readTurn(id))))
-        .filter(turn => hasMessages(turn) && !isCompletedEnvelopeTurn(turn)) : null;
+      const visible = presentation || pageUnit === "messages"
+        ? (await Promise.all(allIds.map(id => transaction.readTurn(id))))
+          .filter(turn => hasMessages(turn) && (!presentation || !isCompletedEnvelopeTurn(turn))) : null;
       const ids = visible ? visible.map(turn => turn.turnId) : allIds;
       const before = normalizeText(beforeTurnId);
       const requestedLimit = Number.parseInt(String(limit || ""), 10);
       const pageLimit = Number.isFinite(requestedLimit) && requestedLimit > 0 ? Math.min(requestedLimit, 100) : 0;
-      const end = before && ids.includes(before) ? ids.indexOf(before) : ids.length;
-      const start = pageLimit ? Math.max(0, end - pageLimit) : 0;
-      const selected = ids.slice(start, end);
-      const turns = visible ? visible.slice(start, end)
-        : (await Promise.all(selected.map((id) => transaction.readTurn(id)))).filter(hasMessages);
+      let page;
+      if (pageUnit === "messages") {
+        page = conversationLogPage(visible, { beforeTurnId: before, limit: pageLimit });
+      } else {
+        const end = before && ids.includes(before) ? ids.indexOf(before) : ids.length;
+        const start = pageLimit ? Math.max(0, end - pageLimit) : 0;
+        const selected = ids.slice(start, end);
+        page = {
+          conversationLog: visible ? visible.slice(start, end)
+            : (await Promise.all(selected.map(id => transaction.readTurn(id)))).filter(hasMessages),
+          hasMoreBefore: start > 0,
+          nextBeforeTurnId: start > 0 ? ids[start] : ""
+        };
+      }
+      const turns = page.conversationLog;
       return {
         conversationLog: turns,
         pagination: {
+          ...(pageUnit === "messages" ? { pageUnit } : {}),
           beforeTurnId: before,
           count: turns.length,
-          hasMoreBefore: start > 0,
+          hasMoreBefore: page.hasMoreBefore,
           limit: pageLimit,
           newestTurnId: turns.at(-1)?.turnId || "",
-          nextBeforeTurnId: start > 0 ? turns[0]?.turnId || selected[0] || "" : "",
+          nextBeforeTurnId: page.nextBeforeTurnId,
           oldestTurnId: turns[0]?.turnId || "",
           totalTurnCount: ids.length
         }

package/src/shared/conversation/pagination.js

@@ -1,5 +1,78 @@
 // Original paged transcript representation, shared by all browser bindings.
-const CONVERSATION_LOG_PAGE_LIMIT = 20;
+const CONVERSATION_LOG_PAGE_LIMIT = 10;
+
+const messageRoles = ["system", "user", "assistant"];
+
+// Live updates retain whole boundary turns. Reasoning/progress never uses the
+// message allowance, and never evicts the question it follows.
+function conversationLogPageStart(turns, limit, end = turns.length) {
+  if (!limit) return 0;
+  let remaining = limit;
+  let start = end;
+  while (start > 0 && remaining > 0) {
+    start -= 1;
+    remaining -= messageRoles.filter(role => turns[start]?.[role]).length;
+  }
+  return turns.slice(0, start).some(turn => messageRoles.some(role => turn?.[role])) ? start : 0;
+}
+
+// A cursor can stop between the question and answer of one stored turn. It is
+// read-only presentation state; stored turn and message identities never change.
+function conversationLogPage(turns, { beforeTurnId = "", limit = 0 } = {}) {
+  const messages = turns.flatMap((turn, index) => messageRoles.filter(role => turn[role])
+    .map(role => ({ index, role, turnId: turn.turnId })));
+  let boundary = turns.findIndex(turn => turn.turnId === beforeTurnId);
+  let beforeRole = "";
+  if (boundary < 0 && beforeTurnId.startsWith("message:")) {
+    try {
+      const [id, role] = JSON.parse(beforeTurnId.slice(8));
+      if (messageRoles.includes(role)) {
+        boundary = turns.findIndex(turn => turn.turnId === id);
+        beforeRole = role;
+      }
+    } catch { /* An unknown cursor retains the existing latest-page behavior. */ }
+  }
+  const beforeRoleIndex = beforeRole ? messageRoles.indexOf(beforeRole) : 0;
+  const foundEnd = boundary < 0 ? -1 : messages.findIndex(message =>
+    message.index > boundary ||
+      (message.index === boundary && messageRoles.indexOf(message.role) >= beforeRoleIndex));
+  const end = foundEnd < 0 ? messages.length : foundEnd;
+  const start = limit > 0 ? Math.max(0, end - limit) : 0;
+  const first = messages[start];
+  const firstRoleIndex = start > 0 ? messageRoles.indexOf(first.role) : 0;
+  const startTurn = start > 0 ? first.index : 0;
+  const endTurn = boundary < 0 ? turns.length : boundary + (beforeRole ? 1 : 0);
+  const selected = turns.slice(startTurn, endTurn).map((turn, offset) => {
+    const index = startTurn + offset;
+    const roles = messageRoles.filter(role => turn[role]);
+    const fromRole = index === startTurn ? firstRoleIndex : 0;
+    const toRole = index === boundary && beforeRole ? beforeRoleIndex : messageRoles.length;
+    const keep = roles.filter(role => {
+      const position = messageRoles.indexOf(role);
+      return position >= fromRole && position < toRole;
+    });
+    if (keep.length === roles.length) return turn;
+    // Progress belongs to the later part of a split turn, next to its answer.
+    const keepActivity = keep.includes(roles.at(-1));
+    const result = { ...turn, paginationPartial: true,
+      thinking: keepActivity ? turn.thinking : [], commentary: keepActivity ? turn.commentary : [] };
+    for (const role of messageRoles) if (!keep.includes(role)) result[role] = null;
+    result.messages = (turn.messages || [turn.system, turn.user, ...(turn.thinking || []),
+      ...(turn.commentary || []), turn.assistant].filter(Boolean))
+      .filter(message => keep.includes(message.role) || (keepActivity && !messageRoles.includes(message.role)));
+    return result;
+  }).filter(turn => messageRoles.some(role => turn[role]) || turn.thinking?.length || turn.commentary?.length);
+  let nextBeforeTurnId = "";
+  if (start > 0) {
+    const split = messageRoles.slice(0, firstRoleIndex).some(role => turns[first.index][role]);
+    nextBeforeTurnId = split ? `message:${JSON.stringify([first.turnId, first.role])}` : first.turnId;
+  }
+  return {
+    conversationLog: selected,
+    hasMoreBefore: start > 0,
+    nextBeforeTurnId
+  };
+}
 
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -8,6 +81,7 @@ function isRecord(value) {
 function normalizeConversationLogPagination(pagination = {}) {
   const source = isRecord(pagination) ? pagination : {};
   return {
+    ...(source.pageUnit === "messages" ? { pageUnit: "messages" } : {}),
     beforeTurnId: String(source.beforeTurnId || "").trim(),
     count: Number.isFinite(Number(source.count)) ? Number(source.count) : 0,
     hasMoreBefore: source.hasMoreBefore === true,
@@ -47,7 +121,22 @@ function mergeConversationLogPages(pages = []) {
         continue;
       }
       if (indexes.has(turnId)) {
-        orderedTurns[indexes.get(turnId)] = turn;
+        const index = indexes.get(turnId);
+        const previous = orderedTurns[index];
+        if (!turn.paginationPartial && !previous.paginationPartial) {
+          orderedTurns[index] = turn;
+          continue;
+        }
+        const merged = { ...previous, ...turn };
+        for (const role of messageRoles) merged[role] = turn[role] || previous[role];
+        const [activity, previousActivity] = [turn, previous].map(part =>
+          (part.messages || [...(part.thinking || []), ...(part.commentary || [])])
+            .filter(message => !messageRoles.includes(message.role)));
+        const retainedActivity = activity.length ? activity : previousActivity;
+        merged.thinking = retainedActivity.filter(message => message.role === "thinking");
+        merged.commentary = retainedActivity.filter(message => message.role === "commentary");
+        merged.messages = [merged.system, merged.user, ...retainedActivity, merged.assistant].filter(Boolean);
+        orderedTurns[index] = merged;
         continue;
       }
       indexes.set(turnId, orderedTurns.length);
@@ -71,6 +160,8 @@ function conversationLogReadQuery({
 
 export {
   CONVERSATION_LOG_PAGE_LIMIT,
+  conversationLogPageStart,
+  conversationLogPage,
   normalizeConversationLogPagination,
   normalizeConversationLogPage,
   mergeConversationLogPages,

package/src/shared/conversation/patches.js

@@ -1,5 +1,5 @@
 import { normalizeThinkingMessageText } from "./thinkingText.js";
-import { normalizeConversationLogPagination } from "./pagination.js";
+import { conversationLogPageStart, normalizeConversationLogPagination } from "./pagination.js";
 
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -125,14 +125,17 @@ function applyConversationLogPatch(payload = {}, patch = null, options = {}) {
       numeric: true
     }
   ));
+  const pagination = normalizeConversationLogPagination(source.pagination);
   const limit = Number.parseInt(String(options.limit || ""), 10);
   const limitedTurns = Number.isFinite(limit) && limit > 0
-    ? nextTurns.slice(-limit)
+    ? nextTurns.slice(pagination.pageUnit === "messages" ? conversationLogPageStart(nextTurns, limit) : -limit)
     : nextTurns;
   const wasTrimmed = limitedTurns.length < nextTurns.length;
-  const pagination = normalizeConversationLogPagination(source.pagination);
   const hasMoreBefore = pagination.hasMoreBefore || wasTrimmed;
   const oldestTurnId = String(limitedTurns[0]?.turnId || "").trim();
+  const beforeCursor = oldestTurnId === pagination.oldestTurnId
+    ? pagination.nextBeforeTurnId || oldestTurnId
+    : oldestTurnId;
   return {
     ...source,
     conversationLog: limitedTurns,
@@ -141,7 +144,7 @@ function applyConversationLogPatch(payload = {}, patch = null, options = {}) {
       count: limitedTurns.length,
       hasMoreBefore,
       newestTurnId: String(limitedTurns.at(-1)?.turnId || "").trim(),
-      nextBeforeTurnId: hasMoreBefore ? oldestTurnId : "",
+      nextBeforeTurnId: hasMoreBefore ? beforeCursor : "",
       oldestTurnId
     }
   };

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();
+    });
+  }
+}