diff --git a/apps/server/src/usage/UsageService.test.ts b/apps/server/src/usage/UsageService.test.ts
index dc3f7ac927147..0ebb1228e0114 100644
--- a/apps/server/src/usage/UsageService.test.ts
+++ b/apps/server/src/usage/UsageService.test.ts
@@ -3508,6 +3508,96 @@ describe("UsageService", () => {
       }),
   );
 
+  it.effect(
+    "reuses old live transcripts across all-time refreshes without retaining deleted history",
+    () =>
+      Effect.gen(function* () {
+        yield* TestClock.setTime(Date.parse("2026-12-01T00:00:00Z"));
+        const { transcript, settings, home } = yield* setup;
+        const lastWrite = Date.parse("2026-08-01T10:00:00Z") / 1000;
+        yield* Effect.promise(async () => {
+          await NodeFSP.writeFile(transcript, claudeLine(1, 5));
+          await NodeFSP.utimes(transcript, lastWrite, lastWrite);
+        });
+        yield* Effect.gen(function* () {
+          const service = yield* UsageService.make;
+          const allTime = {
+            ...WINDOW,
+            sinceDay: UsageDay.make("1970-01-01"),
+            untilDay: UsageDay.make("2026-12-01"),
+          };
+          const open = vi.spyOn(NodeFSP, "open");
+          yield* Effect.addFinalizer(() => Effect.sync(() => open.mockRestore()));
+          open.mockClear();
+          assert.strictEqual(totalOutputTokens(yield* service.readSummary(allTime)), 5);
+          assert.isTrue(open.mock.calls.some(([path]) => path === transcript));
+          open.mockClear();
+          for (const sinceDay of ["2026-11-02", "2026-09-03"]) {
+            const recent = { ...allTime, sinceDay: UsageDay.make(sinceDay) };
+            assert.deepStrictEqual((yield* service.readSummary(recent)).buckets, []);
+          }
+          assert.strictEqual(
+            totalOutputTokens(yield* service.readSummary({ ...allTime, awaitRefresh: true })),
+            5,
+          );
+          assert.isFalse(open.mock.calls.some(([path]) => path === transcript));
+
+          yield* Effect.promise(async () => {
+            await NodeFSP.appendFile(transcript, claudeLine(2, 7));
+            await NodeFSP.utimes(transcript, lastWrite + 86400, lastWrite + 86400);
+          });
+          assert.strictEqual(totalOutputTokens(yield* service.readSummary(allTime)), 12);
+          yield* Effect.promise(async () => {
+            await NodeFSP.writeFile(transcript, claudeLine(3, 9));
+            await NodeFSP.utimes(transcript, lastWrite + 172800, lastWrite + 172800);
+          });
+          assert.strictEqual(totalOutputTokens(yield* service.readSummary(allTime)), 9);
+
+          yield* Effect.promise(() => NodeFSP.rm(transcript));
+          assert.deepStrictEqual((yield* service.readSummary(allTime)).buckets, []);
+          yield* service.awaitPersisted;
+          const restarted = yield* UsageService.make;
+          assert.deepStrictEqual((yield* restarted.readSummary(allTime)).buckets, []);
+        }).pipe(
+          Effect.provide(layerService({ prefix: "usage-service-all-time-test", home, settings })),
+        );
+      }).pipe(Effect.scoped),
+  );
+
+  it.effect("answers a provisional all-time read with old and recent transcripts", () =>
+    Effect.gen(function* () {
+      yield* TestClock.setTime(Date.parse("2026-12-01T00:00:00Z"));
+      const { transcript, settings, home } = yield* setup;
+      const recent = NodePath.join(NodePath.dirname(transcript), "recent.jsonl");
+      yield* Effect.promise(async () => {
+        const oldWrite = Date.parse("2026-08-01T10:00:00Z") / 1000;
+        const recentWrite = Date.parse("2026-11-30T10:00:00Z") / 1000;
+        await NodeFSP.writeFile(transcript, claudeLine(1, 5));
+        await NodeFSP.utimes(transcript, oldWrite, oldWrite);
+        await NodeFSP.writeFile(recent, claudeLine(2, 3));
+        await NodeFSP.utimes(recent, recentWrite, recentWrite);
+      });
+      yield* Effect.gen(function* () {
+        const service = yield* UsageService.make;
+        const allTime = {
+          ...WINDOW,
+          sinceDay: UsageDay.make("1970-01-01"),
+          untilDay: UsageDay.make("2026-12-01"),
+        };
+        assert.strictEqual(totalOutputTokens(yield* service.readSummary(allTime)), 8);
+        // The recent file keeps the source refreshing, so this read cannot fall back to an exact scan.
+        assert.strictEqual(
+          totalOutputTokens(yield* service.readSummary({ ...allTime, provisional: true })),
+          8,
+        );
+      }).pipe(
+        Effect.provide(
+          layerService({ prefix: "usage-service-all-time-provisional", home, settings }),
+        ),
+      );
+    }).pipe(Effect.scoped),
+  );
+
   it.effect("reports saved usage of a removed directory only for windows it reaches", () =>
     Effect.gen(function* () {
       yield* TestClock.setTime(Date.parse("2026-08-12T00:00:00Z"));
diff --git a/apps/server/src/usage/UsageService.ts b/apps/server/src/usage/UsageService.ts
index a55532913c3c6..c297474ef4e3b 100644
--- a/apps/server/src/usage/UsageService.ts
+++ b/apps/server/src/usage/UsageService.ts
@@ -162,6 +162,8 @@ export const make = Effect.gen(function* () {
   const readerContext = yield* Effect.context<BuiltInUsageReadersEnv>();
 
   const fileCache: ScanCache = new Map();
+  // Old live files stay warm without enlarging persisted history or normal-window cache walks.
+  const historicalFileCache: ScanCache = new Map();
   // Reads from concurrent windows can still hold the original record after it is corrected.
   const resolvedRecords = new WeakMap<UsageRecord, UsageRecord>();
   const correctedRecord = (record: UsageRecord) => resolvedRecords.get(record) ?? record;
@@ -518,7 +520,7 @@ export const make = Effect.gen(function* () {
     readonly failed?: true;
     readonly update?: { readonly entry: CachedFile; readonly replaces: CachedFile | undefined };
   }> {
-    const cached = fileCache.get(filePath);
+    const cached = fileCache.get(filePath) ?? historicalFileCache.get(filePath);
     // Provider is part of the identity: if both providers were ever pointed
     // at one directory, a hit parsed by the other parser must not be reused.
     if (
@@ -647,6 +649,7 @@ export const make = Effect.gen(function* () {
   const scanTranscriptDir = Effect.fn("UsageService.scanTranscriptDir")(function* (
     source: TranscriptSource,
     windowStartMs: number,
+    retentionCutoffMs: number,
     fromMemory: boolean,
   ) {
     const { provider, format, dir, volumeId, fileName } = source;
@@ -662,6 +665,17 @@ export const make = Effect.gen(function* () {
     const { files, walked, failedPaths } = yield* Effect.promise(() =>
       listTranscriptFiles(dir, windowStartMs, fileName === undefined ? undefined : { fileName }),
     );
+    if (windowStartMs < retentionCutoffMs && failedPaths === 0) {
+      const livePaths = new Set(files.map((file) => file.path));
+      for (const [filePath, entry] of historicalFileCache) {
+        if (
+          entry.mtimeMs >= windowStartMs &&
+          isWithinDirectory(filePath, dir) &&
+          !livePaths.has(filePath)
+        )
+          historicalFileCache.delete(filePath);
+      }
+    }
     const read = yield* Effect.forEach(
       files,
       (file) =>
@@ -675,18 +689,21 @@ export const make = Effect.gen(function* () {
       // A scan of another window may have cached its own read of this file
       // meanwhile. Then keep whichever read saw the later file, so a slower
       // scan never replaces newer usage with older.
-      const current = fileCache.get(path);
+      const current = fileCache.get(path) ?? historicalFileCache.get(path);
       if (
         current === update.replaces ||
         current === undefined ||
         isLaterRead(update.entry, current)
       ) {
-        fileCache.set(path, {
+        const cache = update.entry.mtimeMs < retentionCutoffMs ? historicalFileCache : fileCache;
+        if (cache === fileCache) historicalFileCache.delete(path);
+        else if (fileCache.delete(path)) cacheDirty = true;
+        cache.set(path, {
           ...update.entry,
           records: correctedBatch(update.entry.records),
           tailRecords: correctedBatch(update.entry.tailRecords),
         });
-        cacheDirty = true;
+        if (cache === fileCache) cacheDirty = true;
       }
       return { path, records, malformedRecords };
     });
@@ -755,7 +772,12 @@ export const make = Effect.gen(function* () {
 
     // Scan independent sources together, directories sequentially to bound open files; keep order, since the first copy decides a duplicate's bucket.
     const [transcripts, scanDirs] = yield* Effect.all(
-      [Effect.forEach(dirs, (dir) => scanTranscriptDir(dir, windowStartMs, fromMemory)), scans],
+      [
+        Effect.forEach(dirs, (dir) =>
+          scanTranscriptDir(dir, windowStartMs, retentionCutoffMs, fromMemory),
+        ),
+        scans,
+      ],
       { concurrency: "unbounded" },
     );
     const scanned: readonly ScannedDir[] = [...transcripts, ...pending, ...scanDirs.flat()];
@@ -820,8 +842,10 @@ export const make = Effect.gen(function* () {
       );
       // A window no complete scan has read would show partial totals, so every directory must cover it.
       // Saved files are keyed by path, so two providers reading one directory keep only one parse.
+      // Windows reaching past retention need the in-memory historical files, which a saved snapshot lacks.
       const fromMemory =
         provisional &&
+        windowStartMs >= retentionCutoffMs &&
         resolved.dirs.length > 0 &&
         new Set(resolved.dirs.map((source) => source.dir)).size === resolved.dirs.length &&
         resolved.dirs.every(
diff --git a/apps/web/src/components/usage/UsagePage.tsx b/apps/web/src/components/usage/UsagePage.tsx
index 8bc8a93a43d69..c542a5631bfbc 100644
--- a/apps/web/src/components/usage/UsagePage.tsx
+++ b/apps/web/src/components/usage/UsagePage.tsx
@@ -51,7 +51,6 @@ import {
   formatTokens,
   formatUsageContractMismatch,
   formatUsd,
-  makeWindow,
   usageSourceMessages,
 } from "@t3tools/shared/usageFormat";
 import { Button, InlineButton } from "../ui/button";
@@ -80,6 +79,7 @@ import { WorkspacePageContainer } from "../WorkspacePageContainer";
 import { UsageLimitsSection } from "./UsageLimits";
 import { UsagePriceOverrides } from "./UsagePriceOverrides";
 import { UsageProviderChart } from "./UsageProviderChart";
+import { makeUsageWindow, trimUsageWindow } from "./usageWindow";
 import { SpeedPremium, UsageModelDialog } from "./UsageModelDialog";
 import { UsageShareBar } from "./UsageShareBar";
 import {
@@ -188,11 +188,7 @@ export function UsagePage() {
   };
   const [windowSelection, setWindowSelection] = useState(() => ({
     days: preferences.windowDays,
-    window: makeWindow(
-      preferences.windowDays,
-      undefined,
-      preferences.windowDays === 1 ? "hour" : "day",
-    ),
+    window: makeUsageWindow(preferences.windowDays),
   }));
   const metric = preferences.metric;
   const showingLimits = metric === "limits";
@@ -204,7 +200,6 @@ export function UsagePage() {
     useState<ReadonlySet<EnvironmentId> | null>(null);
   const hiddenProviders = new Set(preferences.hiddenProviders);
   const { days: windowDays, window } = windowSelection;
-  const isPast24Hours = windowDays === 1;
   const {
     merged: answeredUsage,
     environments,
@@ -214,7 +209,7 @@ export function UsagePage() {
     refresh,
   } = useUsage(window, selectedEnvironmentIds, hiddenProviders);
   const merged = shown?.merged ?? answeredUsage;
-  const shownWindow = shown?.window ?? window;
+  const shownWindow = trimUsageWindow(shown?.window ?? window, merged.daily);
   const shownHourly = shownWindow.resolution === "hour";
   const refreshingUsage = isRefreshing && !showingLimits;
   const showingKept = shown !== null && shown.window !== window;
@@ -240,7 +235,7 @@ export function UsagePage() {
     updatePreferences({ windowDays: days });
     setWindowSelection({
       days,
-      window: makeWindow(days, undefined, days === 1 ? "hour" : "day"),
+      window: makeUsageWindow(days),
     });
   };
   const selectMetric = (nextMetric: UsageMetric) => {
@@ -305,7 +300,7 @@ export function UsagePage() {
       });
       return;
     }
-    const nextWindow = makeWindow(windowDays, undefined, isPast24Hours ? "hour" : "day");
+    const nextWindow = makeUsageWindow(windowDays);
     if (
       nextWindow.sinceDay !== window.sinceDay ||
       nextWindow.untilDay !== window.untilDay ||
@@ -357,7 +352,7 @@ export function UsagePage() {
       ? `${formatDateTimeShort(shownWindow.sinceTime, shownWindow.timeZone, hour12)} to ${formatDateTimeShort(shownWindow.untilTime, shownWindow.timeZone, hour12)}`
       : `${formatDayShort(shownWindow.sinceDay)} to ${formatDayShort(shownWindow.untilDay)}`;
   const topbarContent = (
-    <div className="grid w-full min-w-0 grid-cols-[minmax(0,1fr)_auto] items-center gap-x-3 py-2 @4xl/usage-header:flex">
+    <div className="grid w-full min-w-0 grid-cols-[minmax(0,1fr)_auto] items-center gap-x-3 py-2 @5xl/usage-header:flex">
       <WorkspaceBreadcrumb ariaLabel="Usage breadcrumb" className="min-w-0">
         <WorkspaceBreadcrumbItem>
           <h1>Usage</h1>
@@ -390,7 +385,7 @@ export function UsagePage() {
           {windowLabel}
         </span>
       ) : null}
-      <div className="ms-auto hidden shrink-0 items-center justify-end gap-2 @4xl/usage-header:flex">
+      <div className="ms-auto hidden shrink-0 items-center justify-end gap-2 @5xl/usage-header:flex">
         {/* Limits are always current, so they have no period. The period sits before the metric
             tabs so dropping it never moves them. */}
         {showingLimits ? null : (
@@ -436,7 +431,7 @@ export function UsagePage() {
           <RefreshIcon size="sm" refreshing={isRefreshing} />
         </Button>
       </div>
-      <div className="ms-auto flex shrink-0 items-center justify-end gap-1 @4xl/usage-header:hidden">
+      <div className="ms-auto flex shrink-0 items-center justify-end gap-1 @5xl/usage-header:hidden">
         {showingLimits ? null : (
           <Select value={String(windowDays)} onValueChange={(value) => selectWindow(Number(value))}>
             <SelectTrigger
diff --git a/apps/web/src/components/usage/UsageProviderChart.test.ts b/apps/web/src/components/usage/UsageProviderChart.test.ts
index c01a8b9def2ec..93c64400cd71e 100644
--- a/apps/web/src/components/usage/UsageProviderChart.test.ts
+++ b/apps/web/src/components/usage/UsageProviderChart.test.ts
@@ -1,6 +1,17 @@
 import { describe, expect, it } from "vite-plus/test";
 
-import { buildPeriodColumns } from "./UsageProviderChart";
+import { buildPeriodColumns, formatChartDay } from "./UsageProviderChart";
+
+describe("formatChartDay", () => {
+  it.each([
+    { days: ["2026-01-01", "2026-12-31"], label: "Jan 1" },
+    { days: ["2025-12-31", "2026-01-01"], label: "Jan 1, 2026" },
+    { days: ["2024-01-01", "2026-01-01"], label: "Jan 1, 2026" },
+    { days: ["2026-01-01"], label: "Jan 1" },
+  ])("formats dates across $days", ({ days, label }) => {
+    expect(formatChartDay("2026-01-01", days)).toBe(label);
+  });
+});
 
 describe("buildPeriodColumns", () => {
   const days = ["2026-08-01", "2026-08-02", "2026-08-03"];
diff --git a/apps/web/src/components/usage/UsageProviderChart.tsx b/apps/web/src/components/usage/UsageProviderChart.tsx
index 1745be4df897b..7f61b9eafc32a 100644
--- a/apps/web/src/components/usage/UsageProviderChart.tsx
+++ b/apps/web/src/components/usage/UsageProviderChart.tsx
@@ -22,6 +22,11 @@ const NONE_LOADING: ReadonlySet<UsageProviderKind> = new Set();
 
 export type UsageChartMetric = "tokens" | "cost";
 
+export function formatChartDay(day: string, days: readonly string[]): string {
+  const label = formatDayShort(day);
+  return days[0]?.slice(0, 4) !== days.at(-1)?.slice(0, 4) ? `${label}, ${day.slice(0, 4)}` : label;
+}
+
 interface UsageProviderChartProps {
   readonly providers: readonly UsageProviderKind[];
   readonly loadingProviders?: ReadonlySet<UsageProviderKind>;
@@ -201,14 +206,13 @@ function buildChart(
   const stepX = periods.length < 2 ? 0 : VIEW_WIDTH / (periods.length - 1);
   const paths = providers.map((provider) => {
     const slot = PROVIDER_ORDER.indexOf(provider);
-    const line = curvePath(
-      smoothCurve(
-        columns.map((column, periodIndex) => ({
-          x: periodIndex * stepX,
-          y: valueToY(column.bands[slot]?.value ?? 0, scale.max),
-        })),
-      ),
-    );
+    const points = columns.map((column, periodIndex) => ({
+      x: periodIndex * stepX,
+      y: valueToY(column.bands[slot]?.value ?? 0, scale.max),
+    }));
+    const first = points[0];
+    if (points.length === 1 && first !== undefined) points.push({ ...first, x: VIEW_WIDTH });
+    const line = curvePath(smoothCurve(points));
     return {
       provider,
       loading: loadingProviders.has(provider),
@@ -436,7 +440,9 @@ export function UsageProviderChart({
     cn("transition-opacity", loading && "opacity-40 delay-150");
   const format = metric === "tokens" ? formatTokens : formatUsd;
   const formatPeriod = (period: string) =>
-    resolution === "hour" ? formatHourShort(period, timeZone, hour12) : formatDayShort(period);
+    resolution === "hour"
+      ? formatHourShort(period, timeZone, hour12)
+      : formatChartDay(period, days);
   const formatTooltipPeriod = (period: string) =>
     resolution === "hour" && referenceTime !== undefined
       ? formatRelativeHourShort(period, referenceTime, timeZone, hour12)
diff --git a/apps/web/src/components/usage/usagePagePreferences.test.ts b/apps/web/src/components/usage/usagePagePreferences.test.ts
index 075076a9b3c52..160e426a953cf 100644
--- a/apps/web/src/components/usage/usagePagePreferences.test.ts
+++ b/apps/web/src/components/usage/usagePagePreferences.test.ts
@@ -1,6 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
 
 import { readUsagePagePreferences, saveUsagePagePreferences } from "./usagePagePreferences";
+import { ALL_TIME_WINDOW_DAYS } from "./usageWindow";
 
 const key = "t3code:usage-page-preferences:v1";
 let values: Map<string, string>;
@@ -28,8 +29,16 @@ describe("Usage page preferences", () => {
     saveUsagePagePreferences({ metric: "cost", windowDays: 7, hiddenProviders: ["codex"] });
     expect(readUsagePagePreferences().hiddenProviders).toEqual(["codex"]);
 
-    values.set(key, '{"metric":"tokens","windowDays":30}');
-    expect(readUsagePagePreferences()).toEqual({ metric: "tokens", windowDays: 30 });
+    for (const windowDays of [1, 7, 30, 90]) {
+      values.set(key, JSON.stringify({ metric: "tokens", windowDays }));
+      expect(readUsagePagePreferences()).toEqual({ metric: "tokens", windowDays });
+    }
+
+    saveUsagePagePreferences({ metric: "cost", windowDays: ALL_TIME_WINDOW_DAYS });
+    expect(readUsagePagePreferences()).toEqual({
+      metric: "cost",
+      windowDays: ALL_TIME_WINDOW_DAYS,
+    });
   });
 
   // regression: #10189 an invalid saved usage selection was never replaced
diff --git a/apps/web/src/components/usage/usagePagePreferences.ts b/apps/web/src/components/usage/usagePagePreferences.ts
index 1aeaefc43da12..9c5f49acaac0a 100644
--- a/apps/web/src/components/usage/usagePagePreferences.ts
+++ b/apps/web/src/components/usage/usagePagePreferences.ts
@@ -2,11 +2,12 @@ import { UsageProviderKind } from "@t3tools/contracts";
 import * as Schema from "effect/Schema";
 
 import { getLocalStorageItem, setLocalStorageItem } from "../../hooks/useLocalStorage";
+import { ALL_TIME_WINDOW_DAYS } from "./usageWindow";
 
 const STORAGE_KEY = "t3code:usage-page-preferences:v1";
 const UsagePagePreferencesSchema = Schema.Struct({
   metric: Schema.Literals(["cost", "tokens", "limits"]),
-  windowDays: Schema.Literals([1, 7, 30, 90]),
+  windowDays: Schema.Literals([1, 7, 30, 90, ALL_TIME_WINDOW_DAYS]),
   hiddenProviders: Schema.optional(Schema.Array(UsageProviderKind)),
 });
 export type UsagePagePreferences = typeof UsagePagePreferencesSchema.Type;
diff --git a/apps/web/src/components/usage/usageShortcuts.ts b/apps/web/src/components/usage/usageShortcuts.ts
index f8e66a8533637..c85ba857f1563 100644
--- a/apps/web/src/components/usage/usageShortcuts.ts
+++ b/apps/web/src/components/usage/usageShortcuts.ts
@@ -1,6 +1,7 @@
 import type { KeybindingCommand, ResolvedKeybindingsConfig } from "@t3tools/contracts";
 import type { UsageChartMetric } from "./UsageProviderChart";
 import { resolveShortcutCommand, type ShortcutEventLike } from "../../keybindings";
+import { ALL_TIME_WINDOW_DAYS } from "./usageWindow";
 
 export type UsageMetric = UsageChartMetric | "limits";
 export const METRIC_OPTIONS = [
@@ -14,7 +15,8 @@ export const WINDOW_OPTIONS = [
   { days: 7, label: "7 days", command: "usage.period.week" },
   { days: 30, label: "30 days", command: "usage.period.month" },
   { days: 90, label: "90 days", command: "usage.period.quarter" },
-] as const;
+  { days: ALL_TIME_WINDOW_DAYS, label: "All time", command: "usage.period.all" },
+] as const satisfies readonly { days: number; label: string; command: KeybindingCommand }[];
 
 export function resolveUsageShortcut(
   event: ShortcutEventLike & { target: EventTarget | null },
diff --git a/apps/web/src/components/usage/usageWindow.test.ts b/apps/web/src/components/usage/usageWindow.test.ts
new file mode 100644
index 0000000000000..824b7552cafaf
--- /dev/null
+++ b/apps/web/src/components/usage/usageWindow.test.ts
@@ -0,0 +1,45 @@
+import { UsageDay, type UsageSummaryInput } from "@t3tools/contracts";
+import { afterEach, describe, expect, it, vi } from "vite-plus/test";
+
+import { ALL_TIME_WINDOW_DAYS, makeUsageWindow, trimUsageWindow } from "./usageWindow";
+
+const window: UsageSummaryInput = {
+  sinceDay: UsageDay.make("1970-01-01"),
+  untilDay: UsageDay.make("2026-01-15"),
+  timeZone: "Pacific/Kiritimati",
+  resolution: "day",
+};
+
+describe("Usage windows", () => {
+  afterEach(() => vi.useRealTimers());
+
+  it("requests all history on selection and refresh", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime("2026-01-15T12:00:00Z");
+    const selected = makeUsageWindow(ALL_TIME_WINDOW_DAYS);
+    expect(selected.sinceDay).toBe("1970-01-01");
+    expect(selected.resolution).toBe("day");
+    vi.setSystemTime("2026-01-16T12:00:00Z");
+    const refreshed = makeUsageWindow(ALL_TIME_WINDOW_DAYS);
+    expect(refreshed.sinceDay).toBe(selected.sinceDay);
+    expect(refreshed.untilDay > selected.untilDay).toBe(true);
+  });
+
+  it("starts at the first usage day, including unpriced tokens", () => {
+    const daily = [
+      { day: "2024-12-31", costUsd: 0, totalTokens: 10, byProvider: new Map() },
+      { day: "2026-01-15", costUsd: 1, totalTokens: 20, byProvider: new Map() },
+    ];
+    expect(trimUsageWindow(window, daily)).toEqual({ ...window, sinceDay: "2024-12-31" });
+    expect(window.sinceDay).toBe("1970-01-01");
+  });
+
+  it("shows 30 calendar days when empty, even across a year boundary", () => {
+    expect(trimUsageWindow(window, [])).toEqual({ ...window, sinceDay: "2025-12-17" });
+  });
+
+  it("preserves a fixed window while a different selection is loading", () => {
+    const fixed = { ...window, sinceDay: UsageDay.make("2026-01-09") };
+    expect(trimUsageWindow(fixed, [])).toBe(fixed);
+  });
+});
diff --git a/apps/web/src/components/usage/usageWindow.ts b/apps/web/src/components/usage/usageWindow.ts
new file mode 100644
index 0000000000000..97b9d1c5a823a
--- /dev/null
+++ b/apps/web/src/components/usage/usageWindow.ts
@@ -0,0 +1,29 @@
+import { UsageDay, type UsageSummaryInput } from "@t3tools/contracts";
+import { makeWindow } from "@t3tools/shared/usageFormat";
+import type { DailyTotals } from "@t3tools/shared/usageMerge";
+
+export const ALL_TIME_WINDOW_DAYS = 0;
+const ALL_TIME_SINCE_DAY = UsageDay.make("1970-01-01");
+
+export function makeUsageWindow(days: number): UsageSummaryInput {
+  const window = makeWindow(
+    days === ALL_TIME_WINDOW_DAYS ? 30 : days,
+    undefined,
+    days === 1 ? "hour" : "day",
+  );
+  return days === ALL_TIME_WINDOW_DAYS ? { ...window, sinceDay: ALL_TIME_SINCE_DAY } : window;
+}
+
+export function trimUsageWindow(
+  window: UsageSummaryInput,
+  daily: readonly DailyTotals[],
+): UsageSummaryInput {
+  if (window.sinceDay !== ALL_TIME_SINCE_DAY) return window;
+  // Merged daily totals are sorted, and include usage even when its price is unknown.
+  const firstDay = daily[0]?.day;
+  const fallbackStart = new Date(Date.parse(`${window.untilDay}T00:00:00Z`) - 29 * 86_400_000);
+  return {
+    ...window,
+    sinceDay: UsageDay.make(firstDay ?? fallbackStart.toISOString().slice(0, 10)),
+  };
+}
diff --git a/apps/web/src/keybindings.test.ts b/apps/web/src/keybindings.test.ts
index 3b596f838fa0d..e36611937ac75 100644
--- a/apps/web/src/keybindings.test.ts
+++ b/apps/web/src/keybindings.test.ts
@@ -968,14 +968,20 @@ describe("Usage shortcuts", () => {
     },
   );
 
-  it("matches shifted number keys for periods and only on Usage", () => {
-    const shortcut = event({ key: "!", code: "Digit1", ctrlKey: true, shiftKey: true });
+  it.each([
+    ["!", "Digit1", "usage.period.day"],
+    ["@", "Digit2", "usage.period.week"],
+    ["#", "Digit3", "usage.period.month"],
+    ["$", "Digit4", "usage.period.quarter"],
+    ["%", "Digit5", "usage.period.all"],
+  ])("matches shifted %s for %s only on Usage", (key, code, command) => {
+    const shortcut = event({ key, code, ctrlKey: true, shiftKey: true });
     assert.strictEqual(
       resolveShortcutCommand(shortcut, DEFAULT_RESOLVED_KEYBINDINGS, {
         platform: "Linux",
         context: { usagePageOpen: true },
       }),
-      "usage.period.day",
+      command,
     );
     assert.isNull(
       resolveShortcutCommand(shortcut, DEFAULT_RESOLVED_KEYBINDINGS, {
diff --git a/packages/contracts/src/keybindings.ts b/packages/contracts/src/keybindings.ts
index eda5138b760b9..5116765ba816f 100644
--- a/packages/contracts/src/keybindings.ts
+++ b/packages/contracts/src/keybindings.ts
@@ -114,6 +114,7 @@ export const STATIC_KEYBINDING_COMMANDS = [
   "usage.period.week",
   "usage.period.month",
   "usage.period.quarter",
+  "usage.period.all",
   ...MODEL_PICKER_KEYBINDING_COMMANDS,
   ...THREAD_KEYBINDING_COMMANDS,
 ] as const;
diff --git a/packages/shared/src/keybindings.ts b/packages/shared/src/keybindings.ts
index 9a67264d8bd1f..41f473d795575 100644
--- a/packages/shared/src/keybindings.ts
+++ b/packages/shared/src/keybindings.ts
@@ -148,6 +148,7 @@ export const DEFAULT_KEYBINDINGS: ReadonlyArray<KeybindingRule> = [
   { key: "mod+shift+2", command: "usage.period.week", when: "usagePageOpen" },
   { key: "mod+shift+3", command: "usage.period.month", when: "usagePageOpen" },
   { key: "mod+shift+4", command: "usage.period.quarter", when: "usagePageOpen" },
+  { key: "mod+shift+5", command: "usage.period.all", when: "usagePageOpen" },
 ];
 
 function normalizeKeyToken(token: string): string {