mixdog 0.9.86 → 0.9.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.86",
+  "version": "0.9.87",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -55,7 +55,7 @@
     "test:tool-contracts": "node scripts/tool-smoke.mjs",
     "smoke:patch": "node scripts/apply-patch-edit-smoke.mjs",
     "smoke:output": "node scripts/output-style-smoke.mjs",
-    "smoke:tui": "node scripts/tui-render-smoke.mjs && npm run test:tui-input-render && npm run test:tui-streaming-window && npm run test:tui-queue",
+    "smoke:tui": "node scripts/build-tui.mjs && node scripts/tui-render-smoke.mjs && npm run test:tui-input-render && npm run test:tui-streaming-window && npm run test:tui-queue",
     "smoke:freevars": "node scripts/freevar-smoke.mjs",
     "smoke:logguard": "node scripts/log-writer-guard-smoke.mjs",
     "smoke:live-worker": "node scripts/live-worker-smoke.mjs",

package/src/runtime/agent/orchestrator/agent-trace-format.mjs

@@ -282,12 +282,14 @@ function classifyToolFailure(resultText, toolName) {
         return 'command-exit';
     }
     if (/\[tool-input-validation\]|compacted-history placeholder/.test(text)) return 'schema/args';
-    if (/requires either|invalid arguments|unknown parameter|must be|schema|expected|required|old_string is .*>=/.test(text)) return 'schema/args';
+    if (/hunk rejected|patch failed|context mismatch|context not found/.test(text)
+        || /expected first old(?:\/context| line)/.test(text)) return 'patch/context';
+    if (/requires either|invalid arguments|unknown parameter|unknown memory action/.test(text)
+        || /must be|schema|required|old_string is .*>?=/.test(text)) return 'schema/args';
     if (/not in allow-list|not allowed/.test(text)) return 'permission';
     if (String(toolName || '') === 'shell' || /^\s*\[exit code:\s*\d+\]/i.test(raw)) return 'command-exit';
     if (/enoent|cannot find|not found at this path|path does not exist|no such file|file not found in graph|unreadable/.test(text)) return 'path/enoent';
     if (/timed out|timeout|interrupted|aborted/.test(text)) return 'timeout/abort';
-    if (/hunk rejected|patch failed|context mismatch|expected first old\/context|context not found/.test(text)) return 'patch/context';
     if (/permission|denied|forbidden/.test(text)) return 'permission';
     if (/unknown tool|tool.*not.*available|missing.*tool/.test(text)) return 'tool-surface';
     return 'runtime/failure';

package/src/runtime/agent/orchestrator/providers/oauth-usage.mjs

@@ -2,6 +2,7 @@ import {
   existsSync,
   readFileSync,
 } from 'fs';
