@brimveyn/aimux 1.22.12 → 1.23.1

package/src/services/usage-history/stats.ts

@@ -1,5 +1,6 @@
 import { parseColor, RGBA } from '@opentui/core'
 
+import { daysBetween, parseDayKey } from './insights'
 import { emptyTokens, localDay, type UsageDays, type UsageTokens } from './store'
 
 /** Pure shaping of stored usage days into what the History page renders. */
@@ -11,18 +12,6 @@ export interface HeatmapCell {
   value: number
 }
 
-function parseDay(key: string): Date {
-  const [year, month, day] = key.split('-').map(Number)
-  return new Date(year ?? 0, (month ?? 1) - 1, day ?? 1)
-}
-
-/** Whole days apart. Via `Date.UTC` on the calendar parts: a DST span is not a whole number of 24h periods. */
-function daysBetween(from: Date, to: Date): number {
-  const utcOf = (date: Date): number =>
-    Date.UTC(date.getFullYear(), date.getMonth(), date.getDate())
-  return Math.round((utcOf(to) - utcOf(from)) / 86_400_000)
-}
-
 /** Quartiles of the non-empty days: a linear `value / max` ramp lets one outlier flatten the year to level 1. */
 export function cutPoints(values: number[]): [number, number, number] {
   const sorted = values.filter((value) => value > 0).sort((left, right) => left - right)
@@ -44,11 +33,11 @@ export function coveredWeeks(days: UsageDays, today: Date, maxWeeks: number): nu
   const dates = Object.keys(days).sort()
   const first = dates[0]
   if (first === undefined) return Math.min(maxWeeks, 12)
-  const elapsed = daysBetween(parseDay(first), today)
+  const elapsed = daysBetween(parseDayKey(first), today)
   return Math.max(4, Math.min(maxWeeks, Math.ceil((elapsed + 1) / 7) + 1))
 }
 
