switchroom 0.11.1 → 0.12.1

package/telegram-plugin/tests/auto-fallback-fleet.test.ts

@@ -44,7 +44,7 @@ describe('runFleetAutoFallback', () => {
       fanned: ['alice', 'bob'],
     }));
     const out = await runFleetAutoFallback({
-      state: state('ken@x', ['ken@x', 'me@x', 'pixsoul@x']),
+      state: state('ken@x', ['ken@x', 'me@x', 'you@x']),
       quotas: [
         // ken: just blew 5h
         qOk({
@@ -58,7 +58,7 @@ describe('runFleetAutoFallback', () => {
           sevenDayResetAt: new Date('2026-05-17T10:00:00Z'),
           representativeClaim: 'seven_day',
         }),
-        // pixsoul: healthy 5h/7d
+        // you: healthy 5h/7d
         qOk({ fiveHourUtilizationPct: 8, sevenDayUtilizationPct: 20 }),
       ],
       setActive,
@@ -69,10 +69,10 @@ describe('runFleetAutoFallback', () => {
 
     expect(out.kind).toBe('switched');
     expect(setActive).toHaveBeenCalledTimes(1);
-    expect(setActive).toHaveBeenCalledWith('pixsoul@x');
+    expect(setActive).toHaveBeenCalledWith('you@x');
     if (out.kind === 'switched') {
       expect(out.oldLabel).toBe('ken@x');
-      expect(out.newLabel).toBe('pixsoul@x');
+      expect(out.newLabel).toBe('you@x');
       expect(out.announcement).toContain('5-hour limit on ken@x');
       expect(out.announcement).toContain('Triggered by: agent <b>carrie</b>');
       expect(out.announcement).toContain('plenty of headroom');
@@ -112,7 +112,7 @@ describe('runFleetAutoFallback', () => {
   it('idempotency: skips swap when active probes healthy (stale event)', async () => {
     const setActive = vi.fn();
     const out = await runFleetAutoFallback({
-      state: state('ken@x', ['ken@x', 'pixsoul@x']),
+      state: state('ken@x', ['ken@x', 'you@x']),
       quotas: [
         qOk({ fiveHourUtilizationPct: 5, sevenDayUtilizationPct: 10 }),
         qOk({ fiveHourUtilizationPct: 5, sevenDayUtilizationPct: 10 }),
@@ -147,14 +147,14 @@ describe('runFleetAutoFallback', () => {
   it('falls back to a throttling alternative when no healthy one exists', async () => {
     const setActive = vi.fn(async (label: string) => ({ active: label, fanned: [] }));
     const out = await runFleetAutoFallback({
-      state: state('ken@x', ['ken@x', 'pixsoul@x']),
+      state: state('ken@x', ['ken@x', 'you@x']),
       quotas: [
         qOk({
           fiveHourUtilizationPct: 100,
           fiveHourResetAt: new Date('2026-05-15T05:50:00Z'),
           representativeClaim: 'five_hour',
         }),
-        // pixsoul throttling at 85% but not blocked
+        // you throttling at 85% but not blocked
         qOk({ fiveHourUtilizationPct: 85, sevenDayUtilizationPct: 20 }),
       ],
       setActive,
@@ -164,7 +164,7 @@ describe('runFleetAutoFallback', () => {
     });
 
     expect(out.kind).toBe('switched');
-    expect(setActive).toHaveBeenCalledWith('pixsoul@x');
+    expect(setActive).toHaveBeenCalledWith('you@x');
     if (out.kind === 'switched') {
       expect(out.announcement).toContain('near limit — watch this');
     }
@@ -173,7 +173,7 @@ describe('runFleetAutoFallback', () => {
   it('skips unknown-health (probe failed) when picking a target', async () => {
     const setActive = vi.fn(async (label: string) => ({ active: label, fanned: [] }));
     const out = await runFleetAutoFallback({
-      state: state('ken@x', ['ken@x', 'broken@x', 'pixsoul@x']),
+      state: state('ken@x', ['ken@x', 'broken@x', 'you@x']),
       quotas: [
         qOk({ fiveHourUtilizationPct: 100, fiveHourResetAt: new Date('2026-05-15T05:50:00Z') }),
         { ok: false, reason: 'HTTP 401' },
@@ -186,7 +186,7 @@ describe('runFleetAutoFallback', () => {
     });
 
     expect(out.kind).toBe('switched');
-    expect(setActive).toHaveBeenCalledWith('pixsoul@x');
+    expect(setActive).toHaveBeenCalledWith('you@x');
   });
 });
 

package/telegram-plugin/tests/boot-probes.test.ts

@@ -292,6 +292,59 @@ describe('probeQuota — #1163: /v1/messages headers path', () => {
     expect(result.detail).toContain('18% / 7d')
   })
 
+  it('prefers the broker probe and does NOT do a direct fetch when it succeeds (Option A / #1336)', async () => {
+    const directFetch: typeof fetch = async () => {
+      throw new Error('direct fetch must not run when the broker probe returns a result')
+    }
+    const brokerProbe = async () => ({
+      ok: true as const,
+      data: {
+        fiveHourUtilizationPct: 30,
+        sevenDayUtilizationPct: 12,
+        fiveHourResetAt: null,
+        sevenDayResetAt: null,
+        representativeClaim: null,
+        overageStatus: null,
+        overageDisabledReason: null,
+      },
+    })
+    const result = await probeQuota(claudeDir, agentDir, directFetch, { brokerProbe })
+    expect(result.status).toBe('ok')
+    expect(result.detail).toContain('30% / 5h')
+    expect(result.detail).toContain('12% / 7d')
+  })
+
+  it('falls back to a direct probe when the broker probe returns null (broker unreachable)', async () => {
+    const headers = new Headers({
+      'anthropic-ratelimit-unified-5h-utilization': '0.55',
+      'anthropic-ratelimit-unified-7d-utilization': '0.22',
+    })
+    const directFetch: typeof fetch = async () =>
+      new Response('{}', { status: 200, headers }) as Response
+    const brokerProbe = async () => null
+
+    const result = await probeQuota(claudeDir, agentDir, directFetch, { brokerProbe })
+    expect(result.status).toBe('ok')
+    expect(result.detail).toContain('55% / 5h')
+    expect(result.detail).toContain('22% / 7d')
+  })
+
+  it('falls back to a direct probe when the broker probe throws', async () => {
+    const headers = new Headers({
+      'anthropic-ratelimit-unified-5h-utilization': '0.10',
+      'anthropic-ratelimit-unified-7d-utilization': '0.05',
+    })
+    const directFetch: typeof fetch = async () =>
+      new Response('{}', { status: 200, headers }) as Response
+    const brokerProbe = async () => {
+      throw new Error('broker UDS connect failed')
+    }
+
+    const result = await probeQuota(claudeDir, agentDir, directFetch, { brokerProbe })
+    expect(result.status).toBe('ok')
+    expect(result.detail).toContain('10% / 5h')
+  })
+
   it('surfaces auth rejection with the RFC-H replace-account hint on 403', async () => {
     const fakeFetch: typeof fetch = async () =>
       new Response(null, { status: 403 }) as Response
@@ -830,7 +883,7 @@ describe('probeSkills', () => {
     expect(result.detail).toContain('no skills dir')
   })
 
-  it('returns ok with count when every skill resolves', async () => {
+  it('returns ok with every skill listed under Switchroom bucket when no overlay', async () => {
     const fs = makeSkillsFs(
       { [skillsDir]: ['simplify', 'review'] },
       new Set([
@@ -840,7 +893,40 @@ describe('probeSkills', () => {
     )
     const result = await probeSkills(agentDir, { fs })
     expect(result.status).toBe('ok')
-    expect(result.detail).toContain('2 resolved')
+    expect(result.detail).toBe('Switchroom: review, simplify')
+  })
+
+  it('buckets overlay-installed skills under Agent', async () => {
+    const overlayDir = '/state/agent/skills.d'
+    const fs = makeSkillsFs(
+      {
+        [skillsDir]: ['simplify', 'review', 'webapp-testing'],
+        [overlayDir]: ['webapp-testing.yaml'],
+      },
+      new Set([
+        `${skillsDir}/simplify`, `${skillsDir}/simplify/SKILL.md`,
+        `${skillsDir}/review`, `${skillsDir}/review/SKILL.md`,
+        `${skillsDir}/webapp-testing`, `${skillsDir}/webapp-testing/SKILL.md`,
+        overlayDir,
+      ]),
+    )
+    const result = await probeSkills(agentDir, { fs })
+    expect(result.status).toBe('ok')
+    expect(result.detail).toBe('Switchroom: review, simplify · Agent: webapp-testing')
+  })
+
+  it('lists every skill without a +N more truncation in the healthy case', async () => {
+    const names = Array.from({ length: 12 }, (_, i) => `skill-${i.toString().padStart(2, '0')}`)
+    const fileSet = new Set<string>()
+    for (const n of names) {
+      fileSet.add(`${skillsDir}/${n}`)
+      fileSet.add(`${skillsDir}/${n}/SKILL.md`)
+    }
+    const fs = makeSkillsFs({ [skillsDir]: names }, fileSet)
+    const result = await probeSkills(agentDir, { fs })
+    expect(result.status).toBe('ok')
+    expect(result.detail).not.toContain('+')
+    for (const n of names) expect(result.detail).toContain(n)
   })
 
   it('degraded when at least one symlink dangles, names them up to cap', async () => {
@@ -859,6 +945,8 @@ describe('probeSkills', () => {
     expect(result.detail).toContain('also-gone')
     expect(result.detail).toContain('+1 more')
     expect(result.detail).not.toContain('and-this')
+    // resolved skills still surface alongside the dangling summary
+    expect(result.detail).toContain('Switchroom: review, simplify')
   })
 
   it('returns ok when entries dir is empty', async () => {

package/telegram-plugin/tests/bot-runtime.test.ts

@@ -7,7 +7,7 @@
  * via integration tests; here we keep it to pure unit coverage.
  */
 
-import { describe, it, expect, vi } from 'vitest'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import {
   escapeHtmlForTg,
   preBlock,
@@ -20,6 +20,28 @@ import {
 } from '../shared/bot-runtime.js'
 import type { Context } from 'grammy'
 
+// ─── env hygiene ─────────────────────────────────────────────────────────
+// The exec factories read SWITCHROOM_CONFIG and prepend `--config <path>` to
+// argv. When the test runner inherits SWITCHROOM_CONFIG from the environment
+// (e.g. switchroom-managed shells), this leaks into tests that use `echo`
+// as the cliPath and breaks stdout assertions. Clear before each test and
+// restore after.
+
+let savedSwitchroomConfig: string | undefined
+
+beforeEach(() => {
+  savedSwitchroomConfig = process.env.SWITCHROOM_CONFIG
+  delete process.env.SWITCHROOM_CONFIG
+})
+
+afterEach(() => {
+  if (savedSwitchroomConfig !== undefined) {
+    process.env.SWITCHROOM_CONFIG = savedSwitchroomConfig
+  } else {
+    delete process.env.SWITCHROOM_CONFIG
+  }
+})
+
 // ─── escapeHtmlForTg ─────────────────────────────────────────────────────
 
 describe('escapeHtmlForTg', () => {

package/telegram-plugin/tests/fixtures/service-log-current-claude-code.bin

@@ -339,7 +339,7 @@
 
 
 
-
+
 ❯  
 ────────────────────────────────────────────────────────────────────────────────
 ⏵⏵accepteditson(shift+tabtocycle)·esctointerrupt

package/telegram-plugin/tests/fleet-state.test.ts

@@ -155,8 +155,9 @@ describe('sanitiseToolArg', () => {
     expect(sanitiseToolArg('Write', { file_path: '/tmp/out.json' })).toBe('out.json')
   })
   it('redacts bearer-token-like strings in Bash commands', () => {
-    const out = sanitiseToolArg('Bash', { command: 'curl -H "Authorization: Bearer sk-ant-1234567890abcdef" https://x' })
-    expect(out).not.toContain('sk-ant-1234567890abcdef')
+    const tok = ['sk-ant-', '1234567890abcdef'].join('')
+    const out = sanitiseToolArg('Bash', { command: `curl -H "Authorization: Bearer ${tok}" https://x` })
+    expect(out).not.toContain(tok)
     expect(out.toLowerCase()).toContain('redacted')
   })
   it('returns empty string when no recognisable arg', () => {

package/telegram-plugin/tests/quota-check.test.ts

@@ -7,12 +7,6 @@ import {
   formatQuotaBlock,
   formatQuotaLine,
   parseQuotaHeaders,
-  readAccountAccessToken,
-  fetchAccountQuota,
-  getCachedAccountQuota,
-  prefetchAccountQuotaIfStale,
-  clearAccountQuotaCache,
-  ACCOUNT_QUOTA_CACHE_TTL_MS,
 } from '../quota-check.js'
 
 function makeTempClaudeDir(token: string | null): string {
@@ -189,409 +183,6 @@ describe('fetchQuota', () => {
   })
 })
 
-// ─── Account-level helpers ────────────────────────────────────────────
-
-/** Build a fake $HOME with `~/.switchroom/accounts/<label>/credentials.json`. */
-function makeAccountHome(
-  accounts: Record<string, { accessToken?: string }>,
-): string {
-  const home = mkdtempSync(join(tmpdir(), 'quota-acct-test-'))
-  for (const [label, creds] of Object.entries(accounts)) {
-    const dir = join(home, '.switchroom', 'accounts', label)
-    mkdirSync(dir, { recursive: true })
-    if (creds.accessToken !== undefined) {
-      writeFileSync(
-        join(dir, 'credentials.json'),
-        JSON.stringify({ claudeAiOauth: { accessToken: creds.accessToken } }),
-      )
-    }
-  }
-  return home
-}
-
-describe('readAccountAccessToken', () => {
-  it('returns the access token from credentials.json', () => {
-    const home = makeAccountHome({
-      'pixsoul@gmail.com': { accessToken: 'sk-ant-oat01-fake' },
-    })
-    try {
-      expect(readAccountAccessToken('pixsoul@gmail.com', home)).toBe(
-        'sk-ant-oat01-fake',
-      )
-    } finally {
-      rmSync(home, { recursive: true, force: true })
-    }
-  })
-
-  it('returns null when the account dir is missing', () => {
-    const home = makeAccountHome({})
-    try {
-      expect(readAccountAccessToken('absent', home)).toBeNull()
-    } finally {
-      rmSync(home, { recursive: true, force: true })
-    }
-  })
-
-  it('returns null when accessToken is empty', () => {
-    const home = makeAccountHome({
-      'empty@example.com': { accessToken: '' },
-    })
-    try {
-      expect(readAccountAccessToken('empty@example.com', home)).toBeNull()
-    } finally {
-      rmSync(home, { recursive: true, force: true })
-    }
-  })
-
-  it('returns null when credentials.json is malformed', () => {
-    const home = mkdtempSync(join(tmpdir(), 'quota-acct-bad-'))
-    const dir = join(home, '.switchroom', 'accounts', 'broken')
-    mkdirSync(dir, { recursive: true })
-    writeFileSync(join(dir, 'credentials.json'), '{not json')
-    try {
-      expect(readAccountAccessToken('broken', home)).toBeNull()
-    } finally {
-      rmSync(home, { recursive: true, force: true })
-    }
-  })
-})
-
-describe('fetchAccountQuota — cache + token resolution', () => {
-  beforeEach(() => {
-    clearAccountQuotaCache()
-  })
-
-  it('fetches once, returns cached on subsequent calls within TTL', async () => {
-    const home = makeAccountHome({
-      'work@example.com': { accessToken: 'tok' },
-    })
-    let callCount = 0
-    const fakeFetch = async () => {
-      callCount++
-      return new Response('{}', {
-        status: 200,
-        headers: {
-          'anthropic-ratelimit-unified-5h-utilization': '0.42',
-          'anthropic-ratelimit-unified-7d-utilization': '0.17',
-        },
-      })
-    }
-    try {
-      const r1 = await fetchAccountQuota('work@example.com', {
-        home,
-        fetchImpl: fakeFetch as typeof fetch,
-      })
-      const r2 = await fetchAccountQuota('work@example.com', {
-        home,
-        fetchImpl: fakeFetch as typeof fetch,
-      })
-      expect(r1.ok).toBe(true)
-      expect(r2.ok).toBe(true)
-      expect(callCount).toBe(1) // cache hit on the second call
-    } finally {
-      rmSync(home, { recursive: true, force: true })
-    }
-  })
-
-  it('force=true bypasses the cache', async () => {
-    const home = makeAccountHome({
-      'work@example.com': { accessToken: 'tok' },
-    })
-    let callCount = 0
-    const fakeFetch = async () => {
-      callCount++
-      return new Response('{}', {
-        status: 200,
-        headers: {
-          'anthropic-ratelimit-unified-5h-utilization': '0.5',
-          'anthropic-ratelimit-unified-7d-utilization': '0.5',
-        },
-      })
-    }
-    try {
-      await fetchAccountQuota('work@example.com', {
-        home,
-        fetchImpl: fakeFetch as typeof fetch,
-      })
-      await fetchAccountQuota('work@example.com', {
-        home,
-        fetchImpl: fakeFetch as typeof fetch,
-        force: true,
-      })
-      expect(callCount).toBe(2)
-    } finally {
-      rmSync(home, { recursive: true, force: true })
-    }
-  })
-
-  it('caches missing-credentials failures so the API is not pinged', async () => {
-    const home = makeAccountHome({})
-    let callCount = 0
-    const fakeFetch = async () => {
-      callCount++
-      return new Response('{}')
-    }
-    const r1 = await fetchAccountQuota('absent', {
-      home,
-      fetchImpl: fakeFetch as typeof fetch,
-    })
-    const r2 = await fetchAccountQuota('absent', {
-      home,
-      fetchImpl: fakeFetch as typeof fetch,
-    })
-    expect(r1.ok).toBe(false)
-    expect(r2.ok).toBe(false)
-    expect(callCount).toBe(0) // never reached fetch — token resolution failed first
-  })
-
-  it('cache miss after TTL triggers a fresh fetch', async () => {
-    const home = makeAccountHome({
-      'work@example.com': { accessToken: 'tok' },
-    })
-    let callCount = 0
-    const fakeFetch = async () => {
-      callCount++
-      return new Response('{}', {
-        status: 200,
-        headers: {
-          'anthropic-ratelimit-unified-5h-utilization': '0.3',
-          'anthropic-ratelimit-unified-7d-utilization': '0.3',
-        },
-      })
-    }
-    let nowVal = 1_000_000
-    const now = () => nowVal
-    try {
-      await fetchAccountQuota('work@example.com', {
-        home,
-        fetchImpl: fakeFetch as typeof fetch,
-        now,
-      })
-      // Step time past the TTL.
-      nowVal += ACCOUNT_QUOTA_CACHE_TTL_MS + 1
-      await fetchAccountQuota('work@example.com', {
-        home,
-        fetchImpl: fakeFetch as typeof fetch,
-        now,
-      })
-      expect(callCount).toBe(2)
-    } finally {
-      rmSync(home, { recursive: true, force: true })
-    }
-  })
-
-  // Removed in RFC H: per-account quota.json disk persistence is gone.
-  // switchroom-auth-broker holds canonical quota state and exposes it
-  // via list-state; the gateway's in-process cache is enough between
-  // restarts (and the broker survives gateway restarts, so the state
-  // is preserved at the broker side anyway).
-})
-
-describe('getCachedAccountQuota + prefetchAccountQuotaIfStale', () => {
-  beforeEach(() => {
-    clearAccountQuotaCache()
-  })
-
-  it('returns null on a cold cache, populates after a fetch', async () => {
-    const home = makeAccountHome({
-      'work@example.com': { accessToken: 'tok' },
-    })
-    try {
-      expect(getCachedAccountQuota('work@example.com')).toBeNull()
-      await fetchAccountQuota('work@example.com', {
-        home,
-        fetchImpl: (async () =>
-          new Response('{}', {
-            status: 200,
-            headers: {
-              'anthropic-ratelimit-unified-5h-utilization': '0.42',
-              'anthropic-ratelimit-unified-7d-utilization': '0.17',
-            },
-          })) as typeof fetch,
-      })
-      const cached = getCachedAccountQuota('work@example.com')
-      expect(cached?.ok).toBe(true)
-      if (cached?.ok) {
-        expect(Math.round(cached.data.fiveHourUtilizationPct)).toBe(42)
-      }
-    } finally {
-      rmSync(home, { recursive: true, force: true })
-    }
-  })
-
-  it("returns stale entries verbatim — staleness is the prefetch path's concern, not the read path's (v0.6.11)", async () => {
-    // The dashboard renders sync. Pre-v0.6.11 this function treated
-    // stale cache as a miss → the boot-warmed cache vanished after
-    // 30s and the operator saw empty quota rows on the first /auth
-    // tap of any session past that window. Now stale-but-present
-    // entries are returned; the background prefetch keeps the cache
-    // fresh across renders.
-    const home = makeAccountHome({
-      'work@example.com': { accessToken: 'tok' },
-    })
-    try {
-      const nowVal = 1_000_000
-      await fetchAccountQuota('work@example.com', {
-        home,
-        fetchImpl: (async () =>
-          new Response('{}', {
-            status: 200,
-            headers: {
-              'anthropic-ratelimit-unified-5h-utilization': '0.42',
-              'anthropic-ratelimit-unified-7d-utilization': '0.17',
-            },
-          })) as typeof fetch,
-        now: () => nowVal,
-      })
-      // Within TTL — cached.
-      const fresh = getCachedAccountQuota('work@example.com', nowVal)
-      expect(fresh).not.toBeNull()
-      // Past TTL — STILL returned, identical to the within-TTL read.
-      const after = nowVal + ACCOUNT_QUOTA_CACHE_TTL_MS + 1
-      const stale = getCachedAccountQuota('work@example.com', after)
-      expect(stale).not.toBeNull()
-      expect(stale).toEqual(fresh)
-    } finally {
-      rmSync(home, { recursive: true, force: true })
-    }
-  })
-
-  it('returns null when the label has never been probed', async () => {
-    // The only "no data" path: the cache map has no entry. After
-    // the first probe the entry persists for the lifetime of the
-    // gateway process, regardless of staleness.
-    expect(getCachedAccountQuota('never-probed@example.com')).toBeNull()
-  })
-
-  it('prefetchAccountQuotaIfStale is a noop when cache is fresh', async () => {
-    const home = makeAccountHome({
-      'work@example.com': { accessToken: 'tok' },
-    })
-    let callCount = 0
-    const fakeFetch = (async () => {
-      callCount++
-      return new Response('{}', {
-        status: 200,
-        headers: {
-          'anthropic-ratelimit-unified-5h-utilization': '0.42',
-          'anthropic-ratelimit-unified-7d-utilization': '0.17',
-        },
-      })
-    }) as typeof fetch
-    try {
-      await fetchAccountQuota('work@example.com', { home, fetchImpl: fakeFetch })
-      expect(callCount).toBe(1)
-      // Fresh cache — prefetch should not fire.
-      prefetchAccountQuotaIfStale('work@example.com', { home, fetchImpl: fakeFetch })
-      // Yield once to let any spurious microtasks settle.
-      await Promise.resolve()
-      expect(callCount).toBe(1)
-    } finally {
-      rmSync(home, { recursive: true, force: true })
-    }
-  })
-})
-
-describe('regression: boot-warm + delayed sync-read (v0.6.11)', () => {
-  // The bug: gateway boot-warm fills the cache; cache TTL elapses;
-  // dashboard's sync read returns null; operator sees empty quota
-  // rows on first /auth tap of the session past TTL. Fix: sync read
-  // returns last-known data regardless of staleness; prefetch path
-  // owns the freshness contract. Pin both legs so a future TTL
-  // tweak can't silently re-introduce the bug.
-  it('returns last-known data even after multiple TTL windows have elapsed', async () => {
-    clearAccountQuotaCache()
-    const home = makeAccountHome({
-      'pixsoul@gmail.com': { accessToken: 'tok' },
-    })
-    try {
-      const t0 = 1_000_000
-      // Boot-warm: probe completes at t0.
-      await fetchAccountQuota('pixsoul@gmail.com', {
-        home,
-        fetchImpl: (async () =>
-          new Response('{}', {
-            status: 200,
-            headers: {
-              'anthropic-ratelimit-unified-5h-utilization': '0.04',
-              'anthropic-ratelimit-unified-7d-utilization': '0.78',
-            },
-          })) as typeof fetch,
-        now: () => t0,
-      })
-      // 8.5 minutes later (the screenshot-reproduction window): the
-      // dashboard fetches state. Sync read returns the boot-warmed
-      // values rather than null.
-      const tDashboard = t0 + 8.5 * 60_000
-      const cached = getCachedAccountQuota('pixsoul@gmail.com', tDashboard)
-      expect(cached).not.toBeNull()
-      if (cached?.ok) {
-        expect(cached.data.fiveHourUtilizationPct).toBe(4)
-        expect(cached.data.sevenDayUtilizationPct).toBe(78)
-      } else {
-        throw new Error('expected ok=true cached entry')
-      }
-    } finally {
-      rmSync(home, { recursive: true, force: true })
-    }
-  })
-
-  it('prefetchAccountQuotaIfStale re-probes once the TTL has elapsed', async () => {
-    clearAccountQuotaCache()
-    const home = makeAccountHome({
-      'work@example.com': { accessToken: 'tok' },
-    })
-    try {
-      const t0 = 1_000_000
-      let fetchCount = 0
-      const counterFetch: typeof fetch = async () => {
-        fetchCount++
-        return new Response('{}', {
-          status: 200,
-          headers: {
-            'anthropic-ratelimit-unified-5h-utilization': '0.10',
-            'anthropic-ratelimit-unified-7d-utilization': '0.20',
-          },
-        })
-      }
-      // First probe seeds the cache.
-      await fetchAccountQuota('work@example.com', {
-        home,
-        fetchImpl: counterFetch,
-        now: () => t0,
-      })
-      expect(fetchCount).toBe(1)
-      // Within TTL: prefetch is a no-op.
-      prefetchAccountQuotaIfStale('work@example.com', {
-        home,
-        fetchImpl: counterFetch,
-        now: () => t0 + 60_000,
-      })
-      // Give microtask queue a chance — should still be 1.
-      await new Promise((r) => setTimeout(r, 5))
-      expect(fetchCount).toBe(1)
-      // Past TTL: prefetch fires a fresh probe.
-      prefetchAccountQuotaIfStale('work@example.com', {
-        home,
-        fetchImpl: counterFetch,
-        now: () => t0 + ACCOUNT_QUOTA_CACHE_TTL_MS + 1,
-      })
-      // Wait for the fire-and-forget probe to complete.
-      await new Promise((r) => setTimeout(r, 20))
-      expect(fetchCount).toBe(2)
-    } finally {
-      rmSync(home, { recursive: true, force: true })
-    }
-  })
-
-  it('cache TTL is at least 1 minute — short TTLs cause empty-row regressions', () => {
-    // Pre-v0.6.11 was 30s, which made the boot-warm useless. If a
-    // future PR drops it below 60s, this test catches it before the
-    // empty-row regression hits production.
-    expect(ACCOUNT_QUOTA_CACHE_TTL_MS).toBeGreaterThanOrEqual(60_000)
-  })
-})
-
 describe('fetchQuota — accessToken parameter', () => {
   it('accepts a direct accessToken instead of a config dir', async () => {
     const fakeFetch = async (_url: unknown, init?: RequestInit) => {