@brimveyn/aimux 1.8.0 → 1.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.8.0",
+  "version": "1.9.1",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -60,7 +60,7 @@
     "bump": "bun run scripts/bump.ts"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.5.0",
+    "@brimveyn/aimux-config": "0.5.2",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@xterm/headless": "^6.0.0",

package/src/app-runtime/side-effects.ts

@@ -605,7 +605,12 @@ function handleSwitchSessionByIndex(ctx: SideEffectContext, index: number): void
     logInputDebug('app.sessionBar.switchOutOfRange', { index, total: ordered.length })
     return
   }
-  if (target.id === state.currentSessionId) return
+  if (target.id === state.currentSessionId) {
+    if (state.focusMode === 'git') {
+      dispatch({ type: 'exit-git-mode' })
+    }
+    return
+  }
   handleSwitchSessionEffect(state, backend, dispatch, target)
 }
 

package/src/app.tsx

@@ -1,14 +1,6 @@
 import { type ResolvedConfig, setAutoCommitEnabled } from '@brimveyn/aimux-config'
 import { useKeyboard, useRenderer, useTerminalDimensions } from '@opentui/react'
-import {
-  useCallback,
-  useEffect,
-  useLayoutEffect,
-  useMemo,
-  useReducer,
-  useRef,
-  useState,
-} from 'react'
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
 
 import type { KeyChord } from './input/keymap/key-chord'
 import type { TrieBinding } from './input/keymap/trie'
@@ -32,11 +24,11 @@ import { type TerminalContentOrigin } from './input/raw-input-handler'
 import { getProfileConfigDir, getProfileName } from './profile-paths'
 import { startAIUsageService } from './services/ai-usage/provider'
 import { aiUsageStore } from './state/ai-usage-store'
-import { appStore } from './state/app-store'
+import { appStore, useAppStore } from './state/app-store'
 import { setActiveDispatch, setActiveSideEffectRunner } from './state/dispatch-ref'
 import { loadSessionCatalog } from './state/session-catalog'
 import { loadSnippetCatalog } from './state/snippet-catalog'
-import { appReducer, createInitialState } from './state/store'
+import { createInitialState } from './state/store'
 import { KeymapContext } from './ui/keymap-context'
 import { RootView } from './ui/root'
 import { applyTheme, setTransparent } from './ui/theme'
@@ -81,7 +73,10 @@ export function App({
     setTransparent(config.themeTransparent ?? false)
     return initial
   })
