Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

19.6 KB
Raw Blame
package provider

import (
	"context"
	"errors"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"sync/atomic"
	"testing"
	"time"
)

// fakeClaudeUsage has Claude Code's /usage print out (or fail with err),
// counting its runs, and fails the test on any request magpie makes to
// Anthropic itself.
func fakeClaudeUsage(t *testing.T, out *atomic.Value, fail *atomic.Bool) *atomic.Int32 {
	t.Helper()
	var runs atomic.Int32
	claudeCLIUsage.RLock()
	old := claudeCLIUsage.f
	claudeCLIUsage.RUnlock()
	oldAsked := claudeAsked.Load()
	UsageClaudeVia(func(context.Context, string) (string, error) {
		runs.Add(1)
		if fail != nil && fail.Load() {
			return "", errors.New("Claude Code: network is unreachable")
		}
		return out.Load().(string), nil
	})
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		t.Errorf("magpie asked Anthropic itself: %s", r.URL)
	}))
	oldBase, oldWait, oldUsed := claudeBase, claudeUsageWait, claudeUsedSince
	claudeBase = srv.URL
	claudeUsageWait = func() time.Duration { return usageTestWait }
	claudeUsedSince = func(time.Time) bool { return true }
	claudeAsked.Store(0)
	claudeUsage.Lock()
	claudeUsage.m = nil
	claudeUsage.Unlock()
	t.Cleanup(func() {
		UsageClaudeVia(old)
		claudeBase, claudeUsageWait, claudeUsedSince = oldBase, oldWait, oldUsed
		claudeAsked.Store(oldAsked)
		srv.Close()
		claudeUsage.Lock()
		claudeUsage.m = nil
		claudeUsage.Unlock()
		subscriptionUsageCache.Lock()
		subscriptionUsageCache.asked = false
		subscriptionUsageCache.Unlock()
	})
	return &runs
}

// Claude's usage is Claude Code's /usage, run only when the user asks,
// once an ask, and only for the account Claude Code is signed in to.
func TestClaudeWindowsAsked(t *testing.T) {
	var out atomic.Value
	out.Store("Current session: 40% used · resets " + sessionReset() + "\nCurrent week (all models): 10% used · resets " + soon(3) + " at 2pm (UTC)\n")
	var fail atomic.Bool
	runs := fakeClaudeUsage(t, &out, &fail)
	ctx := context.Background()

	// a saved account is never read, asked or not
	if _, err := claudeWindows(ctx, "saved@x", false); err != errClaudeSaved || runs.Load() != 0 {
		t.Fatalf("saved unasked: %v %d", err, runs.Load())
	}
	// a saved account is never read, asked or not
	AskClaudeUsage()
	if _, err := claudeWindows(ctx, "saved@x", false); err != errClaudeSaved || runs.Load() != 0 {
		t.Fatalf("saved: %v %d", err, runs.Load())
	}

	// asked: one run, then what it told
	ws, err := claudeWindows(ctx, "A@x", true)
	if err != nil || len(ws) != 2 || ws[0].Used != 40 || ws[1].Used != 10 || runs.Load() != 1 {
		t.Fatalf("asked: %v %+v %d", err, ws, runs.Load())
	}
	for range 3 {
		if ws, err = claudeWindows(ctx, "a@x", true); err != nil || len(ws) != 2 || runs.Load() != 1 {
			t.Fatalf("kept: %v %d", err, runs.Load())
		}
	}
	// asked again at once: still the one run
	AskClaudeUsage()
	if _, err = claudeWindows(ctx, "a@x", true); err != nil || runs.Load() != 1 {
		t.Fatalf("too soon: %v %d", err, runs.Load())
	}

	// its wait on, unasked: run again by itself, once
	age := func(d time.Duration) {
		claudeUsage.Lock()
		e := claudeUsage.m["a@x"]
		e.tried = e.tried.Add(-d)
		claudeUsage.m["a@x"] = e
		claudeUsage.Unlock()
	}
	claudeAsked.Store(0) // the ask above was answered by the run before it
	age(usageTestWait - time.Minute)
	if _, err = claudeWindows(ctx, "a@x", true); err != nil || runs.Load() != 1 {
		t.Fatalf("ran before its wait: %v %d", err, runs.Load())
	}
	age(time.Minute)
	out.Store("Current session: 55% used · resets " + sessionReset() + "\n")
	for range 3 {
		if ws, err = claudeWindows(ctx, "a@x", true); err != nil || len(ws) != 1 || ws[0].Used != 55 || runs.Load() != 2 {
			t.Fatalf("every: %v %+v %d", err, ws, runs.Load())
		}
	}

	// a failed run says why, and isn't run again until asked or its wait is up
	claudeUsage.Lock()
	claudeUsage.m["b@x"] = claudeUsageEntry{tried: time.Now().Add(-claudeUsageWaitMax)}
	claudeUsage.Unlock()
	fail.Store(true)
	if _, err = claudeWindows(ctx, "b@x", true); err == nil || runs.Load() != 3 {
		t.Fatalf("failed: %v %d", err, runs.Load())
	}
	if _, err = claudeWindows(ctx, "b@x", true); err == nil || err == errClaudeNotAsked || runs.Load() != 3 {
		t.Fatalf("after a failure: %v %d", err, runs.Load())
	}
}

