fix(sessions): split resumed session usage by day

Author: itvincent-git

src-tauri/src/db.rs

@@ -1,4 +1,6 @@
-use crate::types::{DailyUsageRow, ModelUsage, ProjectUsage, SessionDetailRow};
+use crate::types::{
+    DailyUsageRow, ModelUsage, ProjectUsage, SessionDailyUsageRow, SessionDetailRow,
+};
 use rusqlite::{params, Connection};
 use std::{collections::BTreeMap, path::Path};
 
@@ -447,6 +449,7 @@ pub fn query_session_details(db: &Connection) -> Result<Vec<SessionDetailRow>, S
             let mut cost_usd = 0.0;
             let mut models = std::collections::BTreeSet::new();
             let mut projects = std::collections::BTreeSet::new();
+            let mut daily_usage = Vec::with_capacity(daily_rows.len());
 
             for r in daily_rows {
                 input_tokens += r.input_tokens;
@@ -461,6 +464,17 @@ pub fn query_session_details(db: &Connection) -> Result<Vec<SessionDetailRow>, S
                 for project in r.projects.keys() {
                     projects.insert(project.clone());
                 }
+                daily_usage.push(SessionDailyUsageRow {
+                    date: r.date,
+                    input_tokens: r.input_tokens,
+                    cached_input_tokens: r.cached_input_tokens,
+                    output_tokens: r.output_tokens,
+                    reasoning_output_tokens: r.reasoning_output_tokens,
+                    total_tokens: r.total_tokens,
+                    cost_usd: r.cost_usd,
+                    models: r.models.into_keys().collect(),
+                    projects: r.projects.into_keys().collect(),
+                });
             }
 
             let session_id = Path::new(&path)
@@ -483,6 +497,7 @@ pub fn query_session_details(db: &Connection) -> Result<Vec<SessionDetailRow>, S
                 cost_usd,
                 models: models.into_iter().collect(),
                 projects: projects.into_iter().collect(),
+                daily_usage,
             })
         })
         .map_err(|error| error.to_string())?;
@@ -595,6 +610,66 @@ mod tests {
         let _ = std::fs::remove_file(path);
     }
 
