relay-codex 0.7.0 → 0.7.2

package/README.md

@@ -69,7 +69,8 @@ Use a session's menu to switch accounts after its work finishes. Account menus c
 enable or disable future routing without stopping current tasks. Actions show
 their result, and stopped workers offer a restart.
 Account menus also show earned usage resets when available. Choose **Use available
-reset…** and confirm to spend one; Relay refreshes allowance afterward. Recovery
+reset…** and confirm to spend one; Relay refreshes allowance afterward. The button
+is enabled only with weekly allowance at 0% and its reset more than 48 hours away. Recovery
 never spends these resets automatically.
 
 For tab completion in Zsh, run `source <(relay completion zsh)` after `compinit`.

package/docs/commands.md

@@ -51,13 +51,17 @@ A session cap of zero means unlimited. Removing an account retains its login
 unless you request `--revoke`.
 
 The account menu shows **Usage resets available** and **Use available reset…**
-when Codex reports an earned reset. Choose it and confirm to use one. If the count
+when Codex reports an earned reset. It is enabled only when weekly allowance is
+fully exhausted (0%) and the weekly reset is **more than 48 hours away**. Exactly
+48 hours, any weekly allowance left, or unknown weekly data keeps it disabled.
+The reason appears below the button. Choose it and confirm to use one. If the count
 is unknown, choose **Check allowance now** first. Reset availability is separate
 from purchased workspace credits. Resets are never spent by automatic recovery.
 
 The equivalent terminal command is `relay account reset ACCOUNT --yes`. If a
 response is lost, use the same action again: Relay saves and reuses the pending
-request rather than submitting a new redemption. The menu calls this **Check
+request rather than submitting a new redemption. Pending retries must satisfy
+the same weekly rule; their saved request is retained when locked. The menu calls this **Check
 previous reset…**. An optional `--request-id UUID` also identifies a specific
 logical attempt. Codex chooses the available reset; Relay checks the returned
 result and reads allowance again afterward.
@@ -136,7 +140,9 @@ Each session menu can switch to another enabled account after work and approvals
 finish. The worker checks allowance and session capacity before switching, then
 checks again that the session is idle before changing its login. Rejected actions
 show their reason. Pending menu actions cannot be submitted twice, and results
-remain visible until dismissed or another action starts. Stopped workers offer
+disappear 30 seconds after first being viewed in the menu. Unseen results wait
+until the menu is opened; action progress remains until the action finishes.
+Starting another action replaces its previous result. Stopped workers offer
 Restart; restarting retains any review hold.
 
 Account menus can disable or enable future routing. Disabling an account does not

package/docs/publishing.md

@@ -8,8 +8,8 @@ Friends can run `npx relay-codex` or install it with `npm install -g relay-codex
 The GitHub repository is enough for friends to install or try Relay:
 
 ```sh