func TestParseClaudeUsage(t *testing.T) {
	now := time.Date(2026, 10, 1, 4, 0, 0, 0, time.UTC)
	text := `You are currently using your subscription to power your Claude Code usage

Current session: 13% used · resets Oct 1 at 3:30pm (Asia/Shanghai)
Current week (all models): 4% used · resets Oct 3 at 2pm (Asia/Shanghai)
Current week (Opus): 12.5% used · resets Jan 2 at 2pm (Asia/Shanghai)
Current week (Fable): 0% used

What's contributing to your limits usage?
  96% of your usage came from sessions active for 8+ hours`
	ws, err := parseClaudeUsage(text, now)
	if err != nil {
		t.Fatal(err)
	}
	sh, _ := time.LoadLocation("Asia/Shanghai")
	want := []struct {
		name, model string
		used        float64
		span        time.Duration
		reset       time.Time
	}{
		{"5 hours", "", 13, 5 * time.Hour, time.Date(2026, 10, 1, 15, 30, 0, 0, sh)},
		{"7 days", "", 4, 7 * 24 * time.Hour, time.Date(2026, 10, 3, 14, 0, 0, 0, sh)},
		// a week can't end three months on: it ended last Jan 2, and reads
		// as renewed
		{"7 days · Opus", "opus", 12.5, 7 * 24 * time.Hour, time.Date(2026, 1, 2, 14, 0, 0, 0, sh)},
		{"7 days · Fable", "fable", 0, 7 * 24 * time.Hour, time.Time{}},
	}
	if len(ws) != len(want) {
		t.Fatalf("windows %+v", ws)
	}
	for i, w := range want {
		g := ws[i]
		if g.Name != w.name || g.Model != w.model || g.Used != w.used || g.Span != w.span ||
			(w.reset.IsZero() != (g.ResetsAt == nil)) || (g.ResetsAt != nil && !g.ResetsAt.Equal(w.reset)) {
			t.Errorf("%d: %+v, want %+v", i, g, w)
		}
	}
	// a time alone is the next one
	if r, ok := claudeResetTime("3am (UTC)", now, claudeWeek); !ok || !r.Equal(time.Date(2026, 10, 2, 3, 0, 0, 0, time.UTC)) {
		t.Fatalf("time alone: %v %v", r, ok)
	}
	// Claude Code 2.1.285 on puts a comma where "at" was (#631), read
	// within the week before Oct 9
	seen := time.Date(2026, 10, 3, 4, 0, 0, 0, time.UTC)
	for in, want := range map[string]time.Time{
		"Oct 9, 2:59pm (UTC)":        time.Date(2026, 10, 9, 14, 59, 0, 0, time.UTC),
		"Oct 2, 8pm (UTC)":           time.Date(2026, 10, 2, 20, 0, 0, 0, time.UTC),
		"Jan 2, 9:05am (UTC)":        time.Date(2026, 1, 2, 9, 5, 0, 0, time.UTC),
		"Jan 2, 2027, 9am (UTC)":     time.Date(2027, 1, 2, 9, 0, 0, 0, time.UTC),
		"Oct 3, 2pm (Asia/Shanghai)": time.Date(2026, 10, 3, 14, 0, 0, 0, sh),
	} {
		if r, ok := claudeResetTime(in, seen, claudeWeek); !ok || !r.Equal(want) {
			t.Errorf("%q: %v %v, want %v", in, r, ok, want)
		}
	}
	if _, err := parseClaudeUsage("Error: not logged in", now); err == nil {
		t.Fatal("nothing told, no error")
	}
}

