Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

35.5 KB
Raw Blame
import socket from '../services/socket';
vi.mock('../services/socket', async () => {
  const { EventEmitter } = await import('events');
  return { default: new EventEmitter() };
});
afterEach(() => { vi.useRealTimers(); vi.restoreAllMocks(); });
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { act, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
import { MemoryRouter } from 'react-router';

const api = vi.hoisted(() => ({
  getClaudeCodeModelUsage: vi.fn(() => Promise.resolve({ filesScanned: 0, models: [], totals: {} })),
  getProviderUsage: vi.fn(),
  getUsage: vi.fn(),
  getUsageBackfillStatus: vi.fn(),
  getUsageRollingCost: vi.fn(() => Promise.resolve({ windowDays: 30, instanceCount: 1, series: [], points: [] })),
  startUsageBackfill: vi.fn(),
  updateSubscriptionCosts: vi.fn()
}));

vi.mock('../services/api', () => api);

const UsagePageModule = await import('./UsagePage');
const UsagePage = UsagePageModule.default;
const { arrangeQuotaCells } = UsagePageModule;

const usage = {
  totalSessions: 1,
  totalMessages: 1,
  totalTokens: { input: 10, output: 5 },
  last7Days: [],
  hourlyActivity: Array(24).fill(0),
  topProviders: [],
  topModels: [],
  report: {
    pricingAsOf: '2026-07-01',
    providers: [],
    totals: { estimatedCost: 0, source: 'estimate' }
  }
};

beforeEach(() => {
  vi.clearAllMocks();
  api.getProviderUsage.mockResolvedValue({ providers: [] });
  api.getUsage.mockResolvedValue(usage);
  api.getUsageBackfillStatus.mockResolvedValue({ status: 'idle' });
  api.startUsageBackfill.mockResolvedValue({ status: 'complete', corrected: 2 });
  api.updateSubscriptionCosts.mockResolvedValue({ costs: { claude: 200 } });
});

describe('UsagePage subscription savings', () => {
  it('updates quota cards on completion without recurring fetches', async () => {
    vi.useFakeTimers({ shouldAdvanceTime: true });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    await waitFor(() => expect(api.getProviderUsage).toHaveBeenCalledTimes(1));
    await act(async () => { await vi.advanceTimersByTimeAsync(12_000); });
    expect(api.getProviderUsage).toHaveBeenCalledTimes(1);
    api.getProviderUsage.mockResolvedValue({ providers: [{
      family: 'claude', label: 'Claude Code', supported: true,
      limits: [{ key: 'week', label: 'Updated window', percentUsed: 73, percentRemaining: 27 }],
    }] });
    await act(async () => { socket.emit('provider-quota:updated', {}); });
    expect(await screen.findByText('Updated window')).toBeInTheDocument();
    expect(api.getProviderUsage).toHaveBeenCalledTimes(2);
    expect(api.getProviderUsage).toHaveBeenLastCalledWith({ refresh: false });
  });

  const savings = {
    range: { start: '2026-02-01', end: '2026-02-07', days: 7 },
    configured: false,
    unmatchedApiCost: 0,
    families: [{
      family: 'claude', label: 'Claude Code', enabled: true, monthlyCost: 0, configured: false,
      periodCost: 0, apiCost: 30, savings: 0, multiplier: null
    }],
    totals: { monthlyCost: 0, periodCost: 0, apiCost: 0, savings: 0, savingsPercent: null, multiplier: null }
  };

  it('renders the savings editor from the report payload', async () => {
    api.getUsage.mockResolvedValue({ ...usage, subscriptionSavings: savings });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    expect(screen.getByRole('tab', { name: 'Usage' })).toHaveAttribute('aria-selected', 'true');
    expect(await screen.findByText('Subscription vs. API Cost')).toBeInTheDocument();
  });

  // A new plan price changes every derived figure in the report, so saving one
  // has to pull the whole report back down — not just the prices.
  it('refetches the report after a price is saved', async () => {
    api.getUsage.mockResolvedValue({ ...usage, subscriptionSavings: savings });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    const inputs = await screen.findAllByLabelText('Monthly cost for Claude Code');
    fireEvent.change(inputs[0], { target: { value: '200' } });
    const calls = api.getUsage.mock.calls.length;
    fireEvent.click(screen.getByRole('button', { name: /Save costs/ }));

    await waitFor(() => expect(api.updateSubscriptionCosts).toHaveBeenCalledWith({ claude: 200 }, { silent: true }));
    await waitFor(() => expect(api.getUsage.mock.calls.length).toBeGreaterThan(calls));
  });
});

describe('UsagePage historical reconciliation', () => {
  it('renders backfill events without polling and reconciles missed updates', async () => {
    vi.useFakeTimers({ shouldAdvanceTime: true });
    api.getUsageBackfillStatus.mockResolvedValue({ status: 'running', processed: 1, total: 5 });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    expect(await screen.findByText('Processing 1 of 5 runs…')).toBeInTheDocument();
    await act(async () => { await vi.advanceTimersByTimeAsync(5000); });
    expect(api.getUsageBackfillStatus).toHaveBeenCalledTimes(1);
    api.getUsageBackfillStatus.mockResolvedValue({ status: 'running', processed: 3, total: 5 });
    await act(async () => { socket.emit('usage-backfill:updated', {}); });
    expect(await screen.findByText('Processing 3 of 5 runs…')).toBeInTheDocument();
    expect(api.getUsageBackfillStatus).toHaveBeenCalledTimes(2);
    const usageReads = api.getUsage.mock.calls.length;
    api.getUsageBackfillStatus.mockResolvedValue({ status: 'complete', corrected: 4 });
    await act(async () => { socket.emit('usage-backfill:updated', {}); });
    expect(await screen.findByText('Corrected 4 runs.')).toBeInTheDocument();
    expect(api.getUsage.mock.calls.length).toBe(usageReads + 1);
    await act(async () => { socket.emit('connect'); });
    expect(api.getUsageBackfillStatus).toHaveBeenCalledTimes(4);
    const visibility = vi.spyOn(document, 'visibilityState', 'get');
    visibility.mockReturnValue('hidden');
    act(() => document.dispatchEvent(new Event('visibilitychange')));
    api.getUsageBackfillStatus.mockResolvedValue({ status: 'error', error: 'Example scan failed' });
    visibility.mockReturnValue('visible');
    await act(async () => document.dispatchEvent(new Event('visibilitychange')));
    expect(api.getUsageBackfillStatus).toHaveBeenCalledTimes(5);
    expect(await screen.findByText('Example scan failed')).toBeInTheDocument();
  });

  it('reconciles a completion that beats the start response', async () => {
    api.startUsageBackfill.mockResolvedValue({ status: 'running' });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    const button = await screen.findByRole('button', { name: 'Reconcile now' });
    api.getUsageBackfillStatus.mockResolvedValue({ status: 'complete', corrected: 3 });
    fireEvent.click(button);
    expect(await screen.findByText('Corrected 3 runs.')).toBeInTheDocument();
    expect(api.startUsageBackfill).toHaveBeenCalledTimes(1);
  });

  it('shows the Grok rows reconcile added', async () => {
    api.startUsageBackfill.mockResolvedValue({
      status: 'complete',
      corrected: 2,
      grok: {
        added: 3,
        turns: 1,
        images: 2,
        videos: 0,
        backedUp: true,
        note: 'Long-context premiums were not added because no Grok usage scan has run yet.',
      },
    });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    fireEvent.click(await screen.findByRole('button', { name: 'Reconcile now' }));
    expect(await screen.findByText('Corrected 2 runs.')).toBeInTheDocument();
    expect(await screen.findByText('Added 1 long-context turn and 2 images. Long-context premiums were not added because no Grok usage scan has run yet.')).toBeInTheDocument();
  });

  it('says when reconcile found the Grok ledger already repaired', async () => {
    api.startUsageBackfill.mockResolvedValue({
      status: 'complete',
      corrected: 0,
      grok: { added: 0, turns: 0, images: 0, videos: 0, backedUp: false, note: null },
    });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    fireEvent.click(await screen.findByRole('button', { name: 'Reconcile now' }));
    expect(await screen.findByText('Grok usage was already recorded.')).toBeInTheDocument();
  });

  it('shows the Antigravity rows reconcile added', async () => {
    api.startUsageBackfill.mockResolvedValue({
      status: 'complete',
      corrected: 1,
      agy: {
        added: 4,
        images: 4,
        backedUp: true,
        note: null,
      },
    });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    fireEvent.click(await screen.findByRole('button', { name: 'Reconcile now' }));
    expect(await screen.findByText('Corrected 1 run.')).toBeInTheDocument();
    expect(await screen.findByText('Added 4 images.')).toBeInTheDocument();
  });

  it('starts only from the explicit user action and reports completion', async () => {
    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    const button = await screen.findByRole('button', { name: 'Reconcile now' });
    expect(api.startUsageBackfill).not.toHaveBeenCalled();

    fireEvent.click(button);
    await waitFor(() => expect(api.startUsageBackfill).toHaveBeenCalledWith({ silent: true }));
    expect(await screen.findByText('Corrected 2 runs.')).toBeInTheDocument();
  });
});

describe('UsagePage breakdown visualization and responsiveness', () => {
  it('renders top providers and top models with visual percentage badges and cost metrics', async () => {
    const richUsage = {
      ...usage,
      topProviders: [
        { id: 'claude', name: 'Claude Code', sessions: 10, tokens: 8000 }
      ],
      topModels: [
        { model: 'claude-3-7-sonnet', sessions: 10, tokens: 8000 }
      ],
      report: {
        pricingAsOf: '2026-07-01',
        providers: [
          {
            id: 'claude',
            name: 'Claude Code',
            sessions: 10,
            tokensIn: 5000,
            tokensOut: 3000,
            cacheReadTokens: 1000,
            cacheWriteTokens: 200,
            estimatedCost: 1.5,
            source: 'measured',
            models: [
              {
                model: 'claude-3-7-sonnet',
                sessions: 10,
                tokensIn: 5000,
                tokensOut: 3000,
                cacheReadTokens: 1000,
                cacheWriteTokens: 200,
                images: 2,
                videoSeconds: 6,
                estimatedCost: 1.5
              }
            ]
          }
        ],
        totals: { estimatedCost: 1.5, source: 'measured' }
      }
    };
    api.getUsage.mockResolvedValue(richUsage);

    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    expect(await screen.findByText('Top Providers')).toBeInTheDocument();
    expect(screen.getByText('Top Models')).toBeInTheDocument();

    // Check percentage share badges and cost
    const percentBadges = screen.getAllByText('100%');
    expect(percentBadges.length).toBeGreaterThan(0);

    const costDisplays = screen.getAllByText('$1.50');
    expect(costDisplays.length).toBeGreaterThan(0);
    expect(screen.getAllByText(/2 images/).length).toBeGreaterThan(0);
    expect(screen.getAllByText(/6s video/).length).toBeGreaterThan(0);
  });
});

describe('UsagePage per-provider refresh', () => {
  const card = (family, label, percentUsed) => ({
    family,
    label,
    supported: true,
    limits: [{ key: 'week', label: 'Weekly', percentUsed, percentRemaining: 100 - percentUsed }],
    activity: [],
    approximate: true,
    fetchedAt: new Date().toISOString()
  });

  beforeEach(() => {
    api.getProviderUsage.mockResolvedValue({ providers: [card('claude', 'Claude Code', 10), card('grok', 'Grok', 20)] });
  });

  it('re-reads only the clicked provider and swaps that card in', async () => {
    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    await screen.findByText('Grok');
    expect(await screen.findByText('20% used')).toBeInTheDocument();

    api.getProviderUsage.mockResolvedValueOnce({ providers: [card('grok', 'Grok', 77)] });
    fireEvent.click(screen.getByRole('button', { name: 'Refresh Grok usage' }));

    await waitFor(() => expect(api.getProviderUsage).toHaveBeenCalledWith({ refresh: true, family: 'grok', silent: false }));
    // The refreshed card updates; the untouched Claude card keeps its reading.
    expect(await screen.findByText('77% used')).toBeInTheDocument();
    expect(screen.getByText('10% used')).toBeInTheDocument();
  });

  // The per-card control was a bare 12-14px icon (#8779): a finger that missed
  // it fell back on Refresh all, which respawns every family's scrape.
  it('gives both refresh controls a 44px touch target and blocks a duplicate per-card request', async () => {
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    const grokRefresh = await screen.findByRole('button', { name: 'Refresh Grok usage' });
    const refreshAll = screen.getByRole('button', { name: /Refresh all/ });
    for (const button of [grokRefresh, refreshAll]) {
      expect(button.className.split(/\s+/)).toEqual(expect.arrayContaining(['min-w-11', 'min-h-11']));
    }

    let settle;
    api.getProviderUsage.mockClear();
    api.getProviderUsage.mockReturnValueOnce(new Promise((resolve) => { settle = resolve; }));
    fireEvent.click(grokRefresh);
    await waitFor(() => expect(grokRefresh).toBeDisabled());
    fireEvent.click(grokRefresh);
    expect(api.getProviderUsage).toHaveBeenCalledTimes(1);
    expect(api.getProviderUsage).toHaveBeenCalledWith({ refresh: true, family: 'grok', silent: false });
    // The untouched card stays tappable while Grok's scrape is in flight.
    expect(screen.getByRole('button', { name: 'Refresh Claude Code usage' })).toBeEnabled();

    settle({ providers: [card('grok', 'Grok', 50)] });
    expect(await screen.findByText('50% used')).toBeInTheDocument();
    expect(grokRefresh).toBeEnabled();
  });

  it('keeps the four provider cards in a compact mobile grid', async () => {
    api.getProviderUsage.mockResolvedValue({
      providers: ['claude', 'agy', 'codex', 'grok'].map((family) => card(family, family, 20))
    });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    const providerGrid = await screen.findByLabelText('Subscription provider usage');
    expect(providerGrid.className.split(/\s+/)).toEqual(
      expect.arrayContaining(['grid-cols-2', 'sm:grid-cols-1', 'lg:grid-cols-2'])
    );
    expect(within(providerGrid).getAllByRole('heading')).toHaveLength(4);
  });

  it('drops a card whose provider is no longer enabled', async () => {
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    await screen.findByText('Grok');

    api.getProviderUsage.mockResolvedValueOnce({ providers: [] });
    fireEvent.click(screen.getByRole('button', { name: 'Refresh Grok usage' }));

    await waitFor(() => expect(screen.queryByText('Grok')).not.toBeInTheDocument());
    expect(screen.getByText('Claude Code')).toBeInTheDocument();
  });
});

describe('UsagePage federated quota readings', () => {
  const fleetCard = {
    family: 'claude',
    label: 'Claude Code',
    supported: true,
    limits: [{ key: 'week', label: 'Weekly', percentUsed: 65, percentRemaining: 35 }],
    activity: [],
    approximate: true,
    fetchedAt: '2026-09-03T11:00:00.000Z',
    note: 'Across 2 federated instances (this machine, Example Box) — meters show the freshest reading across them.',
    fleet: {
      count: 2,
      instances: [
        { instanceId: 'inst-self', name: null, self: true, fetchedAt: '2026-09-03T10:00:00.000Z' },
        { instanceId: 'inst-peer', name: 'Example Box', self: false, fetchedAt: '2026-09-03T11:00:00.000Z' },
      ],
    },
  };

  it('shows the subscription plan name on the quota card when the reading named a tier', async () => {
    api.getProviderUsage.mockResolvedValue({
      providers: [{
        family: 'grok',
        label: 'Grok',
        supported: true,
        plan: 'SuperGrok',
        limits: [{ key: 'week', label: 'Weekly', percentUsed: 8, percentRemaining: 92 }],
        activity: [],
        approximate: true,
        fetchedAt: '2026-09-03T11:00:00.000Z',
      }],
    });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    expect(await screen.findByText('SuperGrok')).toBeInTheDocument();
  });

  it('says the card spans instances and names which ones', async () => {
    api.getProviderUsage.mockResolvedValue({ providers: [fleetCard] });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    const pill = await screen.findByText('2 instances');
    expect(pill.closest('[title]').getAttribute('title')).toContain('Example Box');
    expect(screen.getByText(fleetCard.note)).toBeInTheDocument();
  });

  it('shows no fleet pill on a single-machine install', async () => {
    api.getProviderUsage.mockResolvedValue({ providers: [{ ...fleetCard, fleet: undefined, note: 'This machine only — other federated instances have not reported a reading yet.' }] });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    await screen.findByText('Claude Code');
    expect(screen.queryByText(/^\d+ instances$/)).not.toBeInTheDocument();
  });

  // A federated card can be filled by a peer while this machine's own scrape is
  // still running. The meters are worth showing meanwhile, but the card must
  // keep saying it is still reading — that flag is what keeps the page polling
  // until the local reading lands, instead of settling on a stand-in.
  it('shows a peer reading while this machine is still scraping, without hiding that it is still reading', async () => {
    api.getProviderUsage.mockResolvedValue({ providers: [{ ...fleetCard, pending: true }] });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    // Both, not either: the meters are the best number available right now, and
    // the spinner is what says a better one is coming (and what the page's
    // pending poll keys on, so the local reading actually swaps in).
    expect(await screen.findByText('65% used')).toBeInTheDocument();
    expect(screen.getByText("Reading this machine's usage…")).toBeInTheDocument();
  });

  it("attributes a meter standing on another machine's older reading", async () => {
    const hoursAgo = (h) => new Date(Date.now() - h * 60 * 60 * 1000).toISOString();
    // `stale` is now a server-computed verdict (period-relative, see
    // server/lib/quotaWindows.js) — this fixture stands in for what the API
    // would have stamped: the 50h-old weekly reading is well past its window's
    // threshold, the moment-old session reading is not.
    api.getProviderUsage.mockResolvedValue({ providers: [{
      ...fleetCard,
      limits: [
        { key: 'week', label: 'Weekly', percentUsed: 12, percentRemaining: 88, readAt: hoursAgo(50), readBy: 'inst-peer', readByName: 'Example Box', stale: true },
        { key: 'session', label: 'Session', percentUsed: 30, percentRemaining: 70, readAt: hoursAgo(0), readBy: null, readByName: null, stale: false },
      ],
    }] });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    // The stand-in says whose reading it is and how old — a 12% weekly figure
    // read two days ago must not read as this moment's.
    expect(await screen.findByText(/read 2d ago on Example Box/)).toBeInTheDocument();
    // This machine's own reading carries no such caption.
    expect(screen.getByText('30% used')).toBeInTheDocument();
  });
});

describe('UsagePage mobile provider-card layout', () => {
  const metricsCard = {
    family: 'image_gen',
    label: 'Image Gen',
    supported: true,
    plan: 'pro',
    limits: [],
    activity: [],
    metrics: [
      { key: 'codex', label: 'Codex · image_gen', value: 'No renders · 24h', detail: 'quota not reported by this CLI' },
      { key: 'grok', label: 'Grok · image_gen', value: 'No renders · 24h', detail: 'quota not reported by this CLI' },
    ],
    fleet: {
      count: 2,
      instances: [
        { instanceId: 'inst-self', name: null, self: true, fetchedAt: '2026-09-03T10:00:00.000Z' },
        { instanceId: 'inst-peer', name: 'Example Box', self: false, fetchedAt: '2026-09-03T11:00:00.000Z' },
      ],
    },
  };

  // Two cards share the row at phone width, so the header badges are
  // desktop-only and the observed-count tiles stack. Both were regressions the
  // class strings alone did not deliver: `Pill` used to re-assert its own
  // `inline-flex` over the caller's `hidden` (see OWN_DISPLAY in Pill.jsx), and
  // two columns of tiles inside a half-width card wrapped every label onto four
  // lines.
  it('hides the header badges and stacks the count tiles at phone width', async () => {
    api.getProviderUsage.mockResolvedValue({ providers: [metricsCard] });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    await screen.findByRole('heading', { name: 'Image Gen' });
    for (const badge of [screen.getByText('pro'), screen.getByText('2 instances')]) {
      const tokens = badge.className.split(/\s+/);
      expect(tokens).toContain('hidden');
      expect(tokens).not.toContain('inline-flex');
    }

    const tileGrid = screen.getByText('Codex · image_gen').closest('.grid');
    expect(tileGrid.className.split(/\s+/)).toEqual(
      expect.arrayContaining(['grid-cols-1', 'sm:grid-cols-2'])
    );
  });

  it('supports toggling imagegen render periods between 24h, week, and month', async () => {
    const cardWithPeriods = {
      family: 'imagegen',
      label: 'Image Gen',
      supported: true,
      limits: [],
      activity: [],
      period: '24h',
      metrics: [
        {
          key: 'imagegen-agy',
          label: 'Agy · generate_image',
          value: '2 renders · 24h',
          detail: 'quota not reported by this CLI',
          periods: {
            '24h': { key: '24h', label: '24h', count: 2, failed: 0, value: '2 renders · 24h', detail: 'quota not reported by this CLI' },
            '7d': { key: '7d', label: 'Week', count: 7, failed: 1, value: '7 renders · week', detail: '1 failed' },
            '30d': { key: '30d', label: 'Month', count: 25, failed: 1, value: '25 renders · month', detail: '1 failed' },
          },
        },
      ],
    };

    api.getProviderUsage.mockResolvedValue({ providers: [cardWithPeriods] });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    await screen.findByRole('heading', { name: 'Image Gen' });
    expect(screen.getByText('2 renders · 24h')).toBeInTheDocument();

    fireEvent.click(screen.getByRole('button', { name: 'Week' }));
    expect(screen.getByText('7 renders · week')).toBeInTheDocument();

    fireEvent.click(screen.getByRole('button', { name: 'Month' }));
    expect(screen.getByText('25 renders · month')).toBeInTheDocument();
  });
});

describe('arrangeQuotaCells', () => {
  const q = (family) => ({ family, label: family });

  it('orders Claude, Antigravity, then a shared Codex+Grok cell, then the rest', () => {
    // Server order deliberately differs from display order.
    const cells = arrangeQuotaCells(['claude', 'codex', 'agy', 'grok', 'imagegen'].map(q));
    expect(cells.map((c) => c.cards.map((card) => card.family))).toEqual([
      ['claude'], ['agy'], ['codex', 'grok'], ['imagegen']
    ]);
  });

  it('collapses a shared cell to the one family of the pair that is enabled', () => {
    const cells = arrangeQuotaCells([q('grok'), q('claude')]);
    expect(cells.map((c) => c.key)).toEqual(['claude', 'grok']);
  });

  it('renders a family it has no display preference for exactly once, in server order', () => {
    const cells = arrangeQuotaCells([q('imagegen'), q('newthing')]);
    expect(cells.map((c) => c.cards.map((card) => card.family))).toEqual([['imagegen'], ['newthing']]);
  });
});

describe('UsagePage provider reset times', () => {
  it('localizes an ISO reset and adds the relative countdown', async () => {
    // A minute past the 3h mark, so the floor in `timeUntil` can't round to 2h.
    const resetsAt = new Date(Date.now() + 3 * 60 * 60 * 1000 + 60_000).toISOString();
    api.getProviderUsage.mockResolvedValue({
      providers: [{
        family: 'claude',
        label: 'Claude',
        supported: true,
        limits: [{ key: 'week', label: 'Weekly', percentUsed: 40, percentRemaining: 60, resetsAt, timezone: 'UTC' }],
        activity: [],
        approximate: true,
        fetchedAt: new Date().toISOString()
      }]
    });

    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    // Every adapter emits ISO now, so the card must never show a CLI's own
    // wording — it shows a localized instant plus "in 3h".
    const reset = await screen.findByText(/resets .*\(in 3h\)/);
    expect(reset).toBeInTheDocument();
    expect(reset.className.split(/\s+/)).not.toContain('hidden');
    expect(reset.textContent).not.toContain(resetsAt);
  });

  it('gives the Grok weekly reset its own full-width row on the cramped mobile card', async () => {
    // Grok shares a mobile grid cell with Codex, so its card is the narrowest —
    // the reset row must stack under "% used" (flex-col) rather than squeeze
    // onto the same line (flex-row), which was clipping/overlapping it.
    const resetsAt = new Date(Date.now() + 2 * 24 * 60 * 60 * 1000 + 60_000).toISOString();
    api.getProviderUsage.mockResolvedValue({
      providers: [{
        family: 'grok',
        label: 'Grok',
        supported: true,
        limits: [{ key: 'weekly', label: 'Weekly', percentUsed: 8, percentRemaining: 92, resetsAt }],
        activity: [],
        approximate: true,
        fetchedAt: new Date().toISOString()
      }]
    });

    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    const reset = await screen.findByText(/resets .*\(in 2d\)/);
    expect(reset.className.split(/\s+/)).not.toContain('hidden');
    const row = reset.parentElement;
    expect(row.className.split(/\s+/)).toEqual(expect.arrayContaining(['flex-col', 'sm:flex-row']));
  });
});

// The provider-quota section reads every provider on mount, well after the page
// shell has painted. A centered spinner there let the whole page below it jump
// by the card grid's height once the reading landed (#4147).
describe('UsagePage provider-quota loading state (#4147)', () => {
  it('reserves the quota card grid instead of centering a spinner', async () => {
    // Never resolves — hold the section on its loading branch.
    api.getProviderUsage.mockReturnValue(new Promise(() => {}));

    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    const region = await screen.findByRole('status', { name: 'Reading provider usage' });
    expect(region).toHaveAttribute('aria-busy', 'true');
    expect(region.querySelectorAll('.animate-pulse').length).toBeGreaterThan(0);
    // Mirrors the loaded grid so the cards land where the placeholders were.
    expect(region.innerHTML).toContain('lg:grid-cols-2');
  });
});

describe('UsagePage free-tier section (#7408)', () => {
  const freeTier = {
    basis: 'ledger',
    providers: [{
      id: 'opencode-zen-cli',
      name: 'OpenCode Zen CLI',
      free: true,
      sessions: 3,
      messages: 5,
      tokensIn: 1200,
      tokensOut: 3400,
      cacheReadTokens: 0,
      cacheWriteTokens: 0,
      source: 'mixed',
      estimatedCost: 0,
      rateMatch: 'free',
      models: [{
        model: 'opencode/big-pickle',
        sessions: 3,
        messages: 5,
        tokensIn: 1200,
        tokensOut: 3400,
        cacheReadTokens: 0,
        cacheWriteTokens: 0,
        source: 'mixed',
        estimatedCost: 0,
        rateMatch: 'free'
      }]
    }],
    blocks: [{
      providerId: 'opencode-zen-cli',
      model: null,
      category: 'usage-limit',
      message: 'hit your usage limit',
      resetHint: '2 hours',
      at: Date.now() - 60_000,
      volumeSince: { sessions: 1, messages: 2, tokensIn: 100, tokensOut: 200 }
    }]
  };

  it('renders free-tier queries, tokens, and the observed block from the report payload', async () => {
    api.getUsage.mockResolvedValue({ ...usage, freeTier });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    expect(await screen.findByText('Free-tier usage')).toBeInTheDocument();
    expect(screen.getByText('OpenCode Zen CLI')).toBeInTheDocument();
    expect(screen.getByText('opencode/big-pickle')).toBeInTheDocument();
    // Observed block with its reset hint and since-volume.
    expect(screen.getByText(/provider said: 2 hours/)).toBeInTheDocument();
    expect(screen.getByText(/out since/)).toBeInTheDocument();
  });

  it('renders an empty state when no free-tier usage exists yet', async () => {
    api.getUsage.mockResolvedValue({ ...usage, freeTier: { basis: 'ledger', providers: [], blocks: [] } });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);

    expect(await screen.findByText('No free-tier usage recorded in this period.')).toBeInTheDocument();
  });
});

