perf(codex): skip out-of-range date directories when --since/--until is set

Previously, loadTokenUsageEvents() always globbed **/*.jsonl across the
entire sessions directory tree, which reads all historical data regardless
of the requested date range. On large installations (35 GB+, 12 000+
files) this caused the process to be OOM-killed by the OS before producing
any output.

Sessions are stored as YYYY/MM/DD/*.jsonl. When --since or --until is
provided, enumerate the year/month/day directories and prune entire
subtrees that fall outside the range instead of performing a full recursive
glob. Fall back to the recursive glob when no date filters are specified to
preserve existing behaviour.

Thread the since/until values from each command (daily, monthly, session)
into loadTokenUsageEvents() so the directory-level filter is applied.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: jleechan

apps/codex/src/commands/daily.ts

@@ -41,7 +41,7 @@ export const dailyCommand = define({
 			process.exit(1);
 		}
 
-		const { events, missingDirectories } = await loadTokenUsageEvents();
+		const { events, missingDirectories } = await loadTokenUsageEvents({ since, until });
 
 		for (const missing of missingDirectories) {
 			logger.warn(`Codex session directory not found: ${missing}`);

apps/codex/src/commands/monthly.ts

@@ -41,7 +41,7 @@ export const monthlyCommand = define({
 			process.exit(1);
 		}
 
-		const { events, missingDirectories } = await loadTokenUsageEvents();
+		const { events, missingDirectories } = await loadTokenUsageEvents({ since, until });
 
 		for (const missing of missingDirectories) {
 			logger.warn(`Codex session directory not found: ${missing}`);

apps/codex/src/commands/session.ts

@@ -46,7 +46,7 @@ export const sessionCommand = define({
 			process.exit(1);
 		}
 
-		const { events, missingDirectories } = await loadTokenUsageEvents();
+		const { events, missingDirectories } = await loadTokenUsageEvents({ since, until });
 
 		for (const missing of missingDirectories) {
 			logger.warn(`Codex session directory not found: ${missing}`);

apps/codex/src/data-loader.ts

@@ -1,5 +1,5 @@
 import type { TokenUsageDelta, TokenUsageEvent } from './_types.ts';
-import { readFile, stat } from 'node:fs/promises';
+import { readdir, readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import process from 'node:process';
 import { Result } from '@praha/byethrow';
@@ -177,14 +177,84 @@ function asNonEmptyString(value: unknown): string | undefined {
 
 export type LoadOptions = {
 	sessionDirs?: string[];
+	since?: string;
+	until?: string;
 };
 
+/**
+ * List session JSONL files, skipping date directories outside [since, until].
+ *
+ * Codex stores sessions as `YYYY/MM/DD/*.jsonl`. When a date range is provided
+ * we enumerate the directory tree and prune entire year/month/day subtrees that
+ * cannot contain matching sessions, avoiding the cost of a full recursive glob
+ * over potentially large historical archives.
+ */
+async function listSessionFiles(
+	sessionsDir: string,
+	since: string | undefined,
+	until: string | undefined,
+): Promise<string[]> {
+	if (since == null && until == null) {
+		return glob(SESSION_GLOB, { cwd: sessionsDir, absolute: true });
+	}
+
+	const sinceKey = since?.replaceAll('-', '');
+	const untilKey = until?.replaceAll('-', '');
+
+	const tryReaddir = async (dir: string): Promise<string[]> => {
+		const result = await Result.try({
+			try: readdir(dir),
+			catch: (error) => error,
+		});
+		return Result.isFailure(result) ? [] : result.value;
+	};
+
+	const files: string[] = [];
+
+	for (const year of (await tryReaddir(sessionsDir)).filter((e) => /^\d{4}$/.test(e))) {
+		if (sinceKey != null && `${year}1231` < sinceKey) {
+			continue;
+		}
+		if (untilKey != null && `${year}0101` > untilKey) {
+			continue;
+		}
+
+		const yearDir = path.join(sessionsDir, year);
+		for (const month of (await tryReaddir(yearDir)).filter((e) => /^\d{2}$/.test(e))) {
+			if (sinceKey != null && `${year + month}31` < sinceKey) {
+				continue;
+			}
+			if (untilKey != null && `${year + month}01` > untilKey) {
+				continue;
+			}
+
+			const monthDir = path.join(yearDir, month);
+			for (const day of (await tryReaddir(monthDir)).filter((e) => /^\d{2}$/.test(e))) {
+				const dateKey = year + month + day;
+				if (sinceKey != null && dateKey < sinceKey) {
+					continue;
+				}
+				if (untilKey != null && dateKey > untilKey) {
+					continue;
+				}
+
+				const dayDir = path.join(monthDir, day);
+				const dayFiles = await glob('*.jsonl', { cwd: dayDir, absolute: true }).catch(() => []);
+				files.push(...dayFiles);
+			}
+		}
+	}
+
+	return files;
+}
+
 export type LoadResult = {
 	events: TokenUsageEvent[];
 	missingDirectories: string[];
 };
 
 export async function loadTokenUsageEvents(options: LoadOptions = {}): Promise<LoadResult> {
+	const { since, until } = options;
 	const providedDirs =
 		options.sessionDirs != null && options.sessionDirs.length > 0
 			? options.sessionDirs.map((dir) => path.resolve(dir))
@@ -216,10 +286,7 @@ export async function loadTokenUsageEvents(options: LoadOptions = {}): Promise<L
 			continue;
 		}
 
-		const files = await glob(SESSION_GLOB, {
-			cwd: directoryPath,
-			absolute: true,
-		});
+		const files = await listSessionFiles(directoryPath, since, until);
 
 		for (const file of files) {
 			const relativeSessionPath = path.relative(directoryPath, file);
@@ -453,6 +520,50 @@ if (import.meta.vitest != null) {
 			expect(second.cachedInputTokens).toBe(100);
 		});
 
+		it('skips date directories outside the since/until range', async () => {
+			const makeEvent = (timestamp: string, input_tokens: number) =>
+				JSON.stringify({
+					timestamp,
+					type: 'event_msg',
+					payload: {
+						type: 'token_count',
+						info: {
+							last_token_usage: {
+								input_tokens,
+								cached_input_tokens: 0,
+								output_tokens: 100,
+								reasoning_output_tokens: 0,
+								total_tokens: input_tokens + 100,
+							},
+							model: 'gpt-5',
+						},
+					},
+				});
+
+			// Fixture mirrors real Codex layout: YYYY/MM/DD/*.jsonl
+			await using fixture = await createFixture({
+				'2025': {
+					'12': {
+						'31': { 'old.jsonl': makeEvent('2025-12-31T12:00:00.000Z', 999) },
+					},
+				},
+				'2026': {
+					'03': {
+						'01': { 'new.jsonl': makeEvent('2026-03-01T12:00:00.000Z', 1_000) },
+					},
+				},
+			});
+
+			// With since=2026-03-01 the 2025/12/31 file should be skipped entirely.
+			const { events } = await loadTokenUsageEvents({
+				sessionDirs: [fixture.getPath('.')],
+				since: '2026-03-01',
+			});
+
+			expect(events).toHaveLength(1);
+			expect(events[0]!.inputTokens).toBe(1_000);
+		});
+
 		it('falls back to legacy model when metadata is missing entirely', async () => {
 			await using fixture = await createFixture({
 				sessions: {