@jskit-ai/assistant-core 0.2.0 → 0.2.2

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

@@ -320,7 +320,7 @@ export async function inspectPersistentConversationAdmission(options) {
   if (!record.providerConversationId) return { admission: "unknown", turnId: "" };
   const state = requireSuccess(await operations.readConversation(sessionId,
     inputFor(record, { messageId: input.messageId }), options.context));
-  return { admission: state.admitted ? "accepted" : "unknown", turnId: state.runId };
+  return { admission: state.admitted ? "accepted" : state.notAdmitted ? "not-admitted" : "unknown", turnId: state.runId };
 }
 
 export async function preparePersistentConversationChangeover(options) {
@@ -353,7 +353,10 @@ export async function inspectPersistentConversationDelivery(options) {
     const result = await createConversationChangeover({ ...continuity, agent: {
       inspectMessageAdmission: request => inspectMessageAdmission(sessionId, request, context),
       sendMessage() { throw new Error("Receipt inspection cannot submit another native prompt."); }
-    } }).send({ engineId, messages, input: { messageId: input.messageId }, turnMetadata });
+    } }).send({ engineId, messages, input: { messageId: input.messageId }, turnMetadata, inspectOnly: true });
+    if (result?.notSent) return { status: "not-sent", messageId: input.messageId,
+      error: "This message was not sent. Review it before sending a new message.",
+      messageCode: "assistant.conversation.messageNotSent", messageParams: {} };
     accepted = result?.delivered === true;
   } else if (!accepted) {
     if (row && row.user?.receipt !== false) return { status: "accepted", messageId: input.messageId, turnId: row.turnId, duplicate: true };

package/src/server/conversation/runtime.js

@@ -1892,6 +1892,11 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     return { saved: true };
   }
 
+  function notSentReceipt(messageId) {
+    return { status: "not-sent", messageId, error: "This message was not sent. Review it before sending a new message.",
+      messageCode: "assistant.conversation.messageNotSent", messageParams: {} };
+  }
+
   async function recoverDelivery(entry, context, messageId, { observation: suppliedObservation, allowActive = false } = {}) {
     await access(context, entry.id, "inspectDelivery", entry);
     if (entry.active && !allowActive) throw failure("Wait for the current submission before checking delivery.", "conversation_busy", 409, { messageCode: "assistant.conversation.waitForSubmission" });
@@ -1920,8 +1925,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       ["codex", "claude", "opencode"].includes(segment.engine) && segment.request.attempted === false && !segment.request.inspectionOnly &&
       isDeepStrictEqual(segment.request, savedRequests[0].request))) {
       await access(context, entry.id, "inspectDelivery", entry);
-      return { status: "not-sent", messageId, error: "This message was not sent. Review it before sending a new message.",
-        messageCode: "assistant.conversation.messageNotSent", messageParams: {} };
+      return notSentReceipt(messageId);
     }
     const request = existing ? submittedMessage(existing) : metadata.runtime.request;
     if (!request || request.messageId !== messageId || !entry.provider.inspectAdmission) return receipt || { status: "unknown", messageId };
@@ -1930,6 +1934,17 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     const observation = suppliedObservation || await entry.provider.inspectAdmission({ ...request, nativeTurnId: existing?.metadata?.runtime?.nativeTurnId,
       context, configuration: metadata.runtime.configuration });
     await access(context, entry.id, "inspectDelivery", entry);
+    // The engine proved it never admitted this saved request. Record that it
+    // was not sent, as a definite rejection would, so Retry may send it.
+    if (!existing && observation.notAdmitted && pending && !pending.inspectionOnly && !entry.active) {
+      await storage.write(entry.id, async transaction => {
+        const current = await transaction.readMetadata();
+        if (current.runtime.request?.messageId !== messageId) return;
+        current.runtime.request.attempted = false;
+        await transaction.writeMetadata(current);
+      });
+      return notSentReceipt(messageId);
+    }
     if (!observation.accepted) return { ...(receipt || { status: "unknown", messageId }),
       ...(observation.recoveryLimitation ? { recoveryLimitation: observation.recoveryLimitation } : {}) };
     if (entry.driver.canonicalTranscript) {
@@ -2046,7 +2061,8 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
           throw new Error("Receipt inspection cannot submit another native prompt.");
         });
         const delivered = await sender.send({ engineId: entry.engine,
-          messages: await entry.conversation.transcript.history(), input: { messageId } });
+          messages: await entry.conversation.transcript.history(), input: { messageId }, inspectOnly: true });
+        if (delivered?.notSent) return notSentReceipt(messageId);
         if (!delivered?.delivered) throw deliveryFailure(delivered);
       }
       const row = (await readTranscript(entry)).find(turn => submittedMessage(turn)?.messageId === messageId);
