mixdog 0.9.147 → 0.9.149

package/src/runtime/agent/orchestrator/providers/gemini.mjs

@@ -354,9 +354,40 @@ export class GeminiProvider {
             _attachGeminiCacheState(opts, globalCache, currentIter);
             return globalCache.cacheName;
         }
+        // Wait on a shared create while still honouring THIS caller's abort:
+        // the create itself is process-global and must outlive any single
+        // session, so the caller only stops waiting (resolving null) instead of
+        // cancelling the work for everyone.
+        const awaitSharedCreate = (task) => {
+            const signal = opts.signal;
+            if (!(signal instanceof AbortSignal)) return task.then((v) => v, () => null);
+            if (signal.aborted) return Promise.resolve(null);
+            return new Promise((resolve) => {
+                const onAbort = () => resolve(null);
+                signal.addEventListener('abort', onAbort, { once: true });
+                task.then(
+                    (value) => { signal.removeEventListener('abort', onAbort); resolve(value); },
+                    () => { signal.removeEventListener('abort', onAbort); resolve(null); },
+                );
+            });
+        };
+        // Strict singleflight: a WAITER never inherits the creation duty.
+        //
+        // The earlier bounded wait loop still herded. When the shared create
+        // settles, its own cleanup removes the slot BEFORE the waiters resume,
+        // so every waiter saw an empty slot; and a waiter that exhausted its
+        // rounds fell through and created even while another create was in
+        // flight — 8 waiters over repeated failures produced ~4 concurrent
+        // cachedContents POSTs for one prefix.
+        //
+        // The rule is now unconditional: if a create is in flight we wait for
+        // exactly that one, and if it does not yield a cache we proceed
+        // UNCACHED (the cache is an optimization, and the next turn re-creates).
+        // Only the caller that finds an EMPTY slot creates, and it publishes its
+        // task synchronously below, so at most one create per key can exist.
         const inFlightCreate = geminiGlobalCacheCreates.get(globalCacheKey);
         if (inFlightCreate) {
-            const created = await inFlightCreate.catch(() => null);
+            const created = await awaitSharedCreate(inFlightCreate);
             if (created?.cacheName) {
                 try {
                     appendAgentTrace({
@@ -374,6 +405,14 @@ export class GeminiProvider {
                 _attachGeminiCacheState(opts, created, currentIter);
                 return created.cacheName;
             }
+            // Failed or abandoned wait: another caller may still have published
+            // a usable cache for this exact prefix meanwhile.
+            const raced = _getGeminiGlobalCache(globalCacheKey, Date.now());
+            if (raced) {
+                _attachGeminiCacheState(opts, raced, currentIter);
+                return raced.cacheName;
+            }
+            return canAttachState ? state.cacheName : null;
         }
         const createTask = (async () => {
             try {
@@ -398,12 +437,14 @@ export class GeminiProvider {
                 body.contents = cachePrefixContents;
             }
             const url = `https://generativelanguage.googleapis.com/v1beta/cachedContents?key=${encodeURIComponent(apiKey)}`;
-            // Honor the external session abort signal during cache creation, not
-            // only the 20s ceiling. Without merging opts.signal a session that is
-            // aborted (stall-watchdog / closeSession) mid-cache-create leaves this
-            // preflight request running until its own timeout fires.
+            // Deliberately NOT merged with opts.signal. This create is the
+            // process-global singleflight every concurrent session waits on, so
+            // the FIRST caller's abort (stall-watchdog / closeSession) must not
+            // cancel the cache every other session is waiting for — that is the
+            // herd trigger. The 20s ceiling still bounds the preflight request,
+            // and an aborting caller simply stops waiting (awaitSharedCreate).
             const createTotal = createTimeoutSignal(
-                opts.signal,
+                null,
                 PROVIDER_CACHE_CREATE_TOTAL_TIMEOUT_MS,
                 'Gemini cachedContents.create total',
             );
@@ -520,18 +561,23 @@ export class GeminiProvider {
             }
         })();
         geminiGlobalCacheCreates.set(globalCacheKey, createTask);
-        try {
-            const created = await createTask;
-            // A failed refresh must not silently retain a cache that may have
-            // expired or been evicted server-side. The caller proceeds uncached.
-            if (!created?.cacheName) return null;
-            _attachGeminiCacheState(opts, created, currentIter);
-            return created.cacheName;
-        } finally {
+        // Ownership is released by the TASK, never by the awaiting caller: a
+        // caller that walks away (abort) must not retract a still-running create
+        // from the map, or the next caller starts a duplicate POST for the same
+        // prefix — the herd this singleflight exists to prevent.
+        createTask.finally(() => {
             if (geminiGlobalCacheCreates.get(globalCacheKey) === createTask) {
                 geminiGlobalCacheCreates.delete(globalCacheKey);
             }
-        }
+        });
+        // Owner path: same abort semantics as the waiters — the shared create
+        // continues even if this caller stops waiting.
+        const created = await awaitSharedCreate(createTask);
+        // A failed refresh must not silently retain a cache that may have
+        // expired or been evicted server-side. The caller proceeds uncached.
+        if (!created?.cacheName) return null;
+        _attachGeminiCacheState(opts, created, currentIter);
+        return created.cacheName;
     }
 
     async send(messages, model, tools, sendOpts) {

package/src/runtime/agent/orchestrator/providers/lib/anthropic-request-utils.mjs

@@ -1,5 +1,11 @@
 import { providerNativeToolPrefixCount } from '../../../../../session-runtime/provider-request-tools.mjs';
 import { isNativeServerToolBlockType } from './anthropic-native-blocks.mjs';
+import { sanitizeAnthropicContentPairs, foldUserTextIntoToolResultTail } from '../../session/context-utils.mjs';
+import { normalizeContentForAnthropic } from '../media-normalization.mjs';
+import {
+    anthropicFallbackProviderMetadata,
+    parseAnthropicFallbackBlock,
+} from '../anthropic-server-fallback.mjs';
 
 export const ANTHROPIC_CACHE_TTL_STABLE = { type: 'ephemeral', ttl: '1h' };
 export const ANTHROPIC_CACHE_TTL_VOLATILE = { type: 'ephemeral' };
@@ -47,6 +53,117 @@ export function resolveAnthropicCacheTtls(opts) {
     return resolved;
 }
 
+// Message-tail cache budget, shared by both Anthropic providers.
+//
+// 4-BP layout: the tools breakpoint is dropped — the system BP covers the tools
+// prefix via Anthropic's prompt-cache prefix semantics (order: tools → system →
+// messages), which frees its slot for the messages tail. The system blocks hold
+// BP1/BP2/BP3 (tier3), so every consumed slot is already counted there.
+//
+// Env override: ANTHROPIC_MSG_SLOTS=0 disables message caching entirely; any
+// value >=1 first marks the previous user text turn so consecutive requests
+// share a breakpoint, and a second free slot marks the tail for the newest
+// delta. messageTtl === null (no slot, or ttls.messages disabled) turns the
+// tail off.
+export function resolveAnthropicMessageCacheSlots(systemBlocks, ttls) {
+    const usedSlots = systemBlocks.filter(b => b.cache_control).length;
+    const slotsCap = Number.parseInt(process.env.ANTHROPIC_MSG_SLOTS, 10);
+    const defaultSlots = Math.max(0, 4 - usedSlots);
+    const messageSlots = ttls.messages
+        ? (Number.isFinite(slotsCap) && slotsCap >= 0 ? Math.min(slotsCap, defaultSlots) : defaultSlots)
+        : 0;
+    // Key order matches the object both call sites built inline: messageTtl
+    // first, then messageSlots.
+    return { messageTtl: messageSlots > 0 ? ttls.messages : null, messageSlots };
+}
+
+// Single lowering of orchestrator messages to the Anthropic wire shape. The
+// API-key provider (anthropic.mjs, via anthropic-messages.mjs) and the OAuth
+// provider (anthropic-oauth.mjs) both used to carry byte-identical copies;
+// they now share this one.
+//
+// Marker-free lowering. cache_control is applied AFTER sanitization by
+// applyAnthropicCacheMarkers() so that block drops/inserts/reorders performed
+// by sanitizeAnthropicContentPairs cannot move or delete a marked block (the
+// root cause of the sporadic COLD-turn cache miss: pre-sanitize markers landed
+// on blocks the sanitizer then rewrote, so the provider-visible breakpoint
+// diverged from the cached one).
+export function toAnthropicMessages(messages) {
+    const result = [];
+    for (let idx = 0; idx < messages.length; idx++) {
+        const m = messages[idx];
+        if (m.role === 'system') continue;
+        if (m.role === 'assistant' && (m.toolCalls?.length || m.assistantBlocks?.length || m.thinkingBlocks?.length)) {
+            let content;
+            if (m.assistantBlocks?.length) {
+                content = m.assistantBlocks.slice();
+            } else {
+                content = [];
+                // Adaptive-thinking round-trip: prior-turn thinking blocks are
+                // REQUIRED back, unmodified (signature intact; empty thinking
+                // field allowed), and MUST precede tool_use blocks. Emit them
+                // first, verbatim as received from the SSE parser.
+                if (Array.isArray(m.thinkingBlocks)) {
+                    for (const tb of m.thinkingBlocks) {
+                        if (tb && typeof tb === 'object') content.push(tb);
+                    }
+                }
+                if (m.content) content.push({ type: 'text', text: m.content });
+                for (const tc of m.toolCalls || []) {
+                    content.push({
+                        type: 'tool_use',
+                        id: tc.id,
+                        name: tc.name,
+                        input: tc.arguments,
+                    });
+                }
+            }
+            result.push({ role: 'assistant', content });
+            continue;
+        }
+        if (m.role === 'tool') {
+            const last = result[result.length - 1];
+            const native = m.nativeToolSearch;
+            const nativeProvider = String(native?.provider || '').toLowerCase();
+            const anthropicNative = new Set(['anthropic', 'anthropic-oauth']);
+            const references = (!nativeProvider || anthropicNative.has(nativeProvider))
+                && Array.isArray(native?.toolReferences)
+                ? native.toolReferences.map((name) => String(name || '').trim()).filter(Boolean)
+                : [];
+            const block = {
+                type: 'tool_result',
+                tool_use_id: m.toolCallId || '',
+                content: references.length
+                    ? references.map((tool_name) => ({ type: 'tool_reference', tool_name }))
+                    : normalizeContentForAnthropic(m.content),
+                ...((m.toolKind === 'error' || m.isError === true) ? { is_error: true } : {}),
+            };
+            if (last?.role === 'user' && Array.isArray(last.content)) {
+                last.content.push(block);
+            } else {
+                result.push({ role: 'user', content: [block] });
+            }
+            continue;
+        }
+        // First-party client parity: fold a user text turn that directly follows a
+        // tool_result turn into that tool_result's content. A sibling text turn
+        // after tool_result renders as `</function_results>\n\nHuman:` on the wire
+        // and trains the model toward 3-token empty end_turn completions (empty
+        // end_turn livelock prevention; see foldUserTextIntoToolResultTail).
+        //   EXCEPTION: steering-origin user messages (human/TUI interjections)
+        //   keep their own user turn so provenance survives — folding them would
+        //   disguise user input as tool output. Anthropic accepts a user text
+        //   message after a tool_result message, so the turn stays request-valid.
+        const isSteering = m.role === 'user' && m.meta?.source === 'steering';
+        if (m.role === 'user' && !isSteering
+            && foldUserTextIntoToolResultTail(result, normalizeContentForAnthropic(m.content))) {
+            continue;
+        }
+        result.push({ role: m.role, content: normalizeContentForAnthropic(m.content) });
+    }
+    return sanitizeAnthropicContentPairs(result);
+}
+
 export function clampAnthropicThinkingBudget(value, maxTokens) {
     const desired = Math.floor(Number(value));
     const max = Math.floor(Number(maxTokens));
@@ -63,6 +180,7 @@ const REPLAYABLE_ASSISTANT_BLOCK_TYPES = new Set(['thinking', 'redacted_thinking
 
 export function normalizeAnthropicNonStreamingResponse(message, fallbackModel = '') {
     const blocks = Array.isArray(message?.content) ? message.content : [];
+    const fallbackEvents = blocks.map(parseAnthropicFallbackBlock).filter(Boolean);
     const text = blocks
         .filter((block) => block?.type === 'text')
         .map((block) => String(block.text || ''))
@@ -99,13 +217,14 @@ export function normalizeAnthropicNonStreamingResponse(message, fallbackModel =
     const cacheWrite = Number(usage.cache_creation_input_tokens) || 0;
     return {
         content: text,
-        model: message?.model || fallbackModel,
+        model: fallbackEvents.at(-1)?.fallbackModel || message?.model || fallbackModel,
         toolCalls: toolCalls.length ? toolCalls : undefined,
         stopReason: message?.stop_reason || null,
         hasThinkingContent: thinkingBlocks.length > 0,
         contentBlockTypes: blocks.map((block) => block?.type).filter(Boolean),
         thinkingBlocks: thinkingBlocks.length ? thinkingBlocks : undefined,
         assistantBlocks: nativeAssistantBlocks.length ? nativeAssistantBlocks : undefined,
+        providerMetadata: anthropicFallbackProviderMetadata(fallbackEvents),
         usage: {
             inputTokens: input,
             outputTokens: Number(usage.output_tokens) || 0,

package/src/runtime/agent/orchestrator/providers/lib/env-utils.mjs

@@ -1,3 +1,12 @@
+// Shared env-boolean parser: unset/empty keeps `fallback`, and only the
+// documented off-values flip a default-on flag. Single implementation behind
+// the historical `_envFlag` name used by the OpenAI/xAI transport gates.
+export function envFlag(name, fallback = true) {
+    const raw = process.env[name];
+    if (raw == null || raw === '') return fallback;
+    return !['0', 'false', 'off', 'no'].includes(String(raw).toLowerCase());
+}
+
 export function envPositiveInt(name, fallback) {
     const raw = process.env[name];
     if (raw == null || raw === '') return fallback;

package/src/runtime/agent/orchestrator/providers/lib/stream-outcome.mjs

@@ -277,9 +277,6 @@ export function readStreamOutcome(...sources) {
   return _finalize(signals || EMPTY_SIGNALS)
 }
 
-/** Alias kept for callers that read a provider midState directly. */
-export const streamOutcomeFromState = readStreamOutcome
-
 /**
  * Attach the canonical record to `target` (usually a thrown error) and mirror
  * it onto the historical alias flags. Aliases are only ever SET, never

package/src/runtime/agent/orchestrator/providers/oauth-credential-probes.mjs

@@ -1,13 +1,52 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
+import { cursorTokenExpiry } from './cursor-auth.mjs';
 
 const ANTHROPIC_DEFAULT_CREDENTIALS_PATH = join(resolvePluginData(), 'anthropic-oauth-credentials.json');
 
-function readJsonIfExists(path) {
-    if (!path || !existsSync(path)) return null;
-    try { return JSON.parse(readFileSync(path, 'utf-8')); }
-    catch { return null; }
+/**
+ * Read one credential file with THREE distinguishable outcomes:
+ *   { present: false }                → the file is not there (logged out)
+ *   { present: true, unreadable: true } → it exists but cannot be read/parsed
+ *                                         right now (EACCES, lock contention,
+ *                                         a torn write mid atomic-replace)
+ *   { present: true, data }            → parsed content
+ * Collapsing the middle case into "absent" is what let a momentary FS failure
+ * be mistaken for a deliberate logout by every caller downstream.
+ */
+function readCredentialFile(path) {
+    if (!path) return { present: false, data: null, unreadable: false };
+    let raw;
+    try {
+        if (!existsSync(path)) return { present: false, data: null, unreadable: false };
+        raw = readFileSync(path, 'utf-8');
+    } catch {
+        return { present: true, data: null, unreadable: true };
+    }
+    try {
+        return { present: true, data: JSON.parse(raw), unreadable: false };
+    } catch {
+        return { present: true, data: null, unreadable: true };
+    }
+}
+
+// Resolve a probe to 'present' | 'absent' | 'unreadable'. `evaluate` sees only
+// the documents that parsed; if none of them yields usable credentials while at
+// least one candidate file was unreadable, the answer is "cannot tell", never
+// "absent".
+function resolveProbeState(paths, evaluate) {
+    let sawUnreadable = false;
+    const docs = [];
+    for (const path of paths) {
+        if (!path) continue;
+        const file = readCredentialFile(path);
+        if (file.unreadable) { sawUnreadable = true; continue; }
+        if (file.data) docs.push(file.data);
+    }
+    if (evaluate(docs) === true) return 'present';
+    return sawUnreadable ? 'unreadable' : 'absent';
 }
 
 function pushUnique(list, value) {
@@ -17,113 +56,177 @@ function pushUnique(list, value) {
 
 // Short-TTL memo. Under simultaneous multi-agent launch, buildDefaultConfig
 // and registry lazy-init call these probes in bursts; each probe does
-// synchronous existsSync + readFileSync disk work. Cache the boolean per key
+// synchronous existsSync + readFileSync disk work. Cache the STATE per key
 // for a brief window so one launch burst shares a single read instead of N.
 // Kept short so the registry's "re-probe on each getProvider miss" self-heal
 // (a credential file appearing/changing) is delayed by at most PROBE_TTL_MS.
 const PROBE_TTL_MS = 3000;
 const _probeCache = new Map();
-function memoProbe(key, compute) {
+
+// Cheap change-detector for the candidate credential files. statSync is orders
+// of magnitude cheaper than the readFileSync + JSON.parse the memo exists to
+// coalesce, so it runs on every call: the memo may only return a cached answer
+// while the files it was computed from are byte-for-byte the same. Without it a
+// logout stayed invisible for up to PROBE_TTL_MS — long enough for one
+// immediate config reload to re-observe 'present' and keep a revoked provider
+// registered. Removal, appearance and rewrite are all observed immediately.
+//
+// mtimeMs+size alone missed a same-length rewrite that preserved (or restored)
+// the timestamp — exactly the shape of a token refresh written by another
+// process, or of an atomic replace. ctimeMs is bumped by the write itself and
+// cannot be back-dated through utimes, and ino changes on rename-replace, so
+// both join the signature; neither costs an extra syscall.
+function credentialPathsSignature(paths, extra = '') {
+    const parts = [];
+    for (const path of paths) {
+        if (!path) continue;
+        try {
+            const st = statSync(path);
+            parts.push(`${path}:${st.mtimeMs}:${st.ctimeMs}:${st.size}:${st.ino}`);
+        } catch {
+            // Missing (the logout case) or unstattable — both distinct from a
+            // readable file, and both must invalidate a cached answer.
+            parts.push(`${path}:-`);
+        }
+    }
+    if (extra) parts.push(extra);
+    return parts.join('|');
+}
+
+function memoProbe(key, paths, compute, extraSignature = '') {
+    const signature = credentialPathsSignature(paths, extraSignature);
     const hit = _probeCache.get(key);
     const now = Date.now();
-    if (hit && now - hit.ts < PROBE_TTL_MS) return hit.value;
+    if (hit && hit.signature === signature && now - hit.ts < PROBE_TTL_MS) return hit.value;
     const value = compute();
-    _probeCache.set(key, { ts: now, value });
+    _probeCache.set(key, { ts: now, signature, value });
     return value;
 }
 
-export function hasAnthropicOAuthCredentials() {
-  return memoProbe('anthropic-oauth', () => {
-    const paths = [];
-    const candidates = [];
-    pushUnique(paths, process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH);
-    pushUnique(paths, ANTHROPIC_DEFAULT_CREDENTIALS_PATH);
-    for (const path of paths) {
-        const raw = readJsonIfExists(path);
+function anthropicOAuthState() {
+  const paths = [];
+  pushUnique(paths, process.env.ANTHROPIC_OAUTH_CREDENTIALS_PATH);
+  pushUnique(paths, ANTHROPIC_DEFAULT_CREDENTIALS_PATH);
+  return memoProbe('anthropic-oauth', paths, () => {
+    return resolveProbeState(paths, (docs) => {
+      const candidates = [];
+      for (const raw of docs) {
         const oauth = raw?.claudeAiOauth;
         if (oauth?.accessToken) {
-            candidates.push({
-                accessToken: oauth.accessToken,
-                refreshToken: oauth.refreshToken || null,
-                expiresAt: Number(oauth.expiresAt ?? oauth.expires_at) || 0,
-                scopes: Array.isArray(oauth.scopes) ? oauth.scopes : [],
-            });
+          candidates.push({
+            accessToken: oauth.accessToken,
+            refreshToken: oauth.refreshToken || null,
+            expiresAt: Number(oauth.expiresAt ?? oauth.expires_at) || 0,
+            scopes: Array.isArray(oauth.scopes) ? oauth.scopes : [],
+          });
         }
-    }
-    if (!candidates.length) return false;
-    candidates.sort((a, b) => (Number(b.expiresAt) || 0) - (Number(a.expiresAt) || 0));
-    const chosen = candidates[0];
-    const hasInferenceScope = Array.isArray(chosen.scopes) && chosen.scopes.includes('user:inference');
-    const expiresAt = Number(chosen.expiresAt) || 0;
-    return !!(chosen.accessToken && hasInferenceScope
-      && (expiresAt === 0 || expiresAt > Date.now() || chosen.refreshToken));
+      }
+      if (!candidates.length) return false;
+      candidates.sort((a, b) => (Number(b.expiresAt) || 0) - (Number(a.expiresAt) || 0));
+      const chosen = candidates[0];
+      const hasInferenceScope = Array.isArray(chosen.scopes) && chosen.scopes.includes('user:inference');
+      const expiresAt = Number(chosen.expiresAt) || 0;
+      return !!(chosen.accessToken && hasInferenceScope
+        && (expiresAt === 0 || expiresAt > Date.now() || chosen.refreshToken));
+    });
   });
 }
 
-export function hasOpenAIOAuthCredentials() {
-  return memoProbe('openai-oauth', () => {
-    const paths = [
-      process.env.OPENAI_OAUTH_CREDENTIALS_PATH,
-      join(resolvePluginData(), 'openai-oauth.json'),
-    ].filter(Boolean);
-    for (const path of paths) {
-        const raw = readJsonIfExists(path);
-        if (raw?.access_token && raw?.refresh_token) return true;
-    }
-    return false;
-  });
+function openAIOAuthState() {
+  const paths = [
+    process.env.OPENAI_OAUTH_CREDENTIALS_PATH,
+    join(resolvePluginData(), 'openai-oauth.json'),
+  ];
+  return memoProbe('openai-oauth', paths, () => resolveProbeState(
+    paths,
+    (docs) => docs.some((raw) => !!(raw?.access_token && raw?.refresh_token)),
+  ));
 }
 
-export function hasGrokOAuthCredentials() {
-  return memoProbe('grok-oauth', () => {
-    const paths = [
-      process.env.GROK_OAUTH_CREDENTIALS_PATH,
-      join(resolvePluginData(), 'grok-oauth.json'),
-    ].filter(Boolean);
-    return paths.some((path) => {
-      const own = readJsonIfExists(path);
-      return !!(own?.access_token && own?.refresh_token);
-    });
-  });
+function grokOAuthState() {
+  const paths = [
+    process.env.GROK_OAUTH_CREDENTIALS_PATH,
+    join(resolvePluginData(), 'grok-oauth.json'),
+  ];
+  return memoProbe('grok-oauth', paths, () => resolveProbeState(
+    paths,
+    (docs) => docs.some((own) => !!(own?.access_token && own?.refresh_token)),
+  ));
 }
 
 // Antigravity needs a resolved Cloud project alongside the tokens: without it
 // every request 400s, so a half-finished login must not enable the provider.
-export function hasAntigravityOAuthCredentials() {
-  return memoProbe('antigravity-oauth', () => {
-    const paths = [
-      process.env.ANTIGRAVITY_OAUTH_CREDENTIALS_PATH,
-      join(resolvePluginData(), 'antigravity-oauth.json'),
-    ].filter(Boolean);
-    return paths.some((path) => {
-      const own = readJsonIfExists(path);
-      return !!(own?.access_token && own?.refresh_token && own?.project_id);
-    });
-  });
+function antigravityOAuthState() {
+  const paths = [
+    process.env.ANTIGRAVITY_OAUTH_CREDENTIALS_PATH,
+    join(resolvePluginData(), 'antigravity-oauth.json'),
+  ];
+  return memoProbe('antigravity-oauth', paths, () => resolveProbeState(
+    paths,
+    (docs) => docs.some((own) => !!(own?.access_token && own?.refresh_token && own?.project_id)),
+  ));
+}
+
+// Content fingerprint of CURSOR_ACCESS_TOKEN (never the token itself).
+// '-' means unset, which must stay distinguishable from any hash so that
+// deleting the variable invalidates the memo immediately.
+function cursorEnvTokenFingerprint() {
+  const token = process.env.CURSOR_ACCESS_TOKEN;
+  if (!token) return '-';
+  return createHash('sha256').update(String(token)).digest('base64url').slice(0, 22);
 }
 
-export function hasCursorOAuthCredentials() {
-  return memoProbe('cursor-oauth', () => {
+function cursorOAuthState() {
+  const paths = [
+    process.env.CURSOR_OAUTH_CREDENTIALS_PATH,
+    join(resolvePluginData(), 'cursor-oauth.json'),
+  ];
+  // The env token is the whole answer on this branch and has no file metadata
+  // behind it, so its VALUE is what the memo signature has to track: a length
+  // (or a bare present/absent flag) let a swap to an equal-length expired token
+  // keep serving the stale 'present' for up to PROBE_TTL_MS. Hashed rather than
+  // embedded so the memo never holds a second copy of the raw credential.
+  const envSignature = `env:${cursorEnvTokenFingerprint()}`;
+  return memoProbe('cursor-oauth', paths, () => {
+    // An env-provided token needs no file read, so it is never "unreadable".
+    // Expiry is read by the one shared JWT reader (cursor-auth.cursorTokenExpiry),
+    // which answers 0 for a non-JWT or unparseable token — exactly the "assume
+    // usable" outcome this branch already took for those shapes.
     if (process.env.CURSOR_ACCESS_TOKEN) {
-      const parts = String(process.env.CURSOR_ACCESS_TOKEN).split('.');
-      if (parts.length !== 3 || !parts[1]) return true;
-      try {
-        const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8'));
-        const expiresAt = Number(payload?.exp) > 0 ? Number(payload.exp) * 1000 : 0;
-        return expiresAt === 0 || expiresAt > Date.now();
-      } catch {
-        return true;
-      }
+      const expiresAt = cursorTokenExpiry(process.env.CURSOR_ACCESS_TOKEN);
+      return (expiresAt === 0 || expiresAt > Date.now()) ? 'present' : 'absent';
     }
-    const paths = [
-      process.env.CURSOR_OAUTH_CREDENTIALS_PATH,
-      join(resolvePluginData(), 'cursor-oauth.json'),
-    ].filter(Boolean);
-    return paths.some((path) => {
-      const own = readJsonIfExists(path);
+    return resolveProbeState(paths, (docs) => docs.some((own) => {
       if (!own?.access_token) return false;
       const expiresAt = Number(own.expires_at) || 0;
       return expiresAt === 0 || expiresAt > Date.now() || Boolean(own.refresh_token);
-    });
-  });
+    }));
+  }, envSignature);
 }
+
+const OAUTH_PROBE_STATES = new Map([
+  ['anthropic-oauth', anthropicOAuthState],
+  ['openai-oauth', openAIOAuthState],
+  ['grok-oauth', grokOAuthState],
+  ['cursor-oauth', cursorOAuthState],
+  ['antigravity-oauth', antigravityOAuthState],
+]);
+
+/**
+ * Tri-state credential probe: 'present' | 'absent' | 'unreadable'.
+ *
+ * Callers that must tell a deliberate logout ('absent') from a momentary FS
+ * failure ('unreadable') use this; `has*OAuthCredentials()` remains the plain
+ * "can we use it right now" boolean and is exactly `state === 'present'`.
+ */
+export function oauthCredentialProbeState(name) {
+  const probe = OAUTH_PROBE_STATES.get(String(name || ''));
+  if (!probe) return 'absent';
+  try { return probe(); } catch { return 'unreadable'; }
+}
+
+export function hasAnthropicOAuthCredentials() { return anthropicOAuthState() === 'present'; }
+export function hasOpenAIOAuthCredentials() { return openAIOAuthState() === 'present'; }
+export function hasGrokOAuthCredentials() { return grokOAuthState() === 'present'; }
+export function hasAntigravityOAuthCredentials() { return antigravityOAuthState() === 'present'; }
+export function hasCursorOAuthCredentials() { return cursorOAuthState() === 'present'; }