Support fresh weekly reset activation flow

Add detection and activation flow for fresh weekly resets. Introduces shouldActivateFreshWeeklyReset(account:usage:now:) to determine eligibility (checks feature toggle, auth state, future weeklyResetAt, not already attempted, and >=99.5% remaining). Use it to show a "Fresh weekly reset detected. Activation pending." indicator, to trigger immediate runWeeklyAutoKickAttempt (with pause/retry handling), and to adjust scheduling logic. Adds unit tests to assert the pending indicator behavior and updates test helpers (makeAccount signature and a new makeUsage helper).

Author: sameerbajaj

CodexAccounts/ViewModels/AccountsViewModel.swift

@@ -980,6 +980,14 @@ final class AccountsViewModel {
             }
 
             if let weeklyResetAt = usage.weeklyResetAt {
+                if shouldActivateFreshWeeklyReset(account: current, usage: usage, now: now) {
+                    return WeeklyAutoKickIndicator(
+                        symbol: "bolt.circle.fill",
+                        color: .cyan,
+                        help: "Fresh weekly reset detected. Activation pending."
+                    )
+                }
+
                 let secondsUntilReset = weeklyResetAt.timeIntervalSince(now)
                 if secondsUntilReset <= weeklyAutoKickSoonThreshold {
                     return WeeklyAutoKickIndicator(
@@ -1072,6 +1080,17 @@ final class AccountsViewModel {
             return
         }
 
+        if shouldActivateFreshWeeklyReset(account: account, usage: usage, now: now) {
+            let cycleID = usage.weeklyCycleIdentifier
+            if shouldPauseWeeklyAutoKick(account: account, cycleID: cycleID, now: now) {
+                scheduleRetryWeeklyAutoKickCheck(for: accountID, account: account, now: now)
+                return
+            }
+
+            await runWeeklyAutoKickAttempt(for: account, cycleID: cycleID, now: now)
+            return
+        }
+
         if !usage.weeklyResetIsOverdue(now: now, grace: weeklyAutoKickDelay) {
             scheduleNextWeeklyAutoKickCheck(for: accountID, usage: usage, now: now)
             return
@@ -1124,6 +1143,28 @@ final class AccountsViewModel {
         return false
     }
 
+    private func shouldActivateFreshWeeklyReset(
+        account: CodexAccount,
+        usage: AccountUsage,
+        now: Date
+    ) -> Bool {
+        guard isWeeklyAutoKickEnabled(for: account) else { return false }
+        guard account.authState != .needsReauth, account.authState != .degraded else { return false }
+        guard let weeklyResetAt = usage.weeklyResetAt,
+              let cycleID = usage.weeklyCycleIdentifier
+        else {
+            return false
+        }
+        guard weeklyResetAt > now else { return false }
+        guard account.lastWeeklyAutoKickCycleID != cycleID else { return false }
+
+        if let weeklyRemaining = usage.weeklyRemainingPercent {
+            return weeklyRemaining >= 99.5
+        }
+
+        return usage.isWeeklyPrimary && usage.remainingPercent >= 99.5
+    }
+
     private func runWeeklyAutoKickAttempt(for account: CodexAccount, cycleID: String?, now: Date) async {
         guard let attemptAccount = markWeeklyAutoKickAttempt(for: account.id, cycleID: cycleID, now: now) else { return }
 
@@ -1267,7 +1308,9 @@ final class AccountsViewModel {
         let secondsUntilReset = weeklyResetAt.timeIntervalSince(now)
         let nextCheckAt: Date
 
-        if secondsUntilReset <= -weeklyAutoKickDelay {
+        if shouldActivateFreshWeeklyReset(account: account, usage: usage, now: now) {
+            nextCheckAt = now
+        } else if secondsUntilReset <= -weeklyAutoKickDelay {
             nextCheckAt = now.addingTimeInterval(weeklyAutoKickInterval)
         } else if secondsUntilReset <= 0 {
             nextCheckAt = weeklyResetAt.addingTimeInterval(weeklyAutoKickDelay)

CodexAccountsTests/CodexAccountsTests.swift

@@ -134,6 +134,42 @@ struct CodexAccountsTests {
         #expect(!viewModel.isWeeklyAutoKickEnabled(for: forcedOff))
     }
 
+    @Test func freshWeeklyResetShowsActivationPendingForEligibleAccount() async throws {
+        let viewModel = AccountsViewModel()
+        let account = makeAccount(weeklyAutoKickOverride: .forceOn)
+        let usage = makeUsage(
+            weeklyUsedPercent: 0,
+            weeklyResetAt: Date().addingTimeInterval(7 * 24 * 60 * 60 - 30 * 60)
+        )
+
+        viewModel.accounts = [account]
+        viewModel.usageData[account.id] = usage
+
+        let indicator = viewModel.weeklyAutoKickIndicator(for: account, usage: usage)
+
+        #expect(indicator?.help == "Fresh weekly reset detected. Activation pending.")
+    }
+
+    @Test func freshWeeklyResetDoesNotShowPendingAfterCycleAttemptRecorded() async throws {
+        let resetAt = Date().addingTimeInterval(7 * 24 * 60 * 60 - 30 * 60)
+        let usage = makeUsage(
+            weeklyUsedPercent: 0,
+            weeklyResetAt: resetAt
+        )
+        let account = makeAccount(
+            weeklyAutoKickOverride: .forceOn,
+            lastWeeklyAutoKickCycleID: String(Int(resetAt.timeIntervalSince1970))
+        )
+        let viewModel = AccountsViewModel()
+
+        viewModel.accounts = [account]
+        viewModel.usageData[account.id] = usage
+
+        let indicator = viewModel.weeklyAutoKickIndicator(for: account, usage: usage)
+
+        #expect(indicator?.help != "Fresh weekly reset detected. Activation pending.")
+    }
+
     @Test func pinnedAccountsRespectManualPinnedOrderBeforeSortedAccounts() async throws {
         let viewModel = AccountsViewModel()
         let firstPinned = makeAccount(
@@ -189,7 +225,8 @@ struct CodexAccountsTests {
         authState: AuthState = .healthy,
         isPinned: Bool = false,
         pinnedOrder: Int? = nil,
-        weeklyAutoKickOverride: WeeklyAutoKickOverride = .inherit
+        weeklyAutoKickOverride: WeeklyAutoKickOverride = .inherit,
+        lastWeeklyAutoKickCycleID: String? = nil
     ) -> CodexAccount {
         CodexAccount(
             email: email,
@@ -205,7 +242,28 @@ struct CodexAccountsTests {
             addedAt: Date(timeIntervalSince1970: 0),
             isPinned: isPinned,
             pinnedOrder: pinnedOrder,
-            weeklyAutoKickOverride: weeklyAutoKickOverride
+            weeklyAutoKickOverride: weeklyAutoKickOverride,
+            lastWeeklyAutoKickCycleID: lastWeeklyAutoKickCycleID
+        )
+    }
+
+    private func makeUsage(
+        weeklyUsedPercent: Double,
+        weeklyResetAt: Date
+    ) -> AccountUsage {
+        AccountUsage(
+            usedPercent: weeklyUsedPercent,
+            resetAt: weeklyResetAt,
+            primaryWindowSeconds: 7 * 24 * 60 * 60,
+            weeklyUsedPercent: weeklyUsedPercent,
+            weeklyResetAt: weeklyResetAt,
+            weeklyWindowSeconds: 7 * 24 * 60 * 60,
+            creditsBalance: nil,
+            hasCredits: false,
+            isUnlimited: false,
+            lastUpdated: Date(),
+            error: nil,
+            lastActivityAt: nil
         )
     }