-  const [state, dispatch] = useReducer(appReducer, undefined, () => {
+  // Initialize zustand store with computed initial state on first render. Using
+  // useState's lazy initializer guarantees this runs exactly once before any
+  // selector reads. We discard the value — the store is the source of truth.
+  useState(() => {
     const json = loadConfig()
     const sessionBarVisible =
       resolvedConfig.sessionBar?.initialVisible ?? json.sessionBarVisible ?? true
@@ -125,7 +120,7 @@ export function App({
       ...(userGitPane?.diffCount !== undefined ? { diffCount: userGitPane.diffCount } : {}),
     }
 
-    return createInitialState(
+    const initial = createInitialState(
       json.customCommands,
       loadSessionCatalog(),
       loadSnippetCatalog(),
@@ -137,11 +132,18 @@ export function App({
         sidebar: sidebarOverrides,
       }
     )
+    // Replace the module-level default with the fully-resolved initial state.
+    // Preserves the dispatch baked into the store by app-store.ts.
+    appStore.setState(initial)
+    return null
   })
 
-  useLayoutEffect(() => {
-    appStore.setState(state)
-  }, [state])
+  // Single source of truth: read state from zustand. The selector returns the
+  // entire store object, so this component re-renders on every dispatch (same
+  // cadence as the previous useReducer setup), but selectors elsewhere only
+  // re-render on the slices they actually subscribe to.
+  const state = useAppStore((s) => s)
+  const dispatch = state.dispatch
 
   useLayoutEffect(() => {
     setActiveDispatch(dispatch)
@@ -191,6 +193,8 @@ export function App({
     return () => {
       cancelled = true
     }
+    // dispatch is stable (same fn reference from the store) — safe to omit
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
   const resizingRef = useRef(false)

package/src/input/keymap/describe-bindings.ts

@@ -1,4 +1,4 @@
-import type { ModeId, ResolvedKeymapConfig } from '@brimveyn/aimux-config'
+import type { Action, ModeId, ResolvedKeymapConfig } from '@brimveyn/aimux-config'
 
 import { parseKeyNotation } from './key-chord'
 import { formatNotationForDisplay } from './key-format'
@@ -18,6 +18,24 @@ export interface DescribedBindingGroup {
 interface DescribeOptions {
   withDescriptionOnly?: boolean
   dedupeByDescription?: boolean
+  mergeAlternativesByDescription?: boolean
+}
+
+const actionObjectIds = new WeakMap<object, number>()
+let nextActionObjectId = 0
+
+function getActionSignature(action: Action): string {
+  if (typeof action === 'function') {
+    let id = actionObjectIds.get(action)
+    if (id === undefined) {
+      id = nextActionObjectId
+      nextActionObjectId += 1
+      actionObjectIds.set(action, id)
+    }
+    return `fn:${id}`
+  }
+
+  return `json:${JSON.stringify(action)}`
 }
 
 export function describeBindings(
@@ -31,9 +49,52 @@ export function describeBindings(
   const leaderChord = parseKeyNotation(config.leader)[0]
   const seenDescriptions = new Set<string>()
   const result: DescribedBinding[] = []
+  const resultIndexByDescription = new Map<string, number>()
+  const resultIndexByAction = new Map<string, number>()
+  const seenKeysDisplayByIndex = new Map<number, Set<string>>()
 
   for (const binding of mode.bindings) {
+    const keysDisplay = formatNotationForDisplay(binding.keys, leaderChord)
+
+    if (options.mergeAlternativesByDescription) {
+      const actionSignature = getActionSignature(binding.result)
+      const existingIndex = binding.description
+        ? resultIndexByDescription.get(binding.description)
+        : resultIndexByAction.get(actionSignature)
+
+      if (existingIndex === undefined) {
+        if (options.withDescriptionOnly && !binding.description) continue
+        const nextIndex = result.length
+        if (binding.description) resultIndexByDescription.set(binding.description, nextIndex)
+        resultIndexByAction.set(actionSignature, nextIndex)
+        seenKeysDisplayByIndex.set(nextIndex, new Set([keysDisplay]))
+        result.push({
+          description: binding.description,
+          group: binding.group,
+          keys: binding.keys,
+          keysDisplay,
+        })
+        continue
+      }
+
+      const seenKeysDisplay = seenKeysDisplayByIndex.get(existingIndex)
+      if (!seenKeysDisplay || seenKeysDisplay.has(keysDisplay)) continue
+
+      seenKeysDisplay.add(keysDisplay)
+      const existing = result[existingIndex]
+      if (!existing) continue
+      if (!existing.description && binding.description) {
+        existing.description = binding.description
+        existing.group = binding.group
+        resultIndexByDescription.set(binding.description, existingIndex)
+      }
+      existing.keys = `${existing.keys} / ${binding.keys}`
+      existing.keysDisplay = `${existing.keysDisplay} / ${keysDisplay}`
+      continue
+    }
+
     if (options.withDescriptionOnly && !binding.description) continue
+
     if (options.dedupeByDescription && binding.description) {
       if (seenDescriptions.has(binding.description)) continue
       seenDescriptions.add(binding.description)
@@ -42,7 +103,7 @@ export function describeBindings(
       description: binding.description,
       group: binding.group,
       keys: binding.keys,
-      keysDisplay: formatNotationForDisplay(binding.keys, leaderChord),
+      keysDisplay,
     })
   }
 

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',
 }
 

package/src/input/modes/transitions.ts

@@ -2,6 +2,7 @@ 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.confirm', 'modal.git-commit.generating'],
   'modal.git-commit.confirm': ['modal.git-commit', 'git-mode'],
@@ -27,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

@@ -21,6 +21,7 @@ export type ModeId =
   | 'modal.git-commit.confirm'
   | 'modal.git-commit.generating'
   | 'modal.update-available'
+  | 'modal.ai-usage'
 
 export type SideEffect =
   | { type: 'quit'; state: AppState }

package/src/pty/terminal-snapshot.ts

@@ -2,7 +2,7 @@ import type { Terminal } from '@xterm/headless'
 
 import type { TerminalLine, TerminalSnapshot, TerminalSpan } from '../state/types'
 
-import { getCurrentTheme } from '../ui/theme'
+import { getCurrentTokens } from '../ui/theme'
 
 const SNAPSHOT_TAIL_LINE_COUNT = 10
 
@@ -115,15 +115,17 @@ function buildLine(
     let bg = getColorHex(current.getBgColor(), bgMode)
 
     if (current.isInverse()) {
-      const resolvedFg = fg ?? getCurrentTheme().palette.ink
-      const resolvedBg = bg ?? getCurrentTheme().palette.neutral
+      const tokens = getCurrentTokens()
+      const resolvedFg = fg ?? tokens.palette.ink
+      const resolvedBg = bg ?? tokens.bg
       ;[fg, bg] = [resolvedBg, resolvedFg]
     }
 
     const isCursorCell = cursorVisible && cursorColumn === column
     if (isCursorCell) {
-      const resolvedFg = fg ?? getCurrentTheme().palette.ink
-      const resolvedBg = bg ?? getCurrentTheme().palette.neutral
+      const tokens = getCurrentTokens()
+      const resolvedFg = fg ?? tokens.palette.ink
+      const resolvedBg = bg ?? tokens.bg
       ;[fg, bg] = [resolvedBg, resolvedFg]
     }
 

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

@@ -1,12 +1,14 @@
 import type { AIUsageToolConfig } from '@brimveyn/aimux-config'
 
-import type { UsageSnapshot } from '../types'
+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 {
@@ -14,29 +16,67 @@ interface ClaudeKeychainPayload {
     accessToken?: string
     expiresAt?: number
     refreshToken?: string
+    rateLimitTier?: string
+    rate_limit_tier?: string
+    subscriptionType?: string
+    scopes?: string[]
   }
 }
 
-interface UsageWindow {
+interface UsageWindowPayload {
   utilization?: number
   resets_at?: string
 }
 
 interface ClaudeUsageResponse {
-  five_hour?: UsageWindow
-  seven_day?: UsageWindow
-  seven_day_sonnet?: UsageWindow
-  seven_day_opus?: UsageWindow
-  extra_usage?: UsageWindow & { spent_usd?: number; limit_usd?: number }
+  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 (
@@ -64,31 +104,51 @@ async function readClaudeCreds(): Promise<ClaudeOAuthCreds> {
   if (!access) {
     throw new Error('no accessToken in Claude Code keychain')
   }
-  cachedCreds = { accessToken: access, expiresAt: parsed.claudeAiOauth?.expiresAt }
+  cachedCreds = {
+    accessToken: access,
+    expiresAt: parsed.claudeAiOauth?.expiresAt,
+    planTier: planTierFromPayload(parsed),
+  }
   return cachedCreds
 }
 
-function formatRemainingFromIso(iso: string | undefined): string | null {
-  if (!iso) return null
-  const ms = new Date(iso).getTime() - Date.now()
-  if (ms <= 0) return null
-  const totalMin = Math.round(ms / 60_000)
-  const h = Math.floor(totalMin / 60)
-  const m = totalMin % 60
-  return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}h`
+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 now = new Date().toISOString()
+  const nowIso = new Date().toISOString()
   const base: UsageSnapshot = {
     burnRatePerHour: null,
     costUSD: null,
-    lastUpdated: now,
+    lastUpdated: nowIso,
     percent: null,
+    planTier: null,
     resetAt: null,
     timeRemaining: null,
     tokens: { cache: 0, input: 0, output: 0, total: 0 },
     tool: 'claude',
+    windows: [],
   }
 
   try {
@@ -112,23 +172,39 @@ export async function fetchClaudeUsage(_config: AIUsageToolConfig): Promise<Usag
 
     if (response.status === 401 || response.status === 403) {
       cachedCreds = null
-      return { ...base, error: 'claude oauth expired — run `claude` to re-auth' }
+      return {
+        ...base,
+        error: 'claude oauth expired — run `claude` to re-auth',
+        planTier: creds.planTier,
+      }
     }
     if (!response.ok) {
-      return { ...base, error: `claude api ${response.status}` }
+      return { ...base, error: `claude api ${response.status}`, planTier: creds.planTier }
     }
 
     const parsed = (await response.json()) as ClaudeUsageResponse
-    const fiveHour = parsed.five_hour
-    const utilization = typeof fiveHour?.utilization === 'number' ? fiveHour.utilization : null
-    const percent = utilization === null ? null : Math.max(0, Math.min(100, utilization))
+    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,
-      resetAt: fiveHour?.resets_at ?? null,
-      timeRemaining: formatRemainingFromIso(fiveHour?.resets_at),
+      percent: summary?.percent ?? null,
+      planTier: creds.planTier,
+      resetAt: summary?.resetAt ?? null,
+      timeRemaining: summary?.timeRemaining ?? null,
       tool: 'claude',
+      windows,
     }
   } catch (error) {
     return {

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

@@ -4,7 +4,9 @@ import { readFile } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
-import type { UsageSnapshot } from '../types'
+import type { UsageSnapshot, UsageWindow, UsageWindowKind } from '../types'
+
+import { computePace, formatTimeRemaining } from '../pace'
 
 interface CodexAuthFile {
   tokens?: {
@@ -101,39 +103,78 @@ async function loadAuth(): Promise<{ accessToken: string; accountId: string | nu
   }
 }
 
-function formatRemainingFromReset(resetAtSeconds: number | undefined): string | null {
-  if (!resetAtSeconds) return null
-  const diffMs = resetAtSeconds * 1000 - Date.now()
-  if (diffMs <= 0) return null
-  const totalMin = Math.round(diffMs / 60_000)
-  const h = Math.floor(totalMin / 60)
-  const m = totalMin % 60
-  return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}h`
+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 pickPrimaryWindow(rate: CodexUsageResponse['rate_limit']): WindowSnapshot | null {
-  if (!rate) return null
-  // Primary = 5h session window. Pick the one closest to 300 minutes (18000s),
-  // falling back to whichever is defined.
-  const windows = [rate.primary_window, rate.secondary_window].filter(
-    (w): w is WindowSnapshot => !!w
-  )
-  if (windows.length === 0) return null
-  const sessionWindow = windows.find((w) => w.limit_window_seconds === 18_000)
-  return sessionWindow ?? windows[0] ?? null
+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 now = new Date().toISOString()
+  const nowIso = new Date().toISOString()
   const base: UsageSnapshot = {
     burnRatePerHour: null,
     costUSD: null,
-    lastUpdated: now,
+    lastUpdated: nowIso,
     percent: null,
+    planTier: null,
     resetAt: null,
     timeRemaining: null,
     tokens: { cache: 0, input: 0, output: 0, total: 0 },
     tool: 'codex',
+    windows: [],
   }
 
   try {
@@ -164,23 +205,33 @@ export async function fetchCodexUsage(_config: AIUsageToolConfig): Promise<Usage
     }
 
     const parsed = (await response.json()) as CodexUsageResponse
-    const window = pickPrimaryWindow(parsed.rate_limit)
-    if (!window) {
-      return { ...base, error: 'no rate_limit data' }
+    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 percent =
-      typeof window.used_percent === 'number'
-        ? Math.max(0, Math.min(100, window.used_percent))
-        : null
-    const resetAt = window.reset_at ? new Date(window.reset_at * 1000).toISOString() : null
+    const summary = sessionWindow ?? weeklyWindow
 
     return {
       ...base,
-      percent,
-      resetAt,
-      timeRemaining: formatRemainingFromReset(window.reset_at),
+      percent: summary?.percent ?? null,
+      planTier,
+      resetAt: summary?.resetAt ?? null,
+      timeRemaining: summary?.timeRemaining ?? null,
       tool: 'codex',
+      windows,
     }
   } catch (error) {
     return {