@robhowley/pi-openrouter 0.9.0 → 0.10.0

package/extensions/openrouter/__tests__/fixtures.ts

@@ -137,7 +137,8 @@ export function createPiModelConfig(overrides?: Partial<PiModelConfig>): PiModel
 // LocalUsageEvent Fixtures
 // =============================================================================
 
-import type { LocalUsageEvent } from '../types.js';
+import type { LocalUsageEvent, UsageAggregate, UsageSummary } from '../types.js';
+import { createZeroAggregate } from '../types.js';
 
 /**
  * Creates LocalUsageEvent objects for testing local usage aggregation.
@@ -159,3 +160,141 @@ export function createLocalEvents(
     cost: e.cost,
   }));
 }
+
+// =============================================================================
+// Session Context Fixtures
+// =============================================================================
+
+/**
+ * Special marker for session contexts that should throw when getSessionId is called.
+ */
+export const THROW_SESSION_ID = Symbol('THROW_SESSION_ID');
+
+/**
+ * Creates a mock context with a sessionManager for testing.
+ *
+ * @param sessionIdOrMarker - Session ID string, empty string, or THROW_SESSION_ID symbol
+ * @returns Context object with sessionManager.getSessionId() method
+ *
+ * @example
+ * // Normal session ID
+ * const ctx = createSessionCtx('my-session');
+ *
+ * // Empty string fallback
+ * const ctx = createSessionCtx('');
+ *
+ * // Throwing session manager
+ * const ctx = createSessionCtx(THROW_SESSION_ID);
+ */
+export function createSessionCtx(sessionIdOrMarker: string | symbol): {
+  sessionManager: { getSessionId: () => string };
+} {
+  if (sessionIdOrMarker === THROW_SESSION_ID) {
+    return {
+      sessionManager: {
+        getSessionId: () => {
+          throw new Error('Session manager error');
+        },
+      },
+    };
+  }
+  return {
+    sessionManager: {
+      getSessionId: () => sessionIdOrMarker as string,
+    },
+  };
+}
+
+// =============================================================================
+// Request Event Fixtures
+// =============================================================================
+
+/**
+ * Creates an OpenRouter request event for testing.
+ *
+ * @param overrides - Override default provider, payload, or other event properties
+ * @returns Request event object suitable for hook tests
+ *
+ * @example
+ * // Default OpenRouter request
+ * const event = createOpenRouterRequest();
+ *
+ * // With custom model
+ * const event = createOpenRouterRequest({ payload: { model: 'custom/model', messages: [] } });
+ *
+ * // Non-OpenRouter provider
+ * const event = createOpenRouterRequest({ provider: 'anthropic' });
+ */
+export function createOpenRouterRequest(overrides?: {
+  type?: string;
+  provider?: string;
+  payload?: Record<string, unknown>;
+  url?: string;
+}): {
+  type: string;
+  provider: string;
+  payload?: Record<string, unknown>;
+  url?: string;
+} {
+  return {
+    type: 'before_provider_request',
+    provider: 'openrouter',
+    payload: {
+      model: 'openrouter/anthropic/claude-sonnet-4',
+      messages: [],
+    },
+    ...overrides,
+  };
+}
+
+// =============================================================================
+// UsageAggregate Fixtures
+// =============================================================================
+
+/**
+ * Creates a UsageAggregate with overrides.
+ * Starts with zeros and allows customizing specific fields.
+ */
+export function createUsageAggregate(overrides?: Partial<UsageAggregate>): UsageAggregate {
+  return {
+    ...createZeroAggregate(),
+    ...overrides,
+  };
+}
+
+// =============================================================================
+// UsageSummary Fixtures
+// =============================================================================
+
+/**
+ * Creates a UsageSummary with sensible defaults.
+ * Use overrides to customize for specific test cases.
+ *
+ * @example
+ * // Minimal summary
+ * const summary = createUsageSummary();
+ *
+ * // With custom today/local split
+ * const summary = createUsageSummary({
+ *   today: 0.5,
+ *   local: createUsageAggregate({ cost: 2.0, requests: 10 })
+ * });
+ */
+export function createUsageSummary(overrides?: Partial<UsageSummary>): UsageSummary {
+  return {
+    today: 0,
+    week: 0,
+    month: 0,
+    cap: 10,
+    burnRate: 0,
+    topModels: [],
+    byProvider: [],
+    byDay: {},
+    timestamp: Date.now(),
+    hasActivityData: true,
+    official: createZeroAggregate(),
+    local: createZeroAggregate(),
+    combined: createZeroAggregate(),
+    ...overrides,
+  };
+}

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

