@robhowley/pi-openrouter 0.12.1 → 0.14.0

package/README.md

@@ -168,6 +168,20 @@ The extension logs completed OpenRouter turns to local JSONL files in `~/.pi/ope
 
 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`.
 
+To hide only the footer/status bar, set `pi-openrouter.statusEnabled` to `false` in either `~/.pi/agent/settings.json` or `.pi/settings.json`:
+
+```json
+{
+  "pi-openrouter": {
+    "statusEnabled": false
+  }
+}
+```
+
+The default is enabled. Setting `false` hides only the footer/status bar; `/openrouter usage`, `/openrouter models-status`, model sync, and local usage tracking remain available.
+
+Project-local `.pi/settings.json` only overrides the global setting when Pi treats the project as trusted. If trust state is unavailable, `pi-openrouter` falls back to the global setting.
+
 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__/config.test.ts

@@ -0,0 +1,173 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { isStatusEnabled, loadOpenRouterConfig } from '../config.js';
+
+function writeJsonFile(path: string, value: unknown) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(value, null, 2), 'utf-8');
+}
+
+describe.sequential('openrouter config', () => {
+  let originalAgentDir: string | undefined;
+  let testRoot: string;
+  let cwd: string;
+  let agentDir: string;
+
+  beforeEach(() => {
+    originalAgentDir = process.env['PI_CODING_AGENT_DIR'];
+    testRoot = mkdtempSync(join(tmpdir(), 'pi-openrouter-config-'));
+    cwd = join(testRoot, 'repo');
+    agentDir = join(testRoot, 'agent');
+    mkdirSync(cwd, { recursive: true });
+    process.env['PI_CODING_AGENT_DIR'] = agentDir;
+  });
+
+  afterEach(() => {
+    if (originalAgentDir === undefined) {
+      delete process.env['PI_CODING_AGENT_DIR'];
+    } else {
+      process.env['PI_CODING_AGENT_DIR'] = originalAgentDir;
+    }
+
+    rmSync(testRoot, { recursive: true, force: true });
+  });
+
+  function writeGlobalSettings(settings: unknown) {
+    writeJsonFile(join(agentDir, 'settings.json'), settings);
+  }
+
+  function writeProjectSettings(settings: unknown) {
+    writeJsonFile(join(cwd, '.pi', 'settings.json'), settings);
+  }
+
+  it('defaults statusEnabled to true when settings are absent', () => {
+    expect(loadOpenRouterConfig(cwd)).toEqual({
+      statusEnabled: true,
+    });
+    expect(isStatusEnabled(cwd)).toBe(true);
+  });
+
+  it('lets a global false disable status', () => {
+    writeGlobalSettings({
+      'pi-openrouter': {
+        statusEnabled: false,
+      },
+    });
+
+    expect(loadOpenRouterConfig(cwd)).toEqual({
+      statusEnabled: false,
+    });
+    expect(isStatusEnabled(cwd)).toBe(false);
+  });
+
+  it('lets project false override global true', () => {
+    writeGlobalSettings({
+      'pi-openrouter': {
+        statusEnabled: true,
+      },
+    });
+    writeProjectSettings({
+      'pi-openrouter': {
+        statusEnabled: false,
+      },
+    });
+
+    expect(loadOpenRouterConfig(cwd)).toEqual({
+      statusEnabled: false,
+    });
+  });
+
+  it('lets project true override global false', () => {
+    writeGlobalSettings({
+      'pi-openrouter': {
+        statusEnabled: false,
+      },
+    });
+    writeProjectSettings({
+      'pi-openrouter': {
+        statusEnabled: true,
+      },
+    });
+
+    expect(loadOpenRouterConfig(cwd)).toEqual({
+      statusEnabled: true,
+    });
+  });
+
+  it('keeps a global false when trusted project-local settings are malformed', () => {
+    writeGlobalSettings({
+      'pi-openrouter': {
+        statusEnabled: false,
+      },
+    });
+    writeProjectSettings({
+      'pi-openrouter': {
+        statusEnabled: 'invalid',
+      },
+    });
+
+    expect(loadOpenRouterConfig(cwd)).toEqual({
+      statusEnabled: false,
+    });
+
+    writeProjectSettings({
+      'pi-openrouter': 'invalid',
+    });
+
+    expect(loadOpenRouterConfig(cwd)).toEqual({
+      statusEnabled: false,
+    });
+  });
+
+  it('defaults invalid or unset values to true when neither scope has a valid boolean', () => {
+    writeGlobalSettings({
+      'pi-openrouter': {
+        statusEnabled: 'invalid',
+      },
+    });
+
+    expect(loadOpenRouterConfig(cwd)).toEqual({
+      statusEnabled: true,
+    });
+
+    writeGlobalSettings({
+      'pi-openrouter': 'invalid',
+    });
+    writeProjectSettings({});
+
+    expect(loadOpenRouterConfig(cwd)).toEqual({
+      statusEnabled: true,
+    });
+
+    writeGlobalSettings({});
+    writeProjectSettings({
+      'pi-openrouter': {
+        statusEnabled: 'invalid',
+      },
+    });
+
+    expect(loadOpenRouterConfig(cwd)).toEqual({
+      statusEnabled: true,
+    });
+  });
+
+  it('ignores project-local overrides when the project is untrusted', () => {
+    writeGlobalSettings({
+      'pi-openrouter': {
+        statusEnabled: true,
+      },
+    });
+    writeProjectSettings({
+      'pi-openrouter': {
+        statusEnabled: false,
+      },
+    });
+
+    expect(loadOpenRouterConfig(cwd, false)).toEqual({
+      statusEnabled: true,
+    });
+    expect(isStatusEnabled(cwd, false)).toBe(true);
+  });
+});

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

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createOpenRouterRequest, createSessionCtx, THROW_SESSION_ID } from './fixtures.js';
 
 const mocks = vi.hoisted(() => ({
   stopBackgroundRefresh: vi.fn(),
@@ -13,6 +14,7 @@ const mocks = vi.hoisted(() => ({
   isSyncEnabled: vi.fn(),
   setActiveCatalogState: vi.fn(),
   loadOpenRouterStatusBar: vi.fn(),
+  isStatusEnabled: vi.fn(),
 }));
 
 vi.mock('../cache.js', () => ({
@@ -49,6 +51,10 @@ vi.mock('../status-bar.js', () => ({
   loadOpenRouterStatusBar: mocks.loadOpenRouterStatusBar,
 }));
 
+vi.mock('../config.js', () => ({
+  isStatusEnabled: mocks.isStatusEnabled,
+}));
+
 function createMockPi() {
   const handlers = new Map<string, any>();
   return {
@@ -62,8 +68,11 @@ function createMockPi() {
   };
 }
 
-function createMockContext(overrides: { hasUI?: boolean } = {}) {
-  return {
+function createMockContext(
+  overrides: { cwd?: string; hasUI?: boolean; projectTrusted?: boolean } = {},
+) {
+  const ctx = {
+    cwd: overrides.cwd ?? '/repo',
     hasUI: overrides.hasUI ?? true,
     sessionManager: {
       getSessionId: vi.fn(() => 'session-123'),
@@ -76,6 +85,12 @@ function createMockContext(overrides: { hasUI?: boolean } = {}) {
       },
     },
   } as any;
+
+  if (overrides.projectTrusted !== undefined) {
+    ctx.isProjectTrusted = vi.fn(() => overrides.projectTrusted);
+  }
+
+  return ctx;
 }
 
 function createDeferredPromise<T>() {
@@ -110,12 +125,130 @@ describe('openrouter hooks', () => {
     mocks.includeBuiltinRouterModels.mockReturnValue([{ id: 'model-a' }, { id: 'router' }]);
     mocks.isSyncEnabled.mockReturnValue(true);
     mocks.loadOpenRouterStatusBar.mockResolvedValue({ kind: 'empty' });
+    mocks.isStatusEnabled.mockReturnValue(true);
   });
 
   afterEach(() => {
     vi.useRealTimers();
   });
 
+  describe('addSessionIdToOpenRouterRequest', () => {
+    it('adds session_id to OpenRouter requests', async () => {
+      const { addSessionIdToOpenRouterRequest } = await loadHooksModule();
+
+      const result = addSessionIdToOpenRouterRequest(
+        createOpenRouterRequest(),
+        createSessionCtx('stable-session-123'),
+      );
+
+      expect(result).toEqual({
+        model: 'openrouter/anthropic/claude-sonnet-4',
+        messages: [],
+        session_id: 'pi:stable-session-123',
+      });
+    });
+
+    it('returns same session_id for multiple OpenRouter requests in same session', async () => {
+      const { addSessionIdToOpenRouterRequest } = await loadHooksModule();
+      const ctx = createSessionCtx('stable-session-123');
+
+      const result1 = addSessionIdToOpenRouterRequest(
+        createOpenRouterRequest({
+          payload: { model: 'openrouter/model-1', messages: [] },
+        }),
+        ctx,
+      );
+      const result2 = addSessionIdToOpenRouterRequest(
+        createOpenRouterRequest({
+          payload: { model: 'openrouter/model-2', messages: [] },
+        }),
+        ctx,
+      );
+
+      expect(result1?.['session_id']).toBe('pi:stable-session-123');
+      expect(result2?.['session_id']).toBe('pi:stable-session-123');
+      expect(result1?.['session_id']).toBe(result2?.['session_id']);
+    });
+
+    it('does not overwrite existing session_id in payload', async () => {
+      const { addSessionIdToOpenRouterRequest } = await loadHooksModule();
+      const event = createOpenRouterRequest({
+        payload: {
+          model: 'openrouter/anthropic/claude-sonnet-4',
+          messages: [],
+          session_id: 'existing-session-id',
+        },
+      });
+
+      const result = addSessionIdToOpenRouterRequest(event, createSessionCtx('new-session'));
+
+      expect(result).toBeUndefined();
+      expect(event.payload?.['session_id']).toBe('existing-session-id');
+    });
+
+    it('does not tag non-OpenRouter requests', async () => {
+      mocks.isOpenRouterRequest.mockReturnValue(false);
+      const { addSessionIdToOpenRouterRequest } = await loadHooksModule();
+
+      const result = addSessionIdToOpenRouterRequest(
+        createOpenRouterRequest({
+          provider: 'anthropic',
+          payload: {
+            model: 'claude-sonnet-4',
+            messages: [],
+          },
+        }),
+        createSessionCtx('my-session'),
+      );
+
+      expect(result).toBeUndefined();
+    });
+
+    it('fails open when payload is missing', async () => {
+      const { addSessionIdToOpenRouterRequest } = await loadHooksModule();
+      const event = createOpenRouterRequest();
+      delete event.payload;
+
+      const result = addSessionIdToOpenRouterRequest(event, createSessionCtx('my-session'));
+
+      expect(result).toBeUndefined();
+    });
+
+    it('generates fallback UUID when session manager throws', async () => {
+      const { addSessionIdToOpenRouterRequest } = await loadHooksModule();
+
+      const result = addSessionIdToOpenRouterRequest(
+        createOpenRouterRequest({
+          payload: {
+            model: 'openrouter/model',
+            messages: [],
+          },
+        }),
+        createSessionCtx(THROW_SESSION_ID),
+      );
+
+      expect(result?.['session_id']).toMatch(
+        /^pi:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+      );
+    });
+
+    it('fails open when payload getter throws', async () => {
+      const { addSessionIdToOpenRouterRequest } = await loadHooksModule();
+
+      const result = addSessionIdToOpenRouterRequest(
+        {
+          provider: 'openrouter',
+          get payload() {
+            throw new Error('Payload getter error');
+          },
+        },
+        createSessionCtx('my-session'),
+      );
+
+      expect(result).toBeUndefined();
+    });
+  });
+
   it('loads cached startup models, respects cached mode, and seeds active catalog state', async () => {
     const { pi } = createMockPi();
     const { loadStartupCacheState } = await loadHooksModule();
@@ -277,6 +410,43 @@ describe('openrouter hooks', () => {
     );
   });
 
+  it('clears the footer status without loading local spend when status is disabled', async () => {
+    const { handlers, pi } = createMockPi();
+    const ctx = createMockContext({ projectTrusted: false });
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    mocks.isStatusEnabled.mockReturnValue(false);
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({
+      kind: 'ready',
+      text: 'OR $2.14 today · 1.3x 30d avg',
+    });
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {});
+
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
+
+    expect(mocks.isStatusEnabled).toHaveBeenCalledWith('/repo', false);
+    expect(mocks.loadOpenRouterStatusBar).not.toHaveBeenCalled();
+    expect(ctx.ui.setStatus).toHaveBeenCalledWith('openrouter', undefined);
+  });
+
+  it('uses the conservative global-only path when trust state is unavailable from context', async () => {
+    const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    mocks.isStatusEnabled.mockReturnValue(false);
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {});
+
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
+
+    expect(mocks.isStatusEnabled).toHaveBeenCalledWith('/repo', false);
+    expect(mocks.loadOpenRouterStatusBar).not.toHaveBeenCalled();
+  });
+
   it('clears stale startup status asynchronously when cached models exist but local spend is empty', async () => {
     const { handlers, pi } = createMockPi();
     const ctx = createMockContext();
@@ -433,6 +603,48 @@ describe('openrouter hooks', () => {
     randomUuidSpy.mockRestore();
   });
 
+  it('still writes local usage after a turn when status is disabled', async () => {
+    const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+    const randomUuidSpy = vi
+      .spyOn(globalThis.crypto, 'randomUUID')
+      .mockReturnValue('22222222-2222-4222-8222-222222222222');
+
+    mocks.isStatusEnabled.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://openrouter.ai/api/v1/chat/completions',
+        message: {
+          model: 'openrouter/anthropic/claude-sonnet-4',
+          responseId: 'resp-disabled',
+          usage: {
+            input: 4,
+            output: 2,
+            cost: { total: 0.42 },
+          },
+        },
+      },
+      ctx,
+    );
+
+    expect(mocks.writeLocalUsage).toHaveBeenCalledTimes(1);
+    await vi.waitFor(() => {
+      expect(ctx.ui.setStatus).toHaveBeenCalledWith('openrouter', undefined);
+    });
+    expect(mocks.loadOpenRouterStatusBar).not.toHaveBeenCalled();
+
+    randomUuidSpy.mockRestore();
+  });
+
   it('does not write local usage or update status for non-OpenRouter turns', async () => {
     const { handlers, pi } = createMockPi();
     const ctx = createMockContext();
@@ -530,6 +742,34 @@ describe('openrouter hooks', () => {
     expect(ctx.ui.theme.fg).not.toHaveBeenCalled();
   });
 
+  it('does not schedule the UTC-midnight rollover when status is disabled', 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.isStatusEnabled.mockReturnValue(false);
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({
+      kind: 'ready',
+      text: 'OR $4.50 today · 2.0x 30d avg',
+    });
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {});
+
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
+
+    expect(ctx.ui.setStatus).toHaveBeenCalledWith('openrouter', undefined);
+    expect(mocks.loadOpenRouterStatusBar).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(24 * 60 * 60 * 1000);
+
+    expect(ctx.ui.setStatus).toHaveBeenCalledTimes(1);
+    expect(mocks.loadOpenRouterStatusBar).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'));

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

@@ -1,128 +1,29 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { createSessionCtx, createOpenRouterRequest, THROW_SESSION_ID } from './fixtures.js';
 
-describe('addSessionIdToOpenRouterRequest', () => {
+describe('openrouter index entrypoint', () => {
   beforeEach(() => {
     vi.resetModules();
   });
 
-  it('should add session_id to OpenRouter requests', async () => {
-    const { addSessionIdToOpenRouterRequest } = await import('../index.js');
+  it('re-exports named helpers from hooks.js', async () => {
+    const addSessionIdToOpenRouterRequest = vi.fn();
+    const getCurrentSessionId = vi.fn();
 
-    const mockCtx = createSessionCtx('stable-session-123');
-    const mockEvent = createOpenRouterRequest();
-
-    const result = addSessionIdToOpenRouterRequest(mockEvent, mockCtx);
-
-    expect(result).toBeDefined();
-    expect(result?.['session_id']).toBe('pi:stable-session-123');
-    expect(result?.['model']).toBe('openrouter/anthropic/claude-sonnet-4');
-  });
-
-  it('should return same session_id for multiple OpenRouter requests in same session', async () => {
-    const { addSessionIdToOpenRouterRequest } = await import('../index.js');
-
-    const mockCtx = createSessionCtx('stable-session-123');
-    const mockEvent1 = createOpenRouterRequest({
-      payload: { model: 'openrouter/model-1', messages: [] },
-    });
-    const mockEvent2 = createOpenRouterRequest({
-      payload: { model: 'openrouter/model-2', messages: [] },
-    });
-
-    const result1 = addSessionIdToOpenRouterRequest(mockEvent1, mockCtx);
-    const result2 = addSessionIdToOpenRouterRequest(mockEvent2, mockCtx);
-
-    expect(result1?.['session_id']).toBe('pi:stable-session-123');
-    expect(result2?.['session_id']).toBe('pi:stable-session-123');
-    expect(result1?.['session_id']).toBe(result2?.['session_id']);
-  });
-
-  it('should not overwrite existing session_id in payload', async () => {
-    const { addSessionIdToOpenRouterRequest } = await import('../index.js');
-
-    const mockCtx = createSessionCtx('new-session');
-    const mockEvent = createOpenRouterRequest({
-      payload: {
-        model: 'openrouter/anthropic/claude-sonnet-4',
-        messages: [],
-        session_id: 'existing-session-id',
-      },
-    });
-
-    const result = addSessionIdToOpenRouterRequest(mockEvent, mockCtx);
-
-    expect(result).toBeUndefined();
-    expect(mockEvent['payload']?.['session_id']).toBe('existing-session-id');
-  });
-
-  it('should not tag non-OpenRouter requests', async () => {
-    const { addSessionIdToOpenRouterRequest } = await import('../index.js');
-
-    const mockCtx = createSessionCtx('my-session');
-    const mockEvent = createOpenRouterRequest({
-      provider: 'anthropic',
-      payload: {
-        model: 'claude-sonnet-4',
-        messages: [],
-      },
-    });
-
-    const result = addSessionIdToOpenRouterRequest(mockEvent, mockCtx);
-
-    expect(result).toBeUndefined();
-  });
-
-  it('should fail open when payload is missing', async () => {
-    const { addSessionIdToOpenRouterRequest } = await import('../index.js');
-
-    const mockCtx = createSessionCtx('my-session');
-    const mockEvent = createOpenRouterRequest();
-    delete mockEvent['payload'];
-
-    const result = addSessionIdToOpenRouterRequest(mockEvent, mockCtx);
-
-    expect(result).toBeUndefined();
-  });
-
-  it('should generate fallback UUID when session manager throws', async () => {
-    const { addSessionIdToOpenRouterRequest } = await import('../index.js');
-
-    const mockCtx = createSessionCtx(THROW_SESSION_ID);
-    const mockEvent = createOpenRouterRequest({
-      payload: {
-        model: 'openrouter/model',
-        messages: [],
-      },
-    });
-
-    const result = addSessionIdToOpenRouterRequest(mockEvent, mockCtx);
-
-    expect(result).toBeDefined();
-    expect(result?.['session_id']).toMatch(
-      /^pi:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
-    );
-  });
-
-  it('should fail open when payload getter throws', async () => {
-    const { addSessionIdToOpenRouterRequest } = await import('../index.js');
-
-    const mockCtx = createSessionCtx('my-session');
-    const mockEvent = {
-      provider: 'openrouter',
-      get payload() {
-        throw new Error('Payload getter error');
-      },
-    };
+    vi.doMock('../hooks.js', () => ({
+      addSessionIdToOpenRouterRequest,
+      getCurrentSessionId,
+      initializeSessionState: vi.fn(),
+      loadStartupCacheState: vi.fn(),
+      installOpenRouterHooks: vi.fn(),
+    }));
+    vi.doMock('../commands.js', () => ({
+      registerOpenRouterCommands: vi.fn(),
+    }));
 
-    const result = addSessionIdToOpenRouterRequest(mockEvent, mockCtx);
-    expect(result).toBeUndefined();
-  });
-});
+    const index = await import('../index.js');
 
-describe('default extension export', () => {
-  beforeEach(() => {
-    vi.resetModules();
+    expect(index.addSessionIdToOpenRouterRequest).toBe(addSessionIdToOpenRouterRequest);
+    expect(index.getCurrentSessionId).toBe(getCurrentSessionId);
   });
 
   it('composes startup cache loading, hook installation, and command registration', async () => {

package/extensions/openrouter/__tests__/local-usage.test.ts

@@ -121,11 +121,12 @@ describe('writeLocalUsage', () => {
   });
 
   it('appends multiple events to same daily file', async () => {
+    const usageDate = addUtcDays(getCurrentUtcDate(), -1);
     const event1: LocalUsageEvent = {
       id: 'test-1',
       generationId: 'gen-1',
       sessionId: 'session-1',
-      completedAt: '2026-05-22T10:00:00.000Z',
+      completedAt: `${usageDate}T10:00:00.000Z`,
       cost: 0.001,
     };
 
@@ -133,14 +134,14 @@ describe('writeLocalUsage', () => {
       id: 'test-2',
       generationId: 'gen-2',
       sessionId: 'session-2',
-      completedAt: '2026-05-22T15:00:00.000Z',
+      completedAt: `${usageDate}T15:00:00.000Z`,
       cost: 0.002,
     };
 
     await writeLocalUsage(event1);
     await writeLocalUsage(event2);
 
-    const filePath = path.join(testDir, '2026-05-22.jsonl');
+    const filePath = path.join(testDir, `${usageDate}.jsonl`);
     const content = await fs.readFile(filePath, 'utf8');
     const lines = content.trim().split('\n');
 
@@ -150,11 +151,13 @@ describe('writeLocalUsage', () => {
   });
 
   it('writes to different files for different UTC dates', async () => {
+    const firstDate = addUtcDays(getCurrentUtcDate(), -2);
+    const secondDate = addUtcDays(firstDate, 1);
     const event1: LocalUsageEvent = {
       id: 'test-1',
       generationId: 'gen-1',
       sessionId: 'session-1',
-      completedAt: '2026-05-22T23:59:59.999Z',
+      completedAt: `${firstDate}T23:59:59.999Z`,
       cost: 0.001,
     };
 
@@ -162,15 +165,15 @@ describe('writeLocalUsage', () => {
       id: 'test-2',
       generationId: 'gen-2',
       sessionId: 'session-2',
-      completedAt: '2026-05-23T00:00:00.000Z',
+      completedAt: `${secondDate}T00:00:00.000Z`,
       cost: 0.002,
     };
 
     await writeLocalUsage(event1);
     await writeLocalUsage(event2);
 
-    const file1 = await fs.readFile(path.join(testDir, '2026-05-22.jsonl'), 'utf8');
-    const file2 = await fs.readFile(path.join(testDir, '2026-05-23.jsonl'), 'utf8');
+    const file1 = await fs.readFile(path.join(testDir, `${firstDate}.jsonl`), 'utf8');
+    const file2 = await fs.readFile(path.join(testDir, `${secondDate}.jsonl`), 'utf8');
 
     expect(JSON.parse(file1.trim())).toEqual(event1);
     expect(JSON.parse(file2.trim())).toEqual(event2);

package/extensions/openrouter/config.ts

@@ -0,0 +1,44 @@
+import { SettingsManager } from '@earendil-works/pi-coding-agent';
+
+export type OpenRouterConfig = {
+  statusEnabled: boolean;
+};
+
+export const DEFAULT_OPENROUTER_CONFIG: OpenRouterConfig = {
+  statusEnabled: true,
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function getOpenRouterSettings(settings: unknown): unknown {
+  return isRecord(settings) ? settings['pi-openrouter'] : undefined;
+}
+
+function getStatusEnabled(rawConfig: unknown): boolean | undefined {
+  if (!isRecord(rawConfig)) {
+    return undefined;
+  }
+
+  return typeof rawConfig['statusEnabled'] === 'boolean' ? rawConfig['statusEnabled'] : undefined;
+}
+
+export function loadOpenRouterConfig(cwd: string, projectTrusted = true): OpenRouterConfig {
+  const settingsManager = SettingsManager.create(cwd);
+  const globalStatusEnabled = getStatusEnabled(
+    getOpenRouterSettings(settingsManager.getGlobalSettings()),
+  );
+  const projectStatusEnabled = projectTrusted
+    ? getStatusEnabled(getOpenRouterSettings(settingsManager.getProjectSettings()))
+    : undefined;
+
+  return {
+    statusEnabled:
+      projectStatusEnabled ?? globalStatusEnabled ?? DEFAULT_OPENROUTER_CONFIG.statusEnabled,
+  };
+}
+
+export function isStatusEnabled(cwd: string, projectTrusted = true): boolean {
+  return loadOpenRouterConfig(cwd, projectTrusted).statusEnabled;
+}

package/extensions/openrouter/hooks.ts

@@ -16,12 +16,15 @@ import {
   setActiveCatalogState,
 } from './models/sync.js';
 import { loadOpenRouterStatusBar } from './status-bar.js';
+import { isStatusEnabled } from './config.js';
 
 let sessionState: SessionState | null = null;
 let sessionTrackingInstalled = false;
 let openRouterStatusRolloverTimer: ReturnType<typeof setTimeout> | null = null;
 
-type StatusContext = Pick<ExtensionContext, 'hasUI' | 'ui'>;
+type StatusContext = Pick<ExtensionContext, 'cwd' | 'hasUI' | 'ui'> & {
+  isProjectTrusted?: () => boolean;
+};
 
 export interface StartupCacheState {
   info?: {
@@ -213,9 +216,30 @@ function captureLocalUsage(event: unknown, ctx: ExtensionContext): void {
   }
 }
 
+function getProjectTrusted(ctx: StatusContext): boolean {
+  try {
+    return ctx.isProjectTrusted?.() === true;
+  } catch {
+    return false;
+  }
+}
+
+function isOpenRouterStatusEnabled(ctx: StatusContext): boolean {
+  try {
+    return isStatusEnabled(ctx.cwd, getProjectTrusted(ctx));
+  } catch {
+    return true;
+  }
+}
+
 async function refreshOpenRouterUsageStatus(ctx: StatusContext): Promise<void> {
   if (!ctx.hasUI) return;
 
+  if (!isOpenRouterStatusEnabled(ctx)) {
+    ctx.ui.setStatus('openrouter', undefined);
+    return;
+  }
+
   try {
     const statusResult = await loadOpenRouterStatusBar();
 
@@ -258,7 +282,7 @@ function getMillisecondsUntilNextUtcMidnight(now: Date = new Date()): number {
 function scheduleOpenRouterStatusRollover(ctx: StatusContext): void {
   clearOpenRouterStatusRolloverTimer();
 
-  if (!ctx.hasUI) {
+  if (!ctx.hasUI || !isOpenRouterStatusEnabled(ctx)) {
     return;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robhowley/pi-openrouter",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "type": "module",
   "description": "Live OpenRouter spend/account TUI overlays, user-scoped or free-only model sync, api key management, and session tagging for Pi.",
   "license": "MIT",