@jskit-ai/assistant-core 0.2.1 → 0.2.3

package/test/claudeProcess.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, rename, rm, writeFile } from "node:fs/promises";
 import os, { tmpdir } from "node:os";
 import path, { join } from "node:path";
 import { test } from "node:test";
@@ -29,6 +29,9 @@ test("native command construction preserves tool-free constraints without granti
   assert.deepEqual(JSON.parse(coding[coding.indexOf("--mcp-config") + 1]), { mcpServers: { application: { type: "sdk", name: "application" } } });
 });
 
+// Account queries whose credentials are not the subject read them from nowhere.
+const ABSENT_CLAUDE_CONFIG = join(tmpdir(), "jskit-absent-claude-config");
+
 async function fixture(t, body) {
   const directory = await mkdtemp(join(tmpdir(), "jskit-claude-process-"));
   t.after(() => rm(directory, { recursive: true, force: true }));
@@ -110,10 +113,10 @@ test("Claude model configuration maps background calls and resets external setti
 });
 
 test("Claude status reads native JSON and returns only public account details", async () => {
-  const status = await readClaudeCodeAuthStatus({ credentialHome: { home: "/home/fixture" }, commandRunner: async (input) => {
+  const status = await readClaudeCodeAuthStatus({ credentialHome: { home: "/home/fixture-json" }, commandRunner: async (input) => {
     assert.deepEqual(input.args, ["auth", "status", "--json"]);
     assert.equal(input.timeout, 30_000);
-    assert.equal(input.credentialHome.home, "/home/fixture");
+    assert.equal(input.credentialHome.home, "/home/fixture-json");
     return { ok: true, stdout: JSON.stringify({ loggedIn: true, email: "owner@example.test", authMethod: "claude.ai", subscriptionType: "max", accessToken: "not-public" }) };
   } });
   assert.equal(status.loggedIn, true);
@@ -122,8 +125,10 @@ test("Claude status reads native JSON and returns only public account details",
 });
 
 test("Claude signed-out JSON is normal while failed and malformed status responses stay errors", async () => {
+  // Reads of one account share an entry, so each response gets its own account.
+  let account = 0;
   const readStatus = (result) => readClaudeCodeAuthStatus({
-    credentialHome: { home: "/home/fixture" }, commandRunner: async () => result
+    credentialHome: { home: `/home/fixture-signed-out-${account += 1}` }, commandRunner: async () => result
   });
   const signedOut = { ok: false, exitCode: 1, stdout: JSON.stringify({ loggedIn: false, authMethod: "none" }) };
   assert.deepEqual(await readStatus(signedOut), {
@@ -144,7 +149,7 @@ test("Claude signed-out JSON is normal while failed and malformed status respons
   }
 });
 
-test("Claude status shares concurrent reads and invalidates when native account files change", async (t) => {
+test("Claude status shares one read per account and invalidates only when its credentials change", async (t) => {
   const home = await mkdtemp(path.join(os.tmpdir(), "claude-auth-status-"));
   t.after(() => rm(home, { recursive: true, force: true }));
   const configRoot = path.join(home, ".claude");
@@ -163,16 +168,32 @@ test("Claude status shares concurrent reads and invalidates when native account
     await readClaudeCodeAuthStatus(input);
     assert.equal(calls, 1);
   }
-  for (const file of [path.join(configRoot, ".credentials.json"), path.join(home, ".claude.json"), path.join(configRoot, ".claude.json")]) {
-    email = `${calls}@example.test`;
-    // Deliberately not JSON: the wrapper must never parse native credentials.
-    await writeFile(file, "native-account-changed");
-    assert.equal((await readClaudeCodeAuthStatus(input)).email, email);
-    await rm(file);
-    const before = calls;
+  // macOS reuses nothing: file metadata cannot show Keychain changes.
+  if (process.platform === "darwin") return;
+  // Claude Code rewrites .claude.json during ordinary turns: the account is unchanged.
+  for (const file of [path.join(home, ".claude.json"), path.join(configRoot, ".claude.json")]) {
+    await writeFile(file, "rewritten-during-a-turn");
     await readClaudeCodeAuthStatus(input);
-    assert.equal(calls, before + 1);
+    assert.equal(calls, 1, `${path.basename(path.dirname(file))}/.claude.json does not bust the read`);
   }
+  // Another command path and host runner reading the same account share its entry.
+  const otherRunner = async () => assert.fail("The same account is read once.");
+  await readClaudeCodeAuthStatus({ ...input, command: "/opt/other/bin/claude", commandRunner: otherRunner,
+    env: { ...input.env, PATH: "/opt/other/bin", HOME: home } });
+  assert.equal(calls, 1);
+  // Sign-in writes the credentials and sign-out removes them.
+  const credentials = path.join(configRoot, ".credentials.json");
+  email = "second@example.test";
+  // Deliberately not JSON: the wrapper must never parse native credentials.
+  await writeFile(credentials, "native-account-changed");
+  assert.equal((await readClaudeCodeAuthStatus(input)).email, email);
+  assert.equal(calls, 2);
+  await rm(credentials);
+  await readClaudeCodeAuthStatus(input);
+  assert.equal(calls, 3);
+  // A different identity variable is a different account.
+  await readClaudeCodeAuthStatus({ ...input, env: { ...input.env, CLAUDE_CODE_OAUTH_TOKEN: "fixture-token" } });
+  assert.equal(calls, 4);
 });
 
 test("Claude status failures do not poison later reads or share across credential homes", async () => {
@@ -182,12 +203,79 @@ test("Claude status failures do not poison later reads or share across credentia
     return calls === 1 ? { ok: false, error: "Temporary failure" }
       : { ok: true, stdout: JSON.stringify({ loggedIn: false }) };
   };
-  const input = { env: {}, credentialHome: { home: "/home/fixture" }, commandRunner };
+  const input = { env: {}, credentialHome: { home: "/home/fixture-failure" }, commandRunner };
   assert.equal((await readClaudeCodeAuthStatus(input)).error, "Temporary failure");
   assert.equal((await readClaudeCodeAuthStatus(input)).error, undefined);
   assert.equal(calls, 2);
-  await readClaudeCodeAuthStatus({ ...input, credentialHome: { home: "/home/another" } });
+  await readClaudeCodeAuthStatus({ ...input, credentialHome: { home: "/home/fixture-failure-another" } });
+  assert.equal(calls, 3);
+});
+
+test("a Claude status answer holds until the credentials change, even across its own .claude.json rewrite", {
+  skip: process.platform === "darwin"
+}, async (t) => {
+  const home = await mkdtemp(path.join(os.tmpdir(), "claude-auth-status-"));
+  t.after(() => rm(home, { recursive: true, force: true }));
+  const realNow = Date.now;
+  let now = realNow();
+  Date.now = () => now;
+  t.after(() => { Date.now = realNow; });
+  const configRoot = path.join(home, ".claude");
+  await mkdir(configRoot);
+  const credentials = path.join(configRoot, ".credentials.json");
+  await writeFile(credentials, "signed-in");
+  const signedIn = { ok: true, stdout: JSON.stringify({ loggedIn: true, email: "owner@example.test", authMethod: "claude.ai" }) };
+  let calls = 0;
+  let result = signedIn;
+  const input = { env: { CLAUDE_CONFIG_DIR: configRoot }, credentialHome: { home }, commandRunner: async () => {
+    calls += 1;
+    // Each native status run rewrites ~/.claude.json a few seconds later.
+    await writeFile(path.join(home, ".claude.json"), `status-run-${calls}`);
+    return result;
+  } };
+  assert.equal((await readClaudeCodeAuthStatus(input)).email, "owner@example.test");
+  now += 10 * 60_000;
+  assert.equal((await readClaudeCodeAuthStatus(input)).email, "owner@example.test");
+  assert.equal(calls, 1, "the answer is not read again on a timer or after the run's own rewrite");
+  // Sign-out removes the credentials: Claude is asked again at once.
+  await rm(credentials);
+  result = { ok: false, exitCode: 1, stdout: JSON.stringify({ loggedIn: false }) };
+  assert.equal((await readClaudeCodeAuthStatus(input)).loggedIn, false);
+  assert.equal(calls, 2);
+  // A read the host timed out is reported and not asked again at once.
+  await writeFile(credentials, "signed-in-again");
+  result = { ok: false, exitCode: 1, timedOut: true, error: "Command timed out." };
+  assert.equal((await readClaudeCodeAuthStatus(input)).error, "Command timed out.");
+  now += 29_000;
+  assert.equal((await readClaudeCodeAuthStatus(input)).error, "Command timed out.");
   assert.equal(calls, 3);
+  // A read that ran and failed is reported, and asked again next time.
+  now += 2_000;
+  result = { ok: false, exitCode: 2, error: "Claude Code crashed." };
+  assert.equal((await readClaudeCodeAuthStatus(input)).error, "Claude Code crashed.");
+  result = signedIn;
+  assert.equal((await readClaudeCodeAuthStatus(input)).loggedIn, true);
+  assert.equal(calls, 5);
+});
+
+test("an unfinished Claude status read is reported without probing again at once", {
+  skip: process.platform === "darwin"
+}, async (t) => {
+  const realNow = Date.now;
+  let now = realNow();
+  Date.now = () => now;
+  t.after(() => { Date.now = realNow; });
+  let calls = 0;
+  let result = { ok: false, exitCode: 1, retryable: true, error: "Memory-pressure spike." };
+  const input = { env: {}, credentialHome: { home: "/home/fixture-busy" }, commandRunner: async () => { calls += 1; return result; } };
+  assert.equal((await readClaudeCodeAuthStatus(input)).error, "Memory-pressure spike.");
+  now += 29_000;
+  assert.equal((await readClaudeCodeAuthStatus(input)).error, "Memory-pressure spike.");
+  assert.equal(calls, 1);
+  now += 2_000;
+  result = { ok: true, stdout: JSON.stringify({ loggedIn: true, email: "owner@example.test" }) };
+  assert.equal((await readClaudeCodeAuthStatus(input)).loggedIn, true);
+  assert.equal(calls, 2);
 });
 
 test("Claude plan usage retains real windows and never invents an allowance after reset", () => {
@@ -469,22 +557,27 @@ test("Claude account queries isolate concurrent identities and deduplicate each
   for (const method of ["readCatalogue", "readPlanUsage"]) {
     const pending = new Map(["first", "second"].map(id => [id, Promise.withResolvers()]));
     const calls = [];
+    const native = id => ({ command: process.execPath, async stop() { return { scopeEmpty: true }; },
+      get initialization() { calls.push(id); return pending.get(id).promise; },
+      client: { request() { calls.push(id); return pending.get(id).promise; } } });
+    // Plan usage borrows each account's conversation; the model list starts its own Claude.
+    const starting = ["first", "second"];
     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."); }
+      accountIdentity: async context => context.id, configRoot: ABSENT_CLAUDE_CONFIG,
+      processes: () => method === "readPlanUsage" ? starting.map(id => ({ accountIdentity: id, process: native(id) })) : [],
+      createProcess() {
+        if (method === "readPlanUsage") throw new Error("An owned account process should be reused.");
+        return native(starting.shift());
+      }
     });
     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 } } });
+      rate_limits: { five_hour: { utilization: 20 }, limits: [] } });
     pending.get("first").resolve({ models: [{ value: "first" }], rate_limits_available: true,
-      rate_limits: { five_hour: { utilization: 80 } } });
+      rate_limits: { five_hour: { utilization: 80 }, limits: [] } });
     const [a, same, b] = await Promise.all([first, duplicate, second]);
     assert.deepEqual(calls, ["first", "second"], method);
     assert.deepEqual(same, a);
@@ -501,15 +594,247 @@ test("Claude account queries isolate concurrent identities and deduplicate each
   }
 });
 
-test("Claude account queries label temporary startup without changing cached process reuse", async () => {
+test("Claude plan usage shows only an answer from the usage endpoint as current", async () => {
+  let answer;
+  const queries = createClaudeAccountQueries({
+    accountIdentity: async () => "account",
+    processes: () => [{ accountIdentity: "account", process: { client: { request: async () => answer } } }],
+    createProcess() { throw new Error("No temporary Claude can start here."); }
+  });
+  const resets_at = new Date(Date.now() + 86_400_000).toISOString();
+  // Shape of Claude Code's answer while its endpoint read fails or is held: the
+  // window readings of its own last API response, which can be hours old, without
+  // the endpoint's `limits` list and without any age.
+  const seeded = { rate_limits_available: true, rate_limits: { seven_day: { utilization: 7, resets_at } } };
+  answer = seeded;
+  assert.deepEqual(await queries.readPlanUsage({}), { status: "unavailable", windows: [] });
+  queries.invalidateUsage();
+  answer = { rate_limits_available: true, rate_limits: { seven_day: { utilization: 23, resets_at }, limits: [] } };
+  const verified = await queries.readPlanUsage({});
+  assert.equal(verified.status, "available");
+  assert.equal(verified.windows[0].remainingPercent, 77);
+  assert.ok(verified.currentForMs > 0 && verified.currentForMs <= 420_000);
+  queries.invalidateUsage();
+  answer = seeded;
+  const kept = await queries.readPlanUsage({});
+  assert.equal(kept.windows[0].remainingPercent, 77, "an unverified answer replaced the endpoint reading");
+  assert.equal(kept.checkedAt, verified.checkedAt);
+  await queries.invalidate();
+});
+
+test("Claude plan usage asks a temporary Claude when a live process cannot prove its answer", async (t) => {
+  const realNow = Date.now;
+  let now = Date.parse("2026-10-29T03:00:00Z");
+  Date.now = () => now;
+  t.after(() => { Date.now = realNow; });
+  const resets_at = "2026-11-04T05:00:00Z";
+  const starts = [];
+  let stops = 0;
+  let liveReads = 0;
+  let startRefused = false;
+  const queries = createClaudeAccountQueries({
+    accountIdentity: async () => "account",
+    // An idle conversation whose own endpoint read is held answers from old headers.
+    processes: () => [{ accountIdentity: "account", process: { client: { request: async () => {
+      liveReads++;
+      return { rate_limits_available: true, rate_limits: { seven_day: { utilization: 7, resets_at } } };
+    } } } }],
+    createProcess(input) {
+      if (startRefused) throw new Error("Memory is low.");
+      starts.push(input.purpose);
+      return { client: { request: async () => ({ rate_limits_available: true,
+        rate_limits: { seven_day: { utilization: 23, resets_at }, limits: [] } }) },
+      async stop() { stops++; return { scopeEmpty: true }; } };
+    }
+  });
+  const first = await queries.readPlanUsage({});
+  assert.equal(first.status, "available");
+  assert.equal(first.windows[0].remainingPercent, 77);
+  assert.deepEqual(starts, ["usage"]);
+  for (let poll = 1; poll <= 4; poll++) {
+    now += 60_000;
+    assert.equal((await queries.readPlanUsage({})).windows[0].remainingPercent, 77);
+  }
+  assert.equal(liveReads, 5);
+  assert.deepEqual(starts, ["usage"], "a fallback started Claude inside the idle interval");
+  now += 61_000;
+  await queries.readPlanUsage({});
+  assert.deepEqual(starts, ["usage", "usage"]);
+  assert.equal(stops, starts.length, "a temporary usage process outlived its read");
+  // A refused fallback keeps the last verified reading rather than failing the read.
+  now += 301_000;
+  startRefused = true;
+  const kept = await queries.readPlanUsage({});
+  assert.equal(kept.windows[0].remainingPercent, 77);
+  await queries.invalidate();
+});
+
+test("Claude plan usage starts one temporary Claude per idle interval and marks an old reading stale", async (t) => {
+  const realNow = Date.now;
+  let now = Date.parse("2026-10-29T03:00:00Z");
+  Date.now = () => now;
+  t.after(() => { Date.now = realNow; });
+  const starts = [];
+  let stops = 0;
+  let answer = { rate_limits_available: true, rate_limits: {
+    seven_day: { utilization: 23, resets_at: "2026-11-04T05:00:00Z" }, limits: [] } };
+  const queries = createClaudeAccountQueries({
+    accountIdentity: async () => "account",
+    createProcess(input) {
+      starts.push(input.purpose);
+      return { client: { request: async () => answer }, async stop() { stops++; return { scopeEmpty: true }; } };
+    }
+  });
+  const first = await queries.readPlanUsage({});
+  assert.equal(first.status, "available");
+  assert.equal(first.windows[0].remainingPercent, 77);
+  // Pages polling every minute share the account's reading.
+  for (let poll = 1; poll <= 4; poll++) {
+    now += 60_000;
+    assert.equal((await queries.readPlanUsage({})).status, "available");
+  }
+  assert.deepEqual(starts, ["usage"]);
+  now += 61_000;
+  answer = { rate_limits_available: true, rate_limits: { seven_day: { utilization: 7, resets_at: "2026-11-04T05:00:00Z" } } };
+  const unverified = await queries.readPlanUsage({});
+  assert.deepEqual(starts, ["usage", "usage"]);
+  assert.equal(unverified.windows[0].remainingPercent, 77);
+  now += 120_000;
+  const stale = await queries.readPlanUsage({});
+  assert.equal(stale.status, "stale");
+  assert.equal(stale.windows[0].remainingPercent, 77);
+  assert.equal(stale.checkedAt, first.checkedAt);
+  assert.equal("currentForMs" in stale, false);
+  assert.deepEqual(starts, ["usage", "usage"], "a poll inside the idle interval started Claude");
+  assert.equal(stops, starts.length, "a temporary usage process outlived its read");
+  await queries.invalidate();
+});
+
+test("Claude plan usage starts one temporary Claude per account for every owner polling it", async (t) => {
+  const realNow = Date.now;
+  let now = Date.parse("2026-10-29T03:00:00Z");
+  Date.now = () => now;
+  t.after(() => { Date.now = realNow; });
+  const starts = [];
+  let stops = 0;
+  // Three account-query owners in one server process, none with a live conversation.
+  const owners = ["first", "second", "third"].map(owner => createClaudeAccountQueries({
+    accountIdentity: async context => context.account,
+    createProcess(input) {
+      starts.push([owner, input.purpose]);
+      return { client: { request: async () => ({ rate_limits_available: true, rate_limits: {
+        seven_day: { utilization: 23, resets_at: "2026-11-04T05:00:00Z" }, limits: [] } }) },
+      async stop() { stops++; return { scopeEmpty: true }; } };
+    }
+  }));
+  t.after(() => Promise.all(owners.map(queries => queries.invalidate())));
+  const account = { account: "plan-usage-shared-across-owners" };
+  // Requests that arrive while the account is read share that one read.
+  const concurrent = await Promise.all(owners.map(queries => queries.readPlanUsage(account)));
+  assert.deepEqual(starts, [["first", "usage"]]);
+  for (const reading of concurrent) assert.deepEqual(reading, concurrent[0]);
+  assert.equal(concurrent[0].windows[0].remainingPercent, 77);
+  // An hour of every owner polling once a minute.
+  for (let minute = 1; minute < 60; minute++) {
+    now += 60_000;
+    for (const queries of owners) assert.equal((await queries.readPlanUsage(account)).status, "available");
+  }
+  assert.equal(starts.length, 12, "the account started more than one temporary Claude per idle interval");
+  assert.equal(stops, starts.length, "a temporary usage process outlived its read");
+  // Another account is read on its own.
+  await owners[1].readPlanUsage({ account: "plan-usage-another-account" });
+  assert.equal(starts.length, 13);
+});
+
+test("Claude plan usage reuses another owner's live reading instead of starting a temporary Claude", async (t) => {
+  const realNow = Date.now;
+  let now = Date.parse("2026-10-29T03:00:00Z");
+  Date.now = () => now;
+  t.after(() => { Date.now = realNow; });
+  const account = "plan-usage-live-in-another-owner";
+  const answer = { rate_limits_available: true, rate_limits: {
+    seven_day: { utilization: 23, resets_at: "2026-11-04T05:00:00Z" }, limits: [] } };
+  let liveReads = 0;
+  const starts = [];
+  const createProcess = () => {
+    starts.push("usage");
+    return { client: { request: async () => answer }, async stop() { return { scopeEmpty: true }; } };
+  };
+  const withConversation = createClaudeAccountQueries({ accountIdentity: async () => account, createProcess,
+    processes: () => [{ accountIdentity: account, process: { client: { request: async () => { liveReads++; return answer; } } } }] });
+  const idle = createClaudeAccountQueries({ accountIdentity: async () => account, createProcess });
+  t.after(() => Promise.all([withConversation.invalidate(), idle.invalidate()]));
+  const live = await withConversation.readPlanUsage({});
+  assert.equal(liveReads, 1);
+  // Only the idle owner's page stays open: the account's verified reading serves it
+  // until that reading is an idle interval old.
+  for (let minute = 1; minute <= 4; minute++) {
+    now += 60_000;
+    const reading = await idle.readPlanUsage({});
+    assert.equal(reading.checkedAt, live.checkedAt);
+    assert.equal(reading.status, "available");
+  }
+  assert.deepEqual(starts, [], "a temporary Claude started while the account had a recent verified reading");
+  now += 60_000;
+  await idle.readPlanUsage({});
+  assert.deepEqual(starts, ["usage"]);
+});
+
+test("Claude model list starts a Claude only after its account, credentials or Claude Code changed", async (t) => {
+  const root = await mkdtemp(join(tmpdir(), "jskit-claude-catalogue-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const configRoot = join(root, ".claude");
+  await mkdir(configRoot);
+  // Sign-in, a token refresh and an update each replace the file at a stable path.
+  const replace = async (file, contents) => {
+    await writeFile(`${file}.next`, contents);
+    await rename(`${file}.next`, file);
+  };
+  const credentials = join(configRoot, ".credentials.json");
+  const command = join(root, "claude");
+  await replace(credentials, "signed in");
+  await replace(command, "2.1.1");
+  const realNow = Date.now;
+  let now = realNow();
+  Date.now = () => now;
+  t.after(() => { Date.now = realNow; });
+  let account = "account";
+  const starts = [];
+  const queries = createClaudeAccountQueries({ accountIdentity: async () => account, configRoot,
+    // A conversation that started before every change below.
+    processes: () => [{ accountIdentity: account, process: { command, initialization: { models: [{ value: "live" }] } } }],
+    createProcess({ purpose }) {
+      starts.push(purpose);
+      return { command, initialization: { models: [{ value: `read-${starts.length}` }] },
+        async stop() { return { scopeEmpty: true }; } };
+    } });
+  const model = async () => (await queries.readCatalogue({})).models[0].value;
+  // Reconnects, tab returns and closed sessions ask about four times an hour.
+  const askForADay = async (expected) => {
+    for (let read = 0; read < 96; read++, now += 15 * 60_000) assert.equal(await model(), expected);
+  };
+  await askForADay("read-1");
+  assert.deepEqual(starts, ["catalogue"]);
+  await replace(credentials, "refreshed");
+  await askForADay("read-2");
+  await replace(command, "2.1.2");
+  await askForADay("read-3");
+  account = "other account";
+  await askForADay("read-4");
+  assert.deepEqual(starts, ["catalogue", "catalogue", "catalogue", "catalogue"]);
+  await queries.invalidate();
+  assert.equal(await model(), "read-5");
+});
+
+test("Claude account queries label temporary startup and reuse each account's recent reading", async () => {
   const starts = [];
   let stops = 0;
   const queries = createClaudeAccountQueries({
-    accountIdentity: async () => "private-account-identity",
+    accountIdentity: async () => "private-account-identity", configRoot: ABSENT_CLAUDE_CONFIG,
     createProcess(input) {
       starts.push(input);
       return {
-        initialization: { models: [] },
+        initialization: { models: [] }, command: process.execPath,
         client: { request: async () => ({ rate_limits_available: false }) },
         async stop() { stops++; return { scopeEmpty: true }; }
       };
@@ -526,31 +851,33 @@ test("Claude account queries label temporary startup without changing cached pro
   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"]) {
+test("account invalidation cancels held startup and reads without stopping a borrowed conversation", async () => {
+  for (const phase of ["catalogue startup", "owned catalogue", "borrowed usage"]) {
     const started = Promise.withResolvers();
     let stops = 0;
     const native = { client: { request() { started.resolve(); return new Promise(() => {}); } },
+      get initialization() { 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;
+        if (phase !== "catalogue startup") return native;
         started.resolve();
         return new Promise((_resolve, reject) => signal.addEventListener("abort", () => reject(signal.reason), { once: true }));
       }
     });
-    const pending = queries.readPlanUsage({});
+    const pending = phase === "borrowed usage" ? queries.readPlanUsage({}) : queries.readCatalogue({});
     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);
+    assert.equal(stops, phase === "owned catalogue" ? 1 : 0, phase);
   }
 });
 
 for (const method of ["readCatalogue", "readPlanUsage"]) {
-  for (const phase of ["initial identity", "final identity", "retained cleanup"]) {
+  // Plan usage borrows a conversation's process, so it has no cleanup to retain.
+  for (const phase of method === "readPlanUsage" ? ["initial identity", "final identity"] : ["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();
@@ -566,10 +893,14 @@ for (const method of ["readCatalogue", "readPlanUsage"]) {
           }
           return "account";
         },
+        // Usage reads count as native reads of the borrowed conversation process.
+        processes: () => method === "readPlanUsage" ? [{ accountIdentity: "account", process: { client: {
+          request: async () => { starts++; return { rate_limits_available: true, rate_limits: { limits: [] } }; } } } }] : [],
+        configRoot: ABSENT_CLAUDE_CONFIG,
         createProcess() {
           starts++;
           return {
-            initialization: { models: [{ value: `model-${starts}` }] },
+            initialization: { models: [{ value: `model-${starts}` }] }, command: process.execPath,
             client: { request: async () => ({ rate_limits_available: true, rate_limits: {} }) },
             async stop() {
               stops++;