@@ -2057,7 +2073,8 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       await access(context, entry.id, "inspectDelivery", entry);
       // Native-only acceptance is evidence of delivery, not permission to
       // manufacture an authored row or use a native turn ID as its receipt.
-      return observation.accepted ? { status: "accepted", messageId, duplicate: true } : { status: "unknown", messageId };
+      if (observation.accepted) return { status: "accepted", messageId, duplicate: true };
+      return observation.notAdmitted && !entry.active ? notSentReceipt(messageId) : { status: "unknown", messageId };
     }
     const result = await recoverDelivery(entry, context, messageId);
     if (result.status !== "accepted" || entry.engine === "api") return result;

package/test/assistantScroll.browser.test.js

@@ -26,6 +26,31 @@ async function settleReaderAt(body, scrollTop) {
   }, scrollTop)).toBe(true);
 }
 
+// Prepended history starts at those estimates and materializes on a later frame,
+// when scroll anchoring moves scrollTop. Read positions only once that settles.
+async function settleLayout(body) {
+  await expect.poll(() => body.evaluate(async element => {
+    const [top, height] = [element.scrollTop, element.scrollHeight];
+    await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+    return element.scrollTop === top && element.scrollHeight === height;
+  })).toBe(true);
+}
+
+// A gesture's scroll ends after its last input event; a touch drag ends with
+// its fling. A scrollend still queued from earlier scrolling must not count, or
+// the reader is measured while the fling keeps moving it.
+async function scrollGesture(body, lastEventType, perform) {
+  await body.evaluate((element, type) => {
+    element.gestureScrollEnded = new Promise(resolve => {
+      element.addEventListener(type, () => {
+        element.addEventListener("scrollend", () => resolve(), { once: true });
+      }, { once: true, passive: true });
+    });
+  }, lastEventType);
+  await perform();
+  await body.evaluate(element => element.gestureScrollEnded);
+}
+
 const VIEWPORTS = Object.freeze([
   Object.freeze({ name: "phone", width: 390, height: 844 }),
   Object.freeze({ name: "compact", width: 800, height: 900 }),
@@ -266,10 +291,12 @@ test("conversation scrolling preserves history anchors and resets expansion on s
     await page.getByRole("button", { name: "Read more", exact: true }).click();
     await expect(page.getByRole("button", { name: "Show less", exact: true })).toBeVisible();
     const original = page.getByText("Conversation line 1:", { exact: false }).first();
+    await settleLayout(body);
     const originalTop = (await original.boundingBox()).y;
     // Measure history anchoring without Playwright first scrolling to the button.
     await page.getByRole("button", { name: "Load older messages", exact: true }).evaluate(element => element.click());
-    await expect.poll(async () => Math.abs((await original.boundingBox()).y - originalTop)).toBeLessThan(2);
+    await settleLayout(body);
+    expect(Math.abs((await original.boundingBox()).y - originalTop)).toBeLessThan(2);
     const before = await body.evaluate((element) => element.scrollTop);
     await page.getByRole("button", { name: "Append reply", exact: true }).click();
     await expect(page.getByText("New reply.", { exact: false })).toBeAttached();
@@ -370,20 +397,18 @@ test("upward scrolling loads older history once and preserves retry and selectio
         const cdp = await page.context().newCDPSession(page);
         const x = bounds.x + bounds.width / 2;
         const y = bounds.y + 40;
-        const stopped = body.evaluate(element => new Promise(resolve => {
-          element.addEventListener("scrollend", () => resolve(), { once: true });
-        }));
-        await cdp.send("Input.dispatchTouchEvent", { type: "touchStart", touchPoints: [{ x, y }] });
-        for (let offset = 20; offset <= 380; offset += 20) {
-          await cdp.send("Input.dispatchTouchEvent", { type: "touchMove", touchPoints: [{ x, y: y + offset }] });
-          await page.evaluate(() => new Promise(requestAnimationFrame));
-        }
-        await cdp.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] });
-        await stopped;
+        await scrollGesture(body, "touchend", async () => {
+          await cdp.send("Input.dispatchTouchEvent", { type: "touchStart", touchPoints: [{ x, y }] });
+          for (let offset = 20; offset <= 380; offset += 20) {
+            await cdp.send("Input.dispatchTouchEvent", { type: "touchMove", touchPoints: [{ x, y: y + offset }] });
+            await page.evaluate(() => new Promise(requestAnimationFrame));
+          }
+          await cdp.send("Input.dispatchTouchEvent", { type: "touchEnd", touchPoints: [] });
+        });
         await cdp.detach();
       } else {
         await body.hover();
-        await page.mouse.wheel(0, -380);
+        await scrollGesture(body, "wheel", () => page.mouse.wheel(0, -380));
       }
       const pending = page.getByRole("button", { name: "Loading older messages…", exact: true });
       await expect(pending).toBeDisabled();