describe('UsagePage custom date range inputs', () => {
  it('keeps a half-typed date instead of resetting it, and commits once complete', async () => {
    api.getUsage.mockResolvedValue(usage);
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    // Settle mount-time fetches before interacting with the form. ClaudeCodeModelTokensCard
    // calls getClaudeCodeModelUsage on mount; waiting here ensures all mount effects complete
    // before we read the input value, avoiding act warnings from deferred state updates.
    await act(async () => {});
    const from = await screen.findByLabelText('From date');
    const callsBefore = api.getUsage.mock.calls.length;

    // Partially typed segments surface as value "" (happy-dom lacks badInput, so
    // assert the complete-date path plus that a stray year-0002 date never commits).
    fireEvent.change(from, { target: { value: '0002-09-29' } });
    expect(from.value).toBe('0002-09-29');
    expect(api.getUsage.mock.calls.length).toBe(callsBefore);

    // The commit has no debounce: it updates the URL param, and an effect then refetches.
    // Awaiting act flushes that whole chain, so the assertion never races a wall-clock timeout.
    await act(async () => { fireEvent.change(from, { target: { value: '2026-09-29' } }); });
    expect(api.getUsage.mock.calls.length).toBeGreaterThan(callsBefore);
    expect(from.value).toBe('2026-09-29');
  });
});