+import { createHash } from 'crypto';
 import { join } from 'path';
 import { updateJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
@@ -15,6 +16,8 @@ const STALE_DISK_CACHE_TTL_MS = 7 * 24 * 60 * 60_000;
 const NEGATIVE_CACHE_TTL_MS = 5 * 60_000;
 const FETCH_TIMEOUT_MS = 4500;
 const WARN_TTL_MS = 5 * 60_000;
+const CODEX_RESET_CREDITS_URL = 'https://chatgpt.com/backend-api/wham/rate-limit-reset-credits';
+const CODEX_RESET_CONSUME_URL = `${CODEX_RESET_CREDITS_URL}/consume`;
 
 const memoryCache = new Map();
 const inflight = new Map();
@@ -199,6 +202,110 @@ function resetAtMs(value, fallbackSeconds = null) {
   return secs > 0 ? Date.now() + secs * 1000 : null;
 }
 
+function codexAuthShape(auth) {
+  const token = auth?.access_token || auth?.accessToken;
+  if (!token) return null;
+  return {
+    token,
+    accountId: cleanString(auth?.account_id || auth?.accountId),
+  };
+}
+
+function codexHeaders(auth, beta = 'codex-1') {
+  return {
+    Authorization: `Bearer ${auth.token}`,
+    originator: 'Codex Desktop',
+    ...(auth.accountId ? { 'chatgpt-account-id': auth.accountId } : {}),
+    'OpenAI-Beta': beta,
+    Accept: 'application/json',
+  };
+}
+
+function normalizedResetCreditRows(value) {
+  return (Array.isArray(value) ? value : []).map((credit) => ({
+    status: cleanString(credit?.status).toLowerCase(),
+    expiresAt: resetAtMs(credit?.expires_at ?? credit?.expiresAt),
+    grantedAt: resetAtMs(credit?.granted_at ?? credit?.grantedAt),
+  }));
+}
+
+function normalizeOpenAICodexResetCredits(data, accountId = '') {
+  if (!data || typeof data !== 'object') return null;
+  const credits = normalizedResetCreditRows(data.credits);
+  const explicitCount = num(data.available_count ?? data.availableCount, null);
+  const availableRows = credits.filter((credit) => credit.status === 'available');
+  if (explicitCount === null && !credits.length) return null;
+  const availableCount = Math.max(0, Math.floor(explicitCount ?? availableRows.length));
+  const expiryCandidates = availableRows
+    .map((credit) => credit.expiresAt)
+    .filter((value) => Number.isFinite(value) && value > 0);
+  const nextExpiresAt = resetAtMs(data.next_expires_at ?? data.nextExpiresAt)
+    || (expiryCandidates.length ? Math.min(...expiryCandidates) : null);
+  const offerRevision = `v1:${createHash('sha256').update(JSON.stringify({
+    accountId,
+    availableCount,
+    nextExpiresAt,
+    credits,
+  })).digest('hex')}`;
+  return {
+    availableCount,
+    ...(nextExpiresAt ? { nextExpiresAt } : {}),
+    offerRevision,
+  };
+}
+
+async function resolveOpenAICodexAuth(providerObj) {
+  return codexAuthShape(await providerObj?.ensureAuth?.({ reason: 'usage' }));
+}
+
+async function fetchOpenAICodexResetCreditsWithAuth(auth) {
+  const response = await fetch(CODEX_RESET_CREDITS_URL, fetchOptions(codexHeaders(auth)));
+  if (!response.ok) return null;
+  return normalizeOpenAICodexResetCredits(await response.json(), auth.accountId);
+}
+
+export async function fetchOpenAICodexResetCredits(providerObj) {
+  const auth = await resolveOpenAICodexAuth(providerObj);
+  return auth ? await fetchOpenAICodexResetCreditsWithAuth(auth) : null;
+}
+
+function codexResetOutcome(code) {
+  if (code === 'reset') return 'reset';
+  if (code === 'nothing_to_reset') return 'nothingToReset';
+  if (code === 'no_credit') return 'noCredit';
+  if (code === 'already_redeemed') return 'alreadyRedeemed';
+  throw new Error(`Unknown Codex reset outcome: ${cleanString(code) || 'missing'}`);
+}
+
+export async function consumeOpenAICodexResetCredit(providerObj, options = {}) {
+  const expectedOfferRevision = cleanString(options?.expectedOfferRevision);
+  const idempotencyKey = cleanString(options?.idempotencyKey);
+  if (!/^v1:[a-f0-9]{64}$/i.test(expectedOfferRevision)) {
+    throw new TypeError('Codex reset offer revision is invalid');
+  }
+  if (!/^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i.test(idempotencyKey)) {
+    throw new TypeError('Codex reset idempotency key is invalid');
+  }
+  const auth = await resolveOpenAICodexAuth(providerObj);
+  if (!auth) throw new Error('Codex is not signed in');
+  const current = await fetchOpenAICodexResetCreditsWithAuth(auth);
+  if (!current || current.availableCount < 1 || current.offerRevision !== expectedOfferRevision) {
+    return { status: 'offerChanged', resetCredits: current };
+  }
+  const response = await fetch(CODEX_RESET_CONSUME_URL, {
+    ...fetchOptions({
+      ...codexHeaders(auth),
+      'Content-Type': 'application/json',
+    }, 15_000),
+    method: 'POST',
+    body: JSON.stringify({ redeem_request_id: idempotencyKey }),
+  });
+  if (!response.ok) throw new Error(`Codex reset failed: HTTP ${response.status}`);
+  const outcome = codexResetOutcome((await response.json())?.code);
+  const resetCredits = await fetchOpenAICodexResetCreditsWithAuth(auth).catch(() => null);
+  return { outcome, resetCredits };
+}
+
 function labelForDuration(seconds, fallback) {
   const s = num(seconds, 0);
   if (s > 0) {
@@ -482,19 +589,18 @@ function latestClaudeStatuslineUsage() {
 }
 
 async function fetchOpenAICodexUsage(providerObj) {
-  const auth = await providerObj?.ensureAuth?.({ reason: 'usage' });
-  const token = auth?.access_token || auth?.accessToken;
-  if (!token) return null;
-  const res = await fetch('https://chatgpt.com/backend-api/wham/usage', fetchOptions({
-    Authorization: `Bearer ${token}`,
-    originator: 'codex_cli_rs',
-    'chatgpt-account-id': auth.account_id || auth.accountId || '',
-    'OpenAI-Beta': 'responses=experimental',
-    Accept: 'application/json',
-  }));
+  const auth = await resolveOpenAICodexAuth(providerObj);
+  if (!auth) return null;
+  const [res, resetCredits] = await Promise.all([
+    fetch('https://chatgpt.com/backend-api/wham/usage', fetchOptions(
+      codexHeaders(auth, 'responses=experimental'),
+    )),
+    fetchOpenAICodexResetCreditsWithAuth(auth).catch(() => null),
+  ]);
   if (!res.ok) throw new Error(`openai-oauth usage ${res.status}`);
   const data = await res.json();
-  return normalizeOpenAIWhamUsage(data);
+  const usage = normalizeOpenAIWhamUsage(data);
+  return usage && resetCredits ? { ...usage, resetCredits } : usage;
 }
 
 async function fetchAnthropicUsage(providerObj) {
@@ -589,15 +695,18 @@ async function fetchGrokUsage(providerObj, routeInfo) {
   return null;
 }
 
-export async function fetchOAuthUsageSnapshot(routeInfo, providerObj, log = () => {}) {
+export async function fetchOAuthUsageSnapshot(routeInfo, providerObj, log = () => {}, options = {}) {
   const provider = providerKey(routeInfo);
   if (!provider.includes('oauth')) return null;
   const key = routeKey(routeInfo);
   const providerOnly = providerKey(routeInfo);
-  const cached = freshSnapshot(memoryCache.get(key), LIVE_CACHE_TTL_MS)
-    || freshSnapshot(memoryCache.get(providerOnly), LIVE_CACHE_TTL_MS);
-  if (cached) return cached;
-  if (negativeFresh(key) || negativeFresh(providerOnly)) return null;
+  const force = options?.force === true;
+  if (!force) {
+    const cached = freshSnapshot(memoryCache.get(key), LIVE_CACHE_TTL_MS)
+      || freshSnapshot(memoryCache.get(providerOnly), LIVE_CACHE_TTL_MS);
+    if (cached) return cached;
+    if (negativeFresh(key) || negativeFresh(providerOnly)) return null;
+  }
   if (inflight.has(key)) return inflight.get(key);
 
   const task = (async () => {

package/src/runtime/agent/orchestrator/session/manager.mjs

@@ -123,5 +123,8 @@ export {
     flushSessionMetrics,
 } from './manager/session-crud.mjs';
 export { deleteSession } from './store.mjs';
+// Read-only parsed-session access (desktop pane peek): no resume, no
+// ownership, no liveness side effects.
+export { loadSession } from './store.mjs';
 export { closeSession, abortSessionTurn } from './manager/session-close.mjs';
 export { sweepTombstones, startIdleCleanup, stopIdleCleanup } from './manager/idle-cleanup.mjs';

package/src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs

@@ -74,13 +74,20 @@ export const BUILTIN_TOOLS = [
         name: 'shell',
         title: 'Mixdog Shell',
         annotations: { title: 'Mixdog Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: `Run programs or change system state; not for reading, listing or searching. Independent calls in one turn run in parallel; order-dependent commands go in one command or later turns.${_shellSyntaxCheat} ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
+        description: 'Run programs/change state; not file inspection. Calls in one turn run parallel; '
+            + 'combine order-dependent commands. Use async for sleep/watch/dev loops.'
+            + `${_shellSyntaxCheat} ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
         inputSchema: {
             type: 'object',
             properties: {
                 command: { type: 'string', description: 'Command.' },
                 cwd: { type: 'string', description: 'Working directory; persists across calls. Omit to reuse; absolute path changes it.' },
-                timeout: { type: 'number', description: `Timeout ms; default ${_shellDefaultTimeoutMs()}. On sync timeout the command is promoted to a background task_id and keeps running, with any explicit timeout enforced as a background deadline. Sleep-like commands skip promotion: they block the full timeout, then are killed with a [timeout] marker. async runs until done/cancelled unless a timeout is set.` },
+                timeout: {
+                    type: 'number',
+                    description: `Timeout ms; default ${_shellDefaultTimeoutMs()}. `
+                        + 'Sync timeout may return task_id; explicit timeout becomes its deadline. '
+                        + 'Sleeps are killed, not promoted.',
+                },
                 merge_stderr: { type: 'boolean', description: 'Merge stderr.' },
                 mode: { type: 'string', enum: ['sync', 'async'], description: executionModeSchemaDescription('sync') },
                 shell: { type: 'string', enum: ['bash', 'powershell'], description: 'Force shell. Windows defaults to PowerShell; bash = Git Bash/POSIX.' },

package/src/runtime/agent/orchestrator/tools/env-scrub.mjs

@@ -110,5 +110,13 @@ export function scrubProviderSecrets(env) {
 export function scrubRuntimeRootVars(env) {
     if (!env || typeof env !== 'object') return env;
     delete env.MIXDOG_ROOT;
+    // Host-runtime leak: a packaged Electron/daemon host runs with
+    // NODE_ENV=production, and inheriting it silently corrupts model-spawned
+    // shells — `npm install` prunes devDependencies, React resolves its
+    // production build (no `act`), test suites flip red on developer machines
+    // while CI stays green. The value is OUR process's, not the user's OS
+    // env, so shells must not see it. A command that needs NODE_ENV sets it
+    // explicitly.
+    delete env.NODE_ENV;
     return env;
 }

package/src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs

@@ -19,14 +19,15 @@ eof_line: "*** End of File" LF
 %import common.LF
 `;
 
-const APPLY_PATCH_FREEFORM_DESCRIPTION = 'Use the `apply_patch` tool to edit files. This is a FREEFORM tool, so do not wrap the patch in JSON.';
+const APPLY_PATCH_FREEFORM_DESCRIPTION =
+  'Apply an atomic FREEFORM patch, not JSON. Use exact current context; roll back on failure.';
 
 export const PATCH_TOOL_DEFS = [
   {
     name: 'apply_patch',
     title: 'Mixdog Apply Patch',
     annotations: { title: 'Mixdog Apply Patch', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false, compressible: false, compressibleLossless: true },
-    description: 'Apply file edits in one patch; sections run in listed order and all touched paths roll back if any section fails. Do not split a dependent edit across turns.',
+    description: 'Apply one atomic patch; roll back all touched paths on failure.',
     freeformDescription: APPLY_PATCH_FREEFORM_DESCRIPTION,
     freeform: {
       type: 'grammar',
@@ -36,7 +37,7 @@ export const PATCH_TOOL_DEFS = [
     inputSchema: {
       type: 'object',
       properties: {
-        patch: { type: 'string', description: 'Patch text. V4A preferred; one file block per target file, 3 lines of exact context per hunk, @@ anchors when ambiguous; include all new edits in listed order. On failure, the tool rolls all earlier writes back.' },
+        patch: { type: 'string', description: 'V4A patch text; use exact current context; atomic rollback.' },
         format: { type: 'string', enum: ['unified', 'v4a'], description: 'Auto-detected.' },
         base_path: { type: 'string', description: 'Repo root.' },
         dry_run: { type: 'boolean', description: 'Default false. true = validate only, no write.' },

package/src/runtime/agent/orchestrator/tools/token-manifest.json

@@ -1,5 +1,26 @@
 {
   "version": "0.1.0",
-  "_comment": "Synced from immutable token-v release assets. Empty until the first token-v release is published; the runtime falls back to a local cargo build or the in-process WASM worker.",
-  "assets": {}
+  "_comment": "Synced from immutable token-v release assets.",
+  "assets": {
+    "darwin-arm64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/token-v0.1.0/mixdog-token-darwin-arm64",
+      "sha256": "1d5259803207dd5ace466c506d8db4087460a20c1e3f4f6cc249832a8a996f6b"
+    },
+    "darwin-x64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/token-v0.1.0/mixdog-token-darwin-x64",
+      "sha256": "2212a434a89419ce0a4122ce4647e2feb2b4642e26d3e74e11b4de2819a6c2e3"
+    },
+    "linux-arm64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/token-v0.1.0/mixdog-token-linux-arm64",
+      "sha256": "332839da398050218fbed4b6700a3e34dbdcba800893b9a3ba16ebca3e88b9ee"
+    },
+    "linux-x64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/token-v0.1.0/mixdog-token-linux-x64",
+      "sha256": "ac79201259985705cf378d225a25a779591d1f75fefd626e470b398e3d8fdd9c"
+    },
+    "win32-x64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/token-v0.1.0/mixdog-token-win32-x64.exe",
+      "sha256": "da6e39974811123b3e0c72f539c9e5b424261b66a3f2a30eb0e9cc837036d1ba"
+    }
+  }
 }

package/src/runtime/memory/lib/memory-action-handlers.mjs

@@ -877,7 +877,10 @@ export function createMemoryActionHandlers({
       return { text: `retro_eval_active: total=${total} archived=${archived} kept=${kept} updated=${updated} merged=${merged} errors=${errors}` }
     }
 
-    return { text: `unknown memory action: ${action}`, isError: true }
+    return {
+      text: `unknown memory action: ${action}; valid: core, status. Mutation verbs belong in op.`,
+      isError: true,
+    }
   }
 
   const handleToolCall = createToolCallHandler({ handleSearch, handleMemoryAction })

package/src/runtime/memory/tool-defs.mjs

@@ -8,12 +8,24 @@ export const TOOL_DEFS = [
     name: 'memory',
     title: 'Memory Cycle',
     annotations: { title: 'Memory Cycle', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
-    description: 'Core-memory mutation and status; use recall for retrieval. Store durable rules/preferences/facts, one compact ENGLISH clause each — never transient task state. add requires project_id+summary; edit works by id alone.',
+    description: [
+      'Core-memory mutation/status; recall retrieves.',
+      'Mutations use action=core with op; status uses action=status.',
+      'Store only durable compact ENGLISH facts/rules/preferences.',
+    ].join(' '),
     inputSchema: {
       type: 'object',
       properties: {
-        action: { type: 'string', enum: ['core','status'], description: 'Operation.' },
-        op: { type: 'string', enum: ['add','edit','delete','list','candidates','promote','dismiss'], description: 'Mutation op. candidates/promote/dismiss drive core-memory proposal approval.' },
+        action: {
+          type: 'string',
+          enum: ['core','status'],
+          description: 'core for mutations; status otherwise. Mutation verbs belong in op.',
+        },
+        op: {
+          type: 'string',
+          enum: ['add','edit','delete','list','candidates','promote','dismiss'],
+          description: 'Required for action=core.',
+        },
         id: { type: 'number', description: 'Exact memory id.' },
         element: { type: 'string', maxLength: 40, description: 'Memory key/title. Defaults to the first 40 chars of summary. Max 40 chars.' },
         summary: { type: 'string', maxLength: 100, description: 'Memory content: one short English clause, max 100 chars.' },
@@ -22,6 +34,10 @@ export const TOOL_DEFS = [
         confirm: { type: 'string', description: 'Exact confirmation phrase for destructive actions.' },
         project_id: { type: 'string', description: 'Core pool: explicit common or slug. Required for core add only (edit uses the id\'s stored pool); there is no default pool.' },
       },
+      anyOf: [
+        { properties: { action: { const: 'status' } }, required: ['action'] },
+        { properties: { action: { const: 'core' } }, required: ['action', 'op'] },
+      ],
       additionalProperties: false,
       required: ['action'],
     },

package/src/session-runtime/lifecycle-api.mjs

@@ -407,6 +407,21 @@ export function createLifecycleApi(deps) {
     prefetchSession(id) {
       return mgr.prefetchSession?.(id, toolSpecForMode(getMode())) === true;
     },
+    // Read-only session peek (desktop split panes treat every visible pane as
+    // foreground): the parsed session object without resuming, attaching, or
+    // touching ownership/liveness. The current session returns live memory.
+    peekSession(id) {
+      const sessionId = clean(id);
+      if (!sessionId || !/^[A-Za-z0-9_-]+$/.test(sessionId)) return null;
+      const current = getSession();
+      if (current?.id === sessionId) return current;
+      const session = mgr.loadSession?.(sessionId);
+      // `closed` means the previous live owner released this durable session;
+      // it is still a valid historical transcript. Desktop pane peeks are
+      // strictly read-only, so they may inspect it without resuming or
+      // changing ownership. Deleted/tombstoned sessions have no load result.
+      return session || null;
+    },
     async resume(id) {
       clearRoutePreparation?.();
       const prev = getSession();

package/src/session-runtime/provider-auth-api.mjs

@@ -31,6 +31,7 @@ export function createProviderAuthApi({
   refreshProviderCatalogs,
   cachedProviderSetup,
   getUsageDashboard,
+  consumeCodexRateLimitResetCredit,
   collectProviderModels,
 }) {
   function refreshProviderCatalogsSoon() {
@@ -79,6 +80,13 @@ export function createProviderAuthApi({
     async getUsageDashboard(options = {}) {
       return await getUsageDashboard(options);
     },
+    async consumeCodexRateLimitResetCredit(options = {}) {
+      await awaitKeychainPrewarm();
+      if (typeof consumeCodexRateLimitResetCredit !== 'function') {
+        throw new Error('Codex reset is unavailable');
+      }
+      return await consumeCodexRateLimitResetCredit(options);
+    },
     async authenticateProvider(providerId, secret) {
       await awaitKeychainPrewarm();
       const result = String(secret || '').trim()

package/src/session-runtime/provider-usage.mjs

@@ -14,6 +14,7 @@ export function createProviderUsage({
   providerSetup,
   createUsageDashboard,
   fetchOAuthUsageSnapshot,
+  consumeOpenAICodexResetCredit,
   isCloseRequested,
   getProviderSetupWarmupTimer,
   scheduleProviderSetupWarmup,
@@ -64,8 +65,9 @@ export function createProviderUsage({
   }
 
   async function getUsageDashboard(options = {}) {
-    const forceSetup = options?.force === true || options?.refresh === true;
-    if (!forceSetup && caches.usageDashboardCache.dashboard) {
+    const refreshUsage = options?.refresh === true;
+    const forceSetup = options?.force === true || (refreshUsage && options?.refreshSetup !== false);
+    if (!forceSetup && !refreshUsage && caches.usageDashboardCache.dashboard) {
       const cached = {
         ...caches.usageDashboardCache.dashboard,
         refresh: false,
@@ -78,7 +80,7 @@ export function createProviderUsage({
       }
       return cached;
     }
-    if (!forceSetup && caches.usageDashboardPromise) return await caches.usageDashboardPromise;
+    if (!forceSetup && !refreshUsage && caches.usageDashboardPromise) return await caches.usageDashboardPromise;
     const quickSetup = options?.quickSetup !== false;
     const getProvider = (providerId) => reg().getProvider(providerId);
     const log = (message) => {
@@ -98,16 +100,26 @@ export function createProviderUsage({
       });
     }
     const buildDashboard = async () => {
+      let setup;
+      try {
+        setup = await cachedProviderSetup({ force: forceSetup, quick: false });
+      } catch {
+        // One unavailable keychain/provider descriptor must not take down the
+        // whole dashboard. The no-secrets/no-local snapshot still lets cached
+        // and provider-native quota windows refresh.
+        log('provider setup failed; falling back to quick setup');
+        setup = await cachedProviderSetup({ force: forceSetup, quick: true });
+      }
       const dashboard = await createUsageDashboard(displayConfig(), {
         ...(options || {}),
-        setup: await cachedProviderSetup({ force: forceSetup, quick: false }),
+        setup,
         getProvider,
         log,
       });
       caches.usageDashboardCache = { dashboard, at: Date.now() };
       return dashboard;
     };
-    if (forceSetup) return await buildDashboard();
+    if (forceSetup || refreshUsage) return await buildDashboard();
     caches.usageDashboardPromise = buildDashboard()
       .finally(() => {
         caches.usageDashboardPromise = null;
@@ -115,6 +127,18 @@ export function createProviderUsage({
     return await caches.usageDashboardPromise;
   }
 
+  async function consumeCodexRateLimitResetCredit(options = {}) {
+    if (typeof consumeOpenAICodexResetCredit !== 'function') {
+      throw new Error('Codex reset is unavailable');
+    }
+    const providerObj = reg().getProvider('openai-oauth');
+    if (!providerObj) throw new Error('Codex is not signed in');
+    const result = await consumeOpenAICodexResetCredit(providerObj, options);
+    caches.usageDashboardCache = {};
+    const dashboard = await getUsageDashboard({ refresh: true, refreshSetup: false });
+    return { ...result, dashboard };
+  }
+
   return {
     refreshStatuslineUsageSnapshot,
     cachedProviderSetup,
@@ -122,5 +146,6 @@ export function createProviderUsage({
     // (settings hydration) can serve the quick snapshot until then.
     hasProviderSetupCached: () => Boolean(caches.providerSetupCache.setup),
     getUsageDashboard,
+    consumeCodexRateLimitResetCredit,
   };
 }