@@ -394,10 +419,12 @@ test("upward scrolling loads older history once and preserves retry and selectio
         element.dispatchEvent(new Event("scroll"));
       });
       const original = page.getByText("Conversation line 1:", { exact: false }).first();
+      await settleLayout(body);
       const originalTop = (await original.boundingBox()).y;
       await external("Complete history load");
       await expect(pending).toHaveCount(0);
-      await expect.poll(async () => Math.abs((await original.boundingBox()).y - originalTop)).toBeLessThan(2);
+      await settleLayout(body);
+      expect(Math.abs((await original.boundingBox()).y - originalTop)).toBeLessThan(2);
       await expect(requests).toHaveText("History requests: 1");
 
       // Keyboard navigation also requests older history.
@@ -421,11 +448,7 @@ test("upward scrolling loads older history once and preserves retry and selectio
       // Removing the history control re-anchors the scroller, which would
       // cancel a keyboard scroll already in flight; press Home once it settles.
       await expect(page.getByRole("button", { name: "Load older messages", exact: true })).toHaveCount(0);
-      await expect.poll(() => body.evaluate(async element => {
-        const height = element.scrollHeight;
-        await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
-        return element.scrollHeight === height;
-      })).toBe(true);
+      await settleLayout(body);
       await expect.poll(async () => {
         await body.focus();
         return body.evaluate(element => document.activeElement === element);

package/test/claudeConversationSession.test.js

@@ -265,7 +265,7 @@ async function fixture(t, options = {}) {
   await writeFile(account, "owner@example.test");
   await writeFile(command, `#!${process.execPath}
     import { createInterface } from "node:readline";
-    import { appendFileSync, mkdirSync, readFileSync } from "node:fs";
+    import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
     import path from "node:path";
     const args = process.argv.slice(2);
     const structuredResponse = ${JSON.stringify(options.structuredResponse || null)};
@@ -308,6 +308,12 @@ async function fixture(t, options = {}) {
         if (frame.request.subtype === "interrupt") emit({ type: "result", subtype: "success", terminal_reason: "aborted_streaming", result: "" });
         return;
       }
+      // A crash after reading the prompt but before recording it in history.
+      const dropped = path.join(process.env.CLAUDE_CONFIG_DIR, "dropped-once");
+      if (JSON.stringify(frame.message.content).includes("drop once") && !existsSync(dropped)) {
+        writeFileSync(dropped, "");
+        process.exit(1);
+      }
       record(frame);
       const text = typeof frame.message.content === "string" ? frame.message.content
         : frame.message.content.filter(part => part.type === "text").map(part => part.text).join(" ");
@@ -783,6 +789,25 @@ test("uncertain native delivery is reconciled from history without a second infe
   assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 1);
 });
 
+test("a Claude prompt missing from history after its process ended is not sent, and Retry sends it", async t => {
+  const f = await fixture(t);
+  const dropped = { messageId: "dropped-before-history", text: "drop once" };
+  await assert.rejects(f.conversation.send(dropped), error => error.delivery === "uncertain");
+  assert.equal((await f.conversation.wait()).status, "unconfirmed");
+  const receipt = await f.conversation.inspectDelivery({ messageId: dropped.messageId });
+  assert.equal(receipt.status, "not-sent");
+  assert.equal(receipt.messageCode, "assistant.conversation.messageNotSent");
+  // The proof is saved: a reload no longer restores an unconfirmed message.
+  assert.equal((await f.conversation.read()).status, "ready");
+  assert.equal((await f.conversation.inspectDelivery({ messageId: dropped.messageId })).status, "not-sent");
+  const sent = await f.conversation.send(dropped);
+  assert.equal(sent.messageId, dropped.messageId);
+  const finished = await f.conversation.wait();
+  assert.equal(finished.conversationLog.length, 1);
+  assert.equal(finished.conversationLog[0].assistant.text, "Answer: drop once");
+  assert.equal((await f.trace()).filter(row => row.frame?.type === "user").length, 2);
+});
+
 test("inspecting an older accepted Claude message leaves a different pending receipt untouched", async t => {
   const f = await fixture(t);
   const first = await f.conversation.send(input);

package/test/claudeProcess.test.js

@@ -190,6 +190,72 @@ test("Claude status failures do not poison later reads or share across credentia
   assert.equal(calls, 3);
 });
 
+test("a Claude status read that cannot finish keeps Claude's recent answer for unchanged account files", {
+  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 signedIn = { ok: true, stdout: JSON.stringify({ loggedIn: true, email: "owner@example.test", authMethod: "claude.ai" }) };
+  const signedInStatus = { loggedIn: true, email: "owner@example.test", authMethod: "claude.ai", subscriptionType: "" };
+  const timedOut = { ok: false, exitCode: 1, timedOut: true, error: "Command timed out." };
+  let calls = 0;
+  let result = signedIn;
+  const input = { env: { CLAUDE_CONFIG_DIR: path.join(home, ".claude") }, credentialHome: { home },
+    commandRunner: async () => { calls += 1; return result; } };
+  assert.equal((await readClaudeCodeAuthStatus(input)).email, "owner@example.test");
+  // An overloaded host times the next read out, or refuses to start it for now.
+  for (const unfinished of [timedOut, { ok: false, exitCode: 1, retryable: true, error: "Memory-pressure spike." }]) {
+    now += 31_000;
+    result = unfinished;
+    assert.deepEqual(await readClaudeCodeAuthStatus(input), signedInStatus);
+  }
+  // That answer is reused for the normal window, so the busy host is not probed again at once.
+  const probes = calls;
+  now += 29_000;
+  assert.deepEqual(await readClaudeCodeAuthStatus(input), signedInStatus);
+  assert.equal(calls, probes);
+  // A read that ran and failed is still reported.
+  now += 2_000;
+  result = { ok: false, exitCode: 2, error: "Claude Code crashed." };
+  assert.equal((await readClaudeCodeAuthStatus(input)).error, "Claude Code crashed.");
+  // Changed account files need Claude's own new answer.
+  await mkdir(path.join(home, ".claude"));
+  await writeFile(path.join(home, ".claude", ".credentials.json"), "native-account-changed");
+  result = timedOut;
+  assert.equal((await readClaudeCodeAuthStatus(input)).error, "Command timed out.");
+  // The recent answer expires: an old one is not kept forever.
+  now += 31_000;
+  result = signedIn;
+  assert.equal((await readClaudeCodeAuthStatus(input)).loggedIn, true);
+  now += 5 * 60_000 + 1;
+  result = timedOut;
+  assert.equal((await readClaudeCodeAuthStatus(input)).error, "Command timed out.");
+});
+
+test("an unfinished Claude status read with no recent answer 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", () => {
   assert.deepEqual(claudePlanUsage({ rate_limits_available: false }).windows, []);
   const usage = claudePlanUsage({ rate_limits_available: true, rate_limits: {
@@ -482,9 +548,9 @@ test("Claude account queries isolate concurrent identities and deduplicate each
     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,7 +567,123 @@ 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 account queries label temporary startup and reuse each account's recent reading", async () => {
   const starts = [];
   let stops = 0;
   const queries = createClaudeAccountQueries({
@@ -526,31 +708,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,6 +750,9 @@ 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: [] } }; } } } }] : [],
         createProcess() {
           starts++;
           return {

package/test/claudeTurn.test.js

@@ -894,6 +894,24 @@ async function publishedClaudeFixture(t, { publication = true, providerId = "ant
     async reopen() { entry = await owner.open(context, { mainId: conversationId }); return entry; } };
 }
 
+test("Claude proves a prompt was not admitted only once no process can still record it", async t => {
+  const f = await publishedClaudeFixture(t);
+  const { inspectPersistentConversationAdmission } = await import("../src/server/conversation/providers/scoped.js");
+  // Temporary chats inspect the same proof through their native read.
+  const persistent = () => inspectPersistentConversationAdmission({ sessionId: "session", context: {},
+    record: { providerConversationId: f.conversationId }, input: { messageId: "held" }, inputFor: (_record, input) => input,
+    operations: { readConversation: (_sessionId, input) => f.owner.read(f.entry, input) } });
+  await f.send("held");
+  // The live process received the prompt but has not recorded it yet.
+  assert.equal((await f.owner.inspectAdmission(f.entry, { messageId: "held" })).admission, "unknown");
+  assert.equal((await f.owner.read(f.entry, { messageId: "held" })).notAdmitted, false);
+  assert.equal((await persistent()).admission, "unknown");
+  await f.owner.stopConversation(f.entry, "Stopped.");
+  assert.equal((await f.owner.inspectAdmission(f.entry, { messageId: "held" })).admission, "not-admitted");
+  assert.equal((await f.owner.read(f.entry, { messageId: "held" })).notAdmitted, true);
+  assert.equal((await persistent()).admission, "not-admitted");
+});
+
 test("Claude status retains active instructions and applies changed guidance once idle", async t => {
   const f = await publishedClaudeFixture(t);
   await f.send();
@@ -916,6 +934,23 @@ test("Claude active status still rejects account replacement", async t => {
   assert.equal(f.entry.process, null);
 });
 
+test("Claude account change stops running processes without reopening saved conversations", async t => {
+  const f = await publishedClaudeFixture(t);
+  f.context.sessionId = "session-a";
+  await f.send();
+  const closedTerminals = [];
+  // A saved conversation can belong to an archived session whose context no longer resolves.
+  const application = {
+    readContext: async () => { throw new Error("A saved conversation was reopened"); },
+    terminals: { close: async sessionId => { closedTerminals.push(sessionId); return { ok: true, closed: 0 }; } }
+  };
+  const result = await f.owner.invalidateRuntimes({ provider: "claude", reason: "claude-auth-change" }, application,
+    { queries: { invalidate: async () => {} }, failure: error => { throw error; } });
+  assert.equal(result.ok, true);
+  assert.equal(f.entry.process, null, "the running process stopped");
+  assert.deepEqual(closedTerminals, ["session-a"], "the session's Claude terminals closed");
+});
+
 test("Claude continuation supersedes an older completion checkpoint", { timeout: 10_000 }, async t => {
   const f = await publishedClaudeFixture(t);
   await f.send();

package/test/codexTurn.test.js

@@ -3201,6 +3201,37 @@ test("native changeover retries retain original application data including its a
   }
 });
 
+test("native changeover treats a proven not-admitted attempt as not sent", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  const original = { messageId: "lost-request", message: "Prepared prompt", displayMessage: "Original words.",
+    displayAttachments: [], attachmentIds: [], seen: {}, attempted: true, threadId: "thread" };
+  for (const inspectFirst of [true, false]) {
+    let value = { lastEngine: "codex", engines: { codex: { seen: {}, pending: structuredClone(original) } } };
+    let admission = "unknown";
+    const sent = [];
+    const changeover = () => createConversationChangeover({
+      state: { async read() { return structuredClone(value); }, async write(next) { value = structuredClone(next); } },
+      transcript: { async hasMessage() { return false; } },
+      agent: { async inspectMessageAdmission() { return { admission }; },
+        async sendMessage(input) { sent.push(input.message); return { ok: true, delivered: true }; } }
+    });
+    const inspect = () => changeover().send({ engineId: "codex", messages: [], input: { messageId: original.messageId }, inspectOnly: true });
+    assert.equal((await inspect()).code, "conversation_changeover_delivery_unconfirmed", "An unknown receipt is never resent");
+    admission = "not-admitted";
+    if (inspectFirst) {
+      const receipt = await inspect();
+      assert.equal(receipt.notSent, true);
+      assert.equal(receipt.messageId, original.messageId);
+      assert.equal(value.engines.codex.pending.attempted, false);
+      assert.deepEqual(sent, [], "Inspection never sends");
+    }
+    const delivered = await changeover().send({ engineId: "codex", messages: [],
+      input: { messageId: original.messageId, message: "Original words." } });
+    assert.equal(delivered.delivered, true);
+    assert.deepEqual(sent, ["Prepared prompt"], "The proven unsent attempt is sent once, with its original prompt");
+  }
+});
+
 test("initial native seed limits preserve generic history, full returning corrections and delivery ownership", async () => {
   const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
   const attachment = { attachmentId: "retained-file", name: "retained.txt" };