describe('UsagePage report range freshness (#10687)', () => {
  const pricedUsage = (estimatedCost) => ({ ...usage, report: { ...usage.report, totals: { estimatedCost } } });

  it('labels retained figures during a pending and failed replacement, then clears the error on retry', async () => {
    api.getUsage.mockResolvedValueOnce(pricedUsage(123.45));
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    expect(await screen.findByText('$123.45')).toBeInTheDocument();
    let rejectRange;
    api.getUsage.mockReturnValueOnce(new Promise((_resolve, reject) => { rejectRange = reject; }));
    fireEvent.click(screen.getByRole('button', { name: '30 days' }));
    expect(await screen.findByText('Loading selected usage range…')).toBeInTheDocument();
    expect(screen.getByText('Showing usage for 7 days. Retained figures may be stale.')).toBeInTheDocument();
    expect(screen.getByText('$123.45')).toBeInTheDocument();
    await act(async () => rejectRange(new Error('Example unavailable')));
    expect(screen.getByRole('alert')).toHaveTextContent('Usage unavailable for the selected range.');
    expect(screen.getByText('Showing usage for 7 days. Retained figures may be stale.')).toBeInTheDocument();
    api.getUsage.mockResolvedValueOnce(pricedUsage(456.78));
    fireEvent.click(screen.getByRole('button', { name: 'Retry usage' }));
    expect(await screen.findByText('$456.78')).toBeInTheDocument();
    expect(screen.getByText('Showing usage for 30 days.')).toBeInTheDocument();
    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
    expect(api.getUsage).toHaveBeenLastCalledWith({ period: '30d' }, { silent: true });
  });

  it('keeps controls and retry available after an initial invalid custom-range failure', async () => {
    api.getUsage.mockRejectedValueOnce(new Error('Example invalid range'));
    render(<MemoryRouter initialEntries={['/?from=2026-09-30&to=2026-09-01']}><UsagePage /></MemoryRouter>);
    expect(await screen.findByRole('alert')).toHaveTextContent('Usage unavailable');
    expect(screen.queryByText('No usage data available')).not.toBeInTheDocument();
    const from = screen.getByLabelText('From date');
    expect(from).toHaveValue('2026-09-30');
    expect(screen.getByRole('button', { name: 'Retry usage' })).toBeEnabled();
    api.getUsage.mockResolvedValueOnce(pricedUsage(12.34));
    fireEvent.change(from, { target: { value: '2026-08-01' } });
    expect(await screen.findByText('$12.34')).toBeInTheDocument();
    expect(screen.getByText('Showing usage for 2026-08-01 to 2026-09-01.')).toBeInTheDocument();
    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
  });

  it('ignores a superseded failure without clearing the latest pending request or successful report', async () => {
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    await screen.findByText('Showing usage for 7 days.');
    let rejectOlder;
    let resolveLatest;
    api.getUsage.mockReturnValueOnce(new Promise((_resolve, reject) => { rejectOlder = reject; }));
    fireEvent.click(screen.getByRole('button', { name: '30 days' }));
    api.getUsage.mockReturnValueOnce(new Promise((resolve) => { resolveLatest = resolve; }));
    fireEvent.click(screen.getByRole('button', { name: '90 days' }));
    await act(async () => rejectOlder(new Error('Example stale failure')));
    expect(screen.getByText('Loading selected usage range…')).toBeInTheDocument();
    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
    await act(async () => resolveLatest(pricedUsage(90)));
    expect(screen.getByText('Showing usage for 90 days.')).toBeInTheDocument();
    expect(screen.getByText('$90.00')).toBeInTheDocument();
    expect(screen.queryByText('Loading selected usage range…')).not.toBeInTheDocument();
    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
  });
});