@@ -90,6 +90,25 @@ describe('aggregateUsage', () => {
     expect(result.byDay).toEqual({});
   });
 
+  it('should create fresh zero aggregates for official, local, and combined', () => {
+    const result = aggregateUsage({ totalUsage: 0, totalCredits: 0 }, []);
+
+    expect(result.official).toEqual({
+      requests: 0,
+      promptTokens: 0,
+      completionTokens: 0,
+      reasoningTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      cost: 0,
+    });
+    expect(result.local).toEqual(result.official);
+    expect(result.combined).toEqual(result.official);
+    expect(result.official).not.toBe(result.local);
+    expect(result.official).not.toBe(result.combined);
+    expect(result.local).not.toBe(result.combined);
+  });
+
   it('should aggregate by model', () => {
     const credits = {
       totalUsage: 10,

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

@@ -0,0 +1,529 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+  stopBackgroundRefresh: vi.fn(),
+  isOpenRouterRequest: vi.fn(),
+  writeLocalUsage: vi.fn(),
+  loadCache: vi.fn(),
+  getCacheAgeMs: vi.fn(),
+  formatDuration: vi.fn(),
+  mapOpenRouterModels: vi.fn(),
+  includeBuiltinRouterModels: vi.fn(),
+  isSyncEnabled: vi.fn(),
+  loadOpenRouterStatusBar: vi.fn(),
+}));
+
+vi.mock('../cache.js', () => ({
+  stopBackgroundRefresh: mocks.stopBackgroundRefresh,
+}));
+
+vi.mock('../session.js', () => ({
+  isOpenRouterRequest: mocks.isOpenRouterRequest,
+  formatSessionId: (value: string) => `pi:${value}`,
+}));
+
+vi.mock('../local-usage.js', () => ({
+  writeLocalUsage: mocks.writeLocalUsage,
+}));
+
+vi.mock('../models/cache.js', () => ({
+  loadCache: mocks.loadCache,
+  getCacheAgeMs: mocks.getCacheAgeMs,
+  formatDuration: mocks.formatDuration,
+}));
+
+vi.mock('../models/mapper.js', () => ({
+  mapOpenRouterModels: mocks.mapOpenRouterModels,
+}));
+
+vi.mock('../models/sync.js', () => ({
+  includeBuiltinRouterModels: mocks.includeBuiltinRouterModels,
+  isSyncEnabled: mocks.isSyncEnabled,
+}));
+
+vi.mock('../status-bar.js', () => ({
+  loadOpenRouterStatusBar: mocks.loadOpenRouterStatusBar,
+}));
+
+function createMockPi() {
+  const handlers = new Map<string, any>();
+  return {
+    handlers,
+    pi: {
+      on: vi.fn((event: string, handler: unknown) => {
+        handlers.set(event, handler);
+      }),
+      registerProvider: vi.fn(),
+    },
+  };
+}
+
+function createMockContext(overrides: { hasUI?: boolean } = {}) {
+  return {
+    hasUI: overrides.hasUI ?? true,
+    sessionManager: {
+      getSessionId: vi.fn(() => 'session-123'),
+    },
+    ui: {
+      notify: vi.fn(),
+      setStatus: vi.fn(),
+      theme: {
+        fg: vi.fn((_style: string, text: string) => `dim:${text}`),
+      },
+    },
+  } 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');
+}
+
+describe('openrouter hooks', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.resetAllMocks();
+    vi.useRealTimers();
+
+    mocks.isOpenRouterRequest.mockReturnValue(true);
+    mocks.writeLocalUsage.mockResolvedValue(undefined);
+    mocks.loadCache.mockResolvedValue(null);
+    mocks.getCacheAgeMs.mockReturnValue(60000);
+    mocks.formatDuration.mockReturnValue('1 minute');
+    mocks.mapOpenRouterModels.mockResolvedValue({ configs: [{ id: 'model-a' }] });
+    mocks.includeBuiltinRouterModels.mockReturnValue([{ id: 'model-a' }, { id: 'router' }]);
+    mocks.isSyncEnabled.mockReturnValue(true);
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({ kind: 'empty' });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('loads cached startup models and preserves startup cache info', async () => {
+    const { pi } = createMockPi();
+    const { loadStartupCacheState } = await loadHooksModule();
+
+    mocks.loadCache.mockResolvedValue({
+      models: [{ id: 'cached/model-a' }],
+      timestamp: Date.now() - 60000,
+    });
+
+    const startupState = await loadStartupCacheState(pi as any);
+
+    expect(pi.registerProvider).toHaveBeenCalledWith('openrouter', {
+      baseUrl: 'https://openrouter.ai/api/v1',
+      apiKey: 'OPENROUTER_API_KEY',
+      api: 'openai-completions',
+      models: [{ id: 'model-a' }, { id: 'router' }],
+      authHeader: true,
+    });
+    expect(startupState).toEqual({
+      info: {
+        count: 2,
+        age: '1 minute',
+      },
+    });
+  });
+
+  it('keeps startup cache warning behavior unchanged when cached registration fails', async () => {
+    const { pi } = createMockPi();
+    const { loadStartupCacheState } = await loadHooksModule();
+
+    mocks.loadCache.mockResolvedValue({
+      models: [{ id: 'cached/model-a' }],
+      timestamp: Date.now() - 60000,
+    });
+    mocks.mapOpenRouterModels.mockRejectedValue(new Error('mapper failed'));
+
+    const startupState = await loadStartupCacheState(pi as any);
+
+    expect(pi.registerProvider).not.toHaveBeenCalled();
+    expect(startupState).toEqual({
+      warning: 'OpenRouter: cached models found but failed to register: mapper failed',
+    });
+  });
+
+  it('installs the session-tagging hook only once across repeated installs', async () => {
+    const { pi } = createMockPi();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {});
+    installOpenRouterHooks(pi as any, {});
+
+    expect(pi.on.mock.calls.filter(([event]) => event === 'before_provider_request')).toHaveLength(
+      1,
+    );
+    expect(pi.on.mock.calls.filter(([event]) => event === 'turn_end')).toHaveLength(2);
+    expect(pi.on.mock.calls.filter(([event]) => event === 'session_start')).toHaveLength(2);
+    expect(pi.on.mock.calls.filter(([event]) => event === 'session_shutdown')).toHaveLength(2);
+  });
+
+  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' },
+    });
+
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
+
+    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('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',
+    });
+
+    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 () => {
+    const { handlers, pi } = createMockPi();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {});
+
+    const result = handlers.get('before_provider_request')(
+      {
+        provider: 'openrouter',
+        payload: {
+          model: 'openrouter/anthropic/claude-sonnet-4',
+          messages: [],
+        },
+      },
+      {
+        sessionManager: {
+          getSessionId: () => 'session-abc',
+        },
+      },
+    );
+
+    expect(result).toEqual({
+      model: 'openrouter/anthropic/claude-sonnet-4',
+      messages: [],
+      session_id: 'pi:session-abc',
+    });
+  });
+
+  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, {});
+
+    await handlers.get('turn_end')(
+      {
+        url: 'https://openrouter.ai/api/v1/chat/completions',
+        message: {
+          model: 'openrouter/anthropic/claude-sonnet-4',
+          responseId: 'resp-1',
+          usage: {
+            input: 11,
+            output: 7,
+            cacheRead: 3,
+            cacheWrite: 2,
+            cost: { total: 1.25 },
+          },
+        },
+      },
+      ctx,
+    );
+
+    expect(mocks.writeLocalUsage).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: '11111111-1111-4111-8111-111111111111',
+        generationId: 'resp-1',
+        sessionId: 'pi:session-123',
+        model: 'openrouter/anthropic/claude-sonnet-4',
+        requests: 1,
+        promptTokens: 11,
+        completionTokens: 7,
+        reasoningTokens: 0,
+        cacheReadTokens: 3,
+        cacheWriteTokens: 2,
+        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('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);
+  });
+});