@tokscale/cli 1.2.7 → 1.2.8-canary.0

package/src/cli.ts

@@ -60,6 +60,7 @@ import { performance } from "node:perf_hooks";
 import type { SourceType } from "./graph-types.js";
 import type { TUIOptions, TabType } from "./tui/types/index.js";
 import { loadSettings } from "./tui/config/settings.js";
+import { formatDateLocal, parseDateStringToLocal, getStartOfDayTimestamp, getEndOfDayTimestamp, validateTimestampMs } from "./date-utils.js";
 
 type LaunchTUIFunction = (options?: TUIOptions) => Promise<void>;
 
@@ -144,40 +145,94 @@ interface CursorSyncResult {
   error?: string;
 }
 
-// =============================================================================
-// Date Helpers
-// =============================================================================
 
-function formatDate(date: Date): string {
-  return date.toISOString().split("T")[0];
+
+interface DateFilters {
+  since?: string;
+  until?: string;
+  year?: string;
+  sinceTs?: number;
+  untilTs?: number;
 }
 
-function getDateFilters(options: DateFilterOptions): { since?: string; until?: string; year?: string } {
+function getDateFilters(options: DateFilterOptions): DateFilters {
   const today = new Date();
   
-  // --today: just today
   if (options.today) {
-    const todayStr = formatDate(today);
-    return { since: todayStr, until: todayStr };
+    let sinceTs = getStartOfDayTimestamp(today);
+    let untilTs = getEndOfDayTimestamp(today);
+    sinceTs = validateTimestampMs(sinceTs, '--today (since)');
+    untilTs = validateTimestampMs(untilTs, '--today (until)');
+    return {
+      sinceTs,
+      untilTs,
+    };
   }
   
-  // --week: last 7 days
   if (options.week) {
     const weekAgo = new Date(today);
-    weekAgo.setDate(weekAgo.getDate() - 6); // Include today = 7 days
-    return { since: formatDate(weekAgo), until: formatDate(today) };
+    weekAgo.setDate(weekAgo.getDate() - 6);
+    let sinceTs = getStartOfDayTimestamp(weekAgo);
+    let untilTs = getEndOfDayTimestamp(today);
+    sinceTs = validateTimestampMs(sinceTs, '--week (since)');
+    untilTs = validateTimestampMs(untilTs, '--week (until)');
+    return {
+      sinceTs,
+      untilTs,
+    };
   }
   
-  // --month: current calendar month
   if (options.month) {
     const startOfMonth = new Date(today.getFullYear(), today.getMonth(), 1);
-    return { since: formatDate(startOfMonth), until: formatDate(today) };
+    let sinceTs = getStartOfDayTimestamp(startOfMonth);
+    let untilTs = getEndOfDayTimestamp(today);
+    sinceTs = validateTimestampMs(sinceTs, '--month (since)');
+    untilTs = validateTimestampMs(untilTs, '--month (until)');
+    return {
+      sinceTs,
+      untilTs,
+    };
+  }
+  
+  if (options.since || options.until) {
+    let sinceTs: number | undefined;
+    let untilTs: number | undefined;
+    
+    if (options.since) {
+      const sinceDate = parseDateStringToLocal(options.since);
+      if (!sinceDate) {
+        console.error(pc.red(`\n  Error: Invalid --since date '${options.since}'. Use YYYY-MM-DD format with valid date.\n`));
+        process.exit(1);
+      }
+      sinceTs = getStartOfDayTimestamp(sinceDate);
+      sinceTs = validateTimestampMs(sinceTs, '--since');
+    }
+    
+    if (options.until) {
+      const untilDate = parseDateStringToLocal(options.until);
+      if (!untilDate) {
+        console.error(pc.red(`\n  Error: Invalid --until date '${options.until}'. Use YYYY-MM-DD format with valid date.\n`));
+        process.exit(1);
+      }
+      untilTs = getEndOfDayTimestamp(untilDate);
+      untilTs = validateTimestampMs(untilTs, '--until');
+    }
+    
+    if (sinceTs !== undefined && untilTs !== undefined && sinceTs > untilTs) {
+      console.error(pc.red(`\n  Error: --since date must be before --until date.\n`));
+      process.exit(1);
+    }
+    
+    return {
+      since: options.since,
+      until: options.until,
+      year: options.year,
+      sinceTs,
+      untilTs,
+    };
   }
   
-  // Explicit filters
   return {
-    since: options.since,
-    until: options.until,
     year: options.year,
   };
 }
@@ -423,6 +478,8 @@ function buildTUIOptions(
     since: dateFilters.since,
     until: dateFilters.until,
     year: dateFilters.year,
+    sinceTs: dateFilters.sinceTs,
+    untilTs: dateFilters.untilTs,
   };
 }
 
@@ -1048,7 +1105,7 @@ interface LoadedDataSources {
 
 async function loadDataSourcesParallel(
   localSources: SourceType[],
-  dateFilters: { since?: string; until?: string; year?: string },
+  dateFilters: DateFilters,
   onPhase?: (phase: string) => void
 ): Promise<LoadedDataSources> {
   const shouldParseLocal = localSources.length > 0;
@@ -1061,6 +1118,8 @@ async function loadDataSourcesParallel(
           since: dateFilters.since,
           until: dateFilters.until,
           year: dateFilters.year,
+          sinceTs: dateFilters.sinceTs,
+          untilTs: dateFilters.untilTs,
         })
       : Promise.resolve(null),
   ]);
