Fix Codex manual reset refresh (#2710)

Author: endless7

Sources/CodexBar/Providers/Codex/CodexWeeklyResetConfirmation.swift

@@ -143,7 +143,12 @@ struct CodexWeeklyResetConfirmation: Sendable {
                previousWeekly,
                capturedAt: previous.updatedAt)
         {
-            if confirmation.updatedAt < previousBoundary.addingTimeInterval(-2 * 60) {
+            let confirmsManualReset = Self.confirmsManualResetCreditRedemption(
+                previous: previous,
+                confirmation: confirmation)
+            if confirmation.updatedAt < previousBoundary.addingTimeInterval(-2 * 60),
+               !confirmsManualReset
+            {
                 return .preservePrevious
             }
             guard initialBoundary.timeIntervalSince(previousBoundary) >= Self.resetEquivalenceToleranceSeconds,
@@ -155,6 +160,27 @@ struct CodexWeeklyResetConfirmation: Sendable {
         return .publishConfirmation
     }
 
+    private static func confirmsManualResetCreditRedemption(
+        previous: UsageSnapshot,
+        confirmation: UsageSnapshot) -> Bool
+    {
+        guard let previousCredits = previous.codexResetCredits,
+              let confirmationCredits = confirmation.codexResetCredits,
+              self.isFinite(previousCredits.updatedAt),
+              self.isFinite(confirmationCredits.updatedAt),
+              confirmationCredits.updatedAt >= previousCredits.updatedAt
+        else {
+            return false
+        }
+        let previouslyAvailableIDs = Set(previousCredits.credits.lazy
+            .filter { $0.status == .available }
+            .map(\.id))
+        guard !previouslyAvailableIDs.isEmpty else { return false }
+        return confirmationCredits.credits.contains { credit in
+            previouslyAvailableIDs.contains(credit.id) && credit.status == .redeemed
+        }
+    }
+
     private static func initialDecisionWithoutWeeklyBaseline(
         initialWeekly: RateWindow,
         capturedAt: Date) -> InitialDecision

Tests/CodexBarTests/CodexWeeklyResetConfirmationTests.swift

@@ -270,6 +270,47 @@ struct CodexWeeklyResetConfirmationTests {
                 == .preservePrevious)
     }
 
+    @Test
+    func `redeemed reset credit confirms an early manual weekly reset`() throws {
+        let formatter = ISO8601DateFormatter()
+        let previousCapturedAt = try #require(formatter.date(from: "2026-07-28T03:09:20Z"))
+        let previousReset = try #require(formatter.date(from: "2026-08-02T10:17:56Z"))
+        let initialCapturedAt = try #require(formatter.date(from: "2026-07-28T03:59:23Z"))
+        let initialReset = try #require(formatter.date(from: "2026-08-04T03:59:21Z"))
+        let previous = self.snapshot(
+            capturedAt: previousCapturedAt,
+            weeklyUsed: 100,
+            weeklyReset: previousReset,
+            resetCredits: self.resetCredits(
+                status: .available,
+                capturedAt: previousCapturedAt))
+        let initial = self.snapshot(
+            capturedAt: initialCapturedAt,
+            weeklyUsed: 0,
+            weeklyReset: initialReset,
+            resetCredits: self.resetCredits(
+                status: .redeeming,
+                capturedAt: initialCapturedAt))
+        let confirmationCapturedAt = initialCapturedAt.addingTimeInterval(30)
+        let confirmation = self.snapshot(
+            capturedAt: confirmationCapturedAt,
+            weeklyUsed: 0,
+            weeklyReset: initialReset.addingTimeInterval(30),
+            resetCredits: self.resetCredits(
+                status: .redeemed,
+                capturedAt: confirmationCapturedAt))
+
+        #expect(
+            CodexWeeklyResetConfirmation.initialDecision(previous: previous, initial: initial)
+                == .requiresConfirmation)
+        #expect(
+            CodexWeeklyResetConfirmation.confirmationDecision(
+                previous: previous,
+                initial: initial,
+                confirmation: confirmation)
+                == .publishConfirmation)
+    }
+
     @Test
     func `prior boundary due tolerance includes the exact two minute edge`() {
         let previousBoundary = self.resetAt
@@ -442,20 +483,23 @@ struct CodexWeeklyResetConfirmationTests {
         offset: TimeInterval,
         weeklyUsed: Double?,
         weeklyReset: Date?,
-        weeklyInPrimary: Bool = false) -> UsageSnapshot
+        weeklyInPrimary: Bool = false,
+        resetCredits: CodexRateLimitResetCreditsSnapshot? = nil) -> UsageSnapshot
     {
         self.snapshot(
             capturedAt: self.capturedAt.addingTimeInterval(offset),
             weeklyUsed: weeklyUsed,
             weeklyReset: weeklyReset,
-            weeklyInPrimary: weeklyInPrimary)
+            weeklyInPrimary: weeklyInPrimary,
+            resetCredits: resetCredits)
     }
 
     private func snapshot(
         capturedAt: Date,
         weeklyUsed: Double?,
         weeklyReset: Date?,
-        weeklyInPrimary: Bool = false) -> UsageSnapshot
+        weeklyInPrimary: Bool = false,
+        resetCredits: CodexRateLimitResetCreditsSnapshot? = nil) -> UsageSnapshot
     {
         let weekly = weeklyUsed.map {
             RateWindow(
@@ -472,6 +516,26 @@ struct CodexWeeklyResetConfirmationTests {
         return UsageSnapshot(
             primary: weeklyInPrimary ? weekly : session,
             secondary: weeklyInPrimary ? session : weekly,
+            codexResetCredits: resetCredits,
+            updatedAt: capturedAt)
+    }
+
+    private func resetCredits(
+        status: CodexRateLimitResetCreditStatus,
+        capturedAt: Date) -> CodexRateLimitResetCreditsSnapshot
+    {
+        CodexRateLimitResetCreditsSnapshot(
+            credits: [CodexRateLimitResetCredit(
+                id: "manual-reset-credit",
+                resetType: "codex_rate_limits",
+                status: status,
+                grantedAt: capturedAt.addingTimeInterval(-24 * 60 * 60),
+                expiresAt: capturedAt.addingTimeInterval(24 * 60 * 60),
+                redeemStartedAt: status == .available ? nil : capturedAt,
+                redeemedAt: status == .redeemed ? capturedAt : nil,
+                title: nil,
+                description: nil)],
+            availableCount: status == .available ? 1 : 0,
             updatedAt: capturedAt)
     }
 }