// Where the clocks go back and read a reset's time twice, the reading not yet
// past is taken: west of UTC time.Date gives the first reading, east of it
// the second. A time alone is the next day's when the clocks skip it, as
// they skip 2:30am in New York and Berlin or 12:30am in Santiago. Claude
// Code 2.1.290 prints a date on every line of /usage, with "at" or a comma
// by platform; a time alone is the older form.
func TestClaudeResetTimeAroundClockChanges(t *testing.T) {
	zone := func(name string) *time.Location {
		l, err := time.LoadLocation(name)
		if err != nil {
			t.Fatal(err)
		}
		return l
	}
	ny, berlin, santiago := zone("America/New_York"), zone("Europe/Berlin"), zone("America/Santiago")
	fixed := func(name string, hours float64) *time.Location {
		return time.FixedZone(name, int(hours*3600))
	}
	edt, est, cest, cet := fixed("EDT", -4), fixed("EST", -5), fixed("CEST", 2), fixed("CET", 1)
	aedt, aest, lhdt, lhst := fixed("AEDT", 11), fixed("AEST", 10), fixed("+11", 11), fixed("+1030", 10.5)
	for _, c := range []struct {
		now  time.Time
		in   string
		want time.Time
	}{
		// New York reads 2026-11-01 01:00-01:59 twice, EDT then EST
		{time.Date(2026, 11, 1, 1, 20, 0, 0, est), "Nov 1, 1:30am (America/New_York)", time.Date(2026, 11, 1, 1, 30, 0, 0, est)},
		{time.Date(2026, 11, 1, 1, 20, 0, 0, est), "Nov 1 at 1:30am (America/New_York)", time.Date(2026, 11, 1, 1, 30, 0, 0, est)},
		{time.Date(2026, 11, 1, 1, 20, 0, 0, est), "1:30am (America/New_York)", time.Date(2026, 11, 1, 1, 30, 0, 0, est)},
		{time.Date(2026, 11, 1, 1, 0, 0, 0, est), "1am (America/New_York)", time.Date(2026, 11, 1, 1, 0, 0, 0, est)},
		{time.Date(2026, 11, 1, 1, 20, 0, 0, edt), "Nov 1, 1:30am (America/New_York)", time.Date(2026, 11, 1, 1, 30, 0, 0, edt)},
		{time.Date(2026, 11, 1, 1, 20, 0, 0, edt), "1:30am (America/New_York)", time.Date(2026, 11, 1, 1, 30, 0, 0, edt)},
		{time.Date(2026, 11, 1, 1, 50, 0, 0, est), "1:30am (America/New_York)", time.Date(2026, 11, 2, 1, 30, 0, 0, ny)},
		{time.Date(2026, 11, 3, 1, 20, 0, 0, ny), "Nov 3, 1:30am (America/New_York)", time.Date(2026, 11, 3, 1, 30, 0, 0, ny)},
		{time.Date(2026, 11, 3, 1, 20, 0, 0, ny), "1:30am (America/New_York)", time.Date(2026, 11, 3, 1, 30, 0, 0, ny)},
		// a date less than a day past keeps that day's reading
		{time.Date(2026, 11, 2, 1, 0, 0, 0, est), "Nov 1, 1:30am (America/New_York)", time.Date(2026, 11, 1, 1, 30, 0, 0, est)},
		// Berlin reads 2026-10-25 02:00-02:59 twice, CEST then CET
		{time.Date(2026, 10, 25, 2, 20, 0, 0, cest), "Oct 25, 2:30am (Europe/Berlin)", time.Date(2026, 10, 25, 2, 30, 0, 0, cest)},
		{time.Date(2026, 10, 25, 2, 20, 0, 0, cest), "2:30am (Europe/Berlin)", time.Date(2026, 10, 25, 2, 30, 0, 0, cest)},
		{time.Date(2026, 10, 24, 23, 0, 0, 0, cest), "2:30am (Europe/Berlin)", time.Date(2026, 10, 25, 2, 30, 0, 0, cest)},
		{time.Date(2026, 10, 25, 2, 20, 0, 0, cet), "Oct 25, 2:30am (Europe/Berlin)", time.Date(2026, 10, 25, 2, 30, 0, 0, cet)},
		{time.Date(2026, 10, 26, 2, 0, 0, 0, cet), "Oct 25, 2:15am (Europe/Berlin)", time.Date(2026, 10, 25, 2, 15, 0, 0, cet)},
		{time.Date(2026, 4, 5, 2, 20, 0, 0, aedt), "Apr 5, 2:30am (Australia/Sydney)", time.Date(2026, 4, 5, 2, 30, 0, 0, aedt)},
		{time.Date(2026, 4, 5, 2, 20, 0, 0, aest), "Apr 5, 2:30am (Australia/Sydney)", time.Date(2026, 4, 5, 2, 30, 0, 0, aest)},
		{time.Date(2026, 4, 5, 1, 40, 0, 0, lhdt), "Apr 5, 1:45am (Australia/Lord_Howe)", time.Date(2026, 4, 5, 1, 45, 0, 0, lhdt)},
		{time.Date(2026, 4, 5, 1, 40, 0, 0, lhst), "Apr 5, 1:45am (Australia/Lord_Howe)", time.Date(2026, 4, 5, 1, 45, 0, 0, lhst)},
		// the clocks skipped 2:00-2:59 this morning
		{time.Date(2026, 3, 8, 22, 0, 0, 0, ny), "2:30am (America/New_York)", time.Date(2026, 3, 9, 2, 30, 0, 0, ny)},
		{time.Date(2026, 3, 29, 23, 0, 0, 0, berlin), "2:30am (Europe/Berlin)", time.Date(2026, 3, 30, 2, 30, 0, 0, berlin)},
		// Santiago's clocks skip from 2026-09-06 00:00 to 01:00
		{time.Date(2026, 9, 5, 23, 31, 0, 0, santiago), "12:30am (America/Santiago)", time.Date(2026, 9, 7, 0, 30, 0, 0, santiago)},
		{time.Date(2026, 9, 5, 23, 31, 0, 0, santiago), "1:30am (America/Santiago)", time.Date(2026, 9, 6, 1, 30, 0, 0, santiago)},
	} {
		if r, ok := claudeResetTime(c.in, c.now, claudeWeek); !ok || !r.Equal(c.want) {
			t.Errorf("%q at %v: %v %v (in %v), want %v", c.in, c.now, r, ok, r.Sub(c.now), c.want)
		}
	}
}

