fix: preserve Codex spend window under byte pressure

Co-authored-by: Whiteknight07 <fiestyboxer@gmail.com>

Author: steipete

CHANGELOG.md

@@ -2,10 +2,13 @@
 
 ## 0.49.2 — Unreleased
 
+### Fixed
+- Codex: preserve requested Spend Dashboard history when the local cost cache exceeds its byte budget, rather than deleting in-window sessions or repeatedly rebuilding protected data (#2823). Thanks @WillStark for the report and @Whiteknight07 for the initial fix!
+- Codex: avoid repeatedly converting historical token snapshots during cost-cache refreshes, preventing sustained CPU usage on large session histories.
+
 ## 0.49.1 — 2026-08-09
 
 ### Fixed
-- Codex: avoid repeatedly converting historical token snapshots during cost-cache refreshes, preventing sustained CPU usage on large session histories.
 - DeepInfra: show billing-cycle spend against a positive spending limit in the automatic menu-bar icon (#2822). Thanks @selfagency for the report!
 - z.ai: restore pace for verified 5-hour, weekly, and MCP-monthly usage windows without treating rolling 30-day limits as calendar months (#2431). Thanks @kiranmagic7!
 - Codex: publish refreshed core quota immediately while optional Credits and OpenAI Web enrichment continues, without unfreezing cards whose layout still needs reconciliation (#2799). Thanks @Yuxin-Qiao!

Sources/CodexBarCore/Vendored/CostUsage/CostUsageStore+Retention.swift

@@ -283,10 +283,9 @@ extension CostUsageStore {
             }
 
             var catchUpRequired = false
-            // The row budget mirrors the former entry budget: it only ever removes files the
-            // requested window does not read. In-window and recently active files are never
-            // dropped just for a row overage; the byte budget below is the sole authority
-            // that may sacrifice in-window data.
+            // The row and byte budgets only remove files outside the requested window. Once
+            // only protected data remains, preserving report fidelity takes precedence over
+            // forcing the database under its best-effort byte cap.
             while try Self.rowCount(database) > Int64(rowLimit) {
                 guard try Self.deleteOldestRetainedFile(
                     database,
@@ -305,15 +304,8 @@ extension CostUsageStore {
                     sinceDay: sinceDay,
                     untilDay: untilDay,
                     calendar: calendar,
-                    protectRequestedWindow: false)
-                else {
-                    guard try Self.stripOldestRebuildableDetail(database) else { break }
-                    catchUpRequired = true
-                    try Self.markCatchUpRequired(database)
-                    try Self.reclaimFreePages(database)
-                    fileBytes = Self.fileSize(at: self.databaseURL)
-                    continue
-                }
+                    protectRequestedWindow: true)
+                else { break }
                 catchUpRequired = true
                 try Self.reclaimFreePages(database)
                 fileBytes = Self.fileSize(at: self.databaseURL)
@@ -393,43 +385,6 @@ extension CostUsageStore {
         try self.scalarInt(database, "SELECT COUNT(*) FROM files")
     }
 
-    private static func stripOldestRebuildableDetail(_ database: OpaquePointer) throws -> Bool {
-        let statement = try self.prepare(database, """
-        SELECT f.id, f.scan_state
-        FROM files f
-        WHERE NOT EXISTS (SELECT 1 FROM buffered_lines b WHERE b.file_id = f.id)
-          AND ((SELECT COUNT(*) FROM token_snapshots t WHERE t.file_id = f.id) > 0
-            OR (SELECT COUNT(*) FROM usage_rows r WHERE r.file_id = f.id) > 0)
-        ORDER BY f.updated_at_ms, f.id
-        LIMIT 1
-        """)
-        defer { sqlite3_finalize(statement) }
-        guard sqlite3_step(statement) == SQLITE_ROW,
-              let stateData = self.columnData(statement, at: 1),
-              var state = try? JSONDecoder().decode(CostUsageStoreScanState.self, from: stateData)
-        else { return false }
-        let fileID = sqlite3_column_int64(statement, 0)
-        state.isComplete = false
-        state.resumePayload = nil
-        state.tokenTimestampsMonotonic = nil
-        state.nextUsageRowIndex = nil
-        let updatedState = try JSONEncoder().encode(state)
-        let update = try self.prepare(database, """
-        UPDATE files
-        SET parsed_bytes = 0, anchor_indexed_bytes = NULL, anchor_window_start = NULL,
-            anchor_sha256 = NULL, scan_state = ?, scan_complete = 0
-        WHERE id = ?
-        """)
-        defer { sqlite3_finalize(update) }
-        self.bind(updatedState, to: update, at: 1)
-        sqlite3_bind_int64(update, 2, fileID)
-        try self.stepDone(update, database: database)
-        try self.execute(database, "DELETE FROM token_snapshots WHERE file_id = \(fileID)")
-        try self.execute(database, "DELETE FROM usage_rows WHERE file_id = \(fileID)")
-        try self.execute(database, "DELETE FROM accumulators WHERE file_id = \(fileID)")
-        return true
-    }
-
     private static func rebuildDayAggregates(_ database: OpaquePointer) throws {
         try self.execute(database, "DELETE FROM day_aggregates")
         try self.execute(database, """

Tests/CodexBarTests/CostUsageStoreTests.swift

@@ -983,7 +983,7 @@ extension CostUsageStoreTests {
 
 extension CostUsageStoreTests {
     @Test
-    func `save preserves an existing complete previous report across repeated trims`() async throws {
+    func `save preserves an existing previous report when protected data exceeds the byte cap`() async throws {
         let fixture = try StoreFixture()
         defer { fixture.remove() }
         let store = CostUsageStore(cacheRoot: fixture.root)
@@ -1030,7 +1030,7 @@ extension CostUsageStoreTests {
             reportWindow: (sinceKey: "2026-06-01", untilKey: "2026-07-01"),
             fileBudgetBytes: 1)
 
-        #expect(result.catchUpRequired)
+        #expect(result.catchUpRequired == false)
         let metadata = await store.fetchMetadata()
         let payload = try #require(metadata.previousReportPayload)
         let preserved = try JSONDecoder().decode(CostUsageCodexPreviousReport.self, from: payload)
@@ -1040,7 +1040,7 @@ extension CostUsageStoreTests {
     }
 
     @Test
-    func `save catch up report honors a non-gregorian system calendar`() async throws {
+    func `save over byte cap keeps non-gregorian in window report intact`() async throws {
         let fixture = try StoreFixture()
         defer { fixture.remove() }
         let store = CostUsageStore(cacheRoot: fixture.root)
@@ -1063,13 +1063,12 @@ extension CostUsageStoreTests {
             requestedScanWindow: (sinceKey: "2026-06-01", untilKey: "2026-07-01"),
             reportWindow: (sinceKey: "2026-06-01", untilKey: "2026-07-01"),
             fileBudgetBytes: 1)
+        let report = await store.readReport(sinceDay: "2026-06-01", untilDay: "2026-07-01")
 
-        #expect(result.catchUpRequired)
-        let metadata = await store.fetchMetadata()
-        let payload = try #require(metadata.previousReportPayload)
-        let previous = try JSONDecoder().decode(CostUsageCodexPreviousReport.self, from: payload)
-        #expect(previous.data.contains { $0.date == "2026-06-05" })
-        #expect(previous.data.contains { $0.date == "1483-06-05" } == false)
+        #expect(result.catchUpRequired == false)
+        #expect(await store.fetchMetadata().previousReportPayload == nil)
+        #expect(report.aggregates.map(\.day) == ["2026-06-05"])
+        #expect(report.aggregates.contains { $0.day == "1483-06-05" } == false)
     }
 }
 
@@ -1174,35 +1173,49 @@ extension CostUsageStoreTests {
     }
 
     @Test
-    func `in window byte budget trim marks catch up and preserves previous report`() async throws {
+    func `byte budget preserves in window data across repeated enforcement`() async throws {
         let fixture = try StoreFixture()
         defer { fixture.remove() }
         let store = CostUsageStore(cacheRoot: fixture.root)
-        let previous = Data("previous-report".utf8)
-        var metadata = CostUsageStoreMetadata.empty
-        metadata.lastScanUnixMs = 1234
-        metadata.previousReportPayload = previous
-        #expect(await store.setMetadata(metadata))
+        let day = "2026-08-01"
+        let model = "gpt-5.5"
         for (index, path) in ["/rollouts/one.jsonl", "/rollouts/two.jsonl"].enumerated() {
-            #expect(await store.upsertFile(Self.file(path: path, day: "2026-08-01", updatedAt: Int64(index))))
-            let row = CostUsageStoreUsageRow(
+            let file = Self.file(path: path, day: day, updatedAt: Int64(index))
+            #expect(await store.upsertFile(file))
+            #expect(await store.replaceUsageRows(path: path, rows: [CostUsageStoreUsageRow(
                 path: path,
                 rowIndex: 0,
-                payload: Data(repeating: UInt8(index), count: 256 * 1024))
-            #expect(await store.replaceUsageRows(path: path, rows: [row]))
+                payload: Data(repeating: UInt8(index), count: 256 * 1024))]))
+            #expect(await store.replaceFileDayAggregates(
+                path: path,
+                aggregates: [Self.aggregate(day: day, model: model, scale: 1)]))
         }
+        #expect(await store.mergeDayAggregates([Self.aggregate(day: day, model: model, scale: 2)]))
 
-        let result = await store.enforceBudgets(
+        let first = await store.enforceBudgets(
             maxRows: .max,
             maxFileBytes: 1,
-            requestedSinceDay: "2026-08-01",
-            requestedUntilDay: "2026-08-02")
-        let retained = await store.fetchMetadata()
-
-        #expect(result.catchUpRequired)
-        #expect(retained.catchUpPending)
-        #expect(retained.lastScanUnixMs == 0)
-        #expect(retained.previousReportPayload == previous)
+            requestedSinceDay: day,
+            requestedUntilDay: day)
+        let second = await store.enforceBudgets(
+            maxRows: .max,
+            maxFileBytes: 1,
+            requestedSinceDay: day,
+            requestedUntilDay: day)
+        let report = await store.readReport(sinceDay: day, untilDay: day)
+
+        #expect(first.catchUpRequired == false)
+        #expect(second.catchUpRequired == false)
+        #expect(first.deletedRows == 0)
+        #expect(second.deletedRows == 0)
+        #expect(first.rowCount == 2)
+        #expect(second.rowCount == 2)
+        #expect(first.fileBytes > 1)
+        #expect(second.fileBytes > 1)
+        #expect(await store.fetchUsageRows(path: "/rollouts/one.jsonl").count == 1)
+        #expect(await store.fetchUsageRows(path: "/rollouts/two.jsonl").count == 1)
+        #expect(report.aggregates == [Self.aggregate(day: day, model: model, scale: 2)])
+        #expect(await store.fetchMetadata().catchUpPending == false)
     }
 
     @Test
@@ -1230,39 +1243,37 @@ extension CostUsageStoreTests {
     }
 
     @Test
-    func `byte budget strips detail from a protected file instead of stalling`() async throws {
+    func `byte budget removes only data outside the requested window`() async throws {
         let fixture = try StoreFixture()
         defer { fixture.remove() }
         let store = CostUsageStore(cacheRoot: fixture.root)
-        var file = Self.file(path: "/rollouts/resuming.jsonl", day: "2026-08-01")
-        file.scanState.isComplete = false
-        #expect(await store.upsertFile(file))
-        #expect(await store.appendTokenSnapshots([Self.snapshot(path: file.path, eventIndex: 0)]))
-        #expect(await store.replaceUsageRows(path: file.path, rows: [CostUsageStoreUsageRow(
-            path: file.path,
-            rowIndex: 0,
-            payload: Data(repeating: 7, count: 256 * 1024))]))
-        #expect(await store.upsertAccumulator(Self.accumulator(path: file.path)))
+        let stale = Self.file(path: "/rollouts/stale.jsonl", day: "2026-06-01", updatedAt: 0)
+        let current = Self.file(path: "/rollouts/current.jsonl", day: "2026-08-01", updatedAt: 1)
+        for file in [stale, current] {
+            #expect(await store.upsertFile(file))
+            #expect(await store.replaceUsageRows(path: file.path, rows: [CostUsageStoreUsageRow(
+                path: file.path,
+                rowIndex: 0,
+                payload: Data(repeating: 7, count: 256 * 1024))]))
+        }
 
         let result = await store.enforceBudgets(
             maxRows: .max,
             maxFileBytes: 1,
             requestedSinceDay: "2026-08-01",
             requestedUntilDay: "2026-08-02")
 
-        let stripped = try #require(await store.fetchFile(path: file.path))
-        #expect(result.catchUpRequired)
-        #expect(stripped.parsedBytes == 0)
-        #expect(stripped.scanState.isComplete == false)
-        #expect(stripped.scanState.resumePayload == nil)
-        #expect(await store.fetchTokenSnapshots(path: file.path).isEmpty)
-        #expect(await store.fetchUsageRows(path: file.path).isEmpty)
-        #expect(await store.fetchAccumulator(path: file.path) == nil)
-        #expect(await store.fetchMetadata().catchUpPending)
+        #expect(result.deletedRows == 1)
+        #expect(result.rowCount == 1)
+        #expect(result.fileBytes > 1)
+        #expect(await store.fetchFile(path: stale.path) == nil)
+        #expect(await store.fetchFile(path: current.path) != nil)
+        #expect(await store.fetchUsageRows(path: current.path).count == 1)
+        #expect(await store.fetchMetadata().catchUpPending == false)
     }
 
     @Test
-    func `byte budget compacts a fork parent required by a surviving child`() async throws {
+    func `byte budget preserves fork parent detail required by a surviving child`() async throws {
         let fixture = try StoreFixture()
         defer { fixture.remove() }
         let store = CostUsageStore(cacheRoot: fixture.root)
@@ -1295,14 +1306,13 @@ extension CostUsageStoreTests {
             requestedSinceDay: "2026-08-01",
             requestedUntilDay: "2026-08-02")
 
-        // The parent cannot be deleted while the incomplete child still needs its baseline,
-        // so byte pressure compacts its rebuildable detail instead.
-        let compacted = try #require(await store.fetchFile(path: parent.path))
-        #expect(result.catchUpRequired)
-        #expect(compacted.parsedBytes == 0)
-        #expect(compacted.scanState.isComplete == false)
-        #expect(await store.fetchUsageRows(path: parent.path).isEmpty)
+        let retained = try #require(await store.fetchFile(path: parent.path))
+        #expect(result.catchUpRequired == false)
+        #expect(retained.parsedBytes == parent.parsedBytes)
+        #expect(retained.scanState.isComplete)
+        #expect(await store.fetchUsageRows(path: parent.path).count == 1)
         #expect(await store.fetchFile(path: child.path) != nil)
+        #expect(await store.fetchMetadata().catchUpPending == false)
     }
 
     @Test