@brimveyn/aimux 1.7.4 → 1.9.0

package/src/index.tsx

@@ -52,7 +52,7 @@ if (command === 'terminal-manager') {
 
 if (command === '--help' || command === '-h') {
   process.stdout.write(
-    'aimux -- terminal multiplexer for AI CLIs\n\nUsage:\n  aimux                           Start aimux\n  aimux update                    Update to latest version\n  aimux doctor                    Diagnose setup issues\n  aimux restart-daemon            Restart IPC daemon\n  aimux restart-terminal-manager  Restart terminal-manager (kills live sessions)\n\n'
+    'aimux -- terminal multiplexer for AI CLIs\n\nUsage:\n  aimux                           Start aimux\n  aimux update                    Update to latest version\n  aimux doctor                    Diagnose setup issues\n  aimux restart-daemon            Restart IPC daemon\n  aimux restart-terminal-manager  Restart terminal-manager (kills live workspaces)\n\n'
   )
   process.exit(0)
 }

package/src/input/keymap/help-entries.ts

@@ -14,10 +14,10 @@ export const HELP_MODE_LABELS: { modeId: ModeId; label: string }[] = [
   { label: 'Git commit', modeId: 'modal.git-commit' },
   { label: 'New tab', modeId: 'modal.new-tab.command-edit' },
   { label: 'New tab — command', modeId: 'modal.new-tab.command-edit' },
-  { label: 'Session picker', modeId: 'modal.session-picker.filtering' },
-  { label: 'Session picker — filter', modeId: 'modal.session-picker.filtering' },
-  { label: 'Session name', modeId: 'modal.session-name' },
-  { label: 'Create session', modeId: 'modal.create-session' },
+  { label: 'Workspace picker', modeId: 'modal.session-picker.filtering' },
+  { label: 'Workspace picker — filter', modeId: 'modal.session-picker.filtering' },
+  { label: 'Workspace name', modeId: 'modal.session-name' },
+  { label: 'Create workspace', modeId: 'modal.create-session' },
   { label: 'Rename tab', modeId: 'modal.rename-tab' },
   { label: 'Snippet picker', modeId: 'modal.snippet-picker.filtering' },
   { label: 'Snippet picker — filter', modeId: 'modal.snippet-picker.filtering' },

package/src/input/modes/bridge.ts

@@ -24,6 +24,7 @@ const COMMAND_EDIT_MODE_IDS: Partial<Record<SupportedModalType, ModeId>> = {
 }
 
 const MODAL_MODE_IDS: Partial<Record<SupportedModalType, ModeId>> = {
+  'ai-usage': 'modal.ai-usage',
   'update-available': 'modal.update-available',
 }
 
@@ -43,6 +44,9 @@ export function deriveModeId(state: AppState): ModeId {
     if (state.modal.type === 'new-tab' && state.modal.editingCommand !== null) {
       return 'modal.new-tab.editing-command'
     }
+    if (state.modal.type === 'git-commit' && state.modal.stage === 'confirm') {
+      return 'modal.git-commit.confirm'
+    }
     const modalType = state.modal.type
     const commandEditMode = modalType ? COMMAND_EDIT_MODE_IDS[modalType] : undefined
     if (commandEditMode) {
@@ -53,6 +57,9 @@ export function deriveModeId(state: AppState): ModeId {
   }
 
   if (state.focusMode === 'modal') {
+    if (state.modal.type === 'git-commit' && state.modal.stage === 'generating') {
+      return 'modal.git-commit.generating'
+    }
     const modalType = state.modal.type
     const modalMode = modalType ? MODAL_MODE_IDS[modalType] : undefined
     if (modalMode) {

package/src/input/modes/transitions.ts

@@ -2,8 +2,11 @@ import type { ModeId } from './types'
 
 const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
   'git-mode': ['navigation', 'modal.git-commit'],
+  'modal.ai-usage': ['navigation', 'terminal-input'],
   'modal.create-session': ['navigation', 'modal.session-picker.filtering'],
-  'modal.git-commit': ['git-mode'],
+  'modal.git-commit': ['git-mode', 'modal.git-commit.confirm', 'modal.git-commit.generating'],
+  'modal.git-commit.confirm': ['modal.git-commit', 'git-mode'],
+  'modal.git-commit.generating': ['modal.git-commit', 'modal.git-commit.confirm', 'git-mode'],
   'modal.help.filtering': ['navigation'],
   'modal.new-tab.command-edit': ['navigation', 'modal.new-tab.editing-command'],
   'modal.new-tab.editing-command': ['navigation', 'modal.new-tab.command-edit'],
@@ -25,9 +28,10 @@ const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
     'modal.theme-picker.filtering',
     'modal.rename-tab',
     'modal.update-available',
+    'modal.ai-usage',
     'git-mode',
   ],
-  'terminal-input': ['navigation', 'modal.split-picker'],
+  'terminal-input': ['navigation', 'modal.split-picker', 'modal.ai-usage'],
 }
 
 export function isValidTransition(from: ModeId, to: ModeId): boolean {

package/src/input/modes/types.ts

@@ -18,7 +18,10 @@ export type ModeId =
   | 'modal.help.filtering'
   | 'modal.split-picker'
   | 'modal.git-commit'
+  | 'modal.git-commit.confirm'
+  | 'modal.git-commit.generating'
   | 'modal.update-available'
+  | 'modal.ai-usage'
 
 export type SideEffect =
   | { type: 'quit'; state: AppState }
@@ -55,6 +58,8 @@ export type SideEffect =
   | { type: 'git-restore'; path: string }
   | { type: 'git-rm'; path: string }
   | { type: 'git-commit'; title: string; body: string }
+  | { type: 'git-commit-auto'; title: string; body: string }
+  | { type: 'generate-auto-commit-now'; sessionId: string }
   | { type: 'git-push' }
   | { type: 'confirm-update-selection' }
   | { type: 'switch-session-by-index'; index: number }

package/src/ipc/manager-protocol.ts

@@ -14,8 +14,8 @@ import {
   negotiateProtocolVersion,
 } from './protocol'
 
-export const MANAGER_PROTOCOL_MIN_VERSION = 2
-export const MANAGER_PROTOCOL_VERSION = 2
+export const MANAGER_PROTOCOL_MIN_VERSION = 3
+export const MANAGER_PROTOCOL_VERSION = 3
 
 export interface ManagerHelloRequest {
   minVersion: number

package/src/ipc/protocol.ts

@@ -10,14 +10,8 @@ import type {
 
 import { isWorkspaceSnapshotV1 } from '../state/validation'
 
-// v4 widens sessionStatus from a single status enum to independent
-// {working, waiting} flags so a chip can show both at once.
-// v5 folds initial tab activities and session statuses into attachResult so
-// the client applies them atomically with tab creation — previously they
-// arrived as separate events and could lose to the unknown-tab no-op in
-// the reducer.
-export const IPC_PROTOCOL_MIN_VERSION = 6
-export const IPC_PROTOCOL_VERSION = 6
+export const IPC_PROTOCOL_MIN_VERSION = 7
+export const IPC_PROTOCOL_VERSION = 7
 
 export interface ProtocolHelloRequest {
   minVersion: number

package/src/pty/assistant-status-detector.ts

@@ -85,10 +85,10 @@ export class AssistantStatusDetector {
 }
 
 function extractTailText(viewport: TerminalSnapshot, lineCount: number): string {
+  const lines = viewport.tailLines ?? viewport.lines
   // Full-screen TUIs (claude, opencode) paint in the alternate buffer and
   // often leave the last rows blank, putting their status bar higher up.
   // Skip trailing blank rows before taking the last `lineCount`.
-  const lines = viewport.lines
   let end = lines.length
   while (end > 0) {
     const line = lines[end - 1]

package/src/pty/terminal-snapshot.ts

@@ -4,6 +4,8 @@ import type { TerminalLine, TerminalSnapshot, TerminalSpan } from '../state/type
 
 import { getCurrentTheme } from '../ui/theme'
 
+const SNAPSHOT_TAIL_LINE_COUNT = 10
+
 const ANSI_PALETTE = [
   '#000000',
   '#cd0000',
@@ -142,9 +144,11 @@ function buildLine(
 export function snapshotTerminal(terminal: Terminal, cursorVisible = true): TerminalSnapshot {
   const buffer = terminal.buffer.active
   const startLine = buffer.viewportY
+  const tailStartLine = Math.max(0, buffer.baseY + terminal.rows - SNAPSHOT_TAIL_LINE_COUNT)
   const cursorRow = buffer.cursorY
   const cursorColumn = Math.min(buffer.cursorX, Math.max(terminal.cols - 1, 0))
   const lines: TerminalLine[] = []
+  const tailLines: TerminalLine[] = []
 
   for (let row = 0; row < terminal.rows; row += 1) {
     lines.push(
@@ -152,10 +156,27 @@ export function snapshotTerminal(terminal: Terminal, cursorVisible = true): Term
     )
   }
 
+  for (
+    let lineIndex = tailStartLine;
+    lineIndex <= buffer.baseY + terminal.rows - 1;
+    lineIndex += 1
+  ) {
+    const relativeCursorRow = lineIndex - buffer.baseY
+    tailLines.push(
+      buildLine(
+        terminal,
+        lineIndex,
+        relativeCursorRow === cursorRow ? cursorColumn : null,
+        cursorVisible
+      )
+    )
+  }
+
   return {
     baseY: buffer.baseY,
     cursorVisible,
     lines,
+    tailLines,
     viewportY: buffer.viewportY,
   }
 }
@@ -195,6 +216,13 @@ export function areTerminalSnapshotsEqual(
     return false
   }
 
+  const leftTailLines = left.tailLines ?? []
+  const rightTailLines = right.tailLines ?? []
+
+  if (leftTailLines.length !== rightTailLines.length) {
+    return false
+  }
+
   if (
     left.viewportY !== right.viewportY ||
     left.baseY !== right.baseY ||
@@ -203,8 +231,14 @@ export function areTerminalSnapshotsEqual(
     return false
   }
 
-  return left.lines.every((line, index) => {
-    const other = right.lines[index]
-    return other ? areLinesEqual(line, other) : false
-  })
+  return (
+    left.lines.every((line, index) => {
+      const other = right.lines[index]
+      return other ? areLinesEqual(line, other) : false
+    }) &&
+    leftTailLines.every((line, index) => {
+      const other = rightTailLines[index]
+      return other ? areLinesEqual(line, other) : false
+    })
+  )
 }

package/src/services/ai-usage/adapters/claude.ts

@@ -0,0 +1,215 @@
+import type { AIUsageToolConfig } from '@brimveyn/aimux-config'
+
+import type { UsageSnapshot, UsageWindow, UsageWindowKind } from '../types'
+
+import { computePace, formatTimeRemaining } from '../pace'
+import { runCli } from '../spawn'
+
+interface ClaudeOAuthCreds {
+  accessToken: string
+  expiresAt?: number
+  planTier: string | null
+}
+
+interface ClaudeKeychainPayload {
+  claudeAiOauth?: {
+    accessToken?: string
+    expiresAt?: number
+    refreshToken?: string
+    rateLimitTier?: string
+    rate_limit_tier?: string
+    subscriptionType?: string
+    scopes?: string[]
+  }
+}
+
+interface UsageWindowPayload {
+  utilization?: number
+  resets_at?: string
+}
+
+interface ClaudeUsageResponse {
+  five_hour?: UsageWindowPayload
+  seven_day?: UsageWindowPayload
+  seven_day_sonnet?: UsageWindowPayload
+  seven_day_opus?: UsageWindowPayload
+  extra_usage?: UsageWindowPayload & { spent_usd?: number; limit_usd?: number }
+}
+
+const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage'
+const OAUTH_BETA_HEADER = 'oauth-2025-04-20'
+const FETCH_TIMEOUT_MS = 15_000
+
+const FIVE_HOUR_SECONDS = 5 * 60 * 60
+const SEVEN_DAY_SECONDS = 7 * 24 * 60 * 60
+
+let cachedCreds: ClaudeOAuthCreds | null = null
+const CREDS_EXPIRY_BUFFER_MS = 60_000
+
+function normalizePlanTier(raw: string | undefined | null): string | null {
+  if (!raw) return null
+  const trimmed = raw.trim()
+  if (!trimmed) return null
+  const lower = trimmed.toLowerCase()
+  if (lower.includes('max')) return 'Max'
+  if (lower.includes('pro')) return 'Pro'
+  if (lower.includes('team')) return 'Team'
+  if (lower.includes('enterprise')) return 'Enterprise'
+  if (lower.includes('ultra')) return 'Ultra'
+  return trimmed.charAt(0).toUpperCase() + trimmed.slice(1)
+}
+
+function planTierFromPayload(payload: ClaudeKeychainPayload): string | null {
+  const o = payload.claudeAiOauth
+  if (!o) return null
+  const raw = o.rateLimitTier ?? o.rate_limit_tier ?? o.subscriptionType
+  const normalized = normalizePlanTier(raw)
+  if (normalized) return normalized
+  if (Array.isArray(o.scopes)) {
+    for (const scope of o.scopes) {
+      const s = scope.toLowerCase()
+      if (s.includes('max')) return 'Max'
+      if (s.includes('pro')) return 'Pro'
+      if (s.includes('team')) return 'Team'
+      if (s.includes('enterprise')) return 'Enterprise'
+    }
+  }
+  return null
+}
+
+async function readClaudeCreds(): Promise<ClaudeOAuthCreds> {
+  const now = Date.now()
+  if (
+    cachedCreds &&
+    typeof cachedCreds.expiresAt === 'number' &&
+    cachedCreds.expiresAt - CREDS_EXPIRY_BUFFER_MS > now
+  ) {
+    return cachedCreds
+  }
+
+  if (process.platform !== 'darwin') {
+    throw new Error('claude usage requires macOS keychain (darwin only)')
+  }
+  const result = await runCli('security', [
+    'find-generic-password',
+    '-s',
+    'Claude Code-credentials',
+    '-w',
+  ])
+  if (!result.ok) {
+    throw new Error(`keychain read failed — run \`claude\` to sign in`)
+  }
+  const parsed = JSON.parse(result.stdout.trim()) as ClaudeKeychainPayload
+  const access = parsed.claudeAiOauth?.accessToken
+  if (!access) {
+    throw new Error('no accessToken in Claude Code keychain')
+  }
+  cachedCreds = {
+    accessToken: access,
+    expiresAt: parsed.claudeAiOauth?.expiresAt,
+    planTier: planTierFromPayload(parsed),
+  }
+  return cachedCreds
+}
+
+function buildWindow(
+  kind: UsageWindowKind,
+  label: string,
+  payload: UsageWindowPayload | undefined,
+  windowSeconds: number,
+  now: number
+): UsageWindow | null {
+  if (!payload) return null
+  const util = typeof payload.utilization === 'number' ? payload.utilization : null
+  const percent = util === null ? null : Math.max(0, Math.min(100, util))
+  const resetAt = payload.resets_at ?? null
+  const resetAtMs = resetAt ? new Date(resetAt).getTime() : null
+  if (percent === null && !resetAt) return null
+  return {
+    kind,
+    label,
+    pace: kind === 'weekly' ? computePace({ now, percent, resetAtMs, windowSeconds }) : null,
+    percent,
+    resetAt,
+    timeRemaining: formatTimeRemaining(resetAtMs, now),
+    windowSeconds,
+  }
+}
+
+export async function fetchClaudeUsage(_config: AIUsageToolConfig): Promise<UsageSnapshot> {
+  const nowIso = new Date().toISOString()
+  const base: UsageSnapshot = {
+    burnRatePerHour: null,
+    costUSD: null,
+    lastUpdated: nowIso,
+    percent: null,
+    planTier: null,
+    resetAt: null,
+    timeRemaining: null,
+    tokens: { cache: 0, input: 0, output: 0, total: 0 },
+    tool: 'claude',
+    windows: [],
+  }
+
+  try {
+    const creds = await readClaudeCreds()
+
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS)
+    let response: Response
+    try {
+      response = await fetch(USAGE_URL, {
+        headers: {
+          'anthropic-beta': OAUTH_BETA_HEADER,
+          'Authorization': `Bearer ${creds.accessToken}`,
+          'Content-Type': 'application/json',
+        },
+        signal: controller.signal,
+      })
+    } finally {
+      clearTimeout(timer)
+    }
+
+    if (response.status === 401 || response.status === 403) {
+      cachedCreds = null
+      return {
+        ...base,
+        error: 'claude oauth expired — run `claude` to re-auth',
+        planTier: creds.planTier,
+      }
+    }
+    if (!response.ok) {
+      return { ...base, error: `claude api ${response.status}`, planTier: creds.planTier }
+    }
+
+    const parsed = (await response.json()) as ClaudeUsageResponse
+    const now = Date.now()
+
+    const windows: UsageWindow[] = []
+    const session = buildWindow('session', 'Session', parsed.five_hour, FIVE_HOUR_SECONDS, now)
+    if (session) windows.push(session)
+    const weekly = buildWindow('weekly', 'Weekly', parsed.seven_day, SEVEN_DAY_SECONDS, now)
+    if (weekly) windows.push(weekly)
+    const opus = buildWindow('opus', 'Opus', parsed.seven_day_opus, SEVEN_DAY_SECONDS, now)
+    if (opus) windows.push(opus)
+    const sonnet = buildWindow('sonnet', 'Sonnet', parsed.seven_day_sonnet, SEVEN_DAY_SECONDS, now)
+    if (sonnet) windows.push(sonnet)
+
+    const summary = session ?? weekly
+
+    return {
+      ...base,
+      percent: summary?.percent ?? null,
+      planTier: creds.planTier,
+      resetAt: summary?.resetAt ?? null,
+      timeRemaining: summary?.timeRemaining ?? null,
+      tool: 'claude',
+      windows,
+    }
+  } catch (error) {
+    return {
+      ...base,
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
+}

package/src/services/ai-usage/adapters/codex.ts

@@ -0,0 +1,242 @@
+import type { AIUsageToolConfig } from '@brimveyn/aimux-config'
+
+import { readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import type { UsageSnapshot, UsageWindow, UsageWindowKind } from '../types'
+
+import { computePace, formatTimeRemaining } from '../pace'
+
+interface CodexAuthFile {
+  tokens?: {
+    access_token?: string
+    account_id?: string
+  }
+}
+
+interface WindowSnapshot {
+  used_percent?: number
+  reset_at?: number
+  limit_window_seconds?: number
+}
+
+interface CodexUsageResponse {
+  plan_type?: string
+  rate_limit?: {
+    primary_window?: WindowSnapshot | null
+    secondary_window?: WindowSnapshot | null
+  }
+  credits?: {
+    has_credits?: boolean
+    unlimited?: boolean
+    balance?: number | string | null
+  }
+}
+
+const DEFAULT_CHATGPT_BASE = 'https://chatgpt.com/backend-api'
+const USAGE_PATH = '/wham/usage'
+const AUTH_TIMEOUT_MS = 15_000
+
+function codexHome(): string {
+  const env = process.env.CODEX_HOME?.trim()
+  if (env) return env
+  return join(homedir(), '.codex')
+}
+
+function parseChatGPTBaseFromConfig(contents: string): string | null {
+  for (const rawLine of contents.split(/\r?\n/)) {
+    const line = rawLine.split('#', 1)[0]?.trim() ?? ''
+    if (!line) continue
+    const eq = line.indexOf('=')
+    if (eq < 0) continue
+    const key = line.slice(0, eq).trim()
+    if (key !== 'chatgpt_base_url') continue
+    let value = line.slice(eq + 1).trim()
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1)
+    }
+    return value.trim()
+  }
+  return null
+}
+
+function normalizeBase(value: string): string {
+  let trimmed = value.trim() || DEFAULT_CHATGPT_BASE
+  while (trimmed.endsWith('/')) trimmed = trimmed.slice(0, -1)
+  if (
+    (trimmed.startsWith('https://chatgpt.com') || trimmed.startsWith('https://chat.openai.com')) &&
+    !trimmed.includes('/backend-api')
+  ) {
+    trimmed += '/backend-api'
+  }
+  return trimmed
+}
+
+async function resolveUsageURL(): Promise<string> {
+  let base = DEFAULT_CHATGPT_BASE
+  try {
+    const contents = await readFile(join(codexHome(), 'config.toml'), 'utf8')
+    const parsed = parseChatGPTBaseFromConfig(contents)
+    if (parsed) base = parsed
+  } catch {
+    // no config.toml or unreadable — fall back to default
+  }
+  const normalized = normalizeBase(base)
+  const path = normalized.includes('/backend-api') ? USAGE_PATH : '/api/codex/usage'
+  return normalized + path
+}
+
+async function loadAuth(): Promise<{ accessToken: string; accountId: string | null }> {
+  const raw = await readFile(join(codexHome(), 'auth.json'), 'utf8')
+  const parsed = JSON.parse(raw) as CodexAuthFile
+  const accessToken = parsed.tokens?.access_token
+  if (!accessToken) {
+    throw new Error('no access_token in ~/.codex/auth.json — run `codex` to sign in')
+  }
+  return {
+    accessToken,
+    accountId: parsed.tokens?.account_id ?? null,
+  }
+}
+
+function normalizePlanTier(raw: string | undefined | null): string | null {
+  if (!raw) return null
+  const trimmed = raw.trim()
+  if (!trimmed) return null
+  const lower = trimmed.toLowerCase()
+  if (lower === 'pro') return 'Pro'
+  if (lower === 'plus') return 'Plus'
+  if (lower === 'free') return 'Free'
+  if (lower === 'team') return 'Team'
+  if (lower === 'business') return 'Business'
+  if (lower === 'enterprise') return 'Enterprise'
+  if (lower === 'edu' || lower === 'education') return 'Edu'
+  if (lower === 'go') return 'Go'
+  return trimmed.charAt(0).toUpperCase() + trimmed.slice(1)
+}
+
+function buildCodexWindow(
+  kind: UsageWindowKind,
+  label: string,
+  window: WindowSnapshot | null | undefined,
+  now: number
+): UsageWindow | null {
+  if (!window) return null
+  const percent =
+    typeof window.used_percent === 'number' ? Math.max(0, Math.min(100, window.used_percent)) : null
+  const resetAtMs = window.reset_at ? window.reset_at * 1000 : null
+  const resetAt = resetAtMs ? new Date(resetAtMs).toISOString() : null
+  const windowSeconds =
+    typeof window.limit_window_seconds === 'number' ? window.limit_window_seconds : null
+  if (percent === null && !resetAt) return null
+  return {
+    kind,
+    label,
+    pace: computePace({ now, percent, resetAtMs, windowSeconds }),
+    percent,
+    resetAt,
+    timeRemaining: formatTimeRemaining(resetAtMs, now),
+    windowSeconds,
+  }
+}
+
+function orderWindows(
+  primary: WindowSnapshot | null | undefined,
+  secondary: WindowSnapshot | null | undefined
+): {
+  session: WindowSnapshot | null | undefined
+  weekly: WindowSnapshot | null | undefined
+} {
+  const SESSION_MIN_SECONDS = 3 * 3600
+  const SESSION_MAX_SECONDS = 8 * 3600
+  const isSession = (w: WindowSnapshot | null | undefined): boolean => {
+    const s = w?.limit_window_seconds
+    return typeof s === 'number' && s >= SESSION_MIN_SECONDS && s <= SESSION_MAX_SECONDS
+  }
+  if (isSession(primary)) return { session: primary, weekly: secondary }
+  if (isSession(secondary)) return { session: secondary, weekly: primary }
+  return { session: primary, weekly: secondary }
+}
+
+export async function fetchCodexUsage(_config: AIUsageToolConfig): Promise<UsageSnapshot> {
+  const nowIso = new Date().toISOString()
+  const base: UsageSnapshot = {
+    burnRatePerHour: null,
+    costUSD: null,
+    lastUpdated: nowIso,
+    percent: null,
+    planTier: null,
+    resetAt: null,
+    timeRemaining: null,
+    tokens: { cache: 0, input: 0, output: 0, total: 0 },
+    tool: 'codex',
+    windows: [],
+  }
+
+  try {
+    const { accessToken, accountId } = await loadAuth()
+    const url = await resolveUsageURL()
+
+    const headers: Record<string, string> = {
+      'Accept': 'application/json',
+      'Authorization': `Bearer ${accessToken}`,
+      'User-Agent': 'aimux',
+    }
+    if (accountId) headers['ChatGPT-Account-Id'] = accountId
+
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), AUTH_TIMEOUT_MS)
+    let response: Response
+    try {
+      response = await fetch(url, { headers, signal: controller.signal })
+    } finally {
+      clearTimeout(timer)
+    }
+
+    if (response.status === 401 || response.status === 403) {
+      return { ...base, error: 'codex oauth expired — run `codex` to re-auth' }
+    }
+    if (!response.ok) {
+      return { ...base, error: `codex api ${response.status}` }
+    }
+
+    const parsed = (await response.json()) as CodexUsageResponse
+    const planTier = normalizePlanTier(parsed.plan_type)
+    const now = Date.now()
+    const { session, weekly } = orderWindows(
+      parsed.rate_limit?.primary_window,
+      parsed.rate_limit?.secondary_window
+    )
+
+    const windows: UsageWindow[] = []
+    const sessionWindow = buildCodexWindow('session', 'Session', session, now)
+    if (sessionWindow) windows.push(sessionWindow)
+    const weeklyWindow = buildCodexWindow('weekly', 'Weekly', weekly, now)
+    if (weeklyWindow) windows.push(weeklyWindow)
+
+    if (windows.length === 0) {
+      return { ...base, error: 'no rate_limit data', planTier }
+    }
+
+    const summary = sessionWindow ?? weeklyWindow
+
+    return {
+      ...base,
+      percent: summary?.percent ?? null,
+      planTier,
+      resetAt: summary?.resetAt ?? null,
+      timeRemaining: summary?.timeRemaining ?? null,
+      tool: 'codex',
+      windows,
+    }
+  } catch (error) {
+    return {
+      ...base,
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
+}