@jskit-ai/assistant-core 0.2.2 → 0.2.3

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.2",
-    "@jskit-ai/http-runtime": "0.2.0",
-    "@jskit-ai/kernel": "0.2.0",
+    "@jskit-ai/assistant-core": "0.2.3",
+    "@jskit-ai/http-runtime": "0.2.1",
+    "@jskit-ai/kernel": "0.2.1",
     "@mdi/js": "^7.4.47",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.2.0",
-    "@jskit-ai/connectors-catalog": "0.2.0"
+    "@jskit-ai/connectors-core": "0.2.1",
+    "@jskit-ai/connectors-catalog": "0.2.1"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.7",

package/fixtures/responsive-assistant/ConversationFixture.vue

@@ -111,12 +111,12 @@ const adapter = reactive({
         discard(id) {
           if (id !== "temporary" || !previewCanTake.value) return;
           temporaryPresent.value = false;
-          if (previewDelivery.find(id)?.status === "failed") previewDelivery.cancel(id);
+          if (previewDelivery.find(id)?.status === "failed") previewDelivery.remove(id);
         },
         edit(id) {
           if (id !== "temporary" || !previewCanTake.value) return;
           temporaryEditing.value = true;
-          if (previewDelivery.find(id)?.status === "failed") previewDelivery.cancel(id);
+          if (previewDelivery.find(id)?.status === "failed") previewDelivery.remove(id);
         },
         update(id, text) {
           if (id === "temporary" && previewCanTake.value) temporaryWords.value = text;

package/fixtures/responsive-assistant/DeliveryFixture.vue

@@ -25,6 +25,16 @@ const delivery = createAssistantMessageDelivery({ deliver(payload) {
   pendingRequest = Promise.withResolvers();
   return pendingRequest.promise;
 } });
+// A stand-in for the application's server cancel: the recovery fixture answers
+// from its buttons, the others agree at once.
+let cancelAnswer;
+function cancelMessage(id) {
+  if (!delivery.cancel(id)) return false;
+  cancelAnswer = Promise.withResolvers();
+  cancelAnswer.promise.then(agreed => agreed ? delivery.remove(id) : delivery.cancelFailed(id));
+  if (!recoveryFixture) cancelAnswer.resolve(true);
+  return true;
+}
 function accept() {
   const payload = requests.value.at(-1);
   const at = new Date().toISOString();
@@ -56,8 +66,8 @@ const adapter = reactive({
   conversation: { cancellableDelivery: recoveryFixture, turns, visible: true, scrollKey: "delivery", welcomeMessage: "Start a conversation." },
   composer: { draft, canSend: true, submitOnEnter: true, queueWhileSending },
   actions: {
-    ...(recoveryFixture ? { cancel: id => delivery.remove(id) } : {}),
-    setDraft(value) { draft.value = value; }
+    setDraft(value) { draft.value = value; },
+    cancel: cancelMessage
   }
 });
 </script>
@@ -66,6 +76,9 @@ const adapter = reactive({
     <main class="fixture">
       <nav>
         <button v-if="acceptedFixture" @click="turns.unshift({ turnId: 'earlier', user: { messageId: 'accepted-old', text: 'Earlier accepted message', at: '2026-10-16T11:05:00.000Z' } })">Load accepted history</button>
+        <button v-if="recoveryFixture" @click="delivery.find('uncertain').checking = true">Start delivery check</button>
+        <button v-if="recoveryFixture" @click="cancelAnswer?.resolve(false)">Server unreachable</button>
+        <button v-if="recoveryFixture" @click="cancelAnswer?.resolve(true)">Server agrees to cancel</button>
         <button @click="pendingRequest.reject(new Error('Delivery unavailable.'))">Fail request</button>
         <button @click="accept">Accept request</button>
         <button @click="attachments.attachments.push({ attachmentId: 'new-file', fileName: 'next.txt' }); configuration = { tone: 'detailed' }">Prepare newer input</button>

package/locales/en.json

@@ -87,6 +87,8 @@
         "useSuggestion": "Use suggestion: {prompt}"
       },
       "delivery": {
+        "cancelling": "Cancelling…",
+        "cancelUnreachable": "Couldn't reach the server — Cancel again",
         "checkBeforeResend": "Check delivery before resending.",
         "checkPrevious": "Check the previous message's delivery before sending again.",
         "checking": "Checking…",
@@ -213,6 +215,8 @@
         "liveSettingsUnsupported": "This provider does not support live native settings.",
         "completedEnvelopesNeedStorage": "Completed envelopes require runtime-owned canonical storage.",
         "originalReadOnly": "This conversation uses its original read and subscription operations.",
+        "messageCancelUnsupported": "This conversation cannot cancel one message.",
+        "messageCancelled": "This message was cancelled. Send it again as a new message.",
         "authorizedSelectionRequired": "Use the conversation's authorized selection operation.",
         "eventDeliveryRetained": "This scoped conversation retains its original event delivery.",
         "engineChanged": "The selected native engine changed.",
@@ -371,8 +375,6 @@
       "conversation_receipt_unavailable": "The native receipt has no stored authored message.",
       "conversation_goal_unavailable": "The native goal is unavailable. Try reading its status again.",
       "assistant_provider_invalid_response": "Assistant provider returned an invalid response payload.",
-      "assistant_opencode_connection_changing": "OpenCode is changing a connection. Retry after the connection change finishes.",
-      "assistant_opencode_connection_in_use": "Close the other OpenCode conversations that use this connection, then retry this connection change. The saved connection has not changed.",
       "assistant_opencode_conversation_busy": "This conversation is still working.",
       "assistant_opencode_key_verification_failed": "OpenCode rejected the API-key verification request.",
       "assistant_opencode_turn_thread_mismatch": "The OpenCode predecessor history changed before handover generation.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -48,8 +48,8 @@
     "@ai-sdk/perplexity": "^4.0.43",
     "@ai-sdk/togetherai": "^3.0.49",
     "@ai-sdk/xai": "^4.0.58",
-    "@jskit-ai/resource-core": "0.1.191",
-    "@jskit-ai/resource-crud-core": "0.1.191",
+    "@jskit-ai/resource-core": "0.1.192",
+    "@jskit-ai/resource-crud-core": "0.1.192",
     "@mdi/js": "^7.4.47",
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.101",
@@ -58,8 +58,8 @@
     "ws": "^8.20.1"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.2.0",
-    "@jskit-ai/kernel": "0.2.0",
+    "@jskit-ai/http-runtime": "0.2.1",
+    "@jskit-ai/kernel": "0.2.1",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"
   },

package/src/client/conversation/AssistantConversationElement.vue

@@ -327,8 +327,15 @@ async function resend(id) {
   }
   catch { /* The delivery controller retains the error beside the failed message. */ }
 }
+// The application's cancel asks its server and removes the message only once
+// the server agrees. Without one, only a message the server already refused
+// (failed) is removed.
 function cancel(id) {
-  return props.adapter.actions?.cancel ? props.adapter.actions.cancel(id) : props.adapter.delivery?.cancel(id);
+  if (props.adapter.actions?.cancel) return props.adapter.actions.cancel(id);
+  const message = props.adapter.delivery?.find(id);
+  if (message?.status !== "failed") return false;
+  props.adapter.delivery.remove(id);
+  return true;
 }
 function edit(id) {
   if (props.adapter.actions?.edit) return props.adapter.actions.edit(id);

package/src/client/conversation/AssistantGoalControl.vue

@@ -70,9 +70,9 @@ async function setGoal() {
     </template>
     <v-card class="assistant-goal__details pa-3" max-width="360">
       <strong role="status">{{ label }}</strong>
-      <v-btn v-if="(running || (state.pauseBlocked && goal?.status === 'blocked')) && state.pause" size="small" :disabled="state.pending" @click="state.pause()">{{ state.action === 'pause' ? t('jskit.assistant.goal.pausing') : t('jskit.assistant.goal.pause') }}</v-btn>
+      <v-btn v-if="(running || (state.pauseBlocked && goal?.status === 'blocked')) && state.pause" size="small" :disabled="state.stopPending" @click="state.pause()">{{ state.action === 'pause' ? t('jskit.assistant.goal.pausing') : t('jskit.assistant.goal.pause') }}</v-btn>
       <v-btn v-if="['paused', 'blocked', 'usageLimited'].includes(goal?.status) && state.resume" size="small" :disabled="state.pending" @click="state.resume()">{{ state.action === 'resume' ? t('jskit.assistant.goal.resuming') : t('jskit.assistant.goal.resume') }}</v-btn>
-      <v-btn v-if="goal && goal.status !== 'complete' && state.cancel" color="error" size="small" variant="text" :disabled="state.pending" @click="state.cancel()">{{ state.action === 'cancel' ? t('jskit.assistant.goal.cancelling') : t('jskit.assistant.goal.cancel') }}</v-btn>
+      <v-btn v-if="goal && goal.status !== 'complete' && state.cancel" color="error" size="small" variant="text" :disabled="state.stopPending" @click="state.cancel()">{{ state.action === 'cancel' ? t('jskit.assistant.goal.cancelling') : t('jskit.assistant.goal.cancel') }}</v-btn>
       <p v-if="goal" class="my-2">{{ goal.objective }}</p>
       <p v-if="goal?.reason" class="text-body-small my-2">{{ goal.reason }}</p>
       <p v-if="elapsed" class="text-body-small my-2">{{ elapsedText }}</p>

package/src/client/conversation/AssistantTranscript.vue

@@ -65,10 +65,11 @@
       :class="{ 'assistant-transcript__body--settling': initialScrollPending }"
       tabindex="0"
       @keydown.capture="markKeyboardScrollIntent"
-      @pointerdown.self="markUserScrollIntent"
+      @pointerdown.self="markUserScrollIntent()"
       @scroll.passive="updateLatestFollowFromScroll"
-      @touchmove.passive="markUserScrollIntent"
-      @wheel.passive="markUserScrollIntent"
+      @touchstart.passive="rememberTouch"
+      @touchmove.passive="markTouchScrollIntent"
+      @wheel.passive="markUserScrollIntent({ upward: $event.deltaY < 0 })"
     >
       <div
         v-if="welcomeMessage"
@@ -179,12 +180,15 @@
             </div>
             <slot name="user-message-actions" :message="entry.message" :turn="entry.turn" />
             <div
-              v-if="entry.delivery || entry.turn.optimistic?.status === 'failed'"
+              v-if="entry.delivery || entry.turn.optimistic?.status === 'failed' || entry.turn.optimistic?.cancelling || entry.turn.optimistic?.cancelError"
               class="assistant-transcript__optimistic-failure"
             >
-              <span role="status">{{ entry.delivery ? entry.delivery.delivery.error || t('jskit.assistant.delivery.unconfirmedShort') : t('jskit.assistant.transcript.failed', { error: entry.turn.optimistic.error || t('jskit.assistant.delivery.notSent') }) }}</span>
+              <span role="status">{{ entry.turn.optimistic?.cancelling ? t('jskit.assistant.delivery.cancelling')
+                : entry.turn.optimistic?.cancelError ? entry.turn.optimistic.cancelError
+                  : entry.delivery ? entry.delivery.delivery.error || t('jskit.assistant.delivery.unconfirmedShort') : t('jskit.assistant.transcript.failed', { error: entry.turn.optimistic.error || t('jskit.assistant.delivery.notSent') }) }}</span>
               <div v-if="!entry.turn.preview" class="assistant-transcript__optimistic-actions">
                 <v-btn
+                  v-if="!entry.turn.optimistic?.cancelling && !entry.turn.optimistic?.cancelError && (entry.delivery || entry.turn.optimistic?.status === 'failed')"
                   class="assistant-transcript__delivery-action"
                   color="error"
                   size="x-small"
@@ -198,7 +202,7 @@
                   {{ entry.delivery?.delivery.checking ? t('jskit.assistant.delivery.checking') : t('jskit.assistant.delivery.retry') }}
                 </v-btn>
                 <v-btn
-                  v-if="!entry.delivery || cancellableDelivery"
+                  v-if="!entry.delivery || cancellableDelivery || entry.turn.optimistic?.cancelling || entry.turn.optimistic?.cancelError"
                   class="assistant-transcript__delivery-action"
                   size="x-small"
                   type="button"
@@ -208,7 +212,7 @@
                   {{ t("jskit.assistant.transcript.cancel") }}
                 </v-btn>
                 <v-btn
-                  v-if="!entry.delivery"
+                  v-if="!entry.delivery && entry.turn.optimistic?.status === 'failed' && !entry.turn.optimistic.cancelling && !entry.turn.optimistic.cancelError"
                   class="assistant-transcript__delivery-action"
                   size="x-small"
                   type="button"
@@ -328,6 +332,7 @@ import AssistantProgress from "./AssistantProgress.vue";
 import { parseNumberedQuestionPrompt } from "../../shared/conversation/numberedQuestionSugar.js";
 import { parseLongTextReviewBlocks } from "../../shared/conversation/longTextBlocks.js";
 import {
+  scrollDistanceFromBottom,
   scrollElementNearBottom
 } from "../../shared/conversation/scrollFollowState.js";
 import {
@@ -442,6 +447,8 @@ let retainedReaderScrollSnapshot = null;
 let loadMoreRequestVersion = 0;
 let pendingTailFollow = false;
 let previousScrollTop = 0;
+let userScrollIntentUpward = false;
+let lastTouchY = null;
 const USER_SCROLL_INTENT_RESET_MS = 600;
 const LOAD_MORE_THRESHOLD_PX = 160;
 const KEYBOARD_SCROLL_KEYS = new Set([
@@ -454,6 +461,7 @@ const KEYBOARD_SCROLL_KEYS = new Set([
   "PageUp",
   "Spacebar"
 ]);
+const UPWARD_SCROLL_KEYS = new Set(["ArrowUp", "Home", "PageUp"]);
 const TIME_FORMAT = Object.freeze({
   year: "numeric",
   month: "short",
@@ -747,9 +755,10 @@ function resumePendingTailFollow() {
   }
 }
 
-function markUserScrollIntent() {
+function markUserScrollIntent({ upward = false } = {}) {
   retainedReaderScrollSnapshot = null;
   userScrollIntent.value = true;
+  userScrollIntentUpward = upward;
   clearLiveBottomScroll();
   clearScheduledScrolls();
   if (userScrollIntentTimer && typeof window !== "undefined" && typeof window.clearTimeout === "function") {
@@ -778,7 +787,20 @@ function markKeyboardScrollIntent(event = {}) {
   ) {
     return;
   }
-  markUserScrollIntent();
+  markUserScrollIntent({
+    upward: UPWARD_SCROLL_KEYS.has(event.key) || (event.shiftKey && [" ", "Spacebar"].includes(event.key))
+  });
+}
+
+function rememberTouch(event = {}) {
+  lastTouchY = event.touches?.[0]?.clientY ?? null;
+}
+
+function markTouchScrollIntent(event = {}) {
+  const touchY = event.touches?.[0]?.clientY ?? null;
+  // A finger moving down the screen scrolls the transcript up.
+  markUserScrollIntent({ upward: touchY !== null && lastTouchY !== null && touchY > lastTouchY });
+  lastTouchY = touchY;
 }
 
 function scrollToLatestMessageAfterLayout({
@@ -870,13 +892,21 @@ function updateLatestFollowFromScroll(event = {}) {
     loadMoreScrollSnapshot.anchor = visibleHistoryAnchor(target);
     loadMoreScrollSnapshot.scrollHeight = target.scrollHeight;
   }
-  const shouldFollow = scrollElementNearBottom(target);
+  // The reader's own upward scrolling leaves the latest message from its first
+  // frame, even within the follow threshold.
+  const userScrollsUp = userScrollIntent.value && userScrollIntentUpward;
+  const shouldFollow = scrollElementNearBottom(target) &&
+    !(userScrollsUp && scrollDistanceFromBottom(target) > 1);
   if (!shouldFollow && !userScrollIntent.value && followingLatest.value) {
     return;
   }
   followingLatest.value = shouldFollow;
   if (shouldFollow) {
-    clearUserScrollIntent();
+    // A scroll event still at the end, queued before upward input, must not
+    // end that input's intent.
+    if (!userScrollsUp) {
+      clearUserScrollIntent();
+    }
     resumePendingTailFollow();
     return;
   }

package/src/client/conversation/messageDelivery.js

@@ -100,7 +100,8 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
     } : null;
     return {
       optimistic: { error: message.error, id: message.id, status: message.status,
-        ...(message.status === "pending" && message.waiting ? { waiting: message.waiting } : {}) },
+        ...(message.status === "pending" && message.waiting ? { waiting: message.waiting } : {}),
+        ...(message.cancelling ? { cancelling: true } : {}), ...(message.cancelError ? { cancelError: message.cancelError } : {}) },
       turnId: message.id,
       [role]: authored,
       ...(status ? { system: role === "system" ? { ...authored, ...status, text: `${authored.text}\n\n${status.text}` } : status } : {})
@@ -117,7 +118,7 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
     queue = false
   } = {}) {
     if ((state.sending && !queue) || pendingSends.has(messageId) || find(messageId)?.status === "uncertain" ||
-        (!messageText(payload?.message) && !payload?.displayAttachments?.length)) return false;
+        find(messageId)?.cancelling || (!messageText(payload?.message) && !payload?.displayAttachments?.length)) return false;
     if (typeof deliver !== "function") throw new TypeError("Message delivery requires a deliver function.");
     const snapshot = JSON.parse(JSON.stringify(payload));
     const previous = find(messageId);
@@ -147,6 +148,8 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
     try {
       if (predecessor) await predecessor;
       if (!current()) return false;
+      // A queued message cancelled while it waited is never delivered.
+      if (find(messageId)?.cancelling) return false;
       if (uncertainOnError && state.messages.some(entry => entry.id !== messageId && entry.status === "uncertain" && !knownUncertain.has(entry.id))) {
         fail(messageId, t("jskit.assistant.delivery.checkPrevious"));
         return false;
@@ -240,15 +243,29 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
     return true;
   }
 
+  // Cancel of a pending, uncertain or failed message waits for the server: the
+  // message stays, shown as cancelling, until the caller removes it on the
+  // server's agreement or reports that the server could not be reached.
   function cancel(messageId) {
-    if (find(messageId)?.status !== "failed") return false;
-    remove(messageId);
+    const message = find(messageId);
+    if (!message || message.status === "accepted" || message.cancelling) return false;
+    message.cancelling = true;
+    message.cancelError = "";
     return true;
   }
 
+  function cancelFailed(messageId, error = "") {
+    const message = find(messageId);
+    if (!message) return;
+    message.cancelling = false;
+    message.cancelError = String(error || t("jskit.assistant.delivery.cancelUnreachable")).trim();
+  }
+
+  // Only a message that never reached the conversation returns to the draft.
   function edit(messageId, draft = "") {
     const message = find(messageId);
-    if (!message || !cancel(messageId)) return null;
+    if (message?.status !== "failed" || message.cancelling) return null;
+    remove(messageId);
     return draftWithRestoredMessage(message.text, draft);
   }
 
@@ -269,7 +286,7 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
     state.sending = false;
   }
 
-  return { accept, cancel, edit, find, reconcile, remove, resend, reset, restoreUncertain, rejectUnsent, send, state, turns, wait };
+  return { accept, cancel, cancelFailed, edit, find, reconcile, remove, resend, reset, restoreUncertain, rejectUnsent, send, state, turns, wait };
 }
 
 // The composer text after a failed or cancelled message returns to it: the

package/src/client/lib/assistantApi.js

@@ -133,6 +133,11 @@ function createAssistantApi({ request, requestStream, resolveBasePath, resolveSu
       return requestConversation(conversationId, `/deliveries/${encodedMessageId}/inspect`, { method: "POST", signal });
     },
 
+    cancelConversationDelivery(conversationId, messageId, { signal } = {}) {
+      const encodedMessageId = encodeURIComponent(String(messageId || "").trim());
+      return requestConversation(conversationId, `/deliveries/${encodedMessageId}/cancel`, { method: "POST", signal });
+    },
+
     readConversationGoal(conversationId, { signal } = {}) {
       return requestConversation(conversationId, "/goal", { method: "GET", signal });
     },

package/src/server/conversation/claudeProcess.js

@@ -9,9 +9,8 @@ import { createLocalConversationExecution } from "./localExecution.js";
 import { CLAUDE_APPLICATION_TOOL_SERVER } from "./claudeTools.js";
 import { nativeCommandHook, validateCommandWrapper } from "./commandWrapper.js";
 
-const statusReads = new WeakMap();
-const STATUS_REUSE_MS = 30_000;
-const STATUS_UNFINISHED_GRACE_MS = 5 * 60_000;
+const statusReads = new Map();
+const STATUS_RETRY_MS = 30_000;
 const CLAUDE_EXIT_WAIT_MS = 5_000;
 
 /** Person-facing cause for a Claude process that ended without being stopped. */
@@ -28,6 +27,17 @@ export function claudeUnexpectedExitMessage(processExit = {}) {
   return `Claude stopped unexpectedly. ${resume}`;
 }
 
+// A file's metadata, following links, or null when it is absent.
+async function fileRevision(file) {
+  try {
+    const value = await stat(file, { bigint: true });
+    return [value.dev, value.ino, value.size, value.mtimeNs].join(":");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
 export async function readClaudeCodeAuthStatus({
   env = process.env, credentialHome = { home: env.HOME || homedir() }, command = "claude", commandRunner, signal
 } = {}) {
@@ -35,39 +45,28 @@ export async function readClaudeCodeAuthStatus({
   if (typeof commandRunner !== "function") throw new TypeError("Claude account status requires its host capture runner.");
   const configRoot = env.CLAUDE_CONFIG_DIR || path.join(credentialHome.home, ".claude");
   // Inspect file metadata only. Claude still owns reading and validating credentials.
-  const revisions = await Promise.all([
-    path.join(configRoot, ".credentials.json"), path.join(configRoot, ".claude.json"),
-    path.join(credentialHome.home, ".claude.json")
-  ].map(async (file) => {
-    try {
-      const value = await stat(file, { bigint: true });
-      return [value.dev, value.ino, value.size, value.mtimeNs, value.ctimeNs].map(String);
-    } catch (error) {
-      if (error.code === "ENOENT") return null;
-      throw error;
-    }
-  }));
-  let reads = statusReads.get(commandRunner);
-  if (!reads) statusReads.set(commandRunner, reads = new Map());
-  const key = JSON.stringify([command, env, credentialHome]);
-  const revision = JSON.stringify(revisions);
-  const previous = reads.get(key);
+  // Sign-in writes .credentials.json and sign-out removes it. Claude Code also
+  // rewrites .claude.json during turns and after every status read, so that
+  // file is not watched.
+  const revision = await fileRevision(path.join(configRoot, ".credentials.json"));
+  // One entry per account, whichever command path or host runner reads it: only
+  // the account's location and its identity variables count.
+  const key = jsonHash([configRoot, credentialHome.home, Object.entries(env).filter(([name, value]) =>
+    value && (name === "CLAUDE_CODE_OAUTH_TOKEN" || name.startsWith("ANTHROPIC_"))).sort()]);
+  const previous = statusReads.get(key);
   if (previous?.revision === revision && (previous.pending || previous.expiresAt > Date.now())) return previous.value;
-  // Claude's last answer for these exact account files.
-  const answered = previous?.revision === revision ? previous.answered : null;
-  const entry = { revision, pending: true, expiresAt: 0, answered };
-  reads.set(key, entry);
+  const entry = { revision, pending: true, expiresAt: 0 };
+  statusReads.set(key, entry);
   entry.value = readNativeClaudeCodeAuthStatus({ env, credentialHome, command, commandRunner, signal }).then(({ status, unfinished }) => {
-    // A read the host timed out or refused for now says nothing about the account.
-    const value = unfinished && answered && Date.now() - answered.at < STATUS_UNFINISHED_GRACE_MS
-      ? answered.status : Object.freeze(status);
     // Keychain changes cannot be observed with file metadata on macOS.
     if (process.platform !== "darwin") {
-      // Unfinished reads back off too, so a busy host is not probed again by every caller.
-      if (!status.error || unfinished) entry.expiresAt = Date.now() + STATUS_REUSE_MS;
-      if (!status.error) entry.answered = { status: value, at: Date.now() };
+      // Claude's answer holds until its credentials change. A read the host timed
+      // out or refused for now backs off, so a busy host is not probed again by
+      // every caller; a read that ran and failed is asked again next time.
+      if (!status.error) entry.expiresAt = Infinity;
+      else if (unfinished) entry.expiresAt = Date.now() + STATUS_RETRY_MS;
     }
-    return value;
+    return Object.freeze(status);
   }).finally(() => { entry.pending = false; });
   return entry.value;
 }
@@ -250,6 +249,11 @@ const PLAN_USAGE_IDLE_READ_MS = 300_000;
 // A verified reading stays current until the next idle read, one client poll and
 // its read deadline could have replaced it.
 const PLAN_USAGE_CURRENT_MS = 420_000;
+// One plan-usage reading per Claude account in this server process, with its read
+// times and the read in flight. Every account-query owner, page and session asking
+// for the account shares it, so however many ask, the account's one-shot Claude
+// starts at most once per idle interval.
+const planUsageReads = new Map();
 
 /**
  * Claude Code answers `get_usage` from the usage endpoint, or from its saved copy
@@ -278,15 +282,21 @@ export function claudeCatalogueModels(initialization) {
   }));
 }
 
-/** Native account queries share process reuse, caches and retryable cleanup. */
-export function createClaudeAccountQueries({ createProcess, accountIdentity, processes = () => [], isClosing = () => false }) {
+/**
+ * Native account queries share process reuse, caches and retryable cleanup. Plan
+ * usage is shared by `accountIdentity` with every other owner in the process, so
+ * that identity names exactly one Claude account. `configRoot` is the account's
+ * Claude configuration directory, whose credentials the model list follows.
+ */
+export function createClaudeAccountQueries({ createProcess, accountIdentity, configRoot, processes = () => [], isClosing = () => false }) {
   const error = message => Object.assign(new Error(message), { code: "claude_account_query_failed" });
   const accountProcessStops = new Set();
   const accountReads = new Set();
   let catalog;
   const catalogStarts = new Map();
-  const planUsage = new Map();
-  const planUsagePending = new Map();
+  // Accounts whose shared plan-usage reading this owner used, and the reads it started.
+  const usageAccounts = new Set();
+  const usageReads = new Set();
   let revision = 0;
 
   function assertCurrent(expectedRevision) {
@@ -305,7 +315,7 @@ export function createClaudeAccountQueries({ createProcess, accountIdentity, pro
       entry.process && !entry.stopping && entry.accountIdentity === identity);
   }
 
-  async function readAccountProcess(identity, expectedRevision, purpose, read, { borrow = true } = {}) {
+  async function readAccountProcess(identity, expectedRevision, purpose, read, { borrow = false } = {}) {
     assertCurrent(expectedRevision);
     for (const native of accountProcessStops) await stopAccountProcess(native);
     assertCurrent(expectedRevision);
@@ -330,36 +340,60 @@ export function createClaudeAccountQueries({ createProcess, accountIdentity, pro
     }
   }
 
+  // The model list belongs to the account and the Claude Code version that gave
+  // it: the account's credentials file changes with sign-in, sign-out and each
+  // token refresh (which carries a plan change), and the executable with each
+  // Claude Code update. An executable given as a bare name has no metadata.
+  async function catalogueRevision(command) {
+    return JSON.stringify(await Promise.all([fileRevision(path.join(configRoot, ".credentials.json")),
+      fileRevision(command)]));
+  }
+
   return Object.freeze({
     async readCatalogue(context) {
       const expectedRevision = revision;
       assertCurrent(expectedRevision);
       const identity = await accountIdentity(context);
       assertCurrent(expectedRevision);
-      if (!catalog || catalog.identity !== identity || Date.now() - catalog.at > 600_000) {
-        if (!catalogStarts.has(identity)) catalogStarts.set(identity, (async () => {
-          const value = await readAccountProcess(identity, expectedRevision, "catalogue", (native) => native.initialization);
-          if (identity !== await accountIdentity(context)) throw error("The signed-in Claude account changed. Refresh the model list.");
-          assertCurrent(expectedRevision);
-          catalog = { at: Date.now(), identity, value };
-          return value;
-        })().finally(() => { catalogStarts.delete(identity); }));
-        return catalogStarts.get(identity);
+      // An answer is kept until its account, credentials or executable change, so
+      // reading it again starts no Claude.
+      const kept = catalog?.identity === identity ? catalog : null;
+      if (kept && kept.revision === await catalogueRevision(kept.command)) {
+        assertCurrent(expectedRevision);
+        return kept.value;
       }
-      return catalog.value;
+      if (!catalogStarts.has(identity)) catalogStarts.set(identity, (async () => {
+        // A conversation's process answers with what it knew when it started, so
+        // the list comes from a Claude started for this read.
+        const { value, command } = await readAccountProcess(identity, expectedRevision, "catalogue",
+          async (native) => ({ value: await native.initialization, command: native.command }));
+        const answered = await catalogueRevision(command);
+        if (identity !== await accountIdentity(context)) throw error("The signed-in Claude account changed. Refresh the model list.");
+        assertCurrent(expectedRevision);
+        catalog = { identity, command, revision: answered, value };
+        return value;
+      })().finally(() => { catalogStarts.delete(identity); }));
+      return catalogStarts.get(identity);
     },
     async readPlanUsage(context) {
       const expectedRevision = revision;
       assertCurrent(expectedRevision);
       const identity = await accountIdentity(context);
       assertCurrent(expectedRevision);
-      if (planUsagePending.has(identity)) return planUsagePending.get(identity);
-      // One reading per account; a started process is stopped after its read.
-      const usage = planUsage.get(identity) || { liveReadAt: -Infinity, temporaryReadAt: -Infinity, reading: null };
-      planUsage.set(identity, usage);
+      // One reading per account, whichever owner asks; a started process is stopped after its read.
+      let usage = planUsageReads.get(identity);
+      if (!usage) {
+        usage = { liveReadAt: -Infinity, temporaryReadAt: -Infinity, reading: null, pending: null };
+        planUsageReads.set(identity, usage);
+      }
+      usageAccounts.add(identity);
+      if (usage.pending) return usage.pending;
       const live = Boolean(ownedProcess(identity));
       const liveDue = live && Date.now() - usage.liveReadAt >= PLAN_USAGE_LIVE_READ_MS;
-      const temporaryDue = () => Date.now() - usage.temporaryReadAt >= PLAN_USAGE_IDLE_READ_MS;
+      // A one-shot Claude starts only when neither a verified reading nor a one-shot
+      // read is from the last idle interval.
+      const temporaryDue = () => Date.now() - Math.max(usage.temporaryReadAt, usage.reading?.checkedAt ?? -Infinity) >=
+        PLAN_USAGE_IDLE_READ_MS;
       if (!liveDue && (live || !temporaryDue())) return presentPlanUsage(usage.reading);
       const pending = (async () => {
         // A live process's held endpoint read is its own, so a fresh one-shot Claude
@@ -385,18 +419,31 @@ export function createClaudeAccountQueries({ createProcess, accountIdentity, pro
           }
         }
         return presentPlanUsage(usage.reading);
-      })().finally(() => { planUsagePending.delete(identity); });
-      planUsagePending.set(identity, pending);
+      })().finally(() => {
+        usageReads.delete(pending);
+        if (usage.pending === pending) usage.pending = null;
+      });
+      // Requests that arrive while the account is read share that read.
+      usage.pending = pending;
+      usageReads.add(pending);
       return pending;
     },
     // A native usage change lets the next request read again without hiding the last reading.
-    invalidateUsage() { for (const usage of planUsage.values()) usage.liveReadAt = -Infinity; },
+    invalidateUsage() {
+      for (const identity of usageAccounts) {
+        const usage = planUsageReads.get(identity);
+        if (usage) usage.liveReadAt = -Infinity;
+      }
+    },
     async invalidate() {
       revision++;
-      for (const controller of accountReads) controller.abort(error("Claude account query was cancelled for reconnection."));
-      await Promise.allSettled([...catalogStarts.values(), ...planUsagePending.values()]);
+      // Dropped at once: a read started before this cannot store its answer.
       catalog = null;
-      planUsage.clear();
+      for (const controller of accountReads) controller.abort(error("Claude account query was cancelled for reconnection."));
+      await Promise.allSettled([...catalogStarts.values(), ...usageReads]);
+      // The account changed: the next request for an account this owner used reads again.
+      for (const identity of usageAccounts) planUsageReads.delete(identity);
+      usageAccounts.clear();
       for (const native of accountProcessStops) await stopAccountProcess(native);
     }
   });
@@ -478,7 +525,7 @@ export async function createClaudeCodeProcess({
     }, error => {
       if (!stopped && !stopping) stream.destroy(error);
     });
-    return { client, initialization, executionId: native.id, stop };
+    return { client, initialization, executionId: native.id, command, stop };
   } catch (error) {
     // A rejected start may already own an execution and its cleanup proof.
     // Only a returned native handle transfers that cleanup to this owner.