Treat caches as best-effort

Author: Krablante

scripts/benchmark-local.mjs

@@ -127,7 +127,7 @@ function printRows(rows) {
   console.log('| --- | ---: | ---: | --- |');
   for (const row of rows) {
     const time = row.timedOut ? `>${row.wallSeconds.toFixed(2)}s` : `${row.wallSeconds.toFixed(2)}s`;
-    const ram = row.maxRssKb == null ? 'n/a' : `${(row.maxRssKb / 1024 / 1024).toFixed(2)} GB`;
+    const ram = row.maxRssKb == null ? 'n/a' : `${(row.maxRssKb / 1_000_000).toFixed(2)} GB`;
     const result = row.timedOut ? `timed out (${row.status})` : row.status === 0 ? 'complete' : `exit ${row.status}`;
     console.log(`| ${row.label} | ${time} | ${ram} | ${result} |`);
   }

src/engine.mjs

@@ -102,19 +102,24 @@ export async function collectUsage(options = {}) {
   const report = buildReport(aggregate, stats, nextFiles);
 
   if (saveCache) {
-    const saveResult = await saveCacheFile(cacheFile, {
-      version: CACHE_VERSION,
-      source: CACHE_SOURCE,
-      timezone,
-      billingThresholds,
-      updatedAt: new Date().toISOString(),
-      files: nextFiles,
-    }, maxCacheBytes);
-    report.stats.cacheBytes = saveResult.bytes;
-    report.stats.cacheSaveSkippedBySize = !saveResult.saved;
-    if (saveResult.saved) {
-      report.stats.cacheFile = cacheFile;
-      report.stats.cacheEntriesSaved = Object.keys(nextFiles).length;
+    try {
+      const saveResult = await saveCacheFile(cacheFile, {
+        version: CACHE_VERSION,
+        source: CACHE_SOURCE,
+        timezone,
+        billingThresholds,
+        updatedAt: new Date().toISOString(),
+        files: nextFiles,
+      }, maxCacheBytes);
+      report.stats.cacheBytes = saveResult.bytes;
+      report.stats.cacheSaveSkippedBySize = !saveResult.saved;
+      if (saveResult.saved) {
+        report.stats.cacheFile = cacheFile;
+        report.stats.cacheEntriesSaved = Object.keys(nextFiles).length;
+      }
+    } catch (error) {
+      report.stats.cacheSaveSkippedByError = true;
+      report.stats.cacheSaveError = error?.message ?? String(error);
     }
   } else {
     report.stats.cacheSaveSkippedBySize = false;
@@ -782,6 +787,8 @@ function createStats(cache, timezone, billingThresholds = DEFAULT_BILLING_THRESH
     bytesSkippedByTailCache: 0,
     cacheEntriesLoaded: Object.keys(cache.files).length,
     cacheEntriesSaved: 0,
+    cacheSaveSkippedByError: false,
+    cacheSaveError: null,
     discoveryMode: null,
   };
 }

src/pricing.mjs

@@ -143,17 +143,25 @@ export async function loadPricingCatalog(options = {}) {
 
   try {
     const fetched = await fetchLivePricing({ tier, timeoutMs: options.fetchTimeoutMs, priorityModels });
-    await savePricingCache(cacheFile, fetched);
+    let cacheState = cached ? 'refreshed' : 'created';
+    let cacheSaveError = null;
+    try {
+      await savePricingCache(cacheFile, fetched);
+    } catch (error) {
+      cacheState = cached ? 'refreshed-cache-save-failed' : 'created-cache-save-failed';
+      cacheSaveError = error?.message ?? String(error);
+    }
     return createCatalog(fetched.data, {
       source: fetched.source,
       sourceUrl: fetched.sourceUrl,
       fetchedAt: fetched.fetchedAt,
       cacheFile,
-      cacheState: cached ? 'refreshed' : 'created',
+      cacheState,
       ttlHours: ttlMs / 3_600_000,
       modelCount: Object.keys(fetched.data).length,
       tier,
       priorityModels,
+      cacheSaveError,
     });
   } catch (error) {
     const source = cachedForTier?.data ?? bundledPricingData(tier, { priorityModels });

test/engine.test.mjs

@@ -249,6 +249,38 @@ assert.equal(saveCap.stats.cacheSaveSkippedBySize, true);
 assert.equal(saveCap.stats.cacheEntriesSaved, 0);
 assert.equal(saveCap.totals.totalTokens, 7000);
 
+const blockedCacheHome = path.join(root, 'blocked-cache-codex-home');
+const blockedCacheSessions = path.join(blockedCacheHome, 'sessions/2026/05/16');
+await mkdir(blockedCacheSessions, { recursive: true });
+await writeFile(
+  path.join(blockedCacheSessions, 'blocked-cache.jsonl'),
+  [
+    JSON.stringify({ timestamp: '2026-05-16T00:00:00.000Z', type: 'turn_context', payload: { model: 'gpt-test' } }),
+    JSON.stringify({
+      timestamp: '2026-05-16T00:00:01.000Z',
+      type: 'event_msg',
+      payload: {
+        type: 'token_count',
+        info: { last_token_usage: { input_tokens: 3, cached_input_tokens: 1, output_tokens: 2, total_tokens: 5 } },
+      },
+    }),
+    '',
+  ].join('\n'),
+);
+const cachePathBlocker = path.join(root, 'cache-path-blocker');
+await writeFile(cachePathBlocker, 'not a directory');
+const blockedCacheReport = await collectUsage({
+  codexHome: blockedCacheHome,
+  cacheFile: path.join(cachePathBlocker, 'index.json'),
+  timezone: 'UTC',
+  includePricing: false,
+});
+assert.equal(blockedCacheReport.totals.totalTokens, 5);
+assert.equal(blockedCacheReport.stats.cacheSaveSkippedByError, true);
+assert.match(blockedCacheReport.stats.cacheSaveError, /EEXIST|ENOTDIR|not a directory/i);
+assert.equal(blockedCacheReport.stats.cacheEntriesSaved, 0);
+assert.equal(blockedCacheReport.stats.cacheFile, null);
+
 assert.throws(() => normalizeDate('2026-02-30'), /Invalid date/);
 assert.throws(() => normalizeDate('2026-99-99'), /Invalid date/);
 

test/pricing.test.mjs

@@ -348,6 +348,31 @@ try {
   globalThis.fetch = officialPriorityFetch;
 }
 
+const cacheSaveFailureFetch = globalThis.fetch;
+const pricingCachePathBlocker = path.join(root, 'pricing-cache-path-blocker');
+await writeFile(pricingCachePathBlocker, 'not a directory');
+globalThis.fetch = async () => ({
+  ok: true,
+  text: async () => `
+    <div component-export="TextTokenPricingTables" props="&quot;tier&quot;:[0,&quot;standard&quot;],[0,&quot;gpt-live-cache-fail&quot;],[0,9],[0,0.9],[0,18]"></div>
+  `,
+});
+try {
+  const cacheSaveFailureCatalog = await loadPricingCatalog({
+    cacheFile: path.join(pricingCachePathBlocker, 'pricing.json'),
+    ttlMs: 0,
+    fetchTimeoutMs: 1000,
+  });
+  assert.equal(cacheSaveFailureCatalog.metadata.cacheState, 'created-cache-save-failed');
+  assert.match(cacheSaveFailureCatalog.metadata.cacheSaveError, /EEXIST|ENOTDIR|not a directory/i);
+  const livePriceAfterCacheSaveFailure = cacheSaveFailureCatalog.getPricing('gpt-live-cache-fail');
+  assert.equal(livePriceAfterCacheSaveFailure.missing, false);
+  assert.equal(livePriceAfterCacheSaveFailure.detail.source, 'openai-official');
+  assert.equal(livePriceAfterCacheSaveFailure.price.inputCostPerMToken, 9);
+} finally {
+  globalThis.fetch = cacheSaveFailureFetch;
+}
+
 const tierFallbackCatalog = await loadPricingCatalog({
   tier: 'priority',
   pricingData: {