@robhowley/pi-openrouter 0.9.1 → 0.10.0

package/README.md

@@ -48,6 +48,8 @@ The sync uses OpenRouter’s authenticated user model catalog, so Pi can see the
 
 `/openrouter models-status`
 
+Model count and cache health live here. The Pi footer/status bar does not persistently show `OpenRouter {N} models` anymore.
+
 Example status output:
 
 ```text
@@ -61,7 +63,7 @@ To see why models were skipped:
 
 Skipped output may include a grouped suggestion when Pi can offer a safe next step, such as adding a local `contextWindow` override for incomplete metadata.
 
-Skipped models do not make the sync fail; models are skipped when required metadata cannot be safely mapped into Pi’s provider model config. The last successful catalog is cached so Pi can keep using it if a later refresh fails, and the cache persists across sessions. If a session starts with a cached catalog that has not been registered yet, status will show:
+Skipped models do not make the sync fail; models are skipped when required metadata cannot be safely mapped into Pi’s provider model config. The last successful catalog is cached so Pi can keep using it if a later refresh fails, and the cache persists across sessions. If a session starts with a cached catalog that has not been registered yet, `/openrouter models-status` will show:
 
 ```text
 OpenRouter models cached
@@ -122,7 +124,11 @@ pi:[uuid]
 
 ## Local usage tracking
 
-The extension logs completed OpenRouter turns to local JSONL files in `~/.pi/openrouter/usage/` to provide near-real-time usage data for "Today's spend" in the usage overlay. This supplements the OpenRouter Activity API, which typically has a delay.
+The extension logs completed OpenRouter turns to local JSONL files in `~/.pi/openrouter/usage/` to provide near-real-time usage data for the footer/status bar and for "Today's spend" in the usage overlay. This supplements the OpenRouter Activity API, which typically has a delay.
+
+When positive local spend exists in the last 30 UTC days, the footer/status bar shows local-only Today spend and a 30-day average multiplier, for example `OR $2.14 today · 1.3x 30d avg`.
+
+Model count and cache health remain available through `/openrouter models-status`.
 
 **Retention:** Local usage files are automatically cleaned up after 90 days.
 