+    #[test]
+    fn session_details_preserve_daily_usage_for_resumed_sessions() {
+        let path = std::env::temp_dir().join(format!(
+            "codex-usage-db-session-daily-{}.sqlite",
+            Utc::now().timestamp_nanos_opt().unwrap_or_default()
+        ));
+        let mut db = open_database(&path).unwrap();
+        let model_usage = ModelUsage {
+            input_tokens: 100,
+            output_tokens: 40,
+            total_tokens: 140,
+            ..Default::default()
+        };
+        let project_usage = ProjectUsage {
+            input_tokens: 100,
+            output_tokens: 40,
+            total_tokens: 140,
+            models: BTreeMap::from([("gpt-5".to_string(), model_usage.clone())]),
+            ..Default::default()
+        };
+        let daily_row = |date: &str, multiplier: i64| DailyUsageRow {
+            date: date.to_string(),
+            input_tokens: 100 * multiplier,
+            cached_input_tokens: 20 * multiplier,
+            output_tokens: 40 * multiplier,
+            reasoning_output_tokens: 10 * multiplier,
+            total_tokens: 150 * multiplier,
+            cost_usd: 0.01 * multiplier as f64,
+            models: BTreeMap::from([("gpt-5".to_string(), model_usage.clone())]),
+            projects: BTreeMap::from([("/repo/app".to_string(), project_usage.clone())]),
+            updated_at: "2026-07-02T00:00:00.000Z".to_string(),
+        };
+        upsert_session_file_rollups(
+            &mut db,
+            &[SessionFileRollup {
+                path: "/tmp/resumed.jsonl".to_string(),
+                modified_at_ms: 2,
+                size_bytes: 200,
+                rows: vec![daily_row("2026-07-01", 1), daily_row("2026-07-02", 2)],
+                prompt_title: None,
+            }],
+            "2026-07-02T00:00:00.000Z",
+        )
+        .unwrap();
+
+        let sessions = query_session_details(&db).unwrap();
+
+        assert_eq!(sessions.len(), 1);
+        assert_eq!(sessions[0].total_tokens, 450);
+        assert!((sessions[0].cost_usd - 0.03).abs() < f64::EPSILON);
+        assert_eq!(sessions[0].daily_usage.len(), 2);
+        assert_eq!(sessions[0].daily_usage[0].date, "2026-07-01");
+        assert_eq!(sessions[0].daily_usage[0].total_tokens, 150);
+        assert_eq!(sessions[0].daily_usage[1].date, "2026-07-02");
+        assert_eq!(sessions[0].daily_usage[1].total_tokens, 300);
+        assert_eq!(sessions[0].daily_usage[1].models, ["gpt-5"]);
+        assert_eq!(sessions[0].daily_usage[1].projects, ["/repo/app"]);
+        let _ = std::fs::remove_file(path);
+    }
+
     #[test]
     fn reset_usage_state_clears_cached_tables() {
         let path = std::env::temp_dir().join(format!(

src-tauri/src/types.rs

@@ -237,6 +237,21 @@ pub struct UpdateDownloadProgress {
     pub finished: bool,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SessionDailyUsageRow {
+    pub date: String,
+    pub input_tokens: i64,
+    pub cached_input_tokens: i64,
+    pub output_tokens: i64,
+    pub reasoning_output_tokens: i64,
+    pub total_tokens: i64,
+    #[serde(rename = "costUSD")]
+    pub cost_usd: f64,
+    pub models: Vec<String>,
+    pub projects: Vec<String>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SessionDetailRow {
@@ -254,6 +269,7 @@ pub struct SessionDetailRow {
     pub cost_usd: f64,
     pub models: Vec<String>,
     pub projects: Vec<String>,
+    pub daily_usage: Vec<SessionDailyUsageRow>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]

src/App.test.tsx

@@ -864,6 +864,19 @@ describe("App", () => {
             costUSD: 0.001,
             models: ["gpt-5"],
             projects: ["/repo/app"],
+            dailyUsage: [
+              {
+                date: "2026-06-11",
+                inputTokens: 100,
+                cachedInputTokens: 20,
+                outputTokens: 40,
+                reasoningOutputTokens: 0,
+                totalTokens: 140,
+                costUSD: 0.001,
+                models: ["gpt-5"],
+                projects: ["/repo/app"],
+              },
+            ],
           },
         ];
       }

src/components/session-titles.test.tsx

@@ -1,6 +1,6 @@
 // @vitest-environment jsdom
 
-import { render, screen, waitFor } from "@testing-library/react";
+import { render, screen, waitFor, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { describe, expect, it, vi } from "vitest";
 import { ProjectSessionsModal } from "./project-sessions-modal";
@@ -29,10 +29,115 @@ function session(overrides: Partial<SessionDetailRow>): SessionDetailRow {
     costUSD: 0.001,
     models: ["gpt-5"],
     projects: ["/repo/app"],
+    dailyUsage: [
+      {
+        date: "2026-07-15",
+        inputTokens: 100,
+        cachedInputTokens: 20,
+        outputTokens: 40,
+        reasoningOutputTokens: 0,
+        totalTokens: 140,
+        costUSD: 0.001,
+        models: ["gpt-5"],
+        projects: ["/repo/app"],
+      },
+    ],
     ...overrides,
   };
 }
 
+describe("session daily usage", () => {
+  it("splits resumed usage by rollup date and opens the complete session", async () => {
+    const onSessionClick = vi.fn();
+    const resumed = session({
+      inputTokens: 300,
+      cachedInputTokens: 60,
+      outputTokens: 120,
+      totalTokens: 420,
+      costUSD: 0.003,
+      models: ["gpt-5", "gpt-5-mini"],
+      projects: ["/repo/first", "/repo/second"],
+      dailyUsage: [
+        {
+          date: "2026-07-01",
+          inputTokens: 100,
+          cachedInputTokens: 20,
+          outputTokens: 40,
+          reasoningOutputTokens: 0,
+          totalTokens: 140,
+          costUSD: 0.001,
+          models: ["gpt-5"],
+          projects: ["/repo/first"],
+        },
+        {
+          date: "2026-07-02",
+          inputTokens: 200,
+          cachedInputTokens: 40,
+          outputTokens: 80,
+          reasoningOutputTokens: 0,
+          totalTokens: 280,
+          costUSD: 0.002,
+          models: ["gpt-5-mini"],
+          projects: ["/repo/second"],
+        },
+      ],
+    });
+
+    const { rerender } = render(
+      <SessionUsageTable sessions={[resumed]} onSessionClick={onSessionClick} />,
+    );
+
+    const firstDay = document.getElementById("date-group-2026-07-01");
+    const secondDay = document.getElementById("date-group-2026-07-02");
+    expect(firstDay).not.toBeNull();
+    expect(secondDay).not.toBeNull();
+    expect(firstDay).toHaveTextContent("140");
+    expect(firstDay).toHaveTextContent("gpt-5");
+    expect(firstDay).not.toHaveTextContent("420");
+    expect(secondDay).toHaveTextContent("280");
+    expect(secondDay).toHaveTextContent("gpt-5-mini");
+    expect(secondDay).not.toHaveTextContent("420");
+
+    const sessionRow = within(secondDay!).getByText("fallback-session").closest("tr");
+    expect(sessionRow).not.toBeNull();
+    await userEvent.click(sessionRow!);
+    expect(onSessionClick).toHaveBeenCalledWith(resumed);
+
+    rerender(
+      <SessionUsageTable
+        sessions={[resumed]}
+        selectedProject="/repo/first"
+        onSessionClick={onSessionClick}
+      />,
+    );
+    expect(document.getElementById("date-group-2026-07-01")).not.toBeNull();
+    expect(document.getElementById("date-group-2026-07-02")).toBeNull();
+  });
+
+  it("keeps sessions without usage on their modified date", () => {
+    render(<SessionUsageTable sessions={[session({
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      dailyUsage: [{
+        date: "2026-07-01",
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0,
+        reasoningOutputTokens: 0,
+        totalTokens: 0,
+        costUSD: 0,
+        models: [],
+        projects: [],
+      }],
+    })]} />);
+
+    expect(document.getElementById("date-group-2026-07-15")).not.toBeNull();
+    expect(document.getElementById("date-group-2026-07-01")).toBeNull();
+    expect(screen.getAllByText("No activity").length).toBeGreaterThan(0);
+  });
+});
+
 describe("session titles", () => {
   it("shows the summary name with the session ID and falls back to the ID", () => {
     render(

src/components/session-usage-table.tsx

@@ -7,6 +7,11 @@ import { Button } from "@/components/ui/button";
 import dayjs from "dayjs";
 import { useTranslation } from "react-i18next";
 
+type SessionDisplayRow = SessionDetailRow & {
+  usageDate: string;
+  originalSession: SessionDetailRow;
+};
+
 type SessionUsageTableProps = {
   sessions: SessionDetailRow[];
   initialExpandedDate?: string | null;
@@ -63,16 +68,31 @@ export function SessionUsageTable({
     }
   }, [initialExpandedDate]);
 
-  // Group and sort sessions
+  const displaySessions = useMemo<SessionDisplayRow[]>(() => sessions.flatMap((session) => {
+    if (session.totalTokens === 0 || session.dailyUsage.length === 0) {
+      return [{
+        ...session,
+        usageDate: dayjs(session.modifiedAtMs).format("YYYY-MM-DD"),
+        originalSession: session,
+      }];
+    }
+
+    return session.dailyUsage.map((usage) => ({
+      ...session,
+      ...usage,
+      usageDate: usage.date,
+      originalSession: session,
+    }));
+  }), [sessions]);
+
+  // Group and sort session-day rows using the scanner's application-timezone dates.
   const groups = useMemo(() => {
-    const map: Record<string, SessionDetailRow[]> = {};
-    for (const session of sessions) {
-      // If a project filter is active, skip sessions that don't belong to the project
-      if (selectedProject && (!session.projects || !session.projects.includes(selectedProject))) {
+    const map: Record<string, SessionDisplayRow[]> = {};
+    for (const session of displaySessions) {
+      if (selectedProject && !session.projects.includes(selectedProject)) {
         continue;
       }
-      // Extract date part (local time based on timestamp) using dayjs with YYYY-MM-DD format
-      const dateStr = dayjs(session.modifiedAtMs).format("YYYY-MM-DD");
+      const dateStr = session.usageDate;
       if (!map[dateStr]) {
         map[dateStr] = [];
       }
@@ -105,12 +125,12 @@ export function SessionUsageTable({
           projects,
         };
       });
-  }, [sessions, selectedProject]);
+  }, [displaySessions, selectedProject]);
 
   const filteredCount = useMemo(() => {
-    if (!selectedProject) return sessions.length;
-    return sessions.filter((s) => s.projects && s.projects.includes(selectedProject)).length;
-  }, [sessions, selectedProject]);
+    if (!selectedProject) return displaySessions.length;
+    return displaySessions.filter((session) => session.projects.includes(selectedProject)).length;
+  }, [displaySessions, selectedProject]);
 
   const maxGroupTokens = useMemo(() => Math.max(...groups.map(g => g.totalTokens), 1), [groups]);
   const maxGroupCost = useMemo(() => Math.max(...groups.map(g => g.costUSD), 0), [groups]);
@@ -157,7 +177,7 @@ export function SessionUsageTable({
           <h2 className="text-xl font-bold tracking-tight text-foreground flex items-center gap-2.5">
             {t("sessions.title")}
             <span className="inline-flex items-center rounded-full bg-indigo-500/10 px-2.5 py-0.5 text-xs font-semibold text-indigo-400 border border-indigo-500/20">
-              {selectedProject ? t("sessions.showing_info_filtered", { filtered: filteredCount, total: sessions.length }) : t("sessions.showing_info", { count: sessions.length })}
+              {selectedProject ? t("sessions.showing_info_filtered", { filtered: filteredCount, total: displaySessions.length }) : t("sessions.showing_info", { count: displaySessions.length })}
             </span>
           </h2>
           <p className="text-sm text-muted-foreground">
@@ -331,12 +351,12 @@ export function SessionUsageTable({
                               key={session.path}
                               tabIndex={onSessionClick ? 0 : undefined}
                               role={onSessionClick ? "button" : undefined}
-                              onClick={() => onSessionClick?.(session)}
+                              onClick={() => onSessionClick?.(session.originalSession)}
                               onKeyDown={(event) => {
                                 if (!onSessionClick) return;
                                 if (event.key === "Enter" || event.key === " ") {
                                   event.preventDefault();
-                                  onSessionClick(session);
+                                  onSessionClick(session.originalSession);
                                 }
                               }}
                               className="align-top hover:bg-white/[0.01] transition-colors duration-150 cursor-pointer focus-visible:outline focus-visible:outline-2 focus-visible:outline-primary/70"