// A date with no year is in the first year it is less than a day past and
// no more than its window ahead. Claude Code prints the year when it isn't
// this one, so a Dec 31 with none is read past New Year only when /usage ran
// just before midnight.
func TestClaudeResetTimeAtNewYear(t *testing.T) {
	ny, err := time.LoadLocation("America/New_York")
	if err != nil {
		t.Fatal(err)
	}
	for _, c := range []struct {
		now  time.Time
		in   string
		want time.Time
	}{
		{time.Date(2027, 1, 1, 0, 0, 5, 0, ny), "Dec 31, 11:59pm (America/New_York)", time.Date(2026, 12, 31, 23, 59, 0, 0, ny)},
		{time.Date(2027, 1, 1, 0, 0, 5, 0, ny), "Dec 31 at 11:59pm (America/New_York)", time.Date(2026, 12, 31, 23, 59, 0, 0, ny)},
		{time.Date(2027, 1, 1, 1, 0, 0, 0, ny), "Dec 31, 2026, 11pm (America/New_York)", time.Date(2026, 12, 31, 23, 0, 0, 0, ny)},
		// more than a day past is the reading read late, not next year's
		{time.Date(2027, 1, 1, 1, 0, 0, 0, ny), "Dec 30, 11pm (America/New_York)", time.Date(2026, 12, 30, 23, 0, 0, 0, ny)},
		{time.Date(2027, 7, 1, 1, 0, 0, 0, ny), "Jun 30, 11pm (America/New_York)", time.Date(2027, 6, 30, 23, 0, 0, 0, ny)},
		{time.Date(2026, 12, 31, 22, 0, 0, 0, ny), "Jan 1, 2027, 3pm (America/New_York)", time.Date(2027, 1, 1, 15, 0, 0, 0, ny)},
		{time.Date(2026, 12, 31, 22, 0, 0, 0, ny), "Jan 1, 3pm (America/New_York)", time.Date(2027, 1, 1, 15, 0, 0, 0, ny)},
		{time.Date(2026, 12, 31, 22, 0, 0, 0, ny), "Dec 31, 9pm (America/New_York)", time.Date(2026, 12, 31, 21, 0, 0, 0, ny)},
	} {
		if r, ok := claudeResetTime(c.in, c.now, claudeWeek); !ok || !r.Equal(c.want) {
			t.Errorf("%q at %v: %v %v (in %v), want %v", c.in, c.now, r, ok, r.Sub(c.now), c.want)
		}
	}
}