describe('UsagePage image accounting', () => {
  it('shows image accounting as unavailable without hiding the text report or inventing zero usage', async () => {
    api.getUsage.mockResolvedValue({ ...usage, report: { ...usage.report, totals: { estimatedCost: 12 } }, imageRenders: { error: 'Image render usage is unavailable.' } });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    const card = await screen.findByRole('region', { name: 'Codex image usage' });
    expect(within(card).getByRole('status')).toHaveTextContent('Image render usage is unavailable. Text usage remains available.');
    expect(within(card).queryByText(/saved outputs|\$0/)).not.toBeInTheDocument();
    expect(screen.getAllByText('$12.00').length).toBeGreaterThan(0);
  });

  it('shows saved render activity separately from unknown image cost and allowance', async () => {
    api.getUsage.mockResolvedValue({ ...usage, imageRenders: { renderGroups: 8, codexSessions: 6, savedOutputs: 10, jobIdentityGroups: 2, imageCostUsd: null } });
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    const card = await screen.findByRole('region', { name: 'Codex image usage' });
    expect(within(card).getByText(/6 Codex sessions · 10 saved outputs/)).toBeInTheDocument();
    expect(within(card).getByText(/Image tokens, image cost and subscription allowance attribution: unknown/)).toBeInTheDocument();
    expect(within(card).queryByText(/\$0/)).not.toBeInTheDocument();
    expect(within(card).getByText(/2 additional render groups use saved job IDs/)).toBeInTheDocument();
    const reads = api.getUsage.mock.calls.length;
    await act(async () => { socket.emit('image-gen:completed', { mode: 'codex' }); });
    await waitFor(() => expect(api.getUsage.mock.calls.length).toBe(reads + 1));
  });

  it('renders PageHeader with the BarChart3 icon', async () => {
    api.getUsage.mockResolvedValue(usage);
    render(<MemoryRouter><UsagePage /></MemoryRouter>);
    const heading = screen.getByRole('heading', { level: 1, name: 'Subscription Usage' });
    expect(heading).toBeInTheDocument();
    const icon = heading.parentElement?.parentElement?.querySelector('svg');
    expect(icon).toBeInTheDocument();
    expect(icon).toHaveClass('lucide-chart-column');
    await act(async () => {});
  });
});