-npm install -g github:blackspider-ops/relay#v0.7.0
-npx --yes github:blackspider-ops/relay#v0.7.0 --version
+npm install -g github:blackspider-ops/relay#v0.7.2
+npx --yes github:blackspider-ops/relay#v0.7.2 --version
 ```
 
 `npx` runs packages; it is not a separate publishing service. Publishing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-codex",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Keep your Codex sessions moving between your own accounts.",
   "license": "MIT",
   "author": "blackspider-ops",

package/python/Menu.swift

@@ -6,12 +6,18 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
     var buffer = Data()
     var current: [String: Any] = [:]
     var message: String?
-    var actionNotice: String?
+    var actionNotice: String? {
+        didSet { noticeVersion += 1; noticeExpiry?.cancel(); noticeExpiry = nil }
+    }
+    var noticeVersion = 0
+    var noticeExpiry: DispatchWorkItem?
     var actionFailed = false
     var actionRunning = false
     var reconnect: DispatchWorkItem?
     var stopping = false
     var snapshotInFlight = false
+    var resetExpiry: DispatchWorkItem?
+    var menuOpen = false
     let command = Bundle.main.object(forInfoDictionaryKey: "RelayCommand") as? String ?? "/usr/bin/false"
     let state = Bundle.main.object(forInfoDictionaryKey: "RelayState") as? String ?? ""
 
@@ -140,6 +146,15 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         guard let seconds = value as? Double, seconds.isFinite, seconds > 0 else { return nil }
         return seconds
     }
+    static func resetBlockReason(_ account: [String: Any], now: Double = Date().timeIntervalSince1970) -> String? {
+        guard let weekly = account["secondary"] as? [String: Any], let used = (weekly["usedPercent"] as? NSNumber)?.doubleValue, used.isFinite else {
+            return "Reset locked: check allowance to confirm the weekly limit and reset time."
+        }
+        guard used >= 100 else { return "Reset locked: weekly allowance must be fully exhausted (0%)." }
+        guard let at = timestamp(weekly["resetsAt"]) else { return "Reset locked: check allowance to confirm the weekly limit and reset time." }
+        guard at - now > 48 * 60 * 60 else { return "Reset locked: the weekly reset must be more than 48 hours away." }
+        return nil
+    }
     static func accountTimingRows(_ account: [String: Any]) -> [TimingRow] {
         var rows: [TimingRow] = []
         if let primary = account["primary"] as? [String: Any], let at = timestamp(primary["resetsAt"]) {
@@ -182,6 +197,8 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         updateTimes(menu)
         if let visible = item.menu { MenuController.synchronise(visible, with: menu) }
         else { item.menu = menu }
+        if menuOpen { scheduleResetExpiry() }
+        scheduleNoticeExpiry()
     }
     func makeMenu() -> NSMenu {
         let sessions = current["sessions"] as? [[String: Any]] ?? []
@@ -193,7 +210,6 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         if let message = message { text(message, into: menu) }
         if let notice = actionNotice {
             text(notice, into: menu)
-            if !actionRunning { action("Dismiss message", args: ["dismiss"], into: menu) }
         }
         if accounts.isEmpty { text("Add an account with relay setup in Terminal.", into: menu) }
         if liveSessions.isEmpty && !accounts.isEmpty { text("No Relay sessions running. Start with relay run.", into: menu) }
@@ -233,8 +249,10 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
                 if let count = resetCount { text("Usage resets available: \(count)", into: submenu) }
                 else { text("Usage resets: check allowance to see availability.", into: submenu) }
                 if pendingReset || (resetCount ?? 0) > 0 {
+                    let blocked = MenuController.resetBlockReason(account)
                     let reset = action(pendingReset ? "Check previous reset…" : "Use available reset…", args: ["confirm-reset", id, name, pendingReset ? "pending" : "new"], into: submenu)
-                    reset.isEnabled = !actionRunning && !(account["maintenance"] as? Bool ?? false)
+                    reset.isEnabled = !actionRunning && !(account["maintenance"] as? Bool ?? false) && blocked == nil
+                    if let blocked = blocked { text(blocked, into: submenu) }
                 }
                 submenu.addItem(.separator())
                 let enabled = account["enabled"] as? Bool ?? true
@@ -298,16 +316,55 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         return menu
     }
     func menuWillOpen(_ menu: NSMenu) {
+        menuOpen = true
+        render()
         refreshSnapshot()
         updateTimes(menu)
         for entry in menu.items where entry.title == "Open at login" {
             entry.state = FileManager.default.fileExists(atPath: NSHomeDirectory() + "/Library/LaunchAgents/local.relay.menu.plist") ? .on : .off
         }
     }
+    func scheduleResetExpiry() {
+        resetExpiry?.cancel()
+        let now = Date().timeIntervalSince1970
+        let accounts = current["accounts"] as? [[String: Any]] ?? []
+        let boundaries = accounts.compactMap { account -> Double? in
+            guard MenuController.resetBlockReason(account, now: now) == nil, let weekly = account["secondary"] as? [String: Any], let at = MenuController.timestamp(weekly["resetsAt"]) else { return nil }
+            return at - 48 * 60 * 60
+        }
+        if let boundary = boundaries.min() {
+            let expiry = DispatchWorkItem { [weak self] in self?.render() }
+            resetExpiry = expiry
+            DispatchQueue.main.asyncAfter(deadline: .now() + max(0, boundary - now), execute: expiry)
+        }
+    }
+    func menuDidClose(_ menu: NSMenu) { menuOpen = false; resetExpiry?.cancel(); resetExpiry = nil }
+    func scheduleNoticeExpiry() {
+        guard menuOpen, !actionRunning, actionNotice != nil, noticeExpiry == nil else { return }
+        let version = noticeVersion
+        let expiry = DispatchWorkItem { [weak self] in
+            guard let self = self, self.expireNotice(version: version) else { return }
+            self.render()
+        }
+        noticeExpiry = expiry
+        DispatchQueue.main.asyncAfter(deadline: .now() + 30, execute: expiry)
+    }
+    func expireNotice(version: Int) -> Bool {
+        guard !stopping, !actionRunning, actionNotice != nil, noticeVersion == version else { return false }
+        actionNotice = nil; actionFailed = false
+        return true
+    }
+    func resetAllowed(_ id: String) -> Bool {
+        let accounts = current["accounts"] as? [[String: Any]] ?? []
+        guard let account = accounts.first(where: { $0["id"] as? String == id }) else {
+            actionNotice = "Reset locked: account details are unavailable."; actionFailed = true; render(); return false
+        }
+        if let reason = MenuController.resetBlockReason(account) { actionNotice = reason; actionFailed = true; render(); return false }
+        return true
+    }
     @objc func runAction(_ sender: NSMenuItem) {
         guard var args = sender.representedObject as? [String], !args.isEmpty else { return }
         if args[0] == "copy" { NSPasteboard.general.clearContents(); NSPasteboard.general.setString(args[1], forType: .string); return }
-        if args[0] == "dismiss" { actionNotice = nil; actionFailed = false; render(); return }
         guard !actionRunning else { return }
         if args[0] == "confirm-retry" {
             let alert = NSAlert(); alert.messageText = "Continue this task?"; alert.informativeText = "Review any interrupted command or external action in the conversation before continuing."
@@ -317,12 +374,14 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
             args = ["retry", args[1], "--wait"]
         }
         if args[0] == "confirm-reset" {
+            guard resetAllowed(args[1]) else { return }
             let pending = args[3] == "pending"
             let alert = NSAlert(); alert.messageText = pending ? "Check the previous reset?" : "Use one usage reset?"
             alert.informativeText = args[2] + "\n\n" + (pending ? "Relay will check the same pending request. If it already used a reset, another one will not be spent." : "This spends one earned reset on eligible usage limits for this account. Allowance will be checked afterward. Paused tasks and review holds stay paused.")
             alert.addButton(withTitle: pending ? "Check reset" : "Use reset"); alert.addButton(withTitle: "Cancel")
             NSApp.activate(ignoringOtherApps: true)
             guard alert.runModal() == .alertFirstButtonReturn else { return }
+            guard resetAllowed(args[1]) else { return }
             args = ["account", "reset", args[1], "--yes", "--request-id", UUID().uuidString]
         }
         actionRunning = true; actionFailed = false; actionNotice = "Applying change…"; render()
@@ -363,7 +422,7 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         runAction(sender)
     }
     @objc func quitMenu() { stopping = true; reconnect?.cancel(); stream?.terminate(); NSApp.terminate(nil) }
-    func applicationWillTerminate(_ notification: Notification) { stopping = true; stream?.terminate() }
+    func applicationWillTerminate(_ notification: Notification) { stopping = true; noticeExpiry?.cancel(); resetExpiry?.cancel(); stream?.terminate() }
 }
 if CommandLine.arguments.contains("--self-check") {
     let normal = NSImage(systemSymbolName: "arrow.triangle.branch", accessibilityDescription: "Relay")
@@ -413,11 +472,18 @@ if CommandLine.arguments.contains("--self-check") {
     let correctEmpty = empty.items.contains { $0.title.contains("No Relay sessions running") } && empty.items.first { $0.identifier?.rawValue == "account:one" }?.state == .off
     controller.current["sessions"] = originalSessions
     let originalAccounts = controller.current["accounts"]
-    controller.current["accounts"] = [["id": "one", "name": "One", "reset_credits": 2], ["id": "two", "name": "Two", "reset_credits": 0], ["id": "unknown", "name": "Unknown"], ["id": "pending", "name": "Pending", "reset_pending": true]]
+    controller.current["accounts"] = [["id": "one", "name": "One", "reset_credits": 2, "secondary": ["usedPercent": 100, "resetsAt": Date().timeIntervalSince1970 + 72 * 3600]], ["id": "two", "name": "Two", "reset_credits": 0], ["id": "unknown", "name": "Unknown"], ["id": "pending", "name": "Pending", "reset_pending": true]]
     let resets = controller.makeMenu()
     let correctResets = findAction(["confirm-reset", "one", "One", "new"], in: resets)?.isEnabled == true && findAction(["confirm-reset", "two", "Two", "new"], in: resets) == nil && findAction(["confirm-reset", "unknown", "Unknown", "new"], in: resets) == nil && findAction(["confirm-reset", "pending", "Pending", "pending"], in: resets) != nil
     controller.actionRunning = true
     let resetLocked = findAction(["confirm-reset", "one", "One", "new"], in: controller.makeMenu())?.isEnabled == false
+    let policyNow = 2000000000.0
+    let far: [String: Any] = ["secondary": ["usedPercent": 100, "resetsAt": policyNow + 172801]]
+    let exact: [String: Any] = ["secondary": ["usedPercent": 100, "resetsAt": policyNow + 172800]]
+    let near: [String: Any] = ["secondary": ["usedPercent": 100, "resetsAt": policyNow + 172799]]
+    let left: [String: Any] = ["secondary": ["usedPercent": 99.99, "resetsAt": policyNow + 259200]]
+    let correctPolicy = MenuController.resetBlockReason(far, now: policyNow) == nil && MenuController.resetBlockReason(exact, now: policyNow) != nil && MenuController.resetBlockReason(near, now: policyNow) != nil && MenuController.resetBlockReason(left, now: policyNow) != nil && MenuController.resetBlockReason([:], now: policyNow) != nil
+    let pendingLocked = findAction(["confirm-reset", "pending", "Pending", "pending"], in: resets)?.isEnabled == false
     controller.current["accounts"] = originalAccounts
     controller.actionRunning = true; controller.actionNotice = "Applying change…"
     let pending = controller.makeMenu()
@@ -425,11 +491,26 @@ if CommandLine.arguments.contains("--self-check") {
     controller.actionRunning = false; controller.actionNotice = "Task is busy."
     controller.current["at"] = 2000000001.0
     let retainedResult = controller.makeMenu().items.contains { $0.title == "Task is busy." }
+    let noDismissButton = findAction(["dismiss"], in: controller.makeMenu()) == nil
+    controller.menuOpen = false; controller.actionFailed = true; controller.actionNotice = "Unseen result"
+    controller.scheduleNoticeExpiry()
+    let unseenRetained = controller.noticeExpiry == nil && controller.actionNotice == "Unseen result"
+    controller.menuOpen = true; controller.scheduleNoticeExpiry()
+    let startsOnView = controller.noticeExpiry != nil
+    let previousNotice = controller.noticeVersion
+    controller.actionNotice = "Newer result"
+    let newerProtected = !controller.expireNotice(version: previousNotice) && controller.actionNotice == "Newer result"
+    controller.actionRunning = true; controller.scheduleNoticeExpiry()
+    let progressRetained = controller.noticeExpiry == nil && !controller.expireNotice(version: controller.noticeVersion)
+    controller.actionRunning = false
+    let expiresAfterView = controller.expireNotice(version: controller.noticeVersion) && controller.actionNotice == nil && !controller.actionFailed
     print("Account choices and stopped controls correct: \(correctChoices && stoppedControls)")
     print("Pending action protected and result retained: \(correctPending && retainedResult)")
     print("In-use accounts and current choice marked: \(correctMarker && correctMultiple && correctEmpty)")
     print("Available and pending reset actions protected: \(correctResets && resetLocked)")
-    exit(normal != nil && attention != nil && liveUpdate && safeIdentity && correctTiming && correctChoices && stoppedControls && correctPending && retainedResult && correctMarker && correctMultiple && correctEmpty && correctResets && resetLocked ? 0 : 1)
+    print("Weekly zero and more-than-48-hour guard enforced: \(correctPolicy && pendingLocked)")
+    print("Viewed notices expire without hiding unseen or newer results: \(noDismissButton && unseenRetained && startsOnView && newerProtected && progressRetained && expiresAfterView)")
+    exit(normal != nil && attention != nil && liveUpdate && safeIdentity && correctTiming && correctChoices && stoppedControls && correctPending && retainedResult && correctMarker && correctMultiple && correctEmpty && correctResets && resetLocked && correctPolicy && pendingLocked && noDismissButton && unseenRetained && startsOnView && newerProtected && progressRetained && expiresAfterView ? 0 : 1)
 } else {
     let app = NSApplication.shared
     let delegate = MenuController(); app.delegate = delegate; app.run()

package/python/commands.py

@@ -114,6 +114,7 @@ def snapshot(state, include_inactive=False):
                     "usage_checked_at": pool.checked_at(label),
                     "reset_credits": resets.available(usage),
                     "reset_pending": resets.pending(state / "accounts" / label),
+                    "reset_lock_reason": resets.weekly_block_reason(usage),
                     "maintenance": options.get("maintenance", False),
                     "next_check": min(
                         (b["next_check"] for b in blocks if b["account"] == label),

package/python/resets.py

@@ -2,6 +2,7 @@
 
 import hashlib
 import json
+import math
 import time
 import uuid
 
@@ -9,6 +10,29 @@ from pool import Pool, blocked, reset_time
 from settings import atomic_json
 
 OUTCOMES = {"reset", "alreadyRedeemed", "nothingToReset", "noCredit"}
+WEEKLY_RESET_BUFFER = 48 * 60 * 60
+
+
+def weekly_block_reason(snapshot, now=None):
+    window = ((snapshot or {}).get("rateLimits") or {}).get("secondary")
+    if not isinstance(window, dict):
+        return (
+            "Reset locked: check allowance to confirm the weekly limit and reset time."
+        )
+    used, at = window.get("usedPercent"), window.get("resetsAt")
+    if type(used) not in (int, float) or not math.isfinite(used):
+        return (
+            "Reset locked: check allowance to confirm the weekly limit and reset time."
+        )
+    if used < 100:
+        return "Reset locked: weekly allowance must be fully exhausted (0%)."
+    if type(at) not in (int, float) or not math.isfinite(at):
+        return (
+            "Reset locked: check allowance to confirm the weekly limit and reset time."
+        )
+    if at - (time.time() if now is None else now) <= WEEKLY_RESET_BUFFER:
+        return "Reset locked: the weekly reset must be more than 48 hours away."
+    return None
 
 
 def available(snapshot):
@@ -122,13 +146,16 @@ async def consume(state, label, binary, request_id=None):
                 )
             if known and outcome == "reset":
                 outcome = "alreadyRedeemed"
-            if not retry and not known:
+            if not known:
                 current = await rpc.call("account/rateLimits/read")
                 update_allowance(pool, label, current)
+                reason = weekly_block_reason(current)
+                if reason:
+                    raise RouterError(reason)
                 count = available(current)
-                if count == 0:
+                if count == 0 and not retry:
                     return {"outcome": "noCredit", "refreshed": True}
-                if count is None:
+                if count is None and not retry:
                     raise RouterError(
                         "Codex did not report reset availability. Check allowance again before using a reset."
                     )

package/python/router.py

@@ -24,7 +24,7 @@ from pool import Pool, blocked, reset_time, failure_kind, file_lock
 from launch import translate, RESUME_FIELDS
 import settings
 
-VERSION = "0.7.0"
+VERSION = "0.7.2"
 _support = Path.home() / "Library/Application Support"
 _legacy = _support / "Codex Accounts"
 _default_state = _legacy if (_legacy / "accounts").exists() else _support / "Relay"

package/tests/fake_native.py

@@ -127,10 +127,21 @@ for raw in sys.stdin:
             result = {"type": params["type"]}
         elif method == "account/rateLimits/read":
             reset_count = change(lambda d: d.get("reset_credit_count", 1))
+            weekly = change(
+                lambda d: (
+                    {
+                        "usedPercent": d["reset_weekly_used"],
+                        "resetsAt": d["reset_weekly_at"],
+                    }
+                    if "reset_weekly_used" in d
+                    else None
+                )
+            )
             result = {
                 "ordinaryUsageAllowed": True,
                 "rateLimits": {
-                    "primary": {"usedPercent": 20, "resetsAt": int(time.time()) + 3600}
+                    "primary": {"usedPercent": 20, "resetsAt": int(time.time()) + 3600},
+                    "secondary": weekly,
                 },
                 "rateLimitResetCredits": {
                     "availableCount": reset_count,
@@ -149,6 +160,8 @@ for raw in sys.stdin:
                     return {"outcome": "noCredit"}
                 keys.append(key)
                 data["reset_credit_count"] = count - 1
+                if "reset_weekly_used" in data:
+                    data["reset_weekly_used"] = 0
                 return {"outcome": "reset"}
 
             result = change(redeem)

package/tests/test_resets.py

@@ -27,6 +27,8 @@ class ResetService:
         self.residual_limit = False
         self.outcome = None
         self.reject = False
+        self.weekly_used = 100
+        self.weekly_at = time.time() + 72 * 3600
 
     async def call(self, method, params=None):
         await asyncio.sleep(0)
@@ -39,7 +41,11 @@ class ResetService:
                     "primary": {
                         "usedPercent": 100 if self.blocked else 0,
                         "resetsAt": time.time() + 3600,
-                    }
+                    },
+                    "secondary": {
+                        "usedPercent": self.weekly_used,
+                        "resetsAt": self.weekly_at,
+                    },
                 },
                 "rateLimitResetCredits": {
                     "availableCount": self.count,
@@ -194,11 +200,67 @@ class ResetTests(unittest.IsolatedAsyncioTestCase):
             with self.assertRaisesRegex(RouterError, "--yes"):
                 await commands.manage(args, self.root, "fake")
 
+    async def test_weekly_guard_blocks_all_mutation_until_zero_and_more_than_48_hours(
+        self,
+    ):
+        for used, hours in ((0, 72), (99.99, 72), (100, 48), (100, 47), (100, -1)):
+            with self.subTest(used=used, hours=hours):
+                self.service.weekly_used = used
+                self.service.weekly_at = time.time() + hours * 3600
+                with self.assertRaisesRegex(RouterError, "Reset locked"):
+                    await resets.consume(self.root, "one", "fake")
+                self.assertFalse(self.service.calls)
+                self.assertFalse((self.home / "reset-attempt.json").exists())
+        self.service.weekly_used = 100
+        self.service.weekly_at = time.time() + 72 * 3600
+        result = await resets.consume(self.root, "one", "fake")
+        self.assertEqual(result["outcome"], "reset")
+
+    async def test_pending_retry_cannot_bypass_a_changed_weekly_guard(self):
+        self.service.lose_reply = True
+        with self.assertRaises(RouterError):
+            await resets.consume(self.root, "one", "fake")
+        self.service.weekly_used = 0
+        with self.assertRaisesRegex(RouterError, "fully exhausted"):
+            await resets.consume(self.root, "one", "fake")
+        self.assertEqual(len(self.service.calls), 1)
+        self.assertTrue(resets.pending(self.home))
+        self.assertEqual(self.service.count, 1)
+
+    def test_weekly_guard_exact_boundary_unknown_values_and_unrounded_allowance(self):
+        now = 2000000000
+
+        def usage(used, at):
+            return {"rateLimits": {"secondary": {"usedPercent": used, "resetsAt": at}}}
+
+        self.assertIsNone(resets.weekly_block_reason(usage(100, now + 172801), now))
+        for used, at in (
+            (100, now + 172800),
+            (100, now + 172799),
+            (99.999, now + 200000),
+            (100, None),
+            (None, now + 200000),
+            (float("nan"), now + 200000),
+            (100, float("inf")),
+        ):
+            self.assertIsNotNone(resets.weekly_block_reason(usage(used, at), now))
+        self.assertIsNotNone(resets.weekly_block_reason({}, now))
+
     async def test_real_jsonl_helper_redeems_and_refreshes_synthetic_account(self):
         from test_services import fake_executable
 
         self.patch.stop()
         binary = fake_executable(self.root)
+        atomic_json(
+            self.home / "fake-history.json",
+            {
+                "threads": {},
+                "calls": [],
+                "reset_credit_count": 1,
+                "reset_weekly_used": 100,
+                "reset_weekly_at": time.time() + 72 * 3600,
+            },
+        )
         result = await resets.consume(self.root, "one", binary)
         self.assertEqual(result, {"outcome": "reset", "refreshed": True})
         history = json.loads((self.home / "fake-history.json").read_text())