-/** 7 rows (Monday first) by `weeks` columns, oldest left. Cells after today come back empty. */
+/** 7 rows (Sunday first) by `weeks` columns, oldest left. Cells after today come back empty. */
 export function buildHeatmap(
   counts: Record<string, number>,
   weeks: number,
@@ -56,9 +45,13 @@ export function buildHeatmap(
 ): HeatmapCell[][] {
   const cuts = cutPoints(Object.values(counts))
 
-  // Anchored on the Sunday closing this week, so the last column is the week in progress.
-  const mondayIndex = (today.getDay() + 6) % 7
-  const end = new Date(today.getFullYear(), today.getMonth(), today.getDate() + (6 - mondayIndex))
+  // Anchored on the Saturday closing this week, so the last column is the week
+  // in progress. Weeks run Sunday to Saturday, which is what the row labels say.
+  const end = new Date(
+    today.getFullYear(),
+    today.getMonth(),
+    today.getDate() + (6 - today.getDay())
+  )
   // Calendar arithmetic, never `getTime() - n * DAY_MS`: across a DST change the
   // millisecond form lands on 23:00 the day before and rotates every row by one.
   const start = new Date(end.getFullYear(), end.getMonth(), end.getDate() - (weeks * 7 - 1))
@@ -86,21 +79,64 @@ export function buildHeatmap(
   return rows
 }
 
-/** Month initial over each column that opens a month. `cellWidth` mirrors the grid's own. */
-export function monthRuler(grid: HeatmapCell[][], weeks: number, cellWidth: number): string {
-  const initials = 'JFMAMJJASOND'
-  const chars: string[] = Array.from({ length: weeks * cellWidth }, () => ' ')
-  let previous = ''
+export interface MonthLabel {
+  /** 0-based calendar month, so the caller can colour the label like its cells. */
+  month: number
+  name: string
+  /** Cell offset from the left edge of the grid where the name starts. */
+  offset: number
+}
+
+const MONTH_NAMES = [
+  'Jan',
+  'Feb',
+  'Mar',
+  'Apr',
+  'May',
+  'Jun',
+  'Jul',
+  'Aug',
+  'Sep',
+  'Oct',
+  'Nov',
+  'Dec',
+]
+
+/**
+ * One label per month present in the grid, centred over the columns that month
+ * occupies. `cellWidth` mirrors the grid's own so the offsets are in the same
+ * units the caller pads with.
+ *
+ * A column belongs to the month of its first recorded day: a week straddling a
+ * month boundary has to pick one, and the earlier one is where the column
+ * starts on screen.
+ */
+export function monthLabels(grid: HeatmapCell[][], weeks: number, cellWidth: number): MonthLabel[] {
+  const spans: { end: number; month: number; start: number }[] = []
   for (let column = 0; column < weeks; column++) {
-    const day = grid[0]?.[column]?.day
-    if (day == null || day === '') continue
-    const month = day.slice(5, 7)
-    if (month !== previous) {
-      chars[column * cellWidth] = initials[Number(month) - 1] ?? ' '
-      previous = month
-    }
+    const day = grid.map((row) => row[column]?.day ?? '').find((key) => key !== '')
+    if (day === undefined) continue
+    const month = Number(day.slice(5, 7)) - 1
+    const last = spans.at(-1)
+    if (last !== undefined && last.month === month) last.end = column
+    else spans.push({ end: column, month, start: column })
+  }
+
+  const labels: MonthLabel[] = []
+  let usedUpTo = 0
+  for (const span of spans) {
+    const name = MONTH_NAMES[span.month] ?? ''
+    const rendered = name.length
+    const width = (span.end - span.start + 1) * cellWidth
+    const centred = span.start * cellWidth + Math.floor((width - rendered) / 2)
+    // Never behind the previous label: a narrow leading month would otherwise
+    // centre its name on top of the one before it.
+    const offset = Math.max(usedUpTo, centred)
+    if (offset + rendered > weeks * cellWidth) continue
+    labels.push({ month: span.month, name, offset })
+    usedUpTo = offset + rendered + 1
   }
-  return chars.join('')
+  return labels
 }
 
 export function promptCounts(days: UsageDays): Record<string, number> {
@@ -117,8 +153,6 @@ export interface UsageSummary {
   modelTotal: number
   peakPrompts: number
   promptDays: number
-  /** Days carrying token data — a shorter span than `promptDays` once pruning starts. */
-  tokenDays: number
   tokens: UsageTokens
   totalPrompts: number
 }
@@ -137,7 +171,6 @@ export function summarizeDays(days: UsageDays, limit = 6): UsageSummary {
   const branches: Record<string, number> = {}
   let peakPrompts = 0
   let promptDays = 0
-  let tokenDays = 0
   let totalPrompts = 0
 
   for (const day of Object.values(days)) {
@@ -147,7 +180,6 @@ export function summarizeDays(days: UsageDays, limit = 6): UsageSummary {
     tokens.output += day.tokens.output
     tokens.total += day.tokens.total
 
-    if (day.tokens.total > 0) tokenDays += 1
     if (day.prompts > 0) {
       promptDays += 1
       totalPrompts += day.prompts
@@ -172,7 +204,6 @@ export function summarizeDays(days: UsageDays, limit = 6): UsageSummary {
     modelTotal: rankedModels.total,
     peakPrompts,
     promptDays,
-    tokenDays,
     tokens,
     totalPrompts,
   }

package/src/services/usage-history/store.ts

@@ -16,8 +16,8 @@ import { spawnDetachedCommand } from '../../platform/daemon-control'
  * fully round-trip.
  */
 
-export const HISTORY_VERSION = 1
-/** A file that exists but did not parse. Never equal to HISTORY_VERSION, so the save guard refuses it. */
+export const HISTORY_VERSION = 2
+/** A file that exists but did not parse. Below every real version, so the save guard refuses it. */
 const UNREADABLE_VERSION = -1
 const ROLLUP_INTERVAL_MS = 20 * 60 * 60 * 1000
 
@@ -29,14 +29,43 @@ export interface UsageTokens {
   total: number
 }
 
+/**
+ * A running sum, its divisor and the largest sample. Enough for an average and a
+ * record without keeping every sample — which is also why the pages that read
+ * this say "average", never "median": the samples are gone.
+ */
+export interface UsageMean {
+  count: number
+  max: number
+  sum: number
+}
+
+export interface UsageSession {
+  /** ms epoch of the first prompt. */
+  first: number
+  /** ms epoch of the last prompt. */
+  last: number
+  prompts: number
+}
+
 export interface UsageDay {
   /** git branch -> tokens. Recent window only; Codex carries no branch. */
   branches: Record<string, number>
+  /** 24 buckets, prompts per local hour. Empty on a v1 day. */
+  hours: number[]
   /** model id -> tokens. Recent window only. */
   models: Record<string, number>
+  /** Characters per prompt. Empty on a v1 day. */
+  promptChars: UsageMean
+  /** absolute project path -> prompts. Empty on a v1 day. */
+  projects: Record<string, number>
   /** The only field with full-year coverage, and claude-only. */
   prompts: number
+  /** sessionId -> span. Empty on a v1 day. */
+  sessions: Record<string, UsageSession>
   tokens: UsageTokens
+  /** Milliseconds between consecutive assistant turns. Empty on a v1 day. */
+  turnMs: UsageMean
 }
 
 /** 'YYYY-MM-DD' in the machine's local calendar -> that day's usage. */
@@ -60,8 +89,65 @@ export function emptyTokens(): UsageTokens {
   return { cacheRead: 0, cacheWrite: 0, input: 0, output: 0, total: 0 }
 }
 
+export const HOURS_IN_DAY = 24
+
+export function emptyHours(): number[] {
+  return Array.from({ length: HOURS_IN_DAY }, () => 0)
+}
+
+export function emptyMean(): UsageMean {
+  return { count: 0, max: 0, sum: 0 }
+}
+
 export function emptyDay(): UsageDay {
-  return { branches: {}, models: {}, prompts: 0, tokens: emptyTokens() }
+  return {
+    branches: {},
+    hours: emptyHours(),
+    models: {},
+    projects: {},
+    promptChars: emptyMean(),
+    prompts: 0,
+    sessions: {},
+    tokens: emptyTokens(),
+    turnMs: emptyMean(),
+  }
+}
+
+/**
+ * Fills in what a v1 day does not carry, so every reader sees one shape instead
+ * of guarding each field. The filled-in values are empty rather than zeroed
+ * measurements — a page that would render them as `0 min` has to check `count`
+ * and say "no data" instead.
+ */
+function normalizeDay(day: UsageDay): UsageDay {
+  const hours = Array.isArray(day.hours) && day.hours.length === HOURS_IN_DAY ? day.hours : null
+  if (
+    hours !== null &&
+    day.projects != null &&
+    day.sessions != null &&
+    day.promptChars != null &&
+    day.turnMs != null
+  ) {
+    return day
+  }
+  return {
+    ...day,
+    hours: hours ?? emptyHours(),
+    projects: day.projects ?? {},
+    promptChars: day.promptChars ?? emptyMean(),
+    sessions: day.sessions ?? {},
+    turnMs: day.turnMs ?? emptyMean(),
+  }
+}
+
+function normalizeTools(tools: UsageTools): UsageTools {
+  const normalized: UsageTools = {}
+  for (const [tool, days] of Object.entries(tools) as [AIUsageTool, UsageDays][]) {
+    const out: UsageDays = {}
+    for (const [date, day] of Object.entries(days)) out[date] = normalizeDay(day)
+    normalized[tool] = out
+  }
+  return normalized
 }
 
 /** Resolved per call, not at module scope, so a `HOME` override in tests reaches it. */
@@ -84,7 +170,7 @@ export function readUsageHistory(): UsageHistoryFile {
     if (typeof file.tools !== 'object' || file.tools === null) {
       return { tools: {}, version: UNREADABLE_VERSION }
     }
-    return { tools: file.tools, version: file.version }
+    return { tools: normalizeTools(file.tools), version: file.version }
   } catch {
     return { tools: {}, version: UNREADABLE_VERSION }
   }
@@ -95,11 +181,19 @@ function mergeDay(stored: UsageDay, fresh: UsageDay): UsageDay {
   // the richer one. `>=` rather than `>` is what makes re-running converge.
   const keepFresh = fresh.tokens.total >= stored.tokens.total
   // Prompts merge separately: they outlive the transcripts the tokens came from.
+  // Everything derived from `history.jsonl` follows the prompt count for the same
+  // reason — that log is append-only, so it is never the pruned side.
+  const keepFreshPrompts = fresh.prompts >= stored.prompts
   return {
     branches: keepFresh ? fresh.branches : stored.branches,
+    hours: keepFreshPrompts ? fresh.hours : stored.hours,
     models: keepFresh ? fresh.models : stored.models,
+    projects: keepFreshPrompts ? fresh.projects : stored.projects,
+    promptChars: keepFreshPrompts ? fresh.promptChars : stored.promptChars,
     prompts: Math.max(fresh.prompts, stored.prompts),
+    sessions: keepFreshPrompts ? fresh.sessions : stored.sessions,
     tokens: keepFresh ? fresh.tokens : stored.tokens,
+    turnMs: keepFresh ? fresh.turnMs : stored.turnMs,
   }
 }
 
@@ -124,9 +218,12 @@ export function mergeUsageHistory(stored: UsageTools, fresh: UsageTools): UsageT
 export function saveUsageHistory(fresh: UsageTools): boolean {
   const stored = readUsageHistory()
 
-  // A newer aimux owns a shape this build cannot round-trip; an unreadable file
-  // may still hold years this rollup can no longer see. Neither gets written over.
-  if (stored.version !== HISTORY_VERSION) {
+  // Two separate refusals, not one equality check. A newer aimux owns a shape
+  // this build cannot round-trip, and an unreadable file may still hold years
+  // this rollup can no longer see — neither gets written over. An *older* file
+  // is the one case that is safe: this build reads v1 and writes it back as v2,
+  // which is how the upgrade happens at all.
+  if (stored.version > HISTORY_VERSION || stored.version < 1) {
     logDebug('usageHistory.refusedWrite', { version: stored.version })
     return false
   }
@@ -153,6 +250,22 @@ export function saveUsageHistory(fresh: UsageTools): boolean {
   }
 }
 
+/**
+ * Whether what is on disk predates this build's schema.
+ *
+ * Without this an upgrade waits out the whole interval before the new fields
+ * exist, and until then the pages report them as "recorded from the next rollup
+ * onward" — which reads as a bug and costs whoever hits it a diagnosis.
+ *
+ * ponytail: a regex over the raw text rather than a parse. 1.2 MB parses in 6 ms
+ * and this runs before the first frame; no `UsageDay` carries a `version` key,
+ * so the first match is the file's own. Parse it properly if one ever does.
+ */
+export function storedVersionIsStale(raw: string): boolean {
+  const version = Number(/"version":\s*(\d+)/.exec(raw)?.[1])
+  return Number.isFinite(version) && version < HISTORY_VERSION
+}
+
 /**
  * Detached because the parse is a second of CPU over hundreds of MB of JSONL.
  * 20h rather than 24h so opening aimux at the same time each morning does not
@@ -163,8 +276,14 @@ export function maybeSpawnUsageRollup(): void {
     if (process.env.AIMUX_NO_USAGE_ROLLUP === '1') return
     // mtime is the last successful rollup: the file is written on success and
     // nothing else. Beats parsing an ever-growing JSON on the startup path.
-    const rolledUpAt = statSync(usageHistoryPath(), { throwIfNoEntry: false })?.mtimeMs ?? 0
-    if (Date.now() - rolledUpAt < ROLLUP_INTERVAL_MS) return
+    const path = usageHistoryPath()
+    const rolledUpAt = statSync(path, { throwIfNoEntry: false })?.mtimeMs ?? 0
+    if (
+      Date.now() - rolledUpAt < ROLLUP_INTERVAL_MS &&
+      !storedVersionIsStale(readFileSync(path, 'utf8'))
+    ) {
+      return
+    }
     spawnDetachedCommand('usage-rollup')
   } catch (error) {
     logDebug('usageHistory.spawnError', {

package/src/settings/search.ts

@@ -7,17 +7,21 @@ export interface SettingSearchHit {
   row: SettingRow
   sectionId: string
   sectionLabel: string
-  /** Index within its own section, which is what the cursor is expressed in. */
+  /**
+   * Position in the screen's list — counted across every section, matches or
+   * not, because the screen is one list and that is what its cursor holds. So a
+   * search result can be jumped to with the index it already carries.
+   */
   rowIndex: number
 }
 
 /**
- * Every setting the query matches, across every section. Ten sections is more
- * than anyone will scan, and this is the only list in the app you could not type
- * into to find something.
+ * Every setting the query matches, across every section. With no query it is
+ * the screen's own list, which is why both go through here: one filter, so the
+ * list you search and the list you scroll can never disagree.
  *
- * Shared with `getModalOptionCount` so the picker and the reducer that moves its
- * cursor count the same list — two filters would drift the moment one changed.
+ * Shared with `getModalOptionCount` too, so the picker and the reducer that
+ * moves its cursor count the same list.
  */
 export function filterSettingRows(
   projects: readonly ProjectRecord[],
@@ -25,12 +29,12 @@ export function filterSettingRows(
 ): SettingSearchHit[] {
   const needle = (query ?? '').trim().toLowerCase()
   const hits: SettingSearchHit[] = []
+  let rowIndex = -1
 
   for (const section of SETTING_SECTIONS) {
     const rows = sectionRows(section, projects)
-    for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
-      const row = rows[rowIndex]
-      if (!row) continue
+    for (const row of rows) {
+      rowIndex++
       // The id is in the haystack deliberately: it is the key in `aimux.json`, so
       // someone who saw it in that file can search for it.
       const haystack = `${row.label} ${row.description ?? ''} ${row.id} ${section.label}`

package/src/settings/sections/about.ts

@@ -11,6 +11,7 @@ import { settingsStore } from '../settings-store'
  * files are, and how many settings your own config file is holding onto.
  */
 export const ABOUT_SECTION: SettingSection = {
+  glyph: '\u{00A7}',
   id: 'about',
   label: 'About',
   rows: [

package/src/settings/sections/appearance.ts

@@ -10,6 +10,7 @@ import { getCurrentMode, getCurrentThemeId, getTransparent } from '../../ui/them
  * re-renders them all and these reads never go stale.
  */
 export const APPEARANCE_SECTION: SettingSection = {
+  glyph: '\u{25D1}',
   id: 'appearance',
   label: 'Appearance',
   rows: [

package/src/settings/sections/automation.ts

@@ -15,6 +15,7 @@ export const AUTO_COMMIT_TIMEOUT = 'autoCommit.timeoutMs'
  * what `restart` puts on the row.
  */
 export const AUTOMATION_SECTION: SettingSection = {
+  glyph: '\u{27F3}',
   id: 'automation',
   label: 'Automation',
   rows: [

package/src/settings/sections/commands.ts

@@ -46,6 +46,7 @@ function autoCommitModelRow(assistant: (typeof MODEL_ASSISTANTS)[number]): Setti
 }
 
 export const COMMANDS_SECTION: SettingSection = {
+  glyph: '\u{276F}',
   id: 'commands',
   label: 'Commands',
   rows: [

package/src/settings/sections/editor.ts

@@ -11,6 +11,7 @@ const AUTO = 'auto'
  * really need to be.
  */
 export const EDITOR_SECTION: SettingSection = {
+  glyph: '\u{270E}',
   id: 'editor',
   label: 'Editor',
   rows: [

package/src/settings/sections/experimental.ts

@@ -13,6 +13,7 @@ export const ACTIVITY_SPRITES = 'theme.beta.experimentalActivitySprites'
  */
 export const EXPERIMENTAL_SECTION: SettingSection = {
   description: 'Unfinished. These can change behaviour, or go away, in any release.',
+  glyph: '\u{2727}',
   id: 'experimental',
   label: 'Experimental',
   rows: [

package/src/settings/sections/git.ts

@@ -20,6 +20,7 @@ function isFileListMode(value: SettingValue): value is GitFileListMode {
  * `AppState` on change; multi-repo is a module singleton, like auto-commit.
  */
 export const GIT_SECTION: SettingSection = {
+  glyph: '\u{2387}',
   id: 'git',
   label: 'Git',
   rows: [

package/src/settings/sections/index.ts

@@ -44,8 +44,6 @@ export const ALL_SETTING_ROWS: readonly SettingRow[] = SETTING_SECTIONS.flatMap(
   Array.isArray(section.rows) ? section.rows : []
 )
 
-export const DEFAULT_SECTION_ID = SETTING_SECTIONS[0]?.id ?? 'about'
-
 export function getSection(sectionId: string): SettingSection | undefined {
   return SETTING_SECTIONS.find((section) => section.id === sectionId)
 }
@@ -70,18 +68,31 @@ export function sectionRowCount(
   return Array.isArray(section.rows) ? section.rows.length : section.rows(projects).length
 }
 
-/** Rows of the given section, or an empty list when the id is unknown. */
-export function getSectionRows(
-  sectionId: string,
-  projects: readonly ProjectRecord[]
-): readonly SettingRow[] {
-  const section = getSection(sectionId)
-  return section ? sectionRows(section, projects) : []
+/**
+ * How many rows the screen holds in total. The screen is one list, so this is
+ * what clamps its cursor — and like `sectionRowCount`, it counts without
+ * building, which is what keeps the reducer off the disk.
+ */
+export function totalRowCount(projects: readonly ProjectRecord[]): number {
+  let total = 0
+  for (const section of SETTING_SECTIONS) total += sectionRowCount(section, projects)
+  return total
 }
 
-export function getSectionRowCount(sectionId: string, projects: readonly ProjectRecord[]): number {
-  const section = getSection(sectionId)
-  return section ? sectionRowCount(section, projects) : 0
+/**
+ * The flat index of each section's first row, in screen order. What `}` and `{`
+ * jump between, and the reason they can: an empty section contributes no index,
+ * so the cursor never lands on a heading with nothing under it.
+ */
+export function sectionStartIndexes(projects: readonly ProjectRecord[]): number[] {
+  const starts: number[] = []
+  let index = 0
+  for (const section of SETTING_SECTIONS) {
+    const count = sectionRowCount(section, projects)
+    if (count > 0) starts.push(index)
+    index += count
+  }
+  return starts
 }
 
 /** The row with this id, dynamic ones included. */

package/src/settings/sections/integrations.ts

@@ -6,6 +6,7 @@ import type { SettingSection } from '../types'
  * take effect before the next launch.
  */
 export const INTEGRATIONS_SECTION: SettingSection = {
+  glyph: '\u{21C4}',
   id: 'integrations',
   label: 'Integrations',
   rows: [

package/src/settings/sections/layout.ts

@@ -10,6 +10,7 @@ import { dispatchGlobal } from '../../state/dispatch-ref'
  * value it already has.
  */
 export const LAYOUT_SECTION: SettingSection = {
+  glyph: '\u{25A6}',
   id: 'layout',
   label: 'Layout',
   rows: [

package/src/settings/sections/notifications.ts

@@ -53,6 +53,7 @@ export function playNotificationSound(): boolean {
 
 export const NOTIFICATIONS_SECTION: SettingSection = {
   description: 'Plays when an assistant needs an answer, or finishes a turn.',
+  glyph: '\u{25CE}',
   id: 'notifications',
   label: 'Notifications',
   rows: [

package/src/settings/sections/setup.ts

@@ -46,6 +46,7 @@ function setupRow(projectId: string, projectName: string): SettingRow {
 }
 
 export const SETUP_SECTION: SettingSection = {
+  glyph: '\u{2726}',
   id: 'setup',
   label: 'Setup',
   rowCount: (projects) => projects.length,

package/src/settings/sections/status-bar.ts

@@ -20,6 +20,7 @@ const SEPARATORS: { value: StatusBarSeparator; label: string }[] = [
  * worse than no row.
  */
 export const STATUS_BAR_SECTION: SettingSection = {
+  glyph: '\u{25AC}',
   id: 'statusBar',
   label: 'Status bar',
   rows: [

package/src/settings/sections/workspace.ts

@@ -36,6 +36,7 @@ function defaultBaseRefRow(project: ProjectRecord): SettingRow {
 }
 
 export const WORKSPACE_SECTION: SettingSection = {
+  glyph: '\u{2302}',
   id: 'workspace',
   label: 'Workspaces',
   rowCount: (projects) => projects.length,

package/src/settings/types.ts

@@ -86,6 +86,16 @@ export type SettingRow =
 
 export interface SettingSection {
   id: string
+  /**
+   * One cell, text presentation, present in the base fonts — the same rule the
+   * stats screen's section glyphs follow, so the eye finds a section by shape
+   * before it reads the label.
+   *
+   * Required, and on the section rather than in a lookup keyed by id: a map
+   * would need a fallback, and a fallback turns a renamed or added section into
+   * a silent placeholder instead of a compile error.
+   */
+  glyph: string
   label: string
   /** Shown once under the section's title, for a caveat that covers every row. */
   description?: string

package/src/state/actions.ts

@@ -73,8 +73,8 @@ export type ModalAction =
   | { type: 'set-theme-entry-count'; count: number }
   | { type: 'open-theme-picker'; returnTo?: FocusMode }
   | { type: 'open-update-available-modal'; currentVersion: string; latestVersion: string }
+  | { type: 'open-quotas-modal' }
   | { type: 'set-modal-selection-index'; index: number }
-  | { type: 'open-ai-usage-modal' }
   | { type: 'open-workspace-move-modal'; sourceWorkspaceId: string }
   | { type: 'toggle-workspace-move-delete' }
   | { type: 'set-workspace-move-stats'; dirtyFiles: Record<string, number> }
@@ -219,13 +219,22 @@ export type UIAction =
 export type SettingsAction =
   | { type: 'enter-settings' }
   | { type: 'exit-settings' }
-  | { type: 'settings-focus-pane'; pane: 'nav' | 'rows' }
   | { type: 'settings-move-selection'; delta: -1 | 1 }
-  | { type: 'settings-select-section'; sectionId: string }
+  | { type: 'settings-jump-section'; delta: -1 | 1 }
   | { type: 'settings-select-row'; rowIndex: number }
   | { type: 'open-settings-search' }
   | { type: 'open-setting-text-modal'; settingId: string; label: string; value: string }
 
+export type StatsAction =
+  | { type: 'enter-stats' }
+  | { type: 'exit-stats' }
+  | { type: 'stats-move-page'; delta: -1 | 1 }
+  | { type: 'stats-select-page'; pageIndex: number }
+  /** Rows, not pixels: the view holds a scroll offset the page applies to its box. */
+  | { type: 'stats-scroll'; delta: number }
+  /** The offset the scrollbox actually accepted, sent back so the state cannot run past the page. */
+  | { type: 'stats-scroll-settled'; scrollTop: number }
+
 export type GitPanelAction =
   | { type: 'git-refresh-success'; payload: GitRefreshPayload }
   | { type: 'git-refresh-error'; kind: GitPanelError }
@@ -335,6 +344,7 @@ export type AppAction =
   | LayoutAction
   | UIAction
   | SettingsAction
+  | StatsAction
   | DataAction
   | GitPanelAction
   | GitModeAction