@@ -1142,6 +1201,8 @@ async function showModelReport(options: FilterOptions & DateFilterOptions & { be
       since: dateFilters.since,
       until: dateFilters.until,
       year: dateFilters.year,
+      sinceTs: dateFilters.sinceTs,
+      untilTs: dateFilters.untilTs,
     });
   } catch (e) {
     if (spinner) {
@@ -1274,6 +1335,8 @@ async function showMonthlyReport(options: FilterOptions & DateFilterOptions & {
       since: dateFilters.since,
       until: dateFilters.until,
       year: dateFilters.year,
+      sinceTs: dateFilters.sinceTs,
+      untilTs: dateFilters.untilTs,
     });
   } catch (e) {
     if (spinner) {
@@ -1373,6 +1436,8 @@ async function outputJsonReport(
       since: dateFilters.since,
       until: dateFilters.until,
       year: dateFilters.year,
+      sinceTs: dateFilters.sinceTs,
+      untilTs: dateFilters.untilTs,
     });
     console.log(JSON.stringify(report, null, 2));
   } else {
@@ -1382,6 +1447,8 @@ async function outputJsonReport(
       since: dateFilters.since,
       until: dateFilters.until,
       year: dateFilters.year,
+      sinceTs: dateFilters.sinceTs,
+      untilTs: dateFilters.untilTs,
     });
     console.log(JSON.stringify(report, null, 2));
   }
@@ -1425,6 +1492,8 @@ async function handleGraphCommand(options: GraphCommandOptions) {
     since: dateFilters.since,
     until: dateFilters.until,
     year: dateFilters.year,
+    sinceTs: dateFilters.sinceTs,
+    untilTs: dateFilters.untilTs,
   });
 
   const processingTime = performance.now() - startTime;

package/src/date-utils.ts

@@ -0,0 +1,51 @@
+export function formatDateLocal(date: Date): string {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+
+export function parseDateStringToLocal(dateStr: string): Date | null {
+  const match = dateStr.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!match) return null;
+  const [, yearStr, monthStr, dayStr] = match;
+  const year = parseInt(yearStr);
+  const month = parseInt(monthStr) - 1;
+  const day = parseInt(dayStr);
+  const date = new Date(year, month, day);
+  if (date.getFullYear() !== year || date.getMonth() !== month || date.getDate() !== day) {
+    return null;
+  }
+  return date;
+}
+
+export function getStartOfDayTimestamp(date: Date): number {
+  const start = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
+  return start.getTime();
+}
+
+export function getEndOfDayTimestamp(date: Date): number {
+  // Returns start of NEXT day (exclusive upper bound for half-open interval [since, until))
+  const nextDay = new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1, 0, 0, 0, 0);
+  return nextDay.getTime();
+}
+
+export function getContributionLocalDate(contrib: { date: string; timestampMs?: number }): string {
+  if (contrib.timestampMs != null) {
+    return formatDateLocal(new Date(contrib.timestampMs));
+  }
+  return contrib.date;
+}
+
+const MIN_VALID_TIMESTAMP_MS = 1_000_000_000_000;
+const MAX_VALID_TIMESTAMP_MS = 4_102_444_800_000;
+
+export function validateTimestampMs(ts: number, label: string): number {
+  if (!Number.isFinite(ts) || !Number.isSafeInteger(ts)) {
+    throw new Error(`${label} must be a finite safe integer, got ${ts}`);
+  }
+  if (ts < MIN_VALID_TIMESTAMP_MS || ts > MAX_VALID_TIMESTAMP_MS) {
+    throw new Error(`${label} out of valid range (${MIN_VALID_TIMESTAMP_MS}..${MAX_VALID_TIMESTAMP_MS}), got ${ts}`);
+  }
+  return ts;
+}