// A reset ends a window of known length, so it is never further ahead than
// that: a reading too far ahead for its window, as /usage's text read days
// late is, is the latest one past, and the window reads as renewed rather
// than full for a year.
func TestClaudeResetTimeWithinItsWindow(t *testing.T) {
	ny, err := time.LoadLocation("America/New_York")
	if err != nil {
		t.Fatal(err)
	}
	session := 5 * time.Hour
	oct5 := time.Date(2026, 10, 5, 12, 0, 0, 0, time.UTC)
	for _, c := range []struct {
		now  time.Time
		in   string
		span time.Duration
		want time.Time
	}{
		// four days late: last Oct 1, not next year's
		{oct5, "Oct 1, 3pm (UTC)", claudeWeek, time.Date(2026, 10, 1, 15, 0, 0, 0, time.UTC)},
		{oct5, "Oct 1 at 3pm (UTC)", claudeWeek, time.Date(2026, 10, 1, 15, 0, 0, 0, time.UTC)},
		{oct5, "Oct 1, 3pm (UTC)", session, time.Date(2026, 10, 1, 15, 0, 0, 0, time.UTC)},
		// six days on is a week's, not five hours'
		{oct5, "Oct 11, 3pm (UTC)", claudeWeek, time.Date(2026, 10, 11, 15, 0, 0, 0, time.UTC)},
		{oct5, "Oct 11, 3pm (UTC)", session, time.Date(2025, 10, 11, 15, 0, 0, 0, time.UTC)},
		// a window's own length on, and a little over, is still ahead;
		// further is not
		{oct5, "Oct 5, 5pm (UTC)", session, time.Date(2026, 10, 5, 17, 0, 0, 0, time.UTC)},
		{oct5, "Oct 5, 7pm (UTC)", session, time.Date(2026, 10, 5, 19, 0, 0, 0, time.UTC)},
		{oct5, "Oct 5, 7:01pm (UTC)", session, time.Date(2025, 10, 5, 19, 1, 0, 0, time.UTC)},
		{oct5, "Oct 5, 7:30pm (UTC)", session, time.Date(2025, 10, 5, 19, 30, 0, 0, time.UTC)},
		{oct5, "Oct 12, 12pm (UTC)", claudeWeek, time.Date(2026, 10, 12, 12, 0, 0, 0, time.UTC)},
		{oct5, "Oct 12, 2pm (UTC)", claudeWeek, time.Date(2026, 10, 12, 14, 0, 0, 0, time.UTC)},
		{oct5, "Oct 12, 3pm (UTC)", claudeWeek, time.Date(2025, 10, 12, 15, 0, 0, 0, time.UTC)},
		// a week across the night New York's clocks go back ends an hour
		// earlier on the clock
		{time.Date(2026, 10, 29, 14, 0, 0, 0, ny), "Nov 5, 1pm (America/New_York)", claudeWeek, time.Date(2026, 11, 5, 13, 0, 0, 0, ny)},
		// a time alone is the next one within the window, else today's past
		{oct5, "3pm (UTC)", session, time.Date(2026, 10, 5, 15, 0, 0, 0, time.UTC)},
		{oct5, "11am (UTC)", session, time.Date(2026, 10, 5, 11, 0, 0, 0, time.UTC)},
		{oct5, "11am (UTC)", claudeWeek, time.Date(2026, 10, 6, 11, 0, 0, 0, time.UTC)},
		{oct5, "7pm (UTC)", session, time.Date(2026, 10, 5, 19, 0, 0, 0, time.UTC)},
		{oct5, "7:01pm (UTC)", session, time.Date(2026, 10, 4, 19, 1, 0, 0, time.UTC)},
		// the year said is kept
		{oct5, "Oct 1, 2027, 3pm (UTC)", session, time.Date(2027, 10, 1, 15, 0, 0, 0, time.UTC)},
	} {
		if r, ok := claudeResetTime(c.in, c.now, c.span); !ok || !r.Equal(c.want) {
			t.Errorf("%q for %v at %v: %v %v (in %v), want %v", c.in, c.span, c.now, r, ok, r.Sub(c.now), c.want)
		}
	}

	// /usage giving a reset four days past: the full session and week read
	// as renewed, fresh and kept, and routing doesn't hold the account
	var out atomic.Value
	out.Store("Current session: 100% used · resets " + soon(-4) + ", 3pm (UTC)\nCurrent week (all models): 100% used · resets " + soon(-4) + ", 3pm (UTC)\n")
	fakeClaudeUsage(t, &out, nil)
	AskClaudeUsage()
	for _, read := range []bool{true, false} {
		ws, err := claudeWindows(context.Background(), "late@x", read)
		if err != nil || len(ws) != 2 {
			t.Fatalf("read %v: %v %+v", read, err, ws)
		}
		for _, w := range ws {
			if w.Used != 0 || w.ResetsAt != nil {
				t.Errorf("read %v: %s %+v", read, w.Name, w)
			}
		}
		if full := allowanceOf(ws, time.Now()).Full("claude-fable-5-1", SpentShare, time.Now()); !full.IsZero() {
			t.Errorf("read %v: held until %v", read, full)
		}
	}
}