package/extensions/openrouter/__tests__/hooks.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 const mocks = vi.hoisted(() => ({
   stopBackgroundRefresh: vi.fn(),
@@ -10,6 +10,7 @@ const mocks = vi.hoisted(() => ({
   mapOpenRouterModels: vi.fn(),
   includeBuiltinRouterModels: vi.fn(),
   isSyncEnabled: vi.fn(),
+  loadOpenRouterStatusBar: vi.fn(),
 }));
 
 vi.mock('../cache.js', () => ({
@@ -40,6 +41,10 @@ vi.mock('../models/sync.js', () => ({
   isSyncEnabled: mocks.isSyncEnabled,
 }));
 
+vi.mock('../status-bar.js', () => ({
+  loadOpenRouterStatusBar: mocks.loadOpenRouterStatusBar,
+}));
+
 function createMockPi() {
   const handlers = new Map<string, any>();
   return {
@@ -69,6 +74,14 @@ function createMockContext(overrides: { hasUI?: boolean } = {}) {
   } as any;
 }
 
+function createDeferredPromise<T>() {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  const promise = new Promise<T>((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+}
+
 async function loadHooksModule() {
   return import('../hooks.js');
 }
@@ -77,6 +90,7 @@ describe('openrouter hooks', () => {
   beforeEach(() => {
     vi.resetModules();
     vi.resetAllMocks();
+    vi.useRealTimers();
 
     mocks.isOpenRouterRequest.mockReturnValue(true);
     mocks.writeLocalUsage.mockResolvedValue(undefined);
@@ -86,9 +100,14 @@ describe('openrouter hooks', () => {
     mocks.mapOpenRouterModels.mockResolvedValue({ configs: [{ id: 'model-a' }] });
     mocks.includeBuiltinRouterModels.mockReturnValue([{ id: 'model-a' }, { id: 'router' }]);
     mocks.isSyncEnabled.mockReturnValue(true);
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({ kind: 'empty' });
   });
 
-  it('loads cached startup models and preserves startup status text', async () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('loads cached startup models and preserves startup cache info', async () => {
     const { pi } = createMockPi();
     const { loadStartupCacheState } = await loadHooksModule();
 
@@ -148,41 +167,89 @@ describe('openrouter hooks', () => {
     expect(pi.on.mock.calls.filter(([event]) => event === 'session_shutdown')).toHaveLength(2);
   });
 
-  it('keeps session_start status and startup notifications unchanged', async () => {
+  it('sets startup usage status from the local burn-rate helper and keeps cache notifications', async () => {
     const { handlers, pi } = createMockPi();
     const ctx = createMockContext();
     const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
 
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({
+      kind: 'ready',
+      text: 'OR $2.14 today · 1.3x 30d avg',
+    });
+
     initializeSessionState();
     installOpenRouterHooks(pi as any, {
       info: { count: 5, age: '3 minutes' },
     });
 
-    handlers.get('session_start')({ reason: 'startup' }, ctx);
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
 
-    expect(ctx.ui.setStatus).toHaveBeenCalledWith('openrouter', 'dim:OpenRouter 5 models');
+    expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
+    await vi.waitFor(() => {
+      expect(ctx.ui.setStatus).toHaveBeenCalledWith(
+        'openrouter',
+        'dim:OR $2.14 today · 1.3x 30d avg',
+      );
+    });
+    expect(String(ctx.ui.setStatus.mock.calls[0]?.[1] ?? '')).not.toContain('models');
     expect(ctx.ui.notify).toHaveBeenCalledWith(
       'OpenRouter: 5 models loaded from cache (3 minutes old). Run /openrouter models-sync to refresh.',
       'info',
     );
   });
 
-  it('keeps startup warning notifications unchanged', async () => {
+  it('clears stale startup status asynchronously when cached models exist but local spend is empty', async () => {
     const { handlers, pi } = createMockPi();
     const ctx = createMockContext();
     const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+    const statusLoad = createDeferredPromise<{ kind: 'ready'; text: string } | { kind: 'empty' }>();
+
+    mocks.loadOpenRouterStatusBar.mockReturnValue(statusLoad.promise);
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {
+      info: { count: 5, age: '3 minutes' },
+    });
+
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
+
+    expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
+    expect(ctx.ui.notify).toHaveBeenCalledWith(
+      'OpenRouter: 5 models loaded from cache (3 minutes old). Run /openrouter models-sync to refresh.',
+      'info',
+    );
+    expect(ctx.ui.setStatus).not.toHaveBeenCalled();
+
+    statusLoad.resolve({ kind: 'empty' });
+
+    await vi.waitFor(() => {
+      expect(ctx.ui.setStatus).toHaveBeenCalledWith('openrouter', undefined);
+    });
+    expect(ctx.ui.theme.fg).not.toHaveBeenCalled();
+  });
+
+  it('preserves the existing startup status when the usage helper fails open', async () => {
+    const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({ kind: 'failed' });
 
     initializeSessionState();
     installOpenRouterHooks(pi as any, {
       warning: 'OpenRouter: cached models found but failed to register: mapper failed',
     });
 
-    handlers.get('session_start')({ reason: 'startup' }, ctx);
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
 
+    expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
     expect(ctx.ui.notify).toHaveBeenCalledWith(
       'OpenRouter: cached models found but failed to register: mapper failed',
       'warning',
     );
+    await Promise.resolve();
+    expect(ctx.ui.setStatus).not.toHaveBeenCalled();
+    expect(ctx.ui.theme.fg).not.toHaveBeenCalled();
   });
 
   it('keeps before_provider_request session tagging behavior unchanged through the installed hook', async () => {
@@ -214,13 +281,20 @@ describe('openrouter hooks', () => {
     });
   });
 
-  it('keeps turn_end local usage logging unchanged', async () => {
+  it('refreshes the usage status after a successful OpenRouter turn_end local write without blocking the hook', async () => {
     const { handlers, pi } = createMockPi();
     const ctx = createMockContext();
     const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
     const randomUuidSpy = vi
       .spyOn(globalThis.crypto, 'randomUUID')
       .mockReturnValue('11111111-1111-4111-8111-111111111111');
+    const writeLocalUsageDeferred = createDeferredPromise<void>();
+
+    mocks.writeLocalUsage.mockReturnValue(writeLocalUsageDeferred.promise);
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({
+      kind: 'ready',
+      text: 'OR $1.25 today · 30.0x 30d avg',
+    });
 
     initializeSessionState();
     installOpenRouterHooks(pi as any, {});
@@ -258,19 +332,198 @@ describe('openrouter hooks', () => {
         cost: 1.25,
       }),
     );
+    expect(mocks.loadOpenRouterStatusBar).not.toHaveBeenCalled();
+    expect(ctx.ui.setStatus).not.toHaveBeenCalled();
+
+    writeLocalUsageDeferred.resolve();
+
+    await vi.waitFor(() => {
+      expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
+    });
+    const writeCallOrder = mocks.writeLocalUsage.mock.invocationCallOrder[0] ?? 0;
+    const refreshCallOrder = mocks.loadOpenRouterStatusBar.mock.invocationCallOrder[0] ?? 0;
+    expect(writeCallOrder).toBeLessThan(refreshCallOrder);
+    await vi.waitFor(() => {
+      expect(ctx.ui.setStatus).toHaveBeenCalledWith(
+        'openrouter',
+        'dim:OR $1.25 today · 30.0x 30d avg',
+      );
+    });
+    expect(String(ctx.ui.setStatus.mock.calls[0]?.[1] ?? '')).not.toContain('models');
 
     randomUuidSpy.mockRestore();
   });
 
-  it('stops background refresh on session shutdown', async () => {
+  it('does not write local usage or update status for non-OpenRouter turns', async () => {
     const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
     const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
 
+    mocks.isOpenRouterRequest.mockReturnValue(false);
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({
+      kind: 'ready',
+      text: 'OR $9.99 today · 9.9x 30d avg',
+    });
+
     initializeSessionState();
     installOpenRouterHooks(pi as any, {});
 
+    await handlers.get('turn_end')(
+      {
+        url: 'https://api.anthropic.com/v1/messages',
+        message: {
+          model: 'claude-sonnet-4',
+          responseId: 'resp-2',
+          usage: {
+            input: 4,
+            output: 2,
+            cost: { total: 0.42 },
+          },
+        },
+      },
+      ctx,
+    );
+
+    expect(mocks.writeLocalUsage).not.toHaveBeenCalled();
+    expect(mocks.loadOpenRouterStatusBar).not.toHaveBeenCalled();
+    expect(ctx.ui.setStatus).not.toHaveBeenCalled();
+  });
+
+  it('clears stale status after a turn when the usage helper reports empty local spend', async () => {
+    const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({ kind: 'empty' });
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {});
+
+    await handlers.get('turn_end')(
+      {
+        url: 'https://openrouter.ai/api/v1/chat/completions',
+        message: {
+          model: 'openrouter/anthropic/claude-sonnet-4',
+          responseId: 'resp-3',
+          usage: {
+            input: 1,
+            output: 1,
+            cost: { total: 0.01 },
+          },
+        },
+      },
+      ctx,
+    );
+
+    await vi.waitFor(() => {
+      expect(ctx.ui.setStatus).toHaveBeenCalledWith('openrouter', undefined);
+    });
+  });
+
+  it('preserves the existing status after a turn when the usage helper fails open', async () => {
+    const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({ kind: 'failed' });
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {});
+
+    await handlers.get('turn_end')(
+      {
+        url: 'https://openrouter.ai/api/v1/chat/completions',
+        message: {
+          model: 'openrouter/anthropic/claude-sonnet-4',
+          responseId: 'resp-4',
+          usage: {
+            input: 1,
+            output: 1,
+            cost: { total: 0.01 },
+          },
+        },
+      },
+      ctx,
+    );
+
+    await Promise.resolve();
+    expect(ctx.ui.setStatus).not.toHaveBeenCalled();
+    expect(ctx.ui.theme.fg).not.toHaveBeenCalled();
+  });
+
+  it('refreshes the status at UTC midnight and reschedules while the session stays active', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-05-22T23:59:50.000Z'));
+
+    const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    mocks.loadOpenRouterStatusBar
+      .mockResolvedValueOnce({ kind: 'ready', text: 'OR $4.50 today · 2.0x 30d avg' })
+      .mockResolvedValueOnce({ kind: 'ready', text: 'OR $0.25 today · 0.2x 30d avg' })
+      .mockResolvedValueOnce({ kind: 'ready', text: 'OR $0.30 today · 0.2x 30d avg' });
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {});
+
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
+
+    await vi.waitFor(() => {
+      expect(ctx.ui.setStatus).toHaveBeenCalledWith(
+        'openrouter',
+        'dim:OR $4.50 today · 2.0x 30d avg',
+      );
+    });
+    expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
+
+    await vi.advanceTimersByTimeAsync(10_000);
+
+    await vi.waitFor(() => {
+      expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(2);
+    });
+    expect(ctx.ui.setStatus).toHaveBeenLastCalledWith(
+      'openrouter',
+      'dim:OR $0.25 today · 0.2x 30d avg',
+    );
+
+    await vi.advanceTimersByTimeAsync(24 * 60 * 60 * 1000);
+
+    await vi.waitFor(() => {
+      expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(3);
+    });
+    expect(ctx.ui.setStatus).toHaveBeenLastCalledWith(
+      'openrouter',
+      'dim:OR $0.30 today · 0.2x 30d avg',
+    );
+  });
+
+  it('clears the UTC-midnight rollover timer on session shutdown', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-05-22T23:59:50.000Z'));
+
+    const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({
+      kind: 'ready',
+      text: 'OR $1.00 today · 1.0x 30d avg',
+    });
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {});
+
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
+    await vi.waitFor(() => {
+      expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
+    });
+
     handlers.get('session_shutdown')();
 
+    await vi.advanceTimersByTimeAsync(24 * 60 * 60 * 1000);
+
+    expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
     expect(mocks.stopBackgroundRefresh).toHaveBeenCalledTimes(1);
   });
 });

package/extensions/openrouter/__tests__/status-bar.test.ts

@@ -0,0 +1,262 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { setLocalUsageDir, dedupeLocalUsageEvents } from '../local-usage.js';
+import {
+  calculateOpenRouterStatusStats,
+  formatOpenRouterStatusBar,
+  loadOpenRouterStatusBar,
+  loadOpenRouterStatusStats,
+  type OpenRouterStatusStats,
+} from '../status-bar.js';
+import type { LocalUsageEvent } from '../types.js';
+
+let testDir: string;
+
+function createLocalUsageEvent(
+  id: string,
+  completedAt: string,
+  cost: number,
+  overrides: Partial<LocalUsageEvent> = {},
+): LocalUsageEvent {
+  return {
+    id,
+    generationId: `${id}-generation`,
+    sessionId: 'session-test',
+    completedAt,
+    requests: 1,
+    model: 'openrouter/anthropic/claude-sonnet-4',
+    provider: 'anthropic',
+    promptTokens: 10,
+    completionTokens: 5,
+    cost,
+    ...overrides,
+  };
+}
+
+async function writeDailyFile(
+  dateUtc: string,
+  rows: Array<LocalUsageEvent | string>,
+): Promise<void> {
+  const content = rows
+    .map((row) => (typeof row === 'string' ? row : JSON.stringify(row)))
+    .join('\n');
+  await fs.writeFile(path.join(testDir, `${dateUtc}.jsonl`), `${content}\n`, 'utf8');
+}
+
+beforeEach(async () => {
+  testDir = path.join(
+    os.tmpdir(),
+    `pi-openrouter-status-bar-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  await fs.mkdir(testDir, { recursive: true });
+  setLocalUsageDir(testDir);
+});
+
+afterEach(async () => {
+  setLocalUsageDir(null);
+  vi.restoreAllMocks();
+  vi.doUnmock('../local-usage.js');
+  vi.doUnmock('../status-bar.js');
+
+  try {
+    await fs.rm(testDir, { recursive: true, force: true });
+  } catch {
+    // Ignore cleanup errors.
+  }
+});
+
+describe('calculateOpenRouterStatusStats', () => {
+  it('returns null for no local events', () => {
+    expect(calculateOpenRouterStatusStats([], '2026-05-22')).toBeNull();
+  });
+
+  it('returns null when the full 30-day window totals zero local spend', () => {
+    expect(
+      calculateOpenRouterStatusStats(
+        [
+          createLocalUsageEvent('today-zero', '2026-05-22T09:15:00.000Z', 0),
+          createLocalUsageEvent('older-zero', '2026-05-12T09:15:00.000Z', 0),
+        ],
+        '2026-05-22',
+      ),
+    ).toBeNull();
+  });
+
+  it('includes only UTC-today spend and divides by exactly 30 calendar days', () => {
+    const stats = calculateOpenRouterStatusStats(
+      [
+        createLocalUsageEvent('today', '2026-05-22T09:15:00.000Z', 3),
+        createLocalUsageEvent('yesterday', '2026-05-21T09:15:00.000Z', 9),
+      ],
+      '2026-05-22',
+    );
+
+    expect(stats).toEqual({
+      todayLocalSpend: 3,
+      averageLocalDailySpendLast30Days: 0.4,
+      burnRateMultiplier: 7.5,
+    });
+  });
+
+  it('uses only the today-29 through today window', () => {
+    const stats = calculateOpenRouterStatusStats(
+      [
+        createLocalUsageEvent('old', '2026-04-22T12:00:00.000Z', 100),
+        createLocalUsageEvent('boundary', '2026-04-23T12:00:00.000Z', 6),
+        createLocalUsageEvent('recent', '2026-05-21T12:00:00.000Z', 3),
+        createLocalUsageEvent('today', '2026-05-22T12:00:00.000Z', 1.5),
+      ],
+      '2026-05-22',
+    );
+
+    expect(stats).toEqual({
+      todayLocalSpend: 1.5,
+      averageLocalDailySpendLast30Days: 0.35,
+      burnRateMultiplier: 1.5 / 0.35,
+    });
+  });
+
+  it('deduplicates event ids exactly once across the full 30-day window', () => {
+    const events = [
+      createLocalUsageEvent('duplicate-id', '2026-05-20T12:00:00.000Z', 1),
+      createLocalUsageEvent('duplicate-id', '2026-05-22T12:00:00.000Z', 99),
+      createLocalUsageEvent('unique-id', '2026-05-22T13:00:00.000Z', 2),
+    ];
+
+    expect(dedupeLocalUsageEvents(events)).toHaveLength(2);
+    expect(calculateOpenRouterStatusStats(events, '2026-05-22')).toEqual({
+      todayLocalSpend: 2,
+      averageLocalDailySpendLast30Days: 0.1,
+      burnRateMultiplier: 20,
+    });
+  });
+});
+
+describe('formatOpenRouterStatusBar', () => {
+  it('formats the representative status text exactly', () => {
+    const stats: OpenRouterStatusStats = {
+      todayLocalSpend: 2.14,
+      averageLocalDailySpendLast30Days: 1.64,
+      burnRateMultiplier: 1.3,
+    };
+
+    expect(formatOpenRouterStatusBar(stats)).toBe('OR $2.14 today · 1.3x 30d avg');
+  });
+
+  it('formats $0.00 today · 0.0x 30d avg when prior 30-day spend exists but today spend is zero', () => {
+    const stats: OpenRouterStatusStats = {
+      todayLocalSpend: 0,
+      averageLocalDailySpendLast30Days: 0.5,
+      burnRateMultiplier: 0,
+    };
+
+    expect(formatOpenRouterStatusBar(stats)).toBe('OR $0.00 today · 0.0x 30d avg');
+  });
+
+  it('omits the multiplier when given a stats object with no denominator', () => {
+    expect(
+      formatOpenRouterStatusBar({
+        todayLocalSpend: 2.14,
+        averageLocalDailySpendLast30Days: 0,
+        burnRateMultiplier: null,
+      }),
+    ).toBe('OR $2.14 today');
+  });
+});
+
+describe('loadOpenRouterStatusStats and loadOpenRouterStatusBar', () => {
+  it('returns an empty result for empty local usage data', async () => {
+    const now = new Date('2026-05-22T12:00:00.000Z');
+
+    await expect(loadOpenRouterStatusStats(now)).resolves.toBeNull();
+    await expect(loadOpenRouterStatusBar(now)).resolves.toEqual({ kind: 'empty' });
+  });
+
+  it('returns an empty result when the 30-day window has only zero-cost local rows', async () => {
+    await writeDailyFile('2026-05-12', [
+      createLocalUsageEvent('older-zero', '2026-05-12T12:00:00.000Z', 0),
+    ]);
+    await writeDailyFile('2026-05-22', [
+      createLocalUsageEvent('today-zero', '2026-05-22T12:00:00.000Z', 0),
+    ]);
+
+    const now = new Date('2026-05-22T12:00:00.000Z');
+
+    await expect(loadOpenRouterStatusStats(now)).resolves.toBeNull();
+    await expect(loadOpenRouterStatusBar(now)).resolves.toEqual({ kind: 'empty' });
+  });
+
+  it('requests local usage only from today-29 through today', async () => {
+    vi.resetModules();
+    const actualLocalUsage =
+      await vi.importActual<typeof import('../local-usage.js')>('../local-usage.js');
+    const readLocalUsage = vi
+      .fn()
+      .mockResolvedValue([
+        createLocalUsageEvent('boundary', '2026-04-23T12:00:00.000Z', 1),
+        createLocalUsageEvent('today', '2026-05-22T12:00:00.000Z', 2),
+      ]);
+
+    vi.doMock('../local-usage.js', () => ({
+      ...actualLocalUsage,
+      readLocalUsage,
+    }));
+
+    const { loadOpenRouterStatusStats: loadMockedStats } = await import('../status-bar.js');
+
+    await expect(loadMockedStats(new Date('2026-05-22T12:00:00.000Z'))).resolves.toEqual({
+      todayLocalSpend: 2,
+      averageLocalDailySpendLast30Days: 0.1,
+      burnRateMultiplier: 20,
+    });
+    expect(readLocalUsage).toHaveBeenCalledTimes(1);
+    expect(readLocalUsage).toHaveBeenCalledWith({
+      fromDateUtc: '2026-04-23',
+      toDateUtc: '2026-05-22',
+    });
+  });
+
+  it('tolerates missing files and malformed rows while returning a ready status', async () => {
+    await writeDailyFile('2026-05-10', [
+      createLocalUsageEvent('older', '2026-05-10T12:00:00.000Z', 4),
+      '{not json}',
+    ]);
+    await writeDailyFile('2026-05-22', [
+      createLocalUsageEvent('today', '2026-05-22T12:00:00.000Z', 2),
+      '',
+    ]);
+
+    const now = new Date('2026-05-22T12:00:00.000Z');
+
+    await expect(loadOpenRouterStatusStats(now)).resolves.toEqual({
+      todayLocalSpend: 2,
+      averageLocalDailySpendLast30Days: 0.2,
+      burnRateMultiplier: 10,
+    });
+    await expect(loadOpenRouterStatusBar(now)).resolves.toEqual({
+      kind: 'ready',
+      text: 'OR $2.00 today · 10.0x 30d avg',
+    });
+  });
+
+  it('returns a failed result when the local usage read path throws unexpectedly', async () => {
+    vi.resetModules();
+
+    const readLocalUsage = vi.fn().mockRejectedValue(new Error('disk exploded'));
+    vi.doMock('../local-usage.js', async () => {
+      const actual = await vi.importActual<typeof import('../local-usage.js')>('../local-usage.js');
+      return {
+        ...actual,
+        readLocalUsage,
+      };
+    });
+
+    const { loadOpenRouterStatusBar: loadMockedBar } = await import('../status-bar.js');
+
+    await expect(loadMockedBar(new Date('2026-05-22T12:00:00.000Z'))).resolves.toEqual({
+      kind: 'failed',
+    });
+  });
+});

package/extensions/openrouter/hooks.ts

@@ -10,9 +10,13 @@ import { writeLocalUsage, type LocalUsageEvent } from './local-usage.js';
 import { loadCache, getCacheAgeMs, formatDuration } from './models/cache.js';
 import { mapOpenRouterModels } from './models/mapper.js';
 import { includeBuiltinRouterModels, isSyncEnabled } from './models/sync.js';
+import { loadOpenRouterStatusBar } from './status-bar.js';
 
 let sessionState: SessionState | null = null;
 let sessionTrackingInstalled = false;
+let openRouterStatusRolloverTimer: ReturnType<typeof setTimeout> | null = null;
+
+type StatusContext = Pick<ExtensionContext, 'hasUI' | 'ui'>;
 
 export interface StartupCacheState {
   info?: {
@@ -129,15 +133,12 @@ function installSessionTaggingHook(pi: Pick<ExtensionAPI, 'on'>): void {
 }
 
 function installLocalUsageHook(pi: Pick<ExtensionAPI, 'on'>): void {
-  pi.on('turn_end', async (event, ctx) => {
-    await captureLocalUsage(event as unknown, ctx);
+  pi.on('turn_end', (event, ctx) => {
+    captureLocalUsage(event as unknown, ctx);
   });
 }
 
-async function captureLocalUsage(
-  event: unknown,
-  ctx: { sessionManager: { getSessionId(): string } },
-): Promise<void> {
+function captureLocalUsage(event: unknown, ctx: ExtensionContext): void {
   try {
     const turnEvent = event as Record<string, unknown>;
 
@@ -184,17 +185,77 @@ async function captureLocalUsage(
       cost: usage.cost?.total ?? 0,
     };
 
-    writeLocalUsage(localEvent).catch(() => {});
+    void writeLocalUsage(localEvent)
+      .then(() => refreshOpenRouterUsageStatus(ctx))
+      .catch(() => {});
   } catch {
     // Fail open - silently ignore errors
   }
 }
 
+async function refreshOpenRouterUsageStatus(ctx: StatusContext): Promise<void> {
+  if (!ctx.hasUI) return;
+
+  try {
+    const statusResult = await loadOpenRouterStatusBar();
+
+    switch (statusResult.kind) {
+      case 'ready':
+        ctx.ui.setStatus('openrouter', ctx.ui.theme.fg('dim', statusResult.text));
+        return;
+      case 'empty':
+        ctx.ui.setStatus('openrouter', undefined);
+        return;
+      case 'failed':
+        return;
+    }
+  } catch {
+    // Fail open - preserve the existing status on unexpected refresh errors.
+  }
+}
+
+function clearOpenRouterStatusRolloverTimer(): void {
+  if (openRouterStatusRolloverTimer !== null) {
+    clearTimeout(openRouterStatusRolloverTimer);
+    openRouterStatusRolloverTimer = null;
+  }
+}
+
+function getMillisecondsUntilNextUtcMidnight(now: Date = new Date()): number {
+  const nextUtcMidnight = Date.UTC(
+    now.getUTCFullYear(),
+    now.getUTCMonth(),
+    now.getUTCDate() + 1,
+    0,
+    0,
+    0,
+    0,
+  );
+
+  return Math.max(0, nextUtcMidnight - now.getTime());
+}
+
+function scheduleOpenRouterStatusRollover(ctx: StatusContext): void {
+  clearOpenRouterStatusRolloverTimer();
+
+  if (!ctx.hasUI) {
+    return;
+  }
+
+  openRouterStatusRolloverTimer = setTimeout(() => {
+    openRouterStatusRolloverTimer = null;
+    void refreshOpenRouterUsageStatus(ctx).catch(() => {});
+    scheduleOpenRouterStatusRollover(ctx);
+  }, getMillisecondsUntilNextUtcMidnight());
+  openRouterStatusRolloverTimer.unref?.();
+}
+
 function installLifecycleHooks(
   pi: Pick<ExtensionAPI, 'on'>,
   startupState: StartupCacheState,
 ): void {
   pi.on('session_shutdown', () => {
+    clearOpenRouterStatusRolloverTimer();
     stopBackgroundRefresh();
     sessionState?.reset();
   });
@@ -213,10 +274,8 @@ function handleSessionStart(
 
   if (!ctx.hasUI) return;
 
-  if (startupState.info) {
-    const statusText = `OpenRouter ${startupState.info.count} models`;
-    ctx.ui.setStatus('openrouter', ctx.ui.theme.fg('dim', statusText));
-  }
+  void refreshOpenRouterUsageStatus(ctx).catch(() => {});
+  scheduleOpenRouterStatusRollover(ctx);
 
   if (event.reason === 'startup' && startupState.info) {
     const notice = `OpenRouter: ${startupState.info.count} models loaded from cache (${startupState.info.age} old). Run /openrouter models-sync to refresh.`;

package/extensions/openrouter/local-usage.ts

@@ -165,15 +165,9 @@ export async function readLocalUsage(options: ReadLocalUsageOptions): Promise<Lo
 }
 
 /**
- * Aggregate local usage events into UsageAggregate.
- * Deduplicates by id (first occurrence wins).
+ * Deduplicate local usage events by id (first occurrence wins).
  */
-export function aggregateLocal(events: LocalUsageEvent[]): UsageAggregate {
-  if (events.length === 0) {
-    return createZeroAggregate();
-  }
-
-  // Deduplicate by id
+export function dedupeLocalUsageEvents(events: LocalUsageEvent[]): LocalUsageEvent[] {
   const seen = new Set<string>();
   const unique: LocalUsageEvent[] = [];
 
@@ -183,8 +177,19 @@ export function aggregateLocal(events: LocalUsageEvent[]): UsageAggregate {
     unique.push(event);
   }
 
-  // Aggregate
-  const result = unique.reduce((acc, event) => {
+  return unique;
+}
+
+/**
+ * Aggregate local usage events into UsageAggregate.
+ * Deduplicates by id (first occurrence wins).
+ */
+export function aggregateLocal(events: LocalUsageEvent[]): UsageAggregate {
+  if (events.length === 0) {
+    return createZeroAggregate();
+  }
+
+  const result = dedupeLocalUsageEvents(events).reduce((acc, event) => {
     acc.requests += event.requests ?? 1;
     acc.promptTokens += event.promptTokens || 0;
     acc.completionTokens += event.completionTokens || 0;

package/extensions/openrouter/status-bar.ts

@@ -0,0 +1,101 @@
+import {
+  addUtcDays,
+  dedupeLocalUsageEvents,
+  getCurrentUtcDate,
+  getUtcDateFromTimestamp,
+  readLocalUsage,
+} from './local-usage.js';
+import type { LocalUsageEvent } from './types.js';
+
+const STATUS_WINDOW_DAYS = 30;
+const STATUS_WINDOW_LABEL = '30d avg';
+const STATUS_PREFIX = 'OR';
+const STATUS_SEPARATOR = ' · ';
+
+export interface OpenRouterStatusStats {
+  todayLocalSpend: number;
+  averageLocalDailySpendLast30Days: number;
+  burnRateMultiplier: number | null;
+}
+
+export type OpenRouterStatusBarLoadResult =
+  | { kind: 'ready'; text: string }
+  | { kind: 'empty' }
+  | { kind: 'failed' };
+
+function getUtcDateForNow(now?: Date): string {
+  return now ? now.toISOString().slice(0, 10) : getCurrentUtcDate();
+}
+
+export function calculateOpenRouterStatusStats(
+  events: LocalUsageEvent[],
+  nowUtcDate: string = getCurrentUtcDate(),
+): OpenRouterStatusStats | null {
+  const windowStartUtc = addUtcDays(nowUtcDate, -(STATUS_WINDOW_DAYS - 1));
+  const uniqueEvents = dedupeLocalUsageEvents(events);
+
+  let todayLocalSpend = 0;
+  let totalLocalSpendInWindow = 0;
+
+  for (const event of uniqueEvents) {
+    const completedDateUtc = getUtcDateFromTimestamp(event.completedAt);
+    if (completedDateUtc < windowStartUtc || completedDateUtc > nowUtcDate) {
+      continue;
+    }
+
+    const cost = event.cost ?? 0;
+    totalLocalSpendInWindow += cost;
+
+    if (completedDateUtc === nowUtcDate) {
+      todayLocalSpend += cost;
+    }
+  }
+
+  if (totalLocalSpendInWindow <= 0) {
+    return null;
+  }
+
+  const averageLocalDailySpendLast30Days = totalLocalSpendInWindow / STATUS_WINDOW_DAYS;
+
+  return {
+    todayLocalSpend,
+    averageLocalDailySpendLast30Days,
+    burnRateMultiplier:
+      averageLocalDailySpendLast30Days === 0
+        ? null
+        : todayLocalSpend / averageLocalDailySpendLast30Days,
+  };
+}
+
+export function formatOpenRouterStatusBar(stats: OpenRouterStatusStats): string {
+  const today = `${STATUS_PREFIX} $${stats.todayLocalSpend.toFixed(2)} today`;
+  if (stats.burnRateMultiplier === null) {
+    return today;
+  }
+
+  return `${today}${STATUS_SEPARATOR}${stats.burnRateMultiplier.toFixed(1)}x ${STATUS_WINDOW_LABEL}`;
+}
+
+export async function loadOpenRouterStatusStats(now?: Date): Promise<OpenRouterStatusStats | null> {
+  const todayUtc = getUtcDateForNow(now);
+  const fromDateUtc = addUtcDays(todayUtc, -(STATUS_WINDOW_DAYS - 1));
+  const events = await readLocalUsage({ fromDateUtc, toDateUtc: todayUtc });
+
+  return calculateOpenRouterStatusStats(events, todayUtc);
+}
+
+export async function loadOpenRouterStatusBar(now?: Date): Promise<OpenRouterStatusBarLoadResult> {
+  try {
+    const stats = await loadOpenRouterStatusStats(now);
+    if (!stats) {
+      return { kind: 'empty' };
+    }
+
+    return {
+      kind: 'ready',
+      text: formatOpenRouterStatusBar(stats),
+    };
+  } catch {
+    return { kind: 'failed' };
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robhowley/pi-openrouter",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "type": "module",
   "description": "Live OpenRouter spend/account TUI overlays, user-scoped model sync, and session tagging for Pi.",
   "license": "MIT",