package/src/graph-types.ts

@@ -46,9 +46,13 @@ export interface SourceContribution {
  * Daily contribution entry with full granularity
  */
 export interface DailyContribution {
-  /** ISO date string (YYYY-MM-DD) */
+  /** ISO date string (YYYY-MM-DD) in UTC - note: this is the UTC day bucket, not local date */
   date: string;
 
+  /** Unix timestampMs (ms) of earliest message in this UTC day bucket.
+   *  Undefined for days with no valid timestamps. */
+  timestampMs?: number;
+
   /** Aggregated totals for the day */
   totals: {
     /** Total tokens (input + output + cache) */
@@ -157,23 +161,6 @@ export interface TokenContributionData {
   contributions: DailyContribution[];
 }
 
-/**
- * Options for graph data generation
- */
-export interface GraphOptions {
-  /** Filter to specific sources */
-  sources?: SourceType[];
-
-  /** Start date filter (ISO format) */
-  since?: string;
-
-  /** End date filter (ISO format) */
-  until?: string;
-
-  /** Filter to specific year */
-  year?: string;
-}
-
 /**
  * Unified message format for aggregation
  * Used internally to normalize data from different sources
@@ -182,7 +169,7 @@ export interface UnifiedMessage {
   source: SourceType;
   modelId: string;
   providerId?: string;
-  timestamp: number; // Unix milliseconds
+  timestampMs: number; // Unix milliseconds
   tokens: TokenBreakdown;
   cost: number;
 }

package/src/native.ts

@@ -7,7 +7,6 @@
 
 import type {
   TokenContributionData,
-  GraphOptions as TSGraphOptions,
   SourceType,
 } from "./graph-types.js";
 import { loadSettings } from "./tui/config/settings.js";
@@ -41,6 +40,7 @@ interface NativeSourceContribution {
 
 interface NativeDailyContribution {
   date: string;
+  timestampMs?: number;
   totals: NativeDailyTotals;
   intensity: number;
   tokenBreakdown: NativeTokenBreakdown;
@@ -81,14 +81,6 @@ interface NativeGraphResult {
   contributions: NativeDailyContribution[];
 }
 
-interface NativeReportOptions {
-  homeDir?: string;
-  sources?: string[];
-  since?: string;
-  until?: string;
-  year?: string;
-}
-
 interface NativeModelUsage {
   source: string;
   model: string;
@@ -165,6 +157,8 @@ interface NativeLocalParseOptions {
   since?: string;
   until?: string;
   year?: string;
+  sinceTs?: number;
+  untilTs?: number;
 }
 
 interface NativeFinalizeReportOptions {
@@ -174,11 +168,12 @@ interface NativeFinalizeReportOptions {
   since?: string;
   until?: string;
   year?: string;
+  sinceTs?: number;
+  untilTs?: number;
 }
 
 interface NativeCore {
   version(): string;
-  healthCheck(): string;
   parseLocalSources(options: NativeLocalParseOptions): NativeParsedMessages;
   finalizeReport(options: NativeFinalizeReportOptions): NativeModelReport;
   finalizeMonthlyReport(options: NativeFinalizeReportOptions): NativeMonthlyReport;
@@ -190,7 +185,6 @@ interface NativeCore {
 // =============================================================================
 
 let nativeCore: NativeCore | null = null;
-let loadError: Error | null = null;
 
 try {
   // Type assertion needed because dynamic import returns module namespace
@@ -199,7 +193,7 @@ try {
     (m) => (m.default || m) as unknown as NativeCore
   );
 } catch (e) {
-  loadError = e as Error;
+  void e;
 }
 
 // =============================================================================
@@ -254,6 +248,7 @@ function fromNativeResult(result: NativeGraphResult): TokenContributionData {
     })),
     contributions: result.contributions.map((c) => ({
       date: c.date,
+      timestampMs: c.timestampMs ?? undefined,
       totals: {
         tokens: c.totals.tokens,
         cost: c.totals.cost,
@@ -366,6 +361,8 @@ export interface LocalParseOptions {
   since?: string;
   until?: string;
   year?: string;
+  sinceTs?: number;
+  untilTs?: number;
 }
 
 export interface FinalizeOptions {
@@ -374,6 +371,8 @@ export interface FinalizeOptions {
   since?: string;
   until?: string;
   year?: string;
+  sinceTs?: number;
+  untilTs?: number;
 }
 
 
@@ -523,6 +522,8 @@ export async function parseLocalSourcesAsync(options: LocalParseOptions): Promis
     since: options.since,
     until: options.until,
     year: options.year,
+    sinceTs: options.sinceTs,
+    untilTs: options.untilTs,
   };
 
   return runInSubprocess<ParsedMessages>("parseLocalSources", [nativeOptions]);
@@ -540,6 +541,8 @@ export async function finalizeReportAsync(options: FinalizeOptions): Promise<Mod
     since: options.since,
     until: options.until,
     year: options.year,
+    sinceTs: options.sinceTs,
+    untilTs: options.untilTs,
   };
 
   return runInSubprocess<ModelReport>("finalizeReport", [nativeOptions]);
@@ -557,6 +560,8 @@ export async function finalizeMonthlyReportAsync(options: FinalizeOptions): Prom
     since: options.since,
     until: options.until,
     year: options.year,
+    sinceTs: options.sinceTs,
+    untilTs: options.untilTs,
   };
 
   return runInSubprocess<MonthlyReport>("finalizeMonthlyReport", [nativeOptions]);
@@ -574,6 +579,8 @@ export async function finalizeGraphAsync(options: FinalizeOptions): Promise<Toke
     since: options.since,
     until: options.until,
     year: options.year,
+    sinceTs: options.sinceTs,
+    untilTs: options.untilTs,
   };
 
   const result = await runInSubprocess<NativeGraphResult>("finalizeGraph", [nativeOptions]);
@@ -602,6 +609,8 @@ export async function finalizeReportAndGraphAsync(options: FinalizeOptions): Pro
     since: options.since,
     until: options.until,
     year: options.year,
+    sinceTs: options.sinceTs,
+    untilTs: options.untilTs,
   };
 
   const result = await runInSubprocess<NativeReportAndGraph>("finalizeReportAndGraph", [nativeOptions]);

package/src/submit.ts

@@ -13,9 +13,33 @@ import { parseLocalSourcesAsync, finalizeReportAndGraphAsync, type ParsedMessage
 import { syncCursorCache, isCursorLoggedIn, hasCursorUsageCache } from "./cursor.js";
 import type { TokenContributionData } from "./graph-types.js";
 import { formatCurrency } from "./table.js";
+import { parseDateStringToLocal, getStartOfDayTimestamp, getEndOfDayTimestamp, validateTimestampMs } from "./date-utils.js";
 
 const execAsync = promisify(exec);
 
+function getTimestampFilters(since?: string, until?: string): { sinceTs?: number; untilTs?: number } {
+  let sinceTs: number | undefined;
+  let untilTs: number | undefined;
+  
+  if (since) {
+    const sinceDate = parseDateStringToLocal(since);
+    if (sinceDate) {
+      sinceTs = getStartOfDayTimestamp(sinceDate);
+      sinceTs = validateTimestampMs(sinceTs, '--since');
+    }
+  }
+  
+  if (until) {
+    const untilDate = parseDateStringToLocal(until);
+    if (untilDate) {
+      untilTs = getEndOfDayTimestamp(untilDate);
+      untilTs = validateTimestampMs(untilTs, '--until');
+    }
+  }
+  
+  return { sinceTs, untilTs };
+}
+
 interface SubmitOptions {
   opencode?: boolean;
   claude?: boolean;
@@ -213,6 +237,7 @@ export async function submit(options: SubmitOptions = {}): Promise<void> {
 
   // Filter out cursor from local sources (it's handled separately via sync)
   const localSources = sources?.filter((s): s is Exclude<SourceType, "cursor"> => s !== "cursor");
+  const { sinceTs, untilTs } = getTimestampFilters(options.since, options.until);
 
   let data: TokenContributionData;
   try {
@@ -224,6 +249,8 @@ export async function submit(options: SubmitOptions = {}): Promise<void> {
         since: options.since,
         until: options.until,
         year: options.year,
+        sinceTs,
+        untilTs,
       }),
       includeCursor && isCursorLoggedIn()
         ? syncCursorCache()
@@ -243,6 +270,8 @@ export async function submit(options: SubmitOptions = {}): Promise<void> {
       since: options.since,
       until: options.until,
       year: options.year,
+      sinceTs,
+      untilTs,
     });
 
     // Use graph structure for submission, report's cost for display

package/src/tui/App.tsx

@@ -51,6 +51,8 @@ export function App(props: AppProps) {
     since: props.since,
     until: props.until,
     year: props.year,
+    sinceTs: props.sinceTs,
+    untilTs: props.untilTs,
   };
 
   const { data, loading, error, refresh, loadingPhase, isRefreshing } = useData(() => enabledSources(), dateFilters);

package/src/tui/hooks/useData.ts

@@ -23,6 +23,7 @@ import {
 import { syncCursorCache, isCursorLoggedIn, hasCursorUsageCache } from "../../cursor.js";
 import { getModelColor } from "../utils/colors.js";
 import { loadCachedData, saveCachedData, isCacheStale, loadSettings } from "../config/settings.js";
+import { formatDateLocal } from "../../date-utils.js";
 
 export type {
   SortType,
@@ -41,13 +42,15 @@ export interface DateFilters {
   since?: string;
   until?: string;
   year?: string;
+  sinceTs?: number;
+  untilTs?: number;
 }
 
 function buildContributionGrid(contributions: ContributionDay[]): GridCell[][] {
   const grid: GridCell[][] = Array.from({ length: 7 }, () => []);
 
   const today = new Date();
-  const todayStr = today.toISOString().split("T")[0];
+  const todayStr = formatDateLocal(today);
   
   const startDate = new Date(today);
   startDate.setDate(startDate.getDate() - 364);
@@ -64,10 +67,7 @@ function buildContributionGrid(contributions: ContributionDay[]): GridCell[][] {
 
   const currentDate = new Date(startDate);
   while (currentDate <= endDate) {
-    const year = currentDate.getFullYear();
-    const month = String(currentDate.getMonth() + 1).padStart(2, "0");
-    const day = String(currentDate.getDate()).padStart(2, "0");
-    const dateStr = `${year}-${month}-${day}`;
+    const dateStr = formatDateLocal(currentDate);
     const dayOfWeek = currentDate.getDay();
     
     const isFuture = dateStr > todayStr;
@@ -80,12 +80,12 @@ function buildContributionGrid(contributions: ContributionDay[]): GridCell[][] {
   return grid;
 }
 
-function calculatePeakHour(messages: Array<{ timestamp: number }>): string {
+function calculatePeakHour(messages: Array<{ timestampMs: number }>): string {
   if (messages.length === 0) return "N/A";
   
   const hourCounts = new Array(24).fill(0);
   for (const msg of messages) {
-    const hour = new Date(msg.timestamp).getHours();
+    const hour = new Date(msg.timestampMs).getHours();
     hourCounts[hour]++;
   }
   
@@ -105,14 +105,14 @@ function calculatePeakHour(messages: Array<{ timestamp: number }>): string {
   return `${displayHour}${suffix}`;
 }
 
-function calculateLongestSession(messages: Array<{ sessionId: string; timestamp: number }>): string {
+function calculateLongestSession(messages: Array<{ sessionId: string; timestampMs: number }>): string {
   if (messages.length === 0) return "N/A";
   
   const sessions = new Map<string, number[]>();
   for (const msg of messages) {
     if (!msg.sessionId) continue;
     const timestamps = sessions.get(msg.sessionId) || [];
-    timestamps.push(msg.timestamp);
+    timestamps.push(msg.timestampMs);
     sessions.set(msg.sessionId, timestamps);
   }
   
@@ -151,14 +151,14 @@ async function loadData(
   const sources = Array.from(enabledSources);
   const localSources = sources.filter(s => s !== "cursor");
   const includeCursor = sources.includes("cursor");
-  const { since, until, year } = dateFilters ?? {};
+  const { since, until, year, sinceTs, untilTs } = dateFilters ?? {};
 
   setPhase?.("parsing-sources");
   
   const phase1Results = await Promise.allSettled([
     includeCursor && isCursorLoggedIn() ? syncCursorCache() : Promise.resolve({ synced: false, rows: 0, error: undefined }),
     localSources.length > 0
-      ? parseLocalSourcesAsync({ sources: localSources as ("opencode" | "claude" | "codex" | "gemini" | "amp" | "droid" | "openclaw" | "pi")[], since, until, year })
+      ? parseLocalSourcesAsync({ sources: localSources as ("opencode" | "claude" | "codex" | "gemini" | "amp" | "droid" | "openclaw" | "pi")[], since, until, year, sinceTs, untilTs })
       : Promise.resolve({ messages: [], opencodeCount: 0, claudeCount: 0, codexCount: 0, geminiCount: 0, ampCount: 0, droidCount: 0, openclawCount: 0, piCount: 0, processingTimeMs: 0 } as ParsedMessages),
   ]);
 
@@ -189,13 +189,14 @@ async function loadData(
   };
 
   setPhase?.("finalizing-report");
-  // Single call ensures consistent pricing between report and graph
   const { report, graph } = await finalizeReportAndGraphAsync({
     localMessages: localMessages || emptyMessages,
     includeCursor: includeCursor && (cursorSync.synced || hasCursorUsageCache()),
     since,
     until,
     year,
+    sinceTs,
+    untilTs,
   });
 
   const settings = loadSettings();
@@ -217,6 +218,7 @@ async function loadData(
   const dailyMap = new Map<string, DailyEntry>();
   for (const contrib of graph.contributions) {
     const dateStr = contrib.date;
+    
     if (!dailyMap.has(dateStr)) {
       dailyMap.set(dateStr, {
         date: dateStr,
@@ -323,12 +325,17 @@ async function loadData(
     favoriteModel,
     totalTokens: report.totalInput + report.totalOutput + report.totalCacheRead + report.totalCacheWrite,
     sessions: report.totalMessages,
-    longestSession: calculateLongestSession(localMessages?.messages || []),
+    longestSession: calculateLongestSession((localMessages?.messages || []).map((m) => ({
+      sessionId: m.sessionId,
+      timestampMs: m.timestamp,
+    }))),
     currentStreak,
     longestStreak,
     activeDays: dailyEntries.length,
     totalDays: graph.summary.totalDays,
-    peakHour: calculatePeakHour(localMessages?.messages || []),
+    peakHour: calculatePeakHour((localMessages?.messages || []).map((m) => ({
+      timestampMs: m.timestamp,
+    }))),
   };
 
   const dailyModelMap = new Map<string, Map<string, number>>();
@@ -402,6 +409,8 @@ async function loadData(
 
   const dailyBreakdowns = new Map<string, DailyModelBreakdown>();
   for (const contrib of graph.contributions) {
+    const dateStr = contrib.date;
+    
     const models = contrib.sources.map((source: { modelId: string; source: string; tokens: { input: number; output: number; cacheRead: number; cacheWrite: number; reasoning?: number }; cost: number; messages: number }) => ({
       modelId: source.modelId,
       source: source.source,
@@ -416,12 +425,20 @@ async function loadData(
       messages: source.messages,
     }));
     
-    dailyBreakdowns.set(contrib.date, {
-      date: contrib.date,
-      cost: contrib.totals.cost,
-      totalTokens: contrib.totals.tokens,
-      models: models.sort((a, b) => b.cost - a.cost),
-    });
+    const existing = dailyBreakdowns.get(dateStr);
+    if (existing) {
+      existing.cost += contrib.totals.cost;
+      existing.totalTokens += contrib.totals.tokens;
+      existing.models.push(...models);
+      existing.models.sort((a, b) => b.cost - a.cost);
+    } else {
+      dailyBreakdowns.set(dateStr, {
+        date: dateStr,
+        cost: contrib.totals.cost,
+        totalTokens: contrib.totals.tokens,
+        models: models.sort((a, b) => b.cost - a.cost),
+      });
+    }
   }
 
   return {

package/src/tui/types/index.ts

@@ -137,6 +137,8 @@ export interface TUIOptions {
   since?: string;
   until?: string;
   year?: string;
+  sinceTs?: number;
+  untilTs?: number;
   colorPalette?: ColorPaletteName;
 }