// claudeWeek is the length of /usage's "Current week" windows.
const claudeWeek = 7 * 24 * time.Hour

// usageTestWait is the wait between unasked runs of /usage in tests.
const usageTestWait = 7 * time.Minute

// An unasked run of /usage waits a whole number of minutes from 5 to 15,
// drawn afresh each time, so it isn't run on a clock.
func TestClaudeWaitRandom(t *testing.T) {
	seen := map[time.Duration]bool{}
	for range 2000 {
		w := claudeUsageWait()
		if w < claudeUsageWaitMin || w > claudeUsageWaitMax || w%time.Minute != 0 {
			t.Fatalf("wait %v", w)
		}
		seen[w] = true
	}
	if len(seen) != 11 {
		t.Fatalf("waits drawn: %v", seen)
	}
}

// Unasked, /usage is run again only once Claude Code has been used since
// it last was; asked, it is run whether it was or not.
func TestClaudeUsageIdle(t *testing.T) {
	var out atomic.Value
	out.Store("Current session: 40% used · resets " + sessionReset() + "\n")
	runs := fakeClaudeUsage(t, &out, nil)
	var used atomic.Bool
	claudeUsedSince = func(time.Time) bool { return used.Load() }
	ctx := context.Background()

	AskClaudeUsage()
	if _, err := claudeWindows(ctx, "a@x", true); err != nil || runs.Load() != 1 {
		t.Fatalf("asked: %v %d", err, runs.Load())
	}
	claudeAsked.Store(0)
	claudeUsage.Lock()
	e := claudeUsage.m["a@x"]
	e.tried = e.tried.Add(-usageTestWait)
	claudeUsage.m["a@x"] = e
	claudeUsage.Unlock()

	// its wait is up, but nobody used Claude Code
	if ws, err := claudeWindows(ctx, "a@x", true); err != nil || len(ws) != 1 || runs.Load() != 1 {
		t.Fatalf("idle: %v %d", err, runs.Load())
	}
	// asked, it runs all the same
	AskClaudeUsage()
	if _, err := claudeWindows(ctx, "a@x", true); err != nil || runs.Load() != 2 {
		t.Fatalf("asked while idle: %v %d", err, runs.Load())
	}
	claudeAsked.Store(0)
	claudeUsage.Lock()
	e = claudeUsage.m["a@x"]
	e.tried = e.tried.Add(-usageTestWait)
	claudeUsage.m["a@x"] = e
	claudeUsage.Unlock()
	// used since: it runs by itself again
	used.Store(true)
	if _, err := claudeWindows(ctx, "a@x", true); err != nil || runs.Load() != 3 {
		t.Fatalf("used: %v %d", err, runs.Load())
	}
}

// Claude Code was used since a time when one of its sessions was written
// to since then; its other files don't count.
func TestClaudeUsedSince(t *testing.T) {
	claudeHome(t)
	project := filepath.Join(filepath.Dir(claudeCredentialsPath()), "projects", "-Users-x-proj")
	if err := os.MkdirAll(project, 0o700); err != nil {
		t.Fatal(err)
	}
	session := filepath.Join(project, "s.jsonl")
	os.WriteFile(session, []byte("{}\n"), 0o600)
	os.WriteFile(filepath.Join(project, "notes.txt"), nil, 0o600)
	now := time.Now()
	old := now.Add(-time.Hour)
	os.Chtimes(session, old, old)
	if claudeUsedSince(now.Add(-time.Minute)) {
		t.Fatal("used, with no session written to")
	}
	if !claudeUsedSince(now.Add(-2 * time.Hour)) {
		t.Fatal("not used, with a session written to")
	}
	os.Chtimes(session, now, now)
	if !claudeUsedSince(now.Add(-time.Minute)) {
		t.Fatal("not used, with a session just written to")
	}
}

// soon is the day n days from now as /usage writes it ("Oct 3"), so a
// window the tests read hasn't reset whatever day they run.
func soon(n int) string { return time.Now().UTC().AddDate(0, 0, n).Format("Jan 2") }

// sessionReset is a "Current session" reset as /usage prints it: within the
// five hours.
func sessionReset() string {
	return time.Now().UTC().Add(3*time.Hour).Format("Jan 2 at 3:04pm") + " (UTC)"
}