claude-multiacc 2.0.20 → 2.0.22

package/tests/run-tests.sh

@@ -317,7 +317,7 @@ check "passthrough with CLAUDE_CODE_OAUTH_TOKEN" "CFG=none" "$out"
 out="$(CLAUDE_MULTIACC_DISABLE=1 claude 2>&1)"
 check "passthrough when disabled" "CFG=none" "$out"
 
-# ---- 5. headroom selection: most WEEKLY headroom wins (session is only a tiebreaker) --
+# ---- 5. headroom selection: the session gate first, then the WEEKLY headroom band ----
 lj() { # lj <weekly> <session> <max>  -> a fresh limits.json body
   printf '{"fetched_at":%s,"weekly_percent":%s,"session_percent":%s,"max_percent":%s,"buckets":[]}' "$now" "$1" "$2" "$3"
 }
@@ -360,28 +360,131 @@ done
 [ "$all1" = 1 ] && t_ok "Claude headroom band 0 restores strict ranking" \
   || t_fail "Claude zero headroom band" "the runner-up was selected"
 
-# THE KEY CASE from the research: a high (but sub-threshold) SESSION bucket must NOT
-# deprioritize an account whose weekly headroom is better. acct-01: session 85, weekly 10;
-# acct-02: session 20, weekly 70. Both eligible (max<90). acct-01 is the better pick —
-# its near-full bucket is the 5h session (self-heals), weekly is nearly untouched.
+# THE KEY CASE, REVERSED on 2026-09-03. It used to assert that a high (but
+# sub-threshold) SESSION bucket must not deprioritize an account with better weekly
+# headroom. The operator asked for the opposite: "among accounts where high session
+# limits it must choose randomly from ones where highest weekly limits" — an account
+# whose 5h bucket is nearly spent is about to be rejected whatever its weekly headroom.
+# So the SESSION GATE (default 50) is the FIRST cut and the 30-point weekly band ranks
+# only what clears it. acct-01: session 85 (past the gate), weekly 10; acct-02: session
+# 20, weekly 70. Both eligible (max<90) — acct-02 wins every time now.
 lj 10 85 85 > "$ACC/acct-01/limits.json"
 lj 70 20 70 > "$ACC/acct-02/limits.json"
+all2=1
+for _ in $(seq 1 15); do
+  case "$(claude 2>&1)" in *CFG=acct-02*) ;; *) all2=0 ;; esac
+done
+[ "$all2" = "1" ] && t_ok "a session bucket past the gate is skipped while a fresher one exists (70w/20s over 10w/85s)" \
+  || t_fail "session gate" "the account with its 5h bucket at 85% was still selected"
+# The pick has to be auditable: the log names the gate and how many cleared it.
+: > "$ACC/selection.log"
+claude >/dev/null 2>&1
+grep -qE 'acct-02 weekly=70% session=20% band=30 band-count=1 session-gate=50 session-ok=1 pwd=' "$ACC/selection.log" \
+  && t_ok "the selection log carries session-gate=50 session-ok=1 when one of two clears" \
+  || t_fail "session gate log" "$(tail -1 "$ACC/selection.log")"
+
+# Both session buckets inside the gate: the gate has nothing to say and weekly decides,
+# exactly as before the change.
+lj 10 45 45 > "$ACC/acct-01/limits.json"
+lj 70 20 70 > "$ACC/acct-02/limits.json"
+all1=1
+for _ in $(seq 1 15); do
+  case "$(claude 2>&1)" in *CFG=acct-01*) ;; *) all1=0 ;; esac
+done
+[ "$all1" = "1" ] && t_ok "with both sessions inside the gate weekly headroom decides (10w/45s over 70w/20s)" \
+  || t_fail "session gate no-op" "the gate changed a ranking where every candidate cleared it"
+
+# Nobody clears the gate: it COMPARES candidates, it never empties the pool — it steps
+# aside and weekly ranks the whole set (10w wins), and the log says session-ok=0.
+lj 10 85 85 > "$ACC/acct-01/limits.json"
+lj 70 60 70 > "$ACC/acct-02/limits.json"
+: > "$ACC/selection.log"
 all1=1
 for _ in $(seq 1 15); do
   case "$(claude 2>&1)" in *CFG=acct-01*) ;; *) all1=0 ;; esac
 done
-[ "$all1" = "1" ] && t_ok "high session does NOT beat better weekly headroom (10w/85s over 70w/20s)" \
-  || t_fail "weekly-over-session" "ranked the account with less weekly headroom higher"
+[ "$all1" = "1" ] && t_ok "with nobody inside the gate it steps aside and weekly ranks (10w/85s over 70w/60s)" \
+  || t_fail "session gate step-aside" "an empty gate emptied the pool instead of stepping aside"
+grep -qE 'acct-01 weekly=10% session=85% band=30 band-count=1 session-gate=50 session-ok=0 pwd=' "$ACC/selection.log" \
+  && t_ok "the selection log carries session-ok=0 when the gate steps aside" \
+  || t_fail "session gate log" "$(tail -1 "$ACC/selection.log")"
+
+# The gate is a knob, like the band: 100 turns it off and pure weekly ranking returns.
+lj 10 85 85 > "$ACC/acct-01/limits.json"
+lj 70 20 70 > "$ACC/acct-02/limits.json"
+all1=1
+for _ in $(seq 1 15); do
+  case "$(CLAUDE_MULTIACC_SESSION_GATE=100 claude 2>&1)" in *CFG=acct-01*) ;; *) all1=0 ;; esac
+done
+[ "$all1" = "1" ] && t_ok "CLAUDE_MULTIACC_SESSION_GATE=100 disables the gate" \
+  || t_fail "session gate off" "the gate still fired at 100"
+# ...and garbage in that env var falls back to the 50-point default, never to "off".
+all2=1
+for _ in $(seq 1 15); do
+  case "$(CLAUDE_MULTIACC_SESSION_GATE=abc claude 2>&1)" in *CFG=acct-02*) ;; *) all2=0 ;; esac
+done
+[ "$all2" = "1" ] && t_ok "a non-numeric CLAUDE_MULTIACC_SESSION_GATE falls back to 50" \
+  || t_fail "session gate validation" "a garbage gate value changed the outcome"
 
-# In strict mode, equal weekly usage still uses session usage as its tiebreaker.
+# Equal weekly usage: the GATE decides, not a tiebreak. Session stopped being a ranking
+# input inside the band on 2026-09-03 — acct-02's 80-point session bucket simply never
+# reaches the weekly comparison, whether the band is strict or the default 30.
 lj 40 20 40 > "$ACC/acct-01/limits.json"
 lj 40 80 80 > "$ACC/acct-02/limits.json"
 all1=1
 for _ in $(seq 1 15); do
   case "$(CLAUDE_MULTIACC_HEADROOM_BAND=0 claude 2>&1)" in *CFG=acct-01*) ;; *) all1=0 ;; esac
 done
-[ "$all1" = "1" ] && t_ok "strict mode: equal weekly usage uses the session tiebreak" \
-  || t_fail "session tiebreak" "did not use session to break a weekly tie"
+[ "$all1" = "1" ] && t_ok "strict mode: the session gate decides an exact weekly tie" \
+  || t_fail "session gate tie" "a weekly tie was not resolved by the session gate"
+all1=1
+for _ in $(seq 1 15); do
+  case "$(claude 2>&1)" in *CFG=acct-01*) ;; *) all1=0 ;; esac
+done
+[ "$all1" = "1" ] && t_ok "the gate (not the band) removes the session-heavy half of a weekly tie" \
+  || t_fail "session gate tie" "the default band let the 80-point session account back in"
+
+# Inside the gate, session is NOT a tiebreaker any more: an exact weekly tie between two
+# gate-clearing accounts is a coin flip even in strict mode (it used to go to the lower
+# session, through the old weekly*1000+session score).
+lj 40 20 40 > "$ACC/acct-01/limits.json"
+lj 40 45 45 > "$ACC/acct-02/limits.json"
+hits1=0; hits2=0
+for _ in $(seq 1 20); do
+  case "$(CLAUDE_MULTIACC_HEADROOM_BAND=0 claude 2>&1)" in
+    *CFG=acct-01*) hits1=$((hits1+1)) ;;
+    *CFG=acct-02*) hits2=$((hits2+1)) ;;
+  esac
+done
+{ [ "$hits1" -gt 0 ] && [ "$hits2" -gt 0 ]; } \
+  && t_ok "strict mode: session does not break an exact weekly tie inside the gate (acct-01=$hits1 acct-02=$hits2)" \
+  || t_fail "session tiebreak removed" "acct-01=$hits1 acct-02=$hits2 (want both >0)"
+
+# Clearing the gate takes BOTH readings, as in pool-selection.v2: a fresh file with a
+# session reading but no weekly one must not become the sole gate-clearer and win the
+# all-gated tie over an account with a truthful weekly reading — not even with a
+# max_percent to fall back on (the shims used to rank on that; the policy never could).
+# (No writer produces such a file; this pins parity with lib/selector_policy.py.)
+printf '{"fetched_at":%s,"max_percent":10,"session_percent":10,"buckets":[]}' "$now" > "$ACC/acct-01/limits.json"
+lj 20 80 80 > "$ACC/acct-02/limits.json"
+all2=1
+for _ in $(seq 1 15); do
+  case "$(claude 2>&1)" in *CFG=acct-02*) ;; *) all2=0 ;; esac
+done
+[ "$all2" = "1" ] && t_ok "a session reading without a weekly one never clears the gate" \
+  || t_fail "gate needs both readings" "an unknown-weekly account beat a truthful weekly reading"
+
+# ...and the converse: a weekly reading without a session one is not "known" either — it
+# neither clears the gate nor ranks once the gate steps aside (10w/?s vs 70w/80s -> the
+# 70w account, as in pool-selection.v2, where quota_known needs both readings).
+printf '{"fetched_at":%s,"weekly_percent":10,"max_percent":10,"buckets":[]}' "$now" > "$ACC/acct-01/limits.json"
+lj 70 80 80 > "$ACC/acct-02/limits.json"
+all2=1
+for _ in $(seq 1 15); do
+  case "$(claude 2>&1)" in *CFG=acct-02*) ;; *) all2=0 ;; esac
+done
+[ "$all2" = "1" ] && t_ok "a weekly reading without a session one is unknown to both cuts" \
+  || t_fail "known needs both readings" "a session-less weekly reading ranked as known"
 
 # fully equal scores spread load across accounts
 lj 10 10 10 > "$ACC/acct-01/limits.json"
@@ -409,6 +512,10 @@ done
 { [ "$hits1" -gt 0 ] && [ "$hits2" -gt 0 ]; } \
   && t_ok "CLAUDE_SHIM_SELECT=random restores uniform spread" \
   || t_fail "random opt-out" "acct-01=$hits1 acct-02=$hits2"
+# ...and its log line must not claim a gate that never ran (codex review, 2026-09-04).
+grep -qE 'band=30 band-count=2 session-gate=off session-ok=2 pwd=' "$ACC/selection.log" \
+  && t_ok "random mode logs session-gate=off instead of a cut it never made" \
+  || t_fail "random mode gate log" "$(grep 'SHIM_SELECT\|session-gate' "$ACC/selection.log" | tail -1)"
 
 # Unknown telemetry ranks behind every truthful reading, never as neutral or free.
 printf '{"fetched_at":1,"weekly_percent":1,"session_percent":1,"max_percent":1,"buckets":[]}' > "$ACC/acct-01/limits.json"
@@ -478,17 +585,35 @@ printf '%s\nbucket=session percent=95 reason=limits\n' "$((now-10))" > "$ACC/acc
 claude >/dev/null 2>&1
 [ ! -f "$ACC/acct-01/.limited" ] && t_ok "expired marker auto-cleared" || t_fail "expired marker auto-cleared" "marker still present"
 
-# ---- 9. all limited -> least utilized fallback ------------------------------
+# ---- 9. all limited -> the still-serving accounts go through the same two cuts, strict weekly ----
 printf '%s\nx\n' "$((now+3600))" > "$ACC/acct-01/.limited"
 printf '%s\nx\n' "$((now+3600))" > "$ACC/acct-02/.limited"
-printf '{"fetched_at":%s,"max_percent":97,"buckets":[]}' "$now" > "$ACC/acct-01/limits.json"
-printf '{"fetched_at":%s,"max_percent":91,"buckets":[]}' "$now" > "$ACC/acct-02/limits.json"
+lj 97 10 97 > "$ACC/acct-01/limits.json"
+lj 91 10 91 > "$ACC/acct-02/limits.json"
 out="$(claude 2>&1)"
-check "all-limited falls back to least utilized" "CFG=acct-02" "$out"
+check "all-limited falls back to the still-serving account with the most weekly headroom" "CFG=acct-02" "$out"
 grep -q "all-limited fallback=acct-02" "$ACC/selection.log" \
   && t_ok "fallback logged" || t_fail "fallback logged" "no all-limited line in selection.log"
 rm -f "$ACC/acct-01/.limited" "$ACC/acct-02/.limited"
 
+# The fallback applies the SAME two cuts: with every account limit-marked but still
+# serving, an account past the session gate (10w/85s) yields to one inside it (70w/20s)
+# even though its weekly headroom is far better — exactly as in ordinary selection.
+# (On the pre-gate rule this picked 10w/85s, the best strict weekly score.)
+printf '%s\nbucket=weekly_all percent=95 marked_at=x reason=limits\n' "$((now+3600))" > "$ACC/acct-01/.limited"
+printf '%s\nbucket=weekly_all percent=95 marked_at=x reason=limits\n' "$((now+3600))" > "$ACC/acct-02/.limited"
+lj 10 85 85 > "$ACC/acct-01/limits.json"
+lj 70 20 70 > "$ACC/acct-02/limits.json"
+all2=1
+for _ in $(seq 1 12); do
+  case "$(claude 2>&1)" in *CFG=acct-02*) ;; *) all2=0 ;; esac
+done
+[ "$all2" = "1" ] && t_ok "the all-limited fallback applies the session gate before strict weekly (70w/20s over 10w/85s)" \
+  || t_fail "fallback session gate" "the fallback handed out the account past the session gate"
+grep -q "all-limited fallback=acct-02 weekly=70%" "$ACC/selection.log" \
+  && t_ok "the fallback line names the gated pick" || t_fail "fallback gate log" "$(tail -1 "$ACC/selection.log")"
+rm -f "$ACC/acct-01/.limited" "$ACC/acct-02/.limited"
+
 # ---- 9a2. the fallback tells "still serving" from "rejected right now" --------------
 # acct-01: weekly at 99% — worse headroom, but still answering requests.
 # acct-02: session at 100% — far better weekly (7%), but every request bounces until
@@ -512,8 +637,8 @@ check "all exhausted: the soonest reset is handed out" "CFG=acct-02" "$out"
 grep -q "all-exhausted resets_in=" "$ACC/selection.log" \
   && t_ok "the all-exhausted pick is logged with its reset" || t_fail "all-exhausted log" "no line"
 rm -f "$ACC/acct-01/.limited" "$ACC/acct-02/.limited"
-printf '{"fetched_at":%s,"max_percent":97,"buckets":[]}' "$now" > "$ACC/acct-01/limits.json"
-printf '{"fetched_at":%s,"max_percent":91,"buckets":[]}' "$now" > "$ACC/acct-02/limits.json"
+lj 97 10 97 > "$ACC/acct-01/limits.json"
+lj 91 10 91 > "$ACC/acct-02/limits.json"
 
 # ---- 9a3. a token park is credential-scoped ----------------------------------------
 # A dead portable token beside a LIVE login: this session runs the account on the
@@ -717,8 +842,8 @@ rm -f "$ACC/acct-01/server.token"
 printf '%s' "$DEAD_CREDS" > "$ACC/acct-01/.credentials.json"
 printf '%s' "$HEALTHY_CREDS" > "$ACC/acct-02/.credentials.json"
 printf 'sk-ant-oat01-REVOKEDREVOKEDREVOKEDREVOKEDREVOKEDREVOKED' > "$ACC/acct-01/server.token"
-printf '{"fetched_at":%s,"max_percent":1,"buckets":[]}' "$now" > "$ACC/acct-01/limits.json"
-printf '{"fetched_at":%s,"max_percent":50,"buckets":[]}' "$now" > "$ACC/acct-02/limits.json"
+lj 1 1 1 > "$ACC/acct-01/limits.json"      # ranks first, so its preflight is what runs
+lj 50 1 50 > "$ACC/acct-02/limits.json"
 rm -f "$ACC/.last-pick" "$ACC/acct-01/.expired" "$ACC/acct-01/.server-token-verified"
 out="$(claude --resume d6ccbac0-6643-4780-a99e-3afa1683478e 2>&1)"
 check "revoked setup-token fails over before --resume" "CFG=acct-02" "$out"
@@ -1438,8 +1563,14 @@ expected="$(cat "$WORK/stdin13")"
 [ "$out" = "$expected" ] && t_ok "stdin/stdout byte fidelity (-p pipe)" || t_fail "stdin fidelity" "got: $out"
 
 # ---- 14. selection log written ------------------------------------------------
+# One COMPLETE reading first, on purpose: the pool is still carrying the session-only
+# documents an earlier limits pass wrote, and since 2026-09-04 a pool where no account
+# has BOTH percentages is BLIND (bin/claude telem_blind) and logs the blind format
+# instead. The ranked format asserted below only exists when something actually ranked.
+lj 20 10 20 > "$ACC/acct-01/limits.json"
+claude >/dev/null 2>&1
 log_pattern='^[0-9]{4}-[0-9]{2}-[0-9]{2}T.*acct-0[123] weekly=[0-9?]+% session=[0-9?]+%'
-log_pattern="$log_pattern band=30 band-count=[0-9]+ pwd="
+log_pattern="$log_pattern band=30 band-count=[0-9]+ session-gate=50 session-ok=[0-9]+ pwd="
 grep -qE "$log_pattern" "$ACC/selection.log" \
   && t_ok "selection.log format" || t_fail "selection.log format" "no matching lines"
 grep -qE 'sk-ant-oat|accessToken|refreshToken' "$ACC/selection.log" \
@@ -1931,12 +2062,620 @@ assert groups["weekly_scoped:Fable"] == "weekly", groups
 EOF
 [ $? -eq 0 ] && t_ok "limits records weekly_percent(55) + session_percent(88) with correct groups" \
   || t_fail "weekly/session classification" "see limits.json"
-# a session bucket at 88 must NOT poison weekly ranking: score uses weekly(55), not 88
-sc="$(python3 -c "import json;d=json.load(open('$ACC/acct-01/limits.json'));print(d['weekly_percent']*1000+d['session_percent'])")"
-[ "$sc" = "55088" ] && t_ok "ranking score weighs weekly over session (55088)" \
-  || t_fail "ranking score" "got $sc"
+# The two numbers must stay SEPARATE on disk. There is no combined score any more
+# (2026-09-03): the shim GATES on session_percent and BANDS on weekly_percent, so a
+# session bucket at 88 must never be folded into — or allowed to poison — the weekly
+# reading the band ranks on.
+sc="$(python3 -c "import json;d=json.load(open('$ACC/acct-01/limits.json'));print('%s/%s' % (d['weekly_percent'], d['session_percent']))")"
+[ "$sc" = "55/88" ] && t_ok "weekly and session are recorded as separate ranking inputs (55 weekly / 88 session)" \
+  || t_fail "weekly/session ranking inputs" "got $sc"
 rm -f "$ACC/acct-01/limits.json" "$ACC/acct-01/.limited"
 
+# ---- 16-nodata. a 0% bucket with NO reset window is NO DATA, not an empty account ----
+# 2026-09-04, my-mini: for acct-13/acct-14 the usage endpoint answered EVERY bucket
+# `percent: 0, resets_at: null` while Claude Code was being rejected on those same two
+# accounts with "You've hit your weekly limit · resets Sep 8 at 1am" (epoch 1788818400).
+# The writer recorded the zeros verbatim, so two provably exhausted accounts became the
+# leaders of the weekly band and absorbed 31 of the last ~60 picks — and the shim's
+# telemetry-based recovery then deleted their truthful client:seven_day markers about six
+# times a day each. A truthful bucket ALWAYS carries the window it resets in, so 0% with
+# no window is no data. These run in a pool of their own: one no-data account against one
+# honest one makes "which account ranked" unambiguous.
+ND="$WORK/nodata-pool"
+mkdir -p "$ND/acct-01" "$ND/acct-02" "$ND/tmp"
+: > "$ND/.limits-kick"
+cat > "$ND/accounts.json" <<'EOF'
+{"version":1,"server":"none","threshold":90,"accounts":[
+  {"id":"acct-01","email":"nd1@test","home":"mac","added_at":"2026-07-13T00:00:00Z"},
+  {"id":"acct-02","email":"nd2@test","home":"mac","added_at":"2026-07-13T00:00:00Z"}]}
+EOF
+for i in 01 02; do
+  printf '{"claudeAiOauth":{"accessToken":"sk-ant-oat01-nd%s","refreshToken":"r","expiresAt":9999999999999,"refreshTokenExpiresAt":9999999999999}}' \
+    "$i" > "$ND/acct-$i/.credentials.json"
+done
+ndl() { # ndl <weekly> <session> <max> -> a truthful, in-window reading on stdout
+  local t; t="$(date +%s)"
+  printf '{"fetched_at":%s,"source":"oauth","weekly_percent":%s,"session_percent":%s,"max_percent":%s,"weekly_resets_epoch":%s,"buckets":[]}' \
+    "$t" "$1" "$2" "$3" "$((t + 259200))"
+}
+ndlimits() { # ndlimits <fixture> [extra args] -> a real refresh over the whole ND pool
+  local f="$1"; shift
+  CLAUDE_ACCOUNTS_ROOT="$ND" CLAUDE_MULTIACC_USAGE_URL="file://$f" \
+    claude-accounts limits --force "$@" 2>&1
+}
+
+# the incident payload, byte-for-byte in shape: every bucket 0%, every window null
+cat > "$WORK/usage-allzero.json" <<'EOF'
+{"limits":[
+  {"kind":"session","group":"session","percent":0,"resets_at":null,"scope":null},
+  {"kind":"weekly_all","group":"weekly","percent":0,"resets_at":null,"scope":null},
+  {"kind":"weekly_scoped","group":"weekly","percent":0,"resets_at":null,"scope":{"model":{"display_name":"Fable"}}}
+]}
+EOF
+out="$(ndlimits "$WORK/usage-allzero.json")"
+check "an all-zero/no-window payload is reported as no usable telemetry" \
+  "no usable telemetry (account ranks as unknown, not as empty)" "$out"
+python3 - "$ND/acct-01/limits.json" <<'EOF'
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert d.get('no_data') is True, d
+# A MISSING field is what makes the shim's fresh_field/cutoff_field reads fail, which
+# is what makes the account unknown to both cuts. Writing 0 here is the bug.
+for k in ('max_percent', 'weekly_percent', 'session_percent', 'weekly_resets_epoch'):
+    assert k not in d, (k, d)
+assert len(d['buckets']) == 3, d          # the raw buckets stay, for diagnostics
+assert d['fetched_at'] > 0 and d['source'], d
+EOF
+[ $? -eq 0 ] && t_ok "a no-data pass records no_data and NONE of the three percent signals" \
+  || t_fail "no_data document" "see $ND/acct-01/limits.json"
+
+# ONE uninformative bucket beside real ones changes nothing (the live acct-16 shape:
+# weekly_scoped:Fable 0/null next to a real session and a real weekly_all).
+cat > "$WORK/usage-mixed-nodata.json" <<'EOF'
+{"limits":[
+  {"kind":"session","group":"session","percent":12,"resets_at":"2099-01-01T00:00:00+00:00","scope":null},
+  {"kind":"weekly_all","group":"weekly","percent":40,"resets_at":"2099-01-05T00:00:00+00:00","scope":null},
+  {"kind":"weekly_scoped","group":"weekly","percent":0,"resets_at":null,"scope":{"model":{"display_name":"Fable"}}}
+]}
+EOF
+ndlimits "$WORK/usage-mixed-nodata.json" --quiet >/dev/null
+python3 - "$ND/acct-01/limits.json" <<'EOF'
+import json, sys, time, calendar
+d = json.load(open(sys.argv[1]))
+assert 'no_data' not in d, d
+assert (d['session_percent'], d['weekly_percent'], d['max_percent']) == (12, 40, 40), d
+want = calendar.timegm(time.strptime("2099-01-05T00:00:00", "%Y-%m-%dT%H:%M:%S"))
+assert d['weekly_resets_epoch'] == want, d
+assert len(d['buckets']) == 3, d          # the quiet bucket is still recorded
+EOF
+[ $? -eq 0 ] && t_ok "one uninformative bucket beside real ones leaves the ranking untouched (12/40)" \
+  || t_fail "mixed no-data payload" "see $ND/acct-01/limits.json"
+
+# 0% WITH a real window is informative: a genuinely fresh account must still rank empty.
+cat > "$WORK/usage-zero-real-windows.json" <<'EOF'
+{"limits":[
+  {"kind":"session","group":"session","percent":0,"resets_at":"2099-01-01T00:00:00+00:00","scope":null},
+  {"kind":"weekly_all","group":"weekly","percent":0,"resets_at":"2099-01-05T00:00:00+00:00","scope":null}
+]}
+EOF
+ndlimits "$WORK/usage-zero-real-windows.json" --quiet >/dev/null
+python3 - "$ND/acct-01/limits.json" <<'EOF'
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert 'no_data' not in d, d
+assert (d['session_percent'], d['weekly_percent'], d['max_percent']) == (0, 0, 0), d
+EOF
+[ $? -eq 0 ] && t_ok "0% WITH real reset windows still records a real, empty 0% reading" \
+  || t_fail "zero-with-windows payload" "see $ND/acct-01/limits.json"
+
+# ...and the horizon that 0% is valid until comes from the bucket that reported one. A
+# null-window sibling's synthesized now+1h used to win the min() and shorten it.
+cat > "$WORK/usage-zero-mixed-window.json" <<'EOF'
+{"limits":[
+  {"kind":"session","group":"session","percent":0,"resets_at":"2099-01-01T00:00:00+00:00","scope":null},
+  {"kind":"weekly_all","group":"weekly","percent":0,"resets_at":"2099-01-05T00:00:00+00:00","scope":null},
+  {"kind":"weekly_scoped","group":"weekly","percent":0,"resets_at":null,"scope":{"model":{"display_name":"Fable"}}}
+]}
+EOF
+ndlimits "$WORK/usage-zero-mixed-window.json" --quiet >/dev/null
+python3 - "$ND/acct-01/limits.json" <<'EOF'
+import json, sys, time, calendar
+d = json.load(open(sys.argv[1]))
+want = calendar.timegm(time.strptime("2099-01-05T00:00:00", "%Y-%m-%dT%H:%M:%S"))
+assert d['weekly_percent'] == 0 and d['weekly_resets_epoch'] == want, d
+EOF
+[ $? -eq 0 ] && t_ok "a window-less bucket cannot shorten the horizon a real 0% reading is valid for" \
+  || t_fail "no-data horizon" "see $ND/acct-01/limits.json"
+
+# ---- 16-nodata-rank. an unknown account never leads the weekly band ------------------
+# The whole point of the rule: 0/0 ranked BETTER than a truthful 45% account, so every
+# pick went to the exhausted one. Unknown must lose to any account with a real reading.
+ndlimits "$WORK/usage-allzero.json" --quiet >/dev/null
+ndl 45 10 45 > "$ND/acct-02/limits.json"
+rm -f "$ND/.pick-seq" "$ND"/acct-0*/.last-pick "$ND"/acct-0*/.limited
+: > "$ND/selection.log"
+nd_hits=0
+for _ in $(seq 1 10); do
+  case "$(CLAUDE_ACCOUNTS_ROOT="$ND" claude 2>&1)" in *CFG=acct-01*) nd_hits=$((nd_hits+1)) ;; esac
+done
+[ "$nd_hits" = "0" ] \
+  && t_ok "a no-data account never outranks an account with real telemetry (0 of 10 picks)" \
+  || t_fail "no_data ranking" "the fake-zero account took $nd_hits of 10 picks"
+grep -q "acct-02 weekly=45% session=10% band=30 band-count=1" "$ND/selection.log" \
+  && t_ok "the pick logs the known account alone in the band" \
+  || t_fail "no_data band" "selection.log: $(tail -1 "$ND/selection.log" 2>/dev/null)"
+grep -q "acct-01 weekly=0%" "$ND/selection.log" \
+  && t_fail "no_data band leader" "the fake-zero account was logged as a 0% pick" \
+  || t_ok "the fake-zero account is never logged as the band leader"
+
+# ---- 16-nodata-marker. a client-reported WEEKLY rejection outlives any telemetry -----
+# The second half of the incident. Claude Code's own rejection wrote
+# `bucket=client:seven_day percent=100 reason=client-rate-limit` with the server's reset
+# (Sep 8); the next invocation read the fake 0%, called it newer first-hand evidence and
+# deleted the marker. A seven-day window cannot fall from a server-proven 100% to under
+# the threshold before it resets, so no reading may clear it — however fresh and however
+# informative. Here acct-01's telemetry is a REAL 5%, so only the bucket rule can save it.
+ndl 5 5 5 > "$ND/acct-01/limits.json"
+ndl 45 10 45 > "$ND/acct-02/limits.json"
+printf '%s\nbucket=client:seven_day percent=100 marked_at=2020-01-01T00:00:00Z reason=client-rate-limit\n' \
+  "$(( $(date +%s) + 345600 ))" > "$ND/acct-01/.limited"
+rm -f "$ND"/acct-0*/.client-limit-cleared "$ND/.pick-seq" "$ND"/acct-0*/.last-pick
+: > "$ND/selection.log"
+w_hits=0
+for _ in $(seq 1 6); do
+  case "$(CLAUDE_ACCOUNTS_ROOT="$ND" claude 2>&1)" in *CFG=acct-01*) w_hits=$((w_hits+1)) ;; esac
+done
+{ [ -f "$ND/acct-01/.limited" ] && [ "$w_hits" = "0" ]; } \
+  && t_ok "a client:seven_day marker survives fresh below-threshold telemetry" \
+  || t_fail "weekly client marker" "marker=$([ -f "$ND/acct-01/.limited" ] && echo kept || echo DELETED) hits=$w_hits"
+grep -q "client limit cleared by newer telemetry" "$ND/selection.log" \
+  && t_fail "weekly client marker" "the shim logged a recovery for a weekly rejection" \
+  || t_ok "no recovery event is logged for a weekly rejection"
+[ ! -f "$ND/acct-01/.client-limit-cleared" ] \
+  && t_ok "no recovery watermark is written for a weekly rejection" \
+  || t_fail "weekly client marker" "a watermark was written"
+# case-insensitive on the bucket name: seven_day_opus is weekly too
+printf '%s\nbucket=client:Seven_Day_Opus percent=100 marked_at=2020-01-01T00:00:00Z reason=client-rate-limit\n' \
+  "$(( $(date +%s) + 345600 ))" > "$ND/acct-01/.limited"
+CLAUDE_ACCOUNTS_ROOT="$ND" claude >/dev/null 2>&1
+[ -f "$ND/acct-01/.limited" ] && t_ok "a model-scoped weekly bucket (seven_day_opus) is weekly too" \
+  || t_fail "weekly client marker" "seven_day_opus was cleared"
+
+# ...but the 5h window self-heals within hours, so #22 (2026-09-03) still holds: a
+# five_hour marker DOES clear once a below-threshold reading was fetched after it.
+printf '%s\nbucket=client:five_hour percent=100 marked_at=2020-01-01T00:00:00Z reason=client-rate-limit\n' \
+  "$(( $(date +%s) + 1800 ))" > "$ND/acct-01/.limited"
+rm -f "$ND/acct-01/.client-limit-cleared"
+: > "$ND/selection.log"
+CLAUDE_ACCOUNTS_ROOT="$ND" claude >/dev/null 2>&1
+[ ! -f "$ND/acct-01/.limited" ] \
+  && t_ok "a client:five_hour marker still clears on newer below-threshold telemetry (#22)" \
+  || t_fail "five_hour client marker" "the 2026-09-03 recovery stopped working"
+[ -f "$ND/acct-01/.client-limit-cleared" ] \
+  && t_ok "the five_hour recovery still records its watermark" \
+  || t_fail "five_hour client marker" "watermark missing"
+grep -q "acct-01 client limit cleared by newer telemetry (5%)" "$ND/selection.log" \
+  && t_ok "the five_hour recovery still logs the reading it acted on" \
+  || t_fail "five_hour client marker" "selection.log: $(tail -2 "$ND/selection.log" 2>/dev/null | tr '\n' ' ')"
+
+# ---- 16-nodata-shorten. an offender pass must never SHORTEN a weekly client marker ---
+# The writer's offenders branch used to overwrite `.limited` unconditionally: a session
+# bucket crossing the threshold (+1h reset) replaced a client:seven_day marker four days
+# out, and after that hour the provably exhausted account was back in the pool (codex
+# review, 2026-09-04). The client's own reset reaches further and must win.
+printf '%s\nbucket=client:seven_day percent=100 marked_at=2020-01-01T00:00:00Z reason=client-rate-limit\n' \
+  "$(( $(date +%s) + 345600 ))" > "$ND/acct-01/.limited"
+keep_reset_before="$(head -1 "$ND/acct-01/.limited")"
+python3 - "$WORK/usage-shorten.json" <<'PJ'
+import json, sys, datetime
+soon = (datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(hours=1)).isoformat()
+json.dump({"limits": [
+    {"kind": "session", "percent": 95, "resets_at": soon},
+    {"kind": "seven_day", "percent": 0, "resets_at": None},
+]}, open(sys.argv[1], 'w'))
+PJ
+CLAUDE_ACCOUNTS_ROOT="$ND" CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-shorten.json" \
+  claude-accounts limits --force --quiet >/dev/null 2>&1
+{ [ -f "$ND/acct-01/.limited" ] && [ "$(head -1 "$ND/acct-01/.limited")" = "$keep_reset_before" ] \
+  && grep -q 'reason=client-rate-limit' "$ND/acct-01/.limited"; } \
+  && t_ok "an over-threshold session pass keeps the further-reaching weekly client marker" \
+  || t_fail "marker shortened" "now: $(head -2 "$ND/acct-01/.limited" 2>/dev/null | tr '\n' ' ')"
+# ...while a LATER reset may still extend the exclusion (more caution is allowed):
+python3 - "$WORK/usage-extend.json" <<'PJ'
+import json, sys, datetime
+far = (datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(days=6)).isoformat()
+json.dump({"limits": [
+    {"kind": "seven_day", "percent": 95, "resets_at": far},
+]}, open(sys.argv[1], 'w'))
+PJ
+CLAUDE_ACCOUNTS_ROOT="$ND" CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-extend.json" \
+  claude-accounts limits --force --quiet >/dev/null 2>&1
+{ [ -f "$ND/acct-01/.limited" ] && [ "$(head -1 "$ND/acct-01/.limited")" -gt "$keep_reset_before" ]; } \
+  && t_ok "a further-out offender may still extend the marker" \
+  || t_fail "marker extend" "now: $(head -2 "$ND/acct-01/.limited" 2>/dev/null | tr '\n' ' ')"
+rm -f "$ND"/acct-0*/.limited "$ND"/acct-0*/.client-limit-cleared
+# ...and a GARBLED client marker (a first line the shims' num_ok would refuse) must not
+# be preserved by that guard: to the shims it is an active-forever park, so the writer
+# replacing it with a valid offender marker is a repair, not a shortening.
+printf '9999999999999999999\nbucket=client:seven_day reason=client-rate-limit\n' > "$ND/acct-01/.limited"
+CLAUDE_ACCOUNTS_ROOT="$ND" CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-shorten.json" \
+  claude-accounts limits --force --quiet >/dev/null 2>&1
+{ [ -f "$ND/acct-01/.limited" ] && grep -q 'reason=limits' "$ND/acct-01/.limited"; } \
+  && t_ok "a garbled client marker is repaired by the offender write, not preserved" \
+  || t_fail "garbled marker repair" "now: $(head -2 "$ND/acct-01/.limited" 2>/dev/null | tr '\n' ' ')"
+rm -f "$ND"/acct-0*/.limited "$ND"/acct-0*/.client-limit-cleared
+
+# ---- 16-nodata-noclear. an uninformative reading cannot clear ANY marker -------------
+# End to end, in the incident's own order: the fake-zero payload goes through the real
+# writer, then a five_hour marker (the kind that IS allowed to clear) is planted on top.
+# Pre-fix that pass wrote max_percent 0 and the very next invocation deleted the marker
+# with "client limit cleared by newer telemetry (0%)". A reading with no percent at all
+# reads as unknown, and unknown proves nothing.
+ndlimits "$WORK/usage-allzero.json" --quiet >/dev/null
+ndl 45 10 45 > "$ND/acct-02/limits.json"
+printf '%s\nbucket=client:five_hour percent=100 marked_at=2020-01-01T00:00:00Z reason=client-rate-limit\n' \
+  "$(( $(date +%s) + 1800 ))" > "$ND/acct-01/.limited"
+rm -f "$ND/acct-01/.client-limit-cleared" "$ND/.pick-seq" "$ND"/acct-0*/.last-pick
+: > "$ND/selection.log"
+for _ in 1 2 3; do CLAUDE_ACCOUNTS_ROOT="$ND" claude >/dev/null 2>&1; done
+[ -f "$ND/acct-01/.limited" ] \
+  && t_ok "a limits.json with no percent fields cannot clear even a five_hour marker" \
+  || t_fail "no_data marker clearing" "fake-zero telemetry unparked the account"
+grep -q "client limit cleared" "$ND/selection.log" \
+  && t_fail "no_data marker clearing" "a recovery was logged from a no-data reading" \
+  || t_ok "no recovery is logged from a no-data reading"
+[ ! -f "$ND/acct-01/.client-limit-cleared" ] \
+  && t_ok "no recovery watermark is written from a no-data reading" \
+  || t_fail "no_data marker clearing" "a watermark was written from a reading with no percent"
+rm -f "$ND"/acct-0*/.limited "$ND"/acct-0*/.client-limit-cleared
+
+# ---- 16-nodata-writer. the LIMITS PASS obeys the same marker rule as the shim --------
+# The shim's rule above is only half a fix. `claude-accounts limits` runs on a 15-minute
+# schedule and deletes markers itself, and until 2026-09-04 it kept a client rejection
+# only while it was newer than CLIENT_LIMIT_CONFIRM_DELAY (300s) — so five minutes after
+# the shim refused to unpark acct-13, the scheduled pass deleted the same client:seven_day
+# marker anyway, on a payload whose every bucket said `percent 0, resets_at null`. Two
+# writers with two rules is one rule: the weaker one. This is the claude twin of the codex
+# C13c block, and the pass is driven for real (fixture endpoint -> writer -> disk).
+nd_mark() { # nd_mark <acct dir> <bucket> <reset-offset-seconds> <marked_at ISO>
+  printf '%s\nbucket=%s percent=100 marked_at=%s reason=client-rate-limit\n' \
+    "$(( $(date +%s) + $3 ))" "$2" "$4" > "$1/.limited"
+}
+nd_acct01_log() { printf '%s' "$1" | grep 'acct-01' | tr '\n' ' '; }
+# A REAL, informative, below-threshold reading: the kind that IS allowed to clear a
+# five-hour marker, and the one that must never clear a weekly one.
+cat > "$WORK/usage-nd-low.json" <<'EOF'
+{"limits":[
+  {"kind":"session","group":"session","percent":5,"resets_at":"2099-01-01T00:00:00+00:00","scope":null},
+  {"kind":"weekly_all","group":"weekly","percent":5,"resets_at":"2099-01-05T00:00:00+00:00","scope":null}
+]}
+EOF
+
+# (1) A pass that reported nothing proves nothing, so it clears nothing — whatever the
+# marker says and however old it is. On origin/main this marker is 300s past its confirm
+# delay and the pass deletes it with "marker cleared (max 0%)".
+nd_mark "$ND/acct-01" client:seven_day 345600 2020-01-01T00:00:00Z
+rm -f "$ND/acct-01/.client-limit-cleared"
+out="$(ndlimits "$WORK/usage-allzero.json")"
+{ [ -f "$ND/acct-01/.limited" ] && [ ! -f "$ND/acct-01/.client-limit-cleared" ] \
+  && printf '%s' "$out" | grep -q "acct-01: marker kept (no usable telemetry)"; } \
+  && t_ok "a no-data limits pass keeps an aged client:seven_day marker, and logs that it kept it" \
+  || t_fail "writer marker: no-data pass" \
+     "marker=$([ -f "$ND/acct-01/.limited" ] && echo kept || echo DELETED) log: $(nd_acct01_log "$out")"
+
+# (2) ...and a pass that DID report something still cannot clear a weekly rejection
+# before its reset: a seven-day window cannot fall from the server-proven 100% that
+# wrote the marker to 5% while it is still open. The keep must come from the BUCKET
+# rule, not from silence, so the "no usable telemetry" line must NOT appear here.
+nd_mark "$ND/acct-01" client:seven_day 345600 2020-01-01T00:00:00Z
+rm -f "$ND/acct-01/.client-limit-cleared"
+out="$(ndlimits "$WORK/usage-nd-low.json")"
+{ [ -f "$ND/acct-01/.limited" ] && [ ! -f "$ND/acct-01/.client-limit-cleared" ] \
+  && ! printf '%s' "$out" | grep -q "acct-01: marker cleared" \
+  && ! printf '%s' "$out" | grep -q "acct-01: marker kept (no usable telemetry)"; } \
+  && t_ok "an informative 5% pass keeps a client:seven_day marker on the bucket rule alone" \
+  || t_fail "writer marker: weekly vs informative pass" \
+     "marker=$([ -f "$ND/acct-01/.limited" ] && echo kept || echo DELETED) log: $(nd_acct01_log "$out")"
+
+# (3) The 5h window self-heals in hours, so #22 (2026-09-03) still holds at the writer:
+# an aged five_hour rejection DOES clear once a pass has real numbers under the
+# threshold. This one passes on origin/main too — deliberately: it is the guard against
+# over-correcting (2) into "no client marker ever clears", which would strand accounts
+# sitting at 0% usage for days, which is the bug #22 existed to fix.
+nd_mark "$ND/acct-01" client:five_hour 1800 2020-01-01T00:00:00Z
+rm -f "$ND/acct-01/.client-limit-cleared"
+out="$(ndlimits "$WORK/usage-nd-low.json")"
+{ [ ! -f "$ND/acct-01/.limited" ] && [ -f "$ND/acct-01/.client-limit-cleared" ] \
+  && printf '%s' "$out" | grep -q "acct-01: marker cleared (max 5%)"; } \
+  && t_ok "an informative 5% pass still clears an aged client:five_hour marker (#22)" \
+  || t_fail "writer marker: five_hour recovery" \
+     "marker=$([ -f "$ND/acct-01/.limited" ] && echo kept || echo DELETED) log: $(nd_acct01_log "$out")"
+
+# (4) ...but the SAME five_hour marker survives a pass that said nothing. "0%" and "no
+# reading" are the same bytes on origin/main, and that is the whole incident.
+nd_mark "$ND/acct-01" client:five_hour 1800 2020-01-01T00:00:00Z
+rm -f "$ND/acct-01/.client-limit-cleared"
+out="$(ndlimits "$WORK/usage-allzero.json")"
+{ [ -f "$ND/acct-01/.limited" ] && [ ! -f "$ND/acct-01/.client-limit-cleared" ] \
+  && printf '%s' "$out" | grep -q "acct-01: marker kept (no usable telemetry)"; } \
+  && t_ok "a no-data pass keeps even a client:five_hour marker — the kind it may clear when informative" \
+  || t_fail "writer marker: five_hour vs no-data pass" \
+     "marker=$([ -f "$ND/acct-01/.limited" ] && echo kept || echo DELETED) log: $(nd_acct01_log "$out")"
+rm -f "$ND"/acct-0*/.limited "$ND"/acct-0*/.client-limit-cleared
+
+# ---- 16-nodata-signals. each ranking signal comes from a bucket of its OWN kind ------
+# 2026-09-04, second defect: weekly_percent fell back to the overall peak and
+# session_percent to a flat 0. So an account whose weekly buckets said nothing while its
+# 5h bucket read 40% was recorded as 40% WEEKLY — a number no bucket ever reported, on
+# the signal the band ranks on — and its mirror image was recorded as session 0%, which
+# walks straight through the session gate. A signal nobody reported must be ABSENT: the
+# shim needs BOTH readings to call an account known (pick_best's quota_known rule), so a
+# missing one costs the account its place in the band and nothing else.
+cat > "$WORK/usage-session-only.json" <<'EOF'
+{"limits":[
+  {"kind":"session","group":"session","percent":40,"resets_at":"2099-01-01T00:00:00+00:00","scope":null},
+  {"kind":"weekly_all","group":"weekly","percent":0,"resets_at":null,"scope":null},
+  {"kind":"weekly_scoped","group":"weekly","percent":0,"resets_at":null,"scope":{"model":{"display_name":"Fable"}}}
+]}
+EOF
+ndlimits "$WORK/usage-session-only.json" --quiet >/dev/null
+python3 - "$ND/acct-01/limits.json" <<'EOF'
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert 'no_data' not in d, d                    # one bucket DID report: this is a reading
+assert (d['session_percent'], d['max_percent']) == (40, 40), d
+# The two weekly buckets said `0% / no window`. Recording 40 here (round 1's fallback to
+# the overall peak) or 0 (origin/main's max over silent weekly buckets) both invent the
+# only number the weekly band ranks on.
+assert 'weekly_percent' not in d, d
+assert 'weekly_resets_epoch' not in d, d        # a horizon without a reading means nothing
+EOF
+[ $? -eq 0 ] && t_ok "a session-only reading records session+max and NO weekly_percent" \
+  || t_fail "session-only signals" "see $ND/acct-01/limits.json"
+
+# ...and the shim reads that as UNKNOWN, so a truthful 30w/10s account takes every pick.
+ndl 30 10 30 > "$ND/acct-02/limits.json"
+rm -f "$ND/.pick-seq" "$ND"/acct-0*/.last-pick "$ND"/acct-0*/.limited
+: > "$ND/selection.log"
+nd_sess_hits=0
+for _ in $(seq 1 10); do
+  case "$(CLAUDE_ACCOUNTS_ROOT="$ND" claude 2>&1)" in *CFG=acct-01*) nd_sess_hits=$((nd_sess_hits+1)) ;; esac
+done
+[ "$nd_sess_hits" = "0" ] \
+  && t_ok "an account with no weekly reading never enters the band (0 of 10 picks)" \
+  || t_fail "session-only ranking" "the weekly-less account took $nd_sess_hits of 10 picks"
+
+# The mirror image: a weekly reading with nothing to say about the session bucket. Here
+# the rival is WORSE on weekly (80 against 37) and still wins every pick, because it is
+# the only candidate that can clear the session gate — which is exactly what a fabricated
+# `session_percent: 0` would have handed the silent account for free.
+cat > "$WORK/usage-weekly-only.json" <<'EOF'
+{"limits":[
+  {"kind":"session","group":"session","percent":0,"resets_at":null,"scope":null},
+  {"kind":"weekly_all","group":"weekly","percent":37,"resets_at":"2099-01-05T00:00:00+00:00","scope":null}
+]}
+EOF
+ndlimits "$WORK/usage-weekly-only.json" --quiet >/dev/null
+python3 - "$ND/acct-01/limits.json" <<'EOF'
+import json, sys, time, calendar
+d = json.load(open(sys.argv[1]))
+assert 'no_data' not in d, d
+assert (d['weekly_percent'], d['max_percent']) == (37, 37), d
+assert d['weekly_resets_epoch'] == calendar.timegm(
+    time.strptime("2099-01-05T00:00:00", "%Y-%m-%dT%H:%M:%S")), d
+assert 'session_percent' not in d, d             # the 5h bucket reported nothing at all
+EOF
+[ $? -eq 0 ] && t_ok "a weekly-only reading records weekly+max+horizon and NO session_percent" \
+  || t_fail "weekly-only signals" "see $ND/acct-01/limits.json"
+ndl 80 10 80 > "$ND/acct-02/limits.json"
+rm -f "$ND/.pick-seq" "$ND"/acct-0*/.last-pick "$ND"/acct-0*/.limited
+: > "$ND/selection.log"
+nd_wk_hits=0
+for _ in $(seq 1 6); do
+  case "$(CLAUDE_ACCOUNTS_ROOT="$ND" claude 2>&1)" in *CFG=acct-01*) nd_wk_hits=$((nd_wk_hits+1)) ;; esac
+done
+[ "$nd_wk_hits" = "0" ] \
+  && t_ok "an unknown session reading never clears the gate, even with the better weekly (0 of 6)" \
+  || t_fail "weekly-only gate" "the session-less account cleared the gate $nd_wk_hits of 6 times"
+grep -q "acct-02 weekly=80% session=10% band=30 band-count=1 session-gate=50 session-ok=1" "$ND/selection.log" \
+  && t_ok "the log shows one account clearing the gate and one band member" \
+  || t_fail "weekly-only gate log" "$(tail -1 "$ND/selection.log" 2>/dev/null)"
+
+# ---- 16-nodata-blind. a fresh timestamp is not a usable reading ---------------------
+# The third face of the same defect: blindness was judged on fetched_at alone, so a pool
+# of freshly-written no_data documents looked FRESH — selection.log carried no
+# ranking=BLIND line, `status` said nothing was wrong, and every account read as unknown,
+# which is a pool-wide coin flip. An outage that reports itself as healthy is the eleven
+# days of 2026-08-11 all over again, this time with a current timestamp on it.
+ndlimits "$WORK/usage-allzero.json" --quiet >/dev/null      # BOTH accounts: no_data
+rm -f "$ND/.pick-seq" "$ND"/acct-0*/.last-pick "$ND"/acct-0*/.limited
+: > "$ND/selection.log"
+CLAUDE_ACCOUNTS_ROOT="$ND" claude >/dev/null 2>&1
+grep -qE "ranking=BLIND telemetry-age=[0-9]{1,2}s band=30 band-count=2 session-gate=50 session-ok=0 pwd=" \
+  "$ND/selection.log" \
+  && t_ok "an all-no_data pool logs ranking=BLIND although its telemetry is seconds old" \
+  || t_fail "no_data blindness" "$(tail -1 "$ND/selection.log" 2>/dev/null)"
+out="$(CLAUDE_ACCOUNTS_ROOT="$ND" claude-accounts status 2>&1)"
+check "status calls an all-no_data pool blind" "RANKING IS BLIND" "$out"
+# ...and says which KIND of blind, because the two take opposite advice. The eleven-day
+# 2026-08 outage was stale telemetry — fetch again, then log in. This one is current
+# telemetry that says nothing: the credential is working perfectly, so sending the
+# operator to `claude-accounts login` is sending them after a fault that does not exist.
+check "the no_data banner names the endpoint, not the login" \
+  "Those fetches authenticated; a re-login does NOT fix this" "$out"
+case "$out" in
+  *"claude-accounts login <acct-NN>"*)
+    t_fail "no_data banner fix line" "a current-but-unusable pool was told to re-login" ;;
+  *) t_ok "the no_data banner does not prescribe a re-login" ;;
+esac
+CLAUDE_ACCOUNTS_ROOT="$ND" claude-accounts list --json > "$ND/nodata.json" 2>/dev/null
+python3 - "$ND/nodata.json" <<'EOF'
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert d['summary']['telemetry'] == 'blind', d['summary']
+assert d['summary']['ranking_blind'] is True, d['summary']
+for a in d['accounts']:
+    u = a['usage']
+    # The panel has to be able to tell THIS outage from the eleven-day one: the readings
+    # are current (not stale), they simply carry nothing to rank on.
+    assert u['no_data'] is True, a
+    assert u['stale'] is False, a
+    assert u['weekly_percent'] is None and u['session_percent'] is None, a
+EOF
+[ $? -eq 0 ] && t_ok "--json reports ranking_blind with per-account no_data on fresh readings" \
+  || t_fail "json no_data blindness" "see $ND/nodata.json"
+
+# One real reading is enough to rank the pool, and it must take the picks. A no_data
+# neighbour is unknown, not free.
+ndl 30 10 30 > "$ND/acct-02/limits.json"
+: > "$ND/selection.log"
+rm -f "$ND/.pick-seq" "$ND"/acct-0*/.last-pick
+nd_mix_hits=0
+for _ in $(seq 1 6); do
+  case "$(CLAUDE_ACCOUNTS_ROOT="$ND" claude 2>&1)" in *CFG=acct-02*) nd_mix_hits=$((nd_mix_hits+1)) ;; esac
+done
+{ [ "$nd_mix_hits" = "6" ] && ! grep -q "ranking=BLIND" "$ND/selection.log"; } \
+  && t_ok "one no_data account beside a real one leaves the pool ranking, and the real one wins 6/6" \
+  || t_fail "mixed no_data pool" "acct-02 took $nd_mix_hits of 6; $(tail -1 "$ND/selection.log" 2>/dev/null)"
+CLAUDE_ACCOUNTS_ROOT="$ND" claude-accounts list --json > "$ND/nodata-mixed.json" 2>/dev/null
+python3 - "$ND/nodata-mixed.json" <<'EOF'
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert d['summary']['telemetry'] == 'fresh', d['summary']
+assert d['summary']['ranking_blind'] is False, d['summary']
+byid = {a['id']: a for a in d['accounts']}
+assert byid['acct-01']['usage']['no_data'] is True, byid['acct-01']
+# true-only: an ordinary reading must carry the shape every consumer already knows
+assert 'no_data' not in byid['acct-02']['usage'], byid['acct-02']
+EOF
+[ $? -eq 0 ] && t_ok "--json calls the mixed pool fresh and flags only the no_data account" \
+  || t_fail "json mixed no_data" "see $ND/nodata-mixed.json"
+
+# ...and a no_data document is never DEGRADABLE. Degraded ranking exists for stale
+# readings that are still true (a weekly bucket only rises until its reset); a document
+# with no weekly reading and no horizon has nothing to be true. It must drag the pool to
+# BLIND rather than let one neighbour's stale number rank alone.
+printf '{"fetched_at":%s,"source":"oauth","no_data":true,"buckets":[]}' "$(date +%s)" \
+  > "$ND/acct-01/limits.json"
+printf '{"fetched_at":%s,"weekly_percent":4,"session_percent":0,"max_percent":4,"weekly_resets_epoch":%s,"buckets":[]}' \
+  "$(( $(date +%s) - 950000 ))" "$(( $(date +%s) + 200000 ))" > "$ND/acct-02/limits.json"
+: > "$ND/selection.log"
+rm -f "$ND/.pick-seq" "$ND"/acct-0*/.last-pick
+CLAUDE_ACCOUNTS_ROOT="$ND" claude >/dev/null 2>&1
+{ grep -q "ranking=BLIND" "$ND/selection.log" && ! grep -q "ranking=DEGRADED" "$ND/selection.log"; } \
+  && t_ok "an in-window no_data candidate turns degraded ranking off for the whole pool" \
+  || t_fail "no_data degraded" "$(tail -1 "$ND/selection.log" 2>/dev/null)"
+# the same holds once the no_data document itself goes stale (nothing to rank, ever)
+printf '{"fetched_at":%s,"source":"oauth","no_data":true,"buckets":[]}' "$(( $(date +%s) - 950000 ))" \
+  > "$ND/acct-01/limits.json"
+: > "$ND/selection.log"
+rm -f "$ND/.pick-seq" "$ND"/acct-0*/.last-pick
+CLAUDE_ACCOUNTS_ROOT="$ND" claude >/dev/null 2>&1
+{ grep -q "ranking=BLIND" "$ND/selection.log" && ! grep -q "ranking=DEGRADED" "$ND/selection.log"; } \
+  && t_ok "a stale no_data document is not degradable either" \
+  || t_fail "stale no_data degraded" "$(tail -1 "$ND/selection.log" 2>/dev/null)"
+rm -f "$ND"/acct-0*/.limited "$ND"/acct-0*/.client-limit-cleared
+
+# ---- 16-onefield-blind. HALF a reading is not a reading -----------------------------
+# The same defect one layer in, and the one the round-2 fix walked past. Blindness was
+# taught to reject a no_data document — but it accepted one carrying EITHER percentage,
+# while pick_best has always needed BOTH (the quota_known rule) before it will call an
+# account known. The writer emits exactly those half documents, per signal, whenever one
+# group of buckets goes silent (16-nodata-signals above). So a pool whose every reading
+# was session-only tied every account, picked uniformly at RANDOM, logged no
+# ranking=BLIND, and had `status` calling the telemetry fresh — the 2026-08 outage's
+# defining symptom, with a current timestamp on it. Blind is blind however the reading
+# came up short.
+ndl_half() { # ndl_half <session pct> -> a fresh, truthful, SESSION-ONLY reading
+  printf '{"fetched_at":%s,"source":"oauth","session_percent":%s,"max_percent":%s,"buckets":[]}' \
+    "$(date +%s)" "$1" "$1"
+}
+ndl_half 12 > "$ND/acct-01/limits.json"
+ndl_half 18 > "$ND/acct-02/limits.json"
+rm -f "$ND/.pick-seq" "$ND"/acct-0*/.last-pick "$ND"/acct-0*/.limited
+: > "$ND/selection.log"
+CLAUDE_ACCOUNTS_ROOT="$ND" claude >/dev/null 2>&1
+# session-ok=0 is the point, not a detail: both readings carry a session percentage well
+# under the gate, and NEITHER clears it, because the gate is part of the same "known"
+# rule. A pool that cannot rank must not look like one that ranked and tied.
+grep -qE "ranking=BLIND telemetry-age=[0-9]{1,2}s band=30 band-count=2 session-gate=50 session-ok=0 pwd=" \
+  "$ND/selection.log" \
+  && t_ok "a pool of session-only readings logs ranking=BLIND although both are seconds old" \
+  || t_fail "one-signal blindness" "$(tail -1 "$ND/selection.log" 2>/dev/null)"
+out="$(CLAUDE_ACCOUNTS_ROOT="$ND" claude-accounts status 2>&1)"
+check "status calls a one-signal pool blind" "RANKING IS BLIND" "$out"
+check "the one-signal banner says the readings are incomplete" \
+  "ranking needs BOTH a weekly and a session percentage" "$out"
+CLAUDE_ACCOUNTS_ROOT="$ND" claude-accounts list --json > "$ND/onefield.json" 2>/dev/null
+python3 - "$ND/onefield.json" <<'EOF'
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert d['summary']['telemetry'] == 'blind', d['summary']
+assert d['summary']['ranking_blind'] is True, d['summary']
+for a in d['accounts']:
+    u = a['usage']
+    # Current, well-formed, and NOT a no_data document — one real bucket did report.
+    # It simply is not enough to rank on, and the panel has to agree with the shim.
+    assert u['stale'] is False, a
+    assert 'no_data' not in u, a
+    assert u['session_percent'] is not None and u['weekly_percent'] is None, a
+EOF
+[ $? -eq 0 ] && t_ok "--json reports ranking_blind for readings that are half present" \
+  || t_fail "json one-signal blindness" "see $ND/onefield.json"
+
+# ...and the weekly-only mirror of the same rule: known needs BOTH, whichever half is
+# missing. DEGRADED must not fire either — these readings are FRESH, and degraded exists
+# for an outage of age, not for fresh emptiness (codex review, 2026-09-04).
+ndl_whalf() { # ndl_whalf <weekly pct> -> a fresh, truthful, WEEKLY-ONLY reading
+  printf '{"fetched_at":%s,"source":"oauth","weekly_percent":%s,"max_percent":%s,"weekly_resets_epoch":%s,"buckets":[]}' \
+    "$(date +%s)" "$1" "$1" "$(( $(date +%s) + 500000 ))"
+}
+ndl_whalf 4 > "$ND/acct-01/limits.json"
+ndl_whalf 80 > "$ND/acct-02/limits.json"
+rm -f "$ND/.pick-seq" "$ND"/acct-0*/.last-pick "$ND"/acct-0*/.limited
+: > "$ND/selection.log"
+CLAUDE_ACCOUNTS_ROOT="$ND" claude >/dev/null 2>&1
+grep -qE "ranking=BLIND telemetry-age=[0-9]{1,2}s .*session-ok=0 pwd=" "$ND/selection.log" \
+  && t_ok "a pool of weekly-only readings logs ranking=BLIND, not DEGRADED" \
+  || t_fail "weekly-only blindness" "$(tail -1 "$ND/selection.log" 2>/dev/null)"
+! grep -q "ranking=DEGRADED" "$ND/selection.log" \
+  && t_ok "fresh weekly-only readings never promote the pool to DEGRADED" \
+  || t_fail "fresh-degraded" "a fresh one-signal pool ranked DEGRADED"
+CLAUDE_ACCOUNTS_ROOT="$ND" claude-accounts list --json > "$ND/whalf.json" 2>/dev/null
+python3 - "$ND/whalf.json" <<'PJ'
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert d['summary']['ranking_blind'] is True, d['summary']
+PJ
+[ $? -eq 0 ] && t_ok "--json calls the fresh weekly-only pool blind (not degraded)" \
+  || t_fail "json one-signal verdict" "see $ND/whalf.json"
+
+
+# One COMPLETE reading beside them is enough to rank the pool, and it must take every
+# pick — the half readings are unknown, not free. (This holds on the pre-fix tree too:
+# it is the guard against over-correcting "half is blind" into "half is excluded".)
+ndl 30 10 30 > "$ND/acct-02/limits.json"
+rm -f "$ND/.pick-seq" "$ND"/acct-0*/.last-pick
+: > "$ND/selection.log"
+nd_half_hits=0
+for _ in $(seq 1 6); do
+  case "$(CLAUDE_ACCOUNTS_ROOT="$ND" claude 2>&1)" in *CFG=acct-02*) nd_half_hits=$((nd_half_hits+1)) ;; esac
+done
+{ [ "$nd_half_hits" = "6" ] && ! grep -q "ranking=BLIND" "$ND/selection.log"; } \
+  && t_ok "one complete reading beside a session-only one leaves the pool ranking, and wins 6/6" \
+  || t_fail "mixed one-signal pool" \
+     "acct-02 took $nd_half_hits of 6; $(tail -1 "$ND/selection.log" 2>/dev/null)"
+CLAUDE_ACCOUNTS_ROOT="$ND" claude-accounts list --json > "$ND/onefield-mixed.json" 2>/dev/null
+python3 - "$ND/onefield-mixed.json" <<'EOF'
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert d['summary']['telemetry'] == 'fresh', d['summary']
+assert d['summary']['ranking_blind'] is False, d['summary']
+EOF
+[ $? -eq 0 ] && t_ok "--json calls the mixed one-signal pool fresh" \
+  || t_fail "json mixed one-signal" "see $ND/onefield-mixed.json"
+rm -f "$ND"/acct-0*/.limited "$ND"/acct-0*/.client-limit-cleared
+
 # ---- 16-marker. the marker names ONE bucket and carries THAT bucket's reset ----------
 # A 100% session bucket (resets in an hour) beside a 100% Fable-only weekly bucket
 # (resets in five days) used to produce "bucket=session … resets_at=<+1h>" on line 2
@@ -2410,6 +3149,9 @@ EOF
   grep -q "ranking=BLIND" "$SD/selection.log" \
     && t_ok "selection.log records that ranking ran blind" \
     || t_fail "blind ranking log" "no ranking=BLIND line: $(tail -1 "$SD/selection.log")"
+  grep -qE "ranking=BLIND telemetry-age=[0-9]+s band=30 band-count=[0-9]+ session-gate=50 session-ok=0 pwd=" "$SD/selection.log" \
+    && t_ok "the blind line carries both cuts in the standard field order" \
+    || t_fail "blind line fields" "$(tail -1 "$SD/selection.log")"
   grep -q "telemetry-age=9[0-9]\{5\}s" "$SD/selection.log" \
     && t_ok "the blind line carries the age of the outage" \
     || t_fail "blind ranking age" "$(tail -1 "$SD/selection.log")"
@@ -2431,17 +3173,20 @@ EOF
   # ...and telemetry INSIDE the window must still rank. 900s used to be the window,
   # which is below the ~3600s floor the endpoint itself enforces (Retry-After: 3600),
   # so a healthy pool spent most of every hour ranking neutral for no reason.
-  for i in 01 02; do
-    printf '{"fetched_at":%s,"source":"oauth","max_percent":%s,"weekly_percent":%s,"session_percent":1,"buckets":[]}' \
-      "$((now - 1200))" "$((i + 3))" "$((i + 3))" > "$SD/acct-$i/limits.json"
-  done
+  # acct-02 is put OUTSIDE the 30-point band (weekly 40 against acct-01's 4) on purpose:
+  # inside the band the two are peers and the pick is a coin flip, which would make this
+  # assertion about the freshness window flaky for reasons that have nothing to do with it.
+  printf '{"fetched_at":%s,"source":"oauth","max_percent":4,"weekly_percent":4,"session_percent":1,"buckets":[]}' \
+    "$((now - 1200))" > "$SD/acct-01/limits.json"
+  printf '{"fetched_at":%s,"source":"oauth","max_percent":40,"weekly_percent":40,"session_percent":1,"buckets":[]}' \
+    "$((now - 1200))" > "$SD/acct-02/limits.json"
   : > "$SD/selection.log"
   CLAUDE_ACCOUNTS_ROOT="$SD" claude >/dev/null 2>&1
   ! grep -q "ranking=BLIND" "$SD/selection.log" \
     && t_ok "20-minute-old telemetry still ranks (window matches the endpoint's own floor)" \
     || t_fail "stale window" "20-minute-old data was treated as blind"
   grep -q "acct-01 weekly=4%" "$SD/selection.log" \
-    && t_ok "the pool ranks on real numbers and picks the account with more headroom" \
+    && t_ok "the pool ranks on real numbers and picks the account with more headroom (4% over 40%)" \
     || t_fail "headroom ranking" "$(tail -1 "$SD/selection.log")"
 
   # ---- blind does not mean neutral --------------------------------------------
@@ -2467,6 +3212,10 @@ EOF
   grep -q "ranking=DEGRADED" "$SD/selection.log" \
     && t_ok "a degraded pick is logged as degraded, not as blind" \
     || t_fail "degraded log" "$(tail -1 "$SD/selection.log")"
+  # Session is unknown in a degraded pool, so nobody clears the gate: session-ok=0.
+  grep -qE "ranking=DEGRADED telemetry-age=[0-9]+s band=30 band-count=[0-9]+ session-gate=50 session-ok=0 pwd=" "$SD/selection.log" \
+    && t_ok "the degraded line carries both cuts in the standard field order" \
+    || t_fail "degraded line fields" "$(tail -1 "$SD/selection.log")"
   grep -q "acct-02 weekly=4% .*ranking=DEGRADED" "$SD/selection.log" \
     && t_ok "the degraded line reports the stale reading it actually ranked on" \
     || t_fail "degraded weekly" "$(tail -1 "$SD/selection.log")"
@@ -2712,10 +3461,20 @@ RACER
   # threshold on its session bucket (max 91%). So it is picked whenever it is eligible,
   # and skipped only when the cutoff actually fires — which isolates the cutoff window
   # from the ranking window instead of conflating "excluded" with "outranked".
+  # BOTH sessions sit above the 50-point session gate (91 and 55) deliberately: with
+  # acct-02 inside the gate it would be the only gated candidate and win on the gate
+  # alone, and these assertions would then be measuring the gate instead of the cutoff
+  # window. Nobody clearing the gate makes it step aside, so weekly alone ranks here.
   mk_cutoff_pool() { # $1 = age of both readings, in seconds
+    # A FRESH clock, not the suite-wide $now captured at startup: the 800s case leaves
+    # only 100s of headroom inside the 900s cutoff window, and the suite takes longer
+    # than that to get here — under load (2026-09-04, parallel review agents) the reading
+    # aged past the window and the assertion flipped. Ages here must mean age AT THE
+    # SHIM'S OWN CLOCK, whenever this test happens to run.
+    local now; now="$(date -u +%s)"
     printf '{"fetched_at":%s,"weekly_percent":1,"session_percent":91,"max_percent":91,"weekly_resets_epoch":%s,"buckets":[]}' \
       "$((now - $1))" "$((now + 200000))" > "$SD/acct-01/limits.json"
-    printf '{"fetched_at":%s,"weekly_percent":50,"session_percent":5,"max_percent":50,"weekly_resets_epoch":%s,"buckets":[]}' \
+    printf '{"fetched_at":%s,"weekly_percent":50,"session_percent":55,"max_percent":55,"weekly_resets_epoch":%s,"buckets":[]}' \
       "$((now - $1))" "$((now + 200000))" > "$SD/acct-02/limits.json"
     : > "$SD/selection.log"
     rm -f "$SD/.last-pick"
@@ -2965,6 +3724,153 @@ else
   t_ok "sync validation tests skipped (Mac-only feature; server refuses sync by design)"
 fi
 
+# ---- 16d. every limits pass fans telemetry out to the manifest's peers ---------------
+# Why this has teeth (2026-09-04): the runner Macs mini-3..mini-8 hold only portable
+# setup tokens, and the usage endpoint refuses those for good (403, no user:profile), so
+# the ONLY telemetry they can ever rank on is the source machine's. limits_distribute
+# pushes limits.json + .limited to the manifest's `server` AND to every entry in `peers`
+# — nothing had ever proven the peer half, and it is the half that decides whether six
+# machines rank blind. Not Mac-gated like `sync`: a fake rsync on PATH records the argv
+# and the --files-from list (the caller deletes that list as soon as the last push
+# returns, so it is read at invocation time, not afterwards).
+DPOOL="$WORK/distribute-pool"
+mkdir -p "$DPOOL/acct-01" "$DPOOL/acct-02" "$DPOOL/tmp"
+: > "$DPOOL/.limits-kick"
+cat > "$DPOOL/accounts.json" <<'EOF'
+{"version":1,"server":"root@203.0.113.9","server_root":"/root/.claude-accounts",
+ "server_repo":"/root/claude-multiacc","threshold":90,
+ "peers":[
+   {"target":"gas@mini-3","root":"/Users/gas/.claude-accounts","repo":"/Users/gas/claude-multiacc"},
+   {"target":"gas@mini-4","root":"/Users/gas/.claude-accounts","repo":"/Users/gas/claude-multiacc"}],
+ "accounts":[
+   {"id":"acct-01","email":"dp1@test","home":"mac","added_at":"2026-07-13T00:00:00Z"},
+   {"id":"acct-02","email":"dp2@test","home":"mac","added_at":"2026-07-13T00:00:00Z"}]}
+EOF
+for i in 01 02; do
+  printf '{"claudeAiOauth":{"accessToken":"sk-ant-oat01-dp%s","refreshToken":"r","expiresAt":9999999999999,"refreshTokenExpiresAt":9999999999999}}' \
+    "$i" > "$DPOOL/acct-$i/.credentials.json"
+done
+# an exclusion marker rides along with the readings (this one survives a clean pass)
+printf '%s\nbucket=error-cooldown percent=? reason=error-cooldown\n' "$(( $(date +%s) + 600 ))" \
+  > "$DPOOL/acct-02/.limited"
+RSFAKE="$WORK/rsyncfake"
+export RSLOG="$WORK/rsync-push.log"
+mkdir -p "$RSFAKE"
+cat > "$RSFAKE/rsync" <<'EOF'
+#!/usr/bin/env bash
+printf 'RSYNC %s\n' "$*" >> "${RSLOG:?}"
+for a in "$@"; do
+  case "$a" in
+    --files-from=*)
+      while IFS= read -r l; do printf 'FILE %s\n' "$l" >> "$RSLOG"; done < "${a#--files-from=}" ;;
+  esac
+done
+exit 0
+EOF
+chmod +x "$RSFAKE/rsync"
+: > "$RSLOG"
+PATH="$RSFAKE:$PATH" CLAUDE_ACCOUNTS_ROOT="$DPOOL" \
+  CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-low.json" claude-accounts limits --force --quiet
+# The push is deliberately DETACHED — a sleeping peer must never delay the next refresh —
+# so wait for it instead of assuming it finished.
+waited=0
+while [ "$waited" -lt 50 ] && [ "$(grep -c '^RSYNC ' "$RSLOG" 2>/dev/null)" -lt 3 ]; do
+  sleep 0.2; waited=$((waited + 1))
+done
+# The pushes are serialized by a lock dir, so a slow peer can never stack them up. Let
+# it drain before the next case, or that case's push would be dropped, not made.
+dp_drain() {
+  local w=0
+  while [ "$w" -lt 50 ] && [ -d "$DPOOL/tmp/limits-push.lock" ]; do sleep 0.2; w=$((w + 1)); done
+}
+dp_drain
+n_push="$(grep -c '^RSYNC ' "$RSLOG" 2>/dev/null)"
+[ "$n_push" = "3" ] && t_ok "a limits pass pushes once per target (server + 2 peers)" \
+  || t_fail "limits distribute" "expected 3 rsync calls, saw $n_push: $(tr '\n' '|' < "$RSLOG")"
+grep -q "^RSYNC .*root@203.0.113.9:/root/.claude-accounts/" "$RSLOG" \
+  && t_ok "telemetry is pushed to the manifest server" \
+  || t_fail "limits distribute server" "$(grep '^RSYNC' "$RSLOG")"
+for peer in gas@mini-3 gas@mini-4; do
+  grep -q "^RSYNC .*$peer:/Users/gas/.claude-accounts/" "$RSLOG" \
+    && t_ok "telemetry is pushed to manifest peer $peer" \
+    || t_fail "limits distribute peer" "$peer never received a push: $(grep '^RSYNC' "$RSLOG")"
+done
+# ...and every target gets the SAME list: each account's reading, plus any marker.
+for f in "acct-01/limits.json" "acct-02/limits.json" "acct-02/.limited"; do
+  [ "$(grep -c "^FILE $f\$" "$RSLOG")" = "3" ] \
+    && t_ok "the pushed file list names $f for all three targets" \
+    || t_fail "limits distribute file list" "$f appears $(grep -c "^FILE $f\$" "$RSLOG")x, want 3"
+done
+
+# A REPLICA receives telemetry and must never push it back: two writers racing over one
+# pool is last-writer-wins chaos, and a manifest carrying `peers` is itself pushed TO the
+# replicas — so the role marker is a machine-local side file, checked before anything else.
+printf 'replica\n' > "$DPOOL/sync-role"
+: > "$RSLOG"
+PATH="$RSFAKE:$PATH" CLAUDE_ACCOUNTS_ROOT="$DPOOL" \
+  CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-low.json" claude-accounts limits --force --quiet
+sleep 1
+[ ! -s "$RSLOG" ] && t_ok "a replica pool never pushes telemetry (limits_distribute is a no-op)" \
+  || t_fail "replica distribute" "a replica pushed: $(tr '\n' '|' < "$RSLOG")"
+# only an EXACT 'replica' suppresses it — same anchor as sync
+printf 'not-replica\n' > "$DPOOL/sync-role"
+: > "$RSLOG"
+PATH="$RSFAKE:$PATH" CLAUDE_ACCOUNTS_ROOT="$DPOOL" \
+  CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-low.json" claude-accounts limits --force --quiet
+waited=0
+while [ "$waited" -lt 50 ] && [ "$(grep -c '^RSYNC ' "$RSLOG" 2>/dev/null)" -lt 3 ]; do
+  sleep 0.2; waited=$((waited + 1))
+done
+dp_drain
+[ "$(grep -c '^RSYNC ' "$RSLOG" 2>/dev/null)" = "3" ] \
+  && t_ok "only an exact 'replica' value suppresses the telemetry push" \
+  || t_fail "replica anchor (distribute)" "'not-replica' suppressed the push"
+rm -f "$DPOOL/sync-role"
+
+# ---- 16d-lock. a distribute lock is honored while it is alive, broken once it is not -
+# The push serializes on a lock DIRECTORY, and a detached push that is killed (logout,
+# reboot, pkill) never runs its EXIT trap. `mkdir "$lock" || return 0` can then never
+# succeed again: on the live pool one stranded lock stopped ALL telemetry distribution
+# from 2026-09-03 00:29 until it was removed by hand on 2026-09-04 — 32 hours in which
+# every peer ranked on whatever limits.json it happened to already have, which is the
+# blindness this push exists to prevent, and nothing anywhere said so. A push is seconds
+# of rsync under hard timeouts, so a lock older than ten minutes belongs to a process
+# that is gone.
+: > "$RSLOG"
+: > "$DPOOL/sync.log"
+rm -rf "$DPOOL/tmp/limits-push.lock"
+mkdir -p "$DPOOL/tmp/limits-push.lock"
+touch -t 202001010000 "$DPOOL/tmp/limits-push.lock"      # abandoned in 2020, not busy
+PATH="$RSFAKE:$PATH" CLAUDE_ACCOUNTS_ROOT="$DPOOL" \
+  CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-low.json" claude-accounts limits --force --quiet
+waited=0
+while [ "$waited" -lt 50 ] && [ "$(grep -c '^RSYNC ' "$RSLOG" 2>/dev/null)" -lt 3 ]; do
+  sleep 0.2; waited=$((waited + 1))
+done
+dp_drain
+[ "$(grep -c '^RSYNC ' "$RSLOG" 2>/dev/null)" = "3" ] \
+  && t_ok "a stale limits-push lock is broken and the pass distributes anyway" \
+  || t_fail "stale distribute lock" "expected 3 rsync calls, saw $(grep -c '^RSYNC ' "$RSLOG" 2>/dev/null)"
+grep -q "stale limits-push lock broken" "$DPOOL/sync.log" \
+  && t_ok "breaking the lock is recorded, so a recurrence is visible instead of silent" \
+  || t_fail "stale lock log" "sync.log: $(tail -3 "$DPOOL/sync.log" 2>/dev/null | tr '\n' '|')"
+[ ! -d "$DPOOL/tmp/limits-push.lock" ] \
+  && t_ok "the retaken lock is released at the end of the push, not leaked again" \
+  || t_fail "stale lock retake" "the lock dir is still present after the push"
+
+# ...and a lock that a LIVE push is holding is still absolute: two rsyncs racing into one
+# peer is exactly what the lock exists to stop, so a fresh one skips this pass entirely.
+: > "$RSLOG"
+mkdir -p "$DPOOL/tmp/limits-push.lock"                   # mtime = now: someone is pushing
+PATH="$RSFAKE:$PATH" CLAUDE_ACCOUNTS_ROOT="$DPOOL" \
+  CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-low.json" claude-accounts limits --force --quiet
+sleep 1
+{ [ ! -s "$RSLOG" ] && [ -d "$DPOOL/tmp/limits-push.lock" ]; } \
+  && t_ok "a fresh distribute lock is honored: no push, and the lock is left where it was" \
+  || t_fail "live distribute lock" "pushes=$(grep -c '^RSYNC ' "$RSLOG" 2>/dev/null) lock=$([ -d "$DPOOL/tmp/limits-push.lock" ] && echo held || echo REMOVED)"
+rm -rf "$DPOOL/tmp/limits-push.lock"
+unset RSLOG
+
 # API keys are never accepted as credentials (subscription-only requirement)
 printf 'sk-ant-api03-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' > "$WORK/apikey.txt"
 out="$(claude-accounts import apikey@test --id acct-11 --token-file "$WORK/apikey.txt" --no-sync 2>&1)"
@@ -3346,7 +4252,7 @@ check "codex: passthrough with CODEX_HOME" "CFG=other" "$out"
 out="$(CODEX_MULTIACC_DISABLE=1 codex 2>&1)"
 check "codex: passthrough when disabled" "CFG=none" "$out"
 
-# ---- C3. headroom selection --------------------------------------------------------
+# ---- C3. headroom selection: session gate first, then the WEEKLY headroom band ------
 cxlj() { printf '{"fetched_at":%s,"weekly_percent":%s,"session_percent":%s,"max_percent":%s,"buckets":[]}' "$now" "$1" "$2" "$3"; }
 cxlj 80 10 80 > "$CX/acct-01/limits.json"
 cxlj 20 10 20 > "$CX/acct-02/limits.json"
@@ -3377,15 +4283,118 @@ for _ in $(seq 1 10); do
 done
 [ "$all1" = 1 ] && t_ok "codex: headroom band 0 restores strict ranking" \
   || t_fail "codex zero headroom band" "the runner-up was selected"
-# high session must NOT beat better weekly headroom
+# THE KEY CASE, REVERSED on 2026-09-03, in parity with the claude shim (section 5):
+# the operator asked for "among accounts where high session limits it must choose
+# randomly from ones where highest weekly limits", so a nearly-spent 5h bucket is the
+# FIRST cut and the 30-point weekly band ranks only what clears the gate. acct-01:
+# session 85 (past the gate), weekly 10; acct-02: session 20, weekly 70 -> acct-02.
+cxlj 10 85 85 > "$CX/acct-01/limits.json"
+cxlj 70 20 70 > "$CX/acct-02/limits.json"
+all2=1
+for _ in $(seq 1 15); do
+  case "$(codex 2>&1)" in *CFG=acct-02*) ;; *) all2=0 ;; esac
+done
+[ "$all2" = "1" ] && t_ok "codex: a session bucket past the gate is skipped while a fresher one exists (70w/20s over 10w/85s)" \
+  || t_fail "codex session gate" "the account with its 5h bucket at 85% was still selected"
+: > "$CX/selection.log"
+codex >/dev/null 2>&1
+grep -qE 'acct-02 weekly=70% session=20% band=30 band-count=1 session-gate=50 session-ok=1 pwd=' "$CX/selection.log" \
+  && t_ok "codex: the selection log carries session-gate=50 session-ok=1 when one of two clears" \
+  || t_fail "codex session gate log" "$(tail -1 "$CX/selection.log")"
+# Both sessions inside the gate: it has nothing to say and weekly decides as before.
+cxlj 10 45 45 > "$CX/acct-01/limits.json"
+cxlj 70 20 70 > "$CX/acct-02/limits.json"
+all1=1
+for _ in $(seq 1 15); do
+  case "$(codex 2>&1)" in *CFG=acct-01*) ;; *) all1=0 ;; esac
+done
+[ "$all1" = "1" ] && t_ok "codex: with both sessions inside the gate weekly headroom decides (10w/45s over 70w/20s)" \
+  || t_fail "codex session gate no-op" "the gate changed a ranking where every candidate cleared it"
+# Nobody clears it: the gate compares, it never empties the pool — it steps aside.
+cxlj 10 85 85 > "$CX/acct-01/limits.json"
+cxlj 70 60 70 > "$CX/acct-02/limits.json"
+: > "$CX/selection.log"
+all1=1
+for _ in $(seq 1 15); do
+  case "$(codex 2>&1)" in *CFG=acct-01*) ;; *) all1=0 ;; esac
+done
+[ "$all1" = "1" ] && t_ok "codex: with nobody inside the gate it steps aside and weekly ranks (10w/85s over 70w/60s)" \
+  || t_fail "codex session gate step-aside" "an empty gate emptied the pool instead of stepping aside"
+grep -qE 'acct-01 weekly=10% session=85% band=30 band-count=1 session-gate=50 session-ok=0 pwd=' "$CX/selection.log" \
+  && t_ok "codex: the selection log carries session-ok=0 when the gate steps aside" \
+  || t_fail "codex session gate log" "$(tail -1 "$CX/selection.log")"
+# The gate is a knob, like the band: 100 turns it off; garbage falls back to 50.
 cxlj 10 85 85 > "$CX/acct-01/limits.json"
 cxlj 70 20 70 > "$CX/acct-02/limits.json"
 all1=1
+for _ in $(seq 1 15); do
+  case "$(CODEX_MULTIACC_SESSION_GATE=100 codex 2>&1)" in *CFG=acct-01*) ;; *) all1=0 ;; esac
+done
+[ "$all1" = "1" ] && t_ok "codex: CODEX_MULTIACC_SESSION_GATE=100 disables the gate" \
+  || t_fail "codex session gate off" "the gate still fired at 100"
+all2=1
+for _ in $(seq 1 15); do
+  case "$(CODEX_MULTIACC_SESSION_GATE=abc codex 2>&1)" in *CFG=acct-02*) ;; *) all2=0 ;; esac
+done
+[ "$all2" = "1" ] && t_ok "codex: a non-numeric CODEX_MULTIACC_SESSION_GATE falls back to 50" \
+  || t_fail "codex session gate validation" "a garbage gate value changed the outcome"
+# Equal weekly usage: the GATE decides, never a tiebreak — strict band or default 30.
+cxlj 40 20 40 > "$CX/acct-01/limits.json"
+cxlj 40 80 80 > "$CX/acct-02/limits.json"
+all1=1
+for _ in $(seq 1 15); do
+  case "$(CODEX_MULTIACC_HEADROOM_BAND=0 codex 2>&1)" in *CFG=acct-01*) ;; *) all1=0 ;; esac
+done
+[ "$all1" = "1" ] && t_ok "codex: strict mode: the session gate decides an exact weekly tie" \
+  || t_fail "codex session gate tie" "a weekly tie was not resolved by the session gate"
+all1=1
 for _ in $(seq 1 15); do
   case "$(codex 2>&1)" in *CFG=acct-01*) ;; *) all1=0 ;; esac
 done
-[ "$all1" = "1" ] && t_ok "codex: high session does NOT beat better weekly headroom" \
-  || t_fail "codex weekly-over-session" "ranked the account with less weekly headroom higher"
+[ "$all1" = "1" ] && t_ok "codex: the gate (not the band) removes the session-heavy half of a weekly tie" \
+  || t_fail "codex session gate tie" "the default band let the 80-point session account back in"
+
+# Inside the gate, session is NOT a tiebreaker any more: an exact weekly tie between two
+# gate-clearing accounts is a coin flip even in strict mode (it used to go to the lower
+# session, through the old weekly*1000+session score).
+cxlj 40 20 40 > "$CX/acct-01/limits.json"
+cxlj 40 45 45 > "$CX/acct-02/limits.json"
+hits1=0; hits2=0
+for _ in $(seq 1 20); do
+  case "$(CODEX_MULTIACC_HEADROOM_BAND=0 codex 2>&1)" in
+    *CFG=acct-01*) hits1=$((hits1+1)) ;;
+    *CFG=acct-02*) hits2=$((hits2+1)) ;;
+  esac
+done
+{ [ "$hits1" -gt 0 ] && [ "$hits2" -gt 0 ]; } \
+  && t_ok "codex: strict mode: session does not break an exact weekly tie inside the gate (acct-01=$hits1 acct-02=$hits2)" \
+  || t_fail "codex: session tiebreak removed" "acct-01=$hits1 acct-02=$hits2 (want both >0)"
+
+# Clearing the gate takes BOTH readings, as in pool-selection.v2: a fresh file with a
+# session reading but no weekly one must not become the sole gate-clearer and win the
+# all-gated tie over an account with a truthful weekly reading — not even with a
+# max_percent to fall back on (the shims used to rank on that; the policy never could).
+# (No writer produces such a file; this pins parity with lib/selector_policy.py.)
+printf '{"fetched_at":%s,"max_percent":10,"session_percent":10,"buckets":[]}' "$now" > "$CX/acct-01/limits.json"
+cxlj 20 80 80 > "$CX/acct-02/limits.json"
+all2=1
+for _ in $(seq 1 15); do
+  case "$(codex 2>&1)" in *CFG=acct-02*) ;; *) all2=0 ;; esac
+done
+[ "$all2" = "1" ] && t_ok "codex: a session reading without a weekly one never clears the gate" \
+  || t_fail "codex: gate needs both readings" "an unknown-weekly account beat a truthful weekly reading"
+
+# ...and the converse: a weekly reading without a session one is not "known" either — it
+# neither clears the gate nor ranks once the gate steps aside (10w/?s vs 70w/80s -> the
+# 70w account, as in pool-selection.v2, where quota_known needs both readings).
+printf '{"fetched_at":%s,"weekly_percent":10,"max_percent":10,"buckets":[]}' "$now" > "$CX/acct-01/limits.json"
+cxlj 70 80 80 > "$CX/acct-02/limits.json"
+all2=1
+for _ in $(seq 1 15); do
+  case "$(codex 2>&1)" in *CFG=acct-02*) ;; *) all2=0 ;; esac
+done
+[ "$all2" = "1" ] && t_ok "codex: a weekly reading without a session one is unknown to both cuts" \
+  || t_fail "codex: known needs both readings" "a session-less weekly reading ranked as known"
 # equal scores spread load
 cxlj 10 10 10 > "$CX/acct-01/limits.json"
 cxlj 10 10 10 > "$CX/acct-02/limits.json"
@@ -3652,17 +4661,65 @@ c_n="$(printf '%s' "$c_distinct" | wc -w | tr -d ' ')"
 rm -rf "$CX/acct-09"
 rm -f "$CX/.last-pick"
 
-# ---- C6. all limited -> least-utilized fallback -------------------------------------
+# ---- C6. all limited -> the still-serving accounts go through the same two cuts, strict weekly --
 printf '%s\nbucket=7d percent=95 reason=limits\n' "$((now+3600))" > "$CX/acct-01/.limited"
 printf '%s\nbucket=7d percent=99 reason=limits\n' "$((now+3600))" > "$CX/acct-02/.limited"
 cxlj 95 10 95 > "$CX/acct-01/limits.json"
 cxlj 99 10 99 > "$CX/acct-02/limits.json"
 out="$(codex 2>&1)"
-check "codex: all-limited falls back to least utilized" "CFG=acct-01" "$out"
+check "codex: all-limited falls back to the still-serving account with the most weekly headroom" "CFG=acct-01" "$out"
 grep -q "all-limited fallback=acct-01" "$CX/selection.log" \
   && t_ok "codex: all-limited fallback logged" || t_fail "codex fallback log" "no all-limited line"
 rm -f "$CX"/acct-*/.limited "$CX"/acct-*/limits.json
 
+# The fallback applies the SAME two cuts (parity with the claude shim, section 9): an
+# account past the session gate yields to one inside it even with far better weekly.
+printf '%s\nbucket=7d percent=95 reason=limits\n' "$((now+3600))" > "$CX/acct-01/.limited"
+printf '%s\nbucket=7d percent=95 reason=limits\n' "$((now+3600))" > "$CX/acct-02/.limited"
+cxlj 10 85 85 > "$CX/acct-01/limits.json"
+cxlj 70 20 70 > "$CX/acct-02/limits.json"
+all2=1
+for _ in $(seq 1 12); do
+  case "$(codex 2>&1)" in *CFG=acct-02*) ;; *) all2=0 ;; esac
+done
+[ "$all2" = "1" ] && t_ok "codex: the all-limited fallback applies the session gate before strict weekly (70w/20s over 10w/85s)" \
+  || t_fail "codex fallback session gate" "the fallback handed out the account past the session gate"
+grep -q "all-limited fallback=acct-02 weekly=70%" "$CX/selection.log" \
+  && t_ok "codex: the fallback line names the gated pick" || t_fail "codex fallback gate log" "$(tail -1 "$CX/selection.log")"
+rm -f "$CX"/acct-*/.limited "$CX"/acct-*/limits.json
+
+# ---- C6b. the fallback tells "still serving" from "rejected right now" ----------------
+# Ported from the claude shim (2026-08-29) when the session gate reached the fallback.
+# acct-01: 7d window at 99% — worse headroom, but still answering. acct-02: 5h window at
+# 100% — far better weekly (7%), but every request bounces until the reset.
+printf '%s\nbucket=7d percent=99 marked_at=x reason=limits\n' "$((now+3600))" > "$CX/acct-01/.limited"
+printf '%s\nbucket=5h percent=100 marked_at=x reason=limits\n' "$((now+600))" > "$CX/acct-02/.limited"
+cxlj 99 10 99 > "$CX/acct-01/limits.json"
+cxlj 7 100 100 > "$CX/acct-02/limits.json"
+out="$(codex 2>&1)"
+check "codex: a still-serving limited account beats an exhausted one with more headroom" "CFG=acct-01" "$out"
+# The codex-review case (2026-09-04): the exhausted account is the only one INSIDE the
+# session gate; the gate must not resurrect it over a still-serving account outside it.
+printf '%s\nbucket=7d percent=100 marked_at=x reason=limits\n' "$((now+3600))" > "$CX/acct-01/.limited"
+printf '%s\nbucket=7d percent=95 marked_at=x reason=limits\n' "$((now+3600))" > "$CX/acct-02/.limited"
+cxlj 100 20 100 > "$CX/acct-01/limits.json"
+cxlj 95 85 95 > "$CX/acct-02/limits.json"
+out="$(codex 2>&1)"
+check "codex: an exhausted account inside the gate never beats a still-serving one outside it" "CFG=acct-02" "$out"
+# A real client rejection (a 429 the server sent) is exhausted whatever percent says.
+printf '%s\nbucket=client:5h percent=95 marked_at=x reason=client-rate-limit\n' "$((now+600))" > "$CX/acct-01/.limited"
+cxlj 95 10 95 > "$CX/acct-01/limits.json"
+out="$(codex 2>&1)"
+check "codex: a client-rejected account is not the fallback while another still serves" "CFG=acct-02" "$out"
+# Every account exhausted RIGHT NOW: hand out the one that unblocks first.
+printf '%s\nbucket=5h percent=100 marked_at=x reason=limits\n' "$((now+7200))" > "$CX/acct-01/.limited"
+printf '%s\nbucket=5h percent=100 marked_at=x reason=limits\n' "$((now+600))" > "$CX/acct-02/.limited"
+out="$(codex 2>&1)"
+check "codex: all exhausted: the soonest reset is handed out" "CFG=acct-02" "$out"
+grep -q "all-exhausted resets_in=" "$CX/selection.log" \
+  && t_ok "codex: the all-exhausted pick is logged with its reset" || t_fail "codex all-exhausted log" "no line"
+rm -f "$CX"/acct-*/.limited "$CX"/acct-*/limits.json
+
 # ---- C7. dead logins: .expired excludes, heals on newer credential ------------------
 printf '%s\nreason=refresh-denied-http-400 marked_at=t detail=x\n' "$now" > "$CX/acct-01/.expired"
 all2=1
@@ -3682,6 +4739,9 @@ mk_cx_auth "$CX/acct-01/auth.json" a@cx "$FUTURE_EXP"
 out="$(CODEX_SHIM_SELECT=random codex 2>&1)"
 [ ! -f "$CX/acct-01/.expired" ] && t_ok "codex: newer auth.json clears a credential park" \
   || t_fail "codex park heal" ".expired survived a newer credential"
+grep -qE 'band=30 band-count=[0-9]+ session-gate=off session-ok=[0-9]+ pwd=' "$CX/selection.log" \
+  && t_ok "codex: random mode logs session-gate=off instead of a cut it never made" \
+  || t_fail "codex random mode gate log" "$(tail -1 "$CX/selection.log")"
 # an org-blocked park survives a newer credential (policy, not credential)
 printf '%s\nreason=org-blocked marked_at=t detail=x\n' "$now" > "$CX/acct-01/.expired"
 sleep 1
@@ -4095,6 +5155,417 @@ out="$(CODEX_MULTIACC_USAGE_URL="file://$WORK/cx-usage-low.json" codex-accounts
 check "codex: 429 backoff honored" "acct-02: backing off after 429" "$out"
 rm -f "$CX"/acct-*/limits.json
 
+# ---- C13b. codex parity: a 0% window with NO reported reset is NO DATA ---------------
+# The claude pool's 2026-09-04 incident (acct-13/acct-14 served every bucket
+# `percent: 0, resets_at: null`, ranked as the emptiest accounts in the fleet, handed
+# 31 of the last ~60 picks while the client was being rejected on them at their weekly
+# limit) is a payload failure, not a claude-specific one — this writer must refuse the
+# same way. Codex's usage payload carries reset_at INSIDE each window, and this writer
+# formats resets_at itself, so "the payload reported a window" is the distinction.
+CD="$WORK/cx-nodata-pool"
+mkdir -p "$CD/acct-01" "$CD/acct-02" "$CD/tmp"
+: > "$CD/.limits-kick"
+cat > "$CD/accounts.json" <<'EOF'
+{"version":1,"server":"none","threshold":90,"accounts":[
+  {"id":"acct-01","email":"nd1@cx","home":"mac","added_at":"2026-08-21T00:00:00Z"},
+  {"id":"acct-02","email":"nd2@cx","home":"mac","added_at":"2026-08-21T00:00:00Z"}]}
+EOF
+mk_cx_auth "$CD/acct-01/auth.json" nd1@cx "$FUTURE_EXP"
+mk_cx_auth "$CD/acct-02/auth.json" nd2@cx "$FUTURE_EXP"
+cdl() { # cdl <weekly> <session> <max> -> a truthful, in-window reading on stdout
+  printf '{"fetched_at":%s,"source":"chatgpt","weekly_percent":%s,"session_percent":%s,"max_percent":%s,"plan":"pro","buckets":[]}' \
+    "$(date +%s)" "$1" "$2" "$3"
+}
+cdlimits() { # cdlimits <fixture> [extra args] -> a real refresh over the whole CD pool
+  local f="$1"; shift
+  CODEX_ACCOUNTS_ROOT="$CD" CODEX_MULTIACC_USAGE_URL="file://$f" \
+    codex-accounts limits --force "$@" 2>&1
+}
+
+# every window 0% with no reset_at at all: nothing here says anything
+cat > "$WORK/cx-usage-allzero.json" <<'EOF'
+{"email":"nd@cx","plan_type":"pro",
+ "rate_limit":{"allowed":true,"limit_reached":false,
+   "primary_window":{"used_percent":0,"limit_window_seconds":18000},
+   "secondary_window":{"used_percent":0,"limit_window_seconds":604800}},
+ "additional_rate_limits":[]}
+EOF
+out="$(cdlimits "$WORK/cx-usage-allzero.json")"
+check "codex: an all-zero/no-window payload is reported as no usable telemetry" \
+  "no usable telemetry (account ranks as unknown, not as empty)" "$out"
+python3 - "$CD/acct-01/limits.json" <<'EOF'
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert d.get('no_data') is True, d
+for k in ('max_percent', 'weekly_percent', 'session_percent'):
+    assert k not in d, (k, d)
+assert len(d['buckets']) == 2 and d['plan'] == 'pro', d      # diagnostics survive
+# the writer's internal "did the payload report this window" flag never reaches disk
+for b in d['buckets']:
+    assert '_reset_known' not in b, b
+EOF
+[ $? -eq 0 ] && t_ok "codex: a no-data pass records no_data and none of the percent signals" \
+  || t_fail "codex no_data document" "see $CD/acct-01/limits.json"
+
+# one silent model window beside real ones changes nothing
+cat > "$WORK/cx-usage-mixed-nodata.json" <<EOF
+{"email":"nd@cx","plan_type":"pro",
+ "rate_limit":{"allowed":true,"limit_reached":false,
+   "primary_window":{"used_percent":5,"limit_window_seconds":18000,"reset_at":$((now+3600))},
+   "secondary_window":{"used_percent":9,"limit_window_seconds":604800,"reset_at":$((now+90000))}},
+ "additional_rate_limits":[
+   {"limit_name":"GPT-5.3-Codex-Spark","rate_limit":{"allowed":true,"limit_reached":false,
+     "primary_window":{"used_percent":0,"limit_window_seconds":18000},
+     "secondary_window":{"used_percent":0,"limit_window_seconds":604800}}}]}
+EOF
+cdlimits "$WORK/cx-usage-mixed-nodata.json" --quiet >/dev/null
+python3 - "$CD/acct-01/limits.json" <<'EOF'
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert 'no_data' not in d, d
+assert (d['session_percent'], d['weekly_percent'], d['max_percent']) == (5, 9, 9), d
+assert len(d['buckets']) == 4, d          # the two silent model windows are still recorded
+EOF
+[ $? -eq 0 ] && t_ok "codex: one silent model window beside real ones leaves the ranking untouched (5/9)" \
+  || t_fail "codex mixed no-data payload" "see $CD/acct-01/limits.json"
+
+# 0% WITH reported resets is a real, empty reading
+cat > "$WORK/cx-usage-zero-real-windows.json" <<EOF
+{"email":"nd@cx","plan_type":"pro",
+ "rate_limit":{"allowed":true,"limit_reached":false,
+   "primary_window":{"used_percent":0,"limit_window_seconds":18000,"reset_at":$((now+3600))},
+   "secondary_window":{"used_percent":0,"limit_window_seconds":604800,"reset_at":$((now+90000))}},
+ "additional_rate_limits":[]}
+EOF
+cdlimits "$WORK/cx-usage-zero-real-windows.json" --quiet >/dev/null
+python3 - "$CD/acct-01/limits.json" <<'EOF'
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert 'no_data' not in d, d
+assert (d['session_percent'], d['weekly_percent'], d['max_percent']) == (0, 0, 0), d
+EOF
+[ $? -eq 0 ] && t_ok "codex: 0% WITH reported reset windows still records a real, empty reading" \
+  || t_fail "codex zero-with-windows payload" "see $CD/acct-01/limits.json"
+
+# ...and an unknown account loses to any account with a real reading
+cdlimits "$WORK/cx-usage-allzero.json" --quiet >/dev/null
+cdl 45 10 45 > "$CD/acct-02/limits.json"
+rm -f "$CD/.pick-seq" "$CD"/acct-0*/.last-pick "$CD"/acct-0*/.limited
+: > "$CD/selection.log"
+cd_hits=0
+for _ in $(seq 1 10); do
+  case "$(CODEX_ACCOUNTS_ROOT="$CD" codex 2>&1)" in *CFG=acct-01*) cd_hits=$((cd_hits+1)) ;; esac
+done
+[ "$cd_hits" = "0" ] \
+  && t_ok "codex: a no-data account never outranks one with real telemetry (0 of 10 picks)" \
+  || t_fail "codex no_data ranking" "the fake-zero account took $cd_hits of 10 picks"
+grep -q "acct-02 weekly=45% session=10% band=30 band-count=1" "$CD/selection.log" \
+  && t_ok "codex: the pick logs the known account alone in the band" \
+  || t_fail "codex no_data band" "selection.log: $(tail -1 "$CD/selection.log" 2>/dev/null)"
+
+# ---- C13c. codex parity: ONE marker rule, driven through the REAL rollout path -------
+# The codex shim has no telemetry-based clearing path at all (a marker leaves it only
+# when its own reset epoch passes), so the whole rule lives in `codex-accounts limits`.
+# Until 2026-09-04 that writer kept EVERY active client marker unconditionally, which
+# looks safe and is half wrong in each direction: a 7d rejection was safe by accident
+# rather than by rule, and a 5h rejection — a window that refills within hours — parked
+# the account until its own epoch, the exact stranding #22 (2026-09-03) had to fix on the
+# claude side.
+#
+# These cases no longer HAND the writer a marker. bin/codex writes it, from a rollout
+# transcript, the way a rejected run does — because the rule the writer applies reads a
+# token the SHIM chooses, and testing it on a hand-written marker tests a vocabulary the
+# product never produces. That is exactly what went wrong once already: the guard matched
+# seven_day/7d/weekly while the scan labelled markers `client:primary`/`client:secondary`
+# after the rollout's own rate_limits KEY names, which map to no fixed window at all
+# (live payloads report `primary` as the 10080-minute one). Weekly protection was a no-op
+# on this provider, and four green assertions said otherwise. The label is now derived
+# from the record's own `window_minutes` at write time, and these tests drive that
+# derivation end to end: rollout -> shim -> marker -> limits pass -> selection.
+# A third, healthy account: with only two, "everything was parked so the pool fell back"
+# and "the freed account was chosen" produce the same log line.
+mkdir -p "$CD/acct-03"
+mk_cx_auth "$CD/acct-03/auth.json" nd3@cx "$FUTURE_EXP"
+python3 - "$CD/accounts.json" <<'EOF'
+import json, sys
+d = json.load(open(sys.argv[1]))
+if not any(a['id'] == 'acct-03' for a in d['accounts']):
+    d['accounts'].append({"id": "acct-03", "email": "nd3@cx", "home": "mac",
+                          "added_at": "2026-08-21T00:00:00Z"})
+json.dump(d, open(sys.argv[1], 'w'))
+EOF
+cx_mark() { # cx_mark <acct dir> <bucket> <reset-offset-seconds> <marked_at ISO>
+  printf '%s\nbucket=%s percent=100 marked_at=%s reason=client-rate-limit\n' \
+    "$(( $(date +%s) + $3 ))" "$2" "$4" > "$1/.limited"
+}
+cx_rollout() { # cx_rollout <acct dir> <used_percent> <resets_at epoch> <window_minutes|-> <record ISO>
+  # One rollout, shaped like the real transcript: the codex CLI writes the windows the
+  # server reported into every run's JSONL, and client_limit_scan reads the newest tail.
+  # window_minutes rides in the SAME fragment as used_percent/resets_at — which is why
+  # the shim can label the marker with the window that was actually spent.
+  local day="$1/sessions/2026/09/04" f win=""
+  rm -rf "$1/sessions"
+  mkdir -p "$day"
+  f="$day/rollout-2026-09-04T01-43-21-c13c0001-7fc3-7291-a0fc-7b4e2b035f1a.jsonl"
+  [ "$4" = "-" ] || win="\"window_minutes\":$4,"
+  {
+    printf '{"timestamp":"%s","type":"session_meta","payload":{"session_id":"c13c0001","cwd":"/proj"}}\n' "$5"
+    printf '{"timestamp":"%s","type":"event_msg","payload":{"type":"token_count","info":{"model_context_window":258400},"rate_limits":{"limit_id":"codex","limit_name":null,"primary":{"used_percent":%s,%s"resets_at":%s},"secondary":null,"credits":{"has_credits":false,"unlimited":false}}}}\n' \
+      "$5" "$2" "$win" "$3"
+  } > "$f"
+  rm -f "$1/.client-scan"
+}
+cx_bucket() { # the bucket token on line 2 of <acct dir>/.limited, or '<none>'
+  local b=""
+  [ -f "$1/.limited" ] && b="$(sed -n '2s/.*bucket=\([^ ]*\).*/\1/p' "$1/.limited" 2>/dev/null)"
+  printf '%s\n' "${b:-<none>}"
+}
+cdlimits0() { # cdlimits with the confirm delay OFF — a marker kept by this pass is kept
+              # by RULE, never merely because the rejection is seconds old. (Real markers
+              # are written by the shim moments before, so there is no "aged" marker to
+              # fabricate; the delay is pinned separately below.)
+  local f="$1"; shift
+  CODEX_ACCOUNTS_ROOT="$CD" CODEX_MULTIACC_USAGE_URL="file://$f" \
+    CODEX_MULTIACC_CLIENT_LIMIT_CONFIRM_DELAY=0 codex-accounts limits --force "$@" 2>&1
+}
+cx_shim() { CODEX_ACCOUNTS_ROOT="$CD" codex >/dev/null 2>&1; }
+rm -f "$CD"/acct-0*/.limited "$CD"/acct-0*/.client-limit-cleared "$CD"/acct-0*/.client-scan
+rm -rf "$CD"/acct-0*/sessions
+cx_now="$(date +%s)"
+cx_wreset=$((cx_now + 345600))          # four days out: a weekly window, still open
+cx_sreset=$((cx_now + 1800))            # half an hour out: a five-hour window
+# A record STAMPED BEFORE any clear: the watermark tests below turn on this timestamp,
+# and a rollout the writer's clear did not supersede would prove nothing about it.
+cx_ts_old="$(python3 -c 'import time; print(time.strftime("%Y-%m-%dT%H:%M:%S.120Z", time.gmtime(time.time() - 600)))')"
+
+# (1) The marker names the WINDOW the server spent, not the key the payload happened to
+# use. 10080 minutes is the weekly bucket however the rollout labels it.
+cx_rollout "$CD/acct-01" "97.4" "$cx_wreset" 10080 "$cx_ts_old"
+: > "$CD/selection.log"
+cx_shim
+{ [ "$(cx_bucket "$CD/acct-01")" = "client:7d" ] \
+  && grep -q "acct-01 LIMITED by its own run (7d:97, resets $cx_wreset) — client-reported" \
+       "$CD/selection.log"; } \
+  && t_ok "codex: a 10080-minute rejection is marked client:7d, not after the rollout's key name" \
+  || t_fail "codex weekly marker label" \
+     "bucket=$(cx_bucket "$CD/acct-01") log: $(tail -1 "$CD/selection.log" 2>/dev/null)"
+
+# (2) ...and THAT is the token the writer's weekly guard reads. An informative pass with
+# real numbers far under the threshold, and the confirm delay switched off so nothing but
+# the bucket rule can be keeping it: the marker has to survive the pass AND the next
+# launch, because a weekly window cannot fall from the server-proven 97% that wrote it to
+# 9% while it is still open.
+out="$(cdlimits0 "$WORK/cx-usage-low.json")"
+cx_shim
+{ [ "$(cx_bucket "$CD/acct-01")" = "client:7d" ] \
+  && [ ! -f "$CD/acct-01/.client-limit-cleared" ] \
+  && ! printf '%s' "$out" | grep -q "acct-01: marker cleared"; } \
+  && t_ok "codex: the client:7d marker outlives an informative 9% pass and the launch after it" \
+  || t_fail "codex weekly marker vs informative pass" \
+     "bucket=$(cx_bucket "$CD/acct-01") log: $(printf '%s' "$out" | grep acct-01 | tr '\n' ' ')"
+
+# (3) A pass that reported nothing proves nothing, and has to SAY so — or a 32-hour
+# telemetry stall reads exactly like a healthy pool.
+out="$(cdlimits0 "$WORK/cx-usage-allzero.json")"
+{ [ "$(cx_bucket "$CD/acct-01")" = "client:7d" ] \
+  && printf '%s' "$out" | grep -q "acct-01: marker kept (no usable telemetry)"; } \
+  && t_ok "codex: a no-data pass keeps the client:7d marker, and logs that it kept it" \
+  || t_fail "codex weekly marker vs no-data pass" \
+     "bucket=$(cx_bucket "$CD/acct-01") log: $(printf '%s' "$out" | grep acct-01 | tr '\n' ' ')"
+
+# (4) The differential, from the same code path with one number changed: 300 minutes is
+# the self-healing session window, so the identical rejection on acct-02 is labelled
+# client:5h and DOES clear on an informative pass — the #22 (2026-09-03) behavior, which
+# over-correcting (2) into "no client marker ever clears" would have destroyed.
+cx_rollout "$CD/acct-02" "99.0" "$cx_sreset" 300 "$cx_ts_old"
+cx_shim
+cx_5h_bucket="$(cx_bucket "$CD/acct-02")"
+out="$(cdlimits0 "$WORK/cx-usage-low.json")"
+{ [ "$cx_5h_bucket" = "client:5h" ] && [ ! -f "$CD/acct-02/.limited" ] \
+  && printf '%s' "$out" | grep -q "acct-02: marker cleared (max 9%)" \
+  && [ "$(cx_bucket "$CD/acct-01")" = "client:7d" ]; } \
+  && t_ok "codex: a 300-minute rejection is marked client:5h and clears, beside a 7d one that does not" \
+  || t_fail "codex 5h vs 7d marker rule" \
+     "5h-marked=$cx_5h_bucket 5h-now=$(cx_bucket "$CD/acct-02") 7d=$(cx_bucket "$CD/acct-01") log: $(printf '%s' "$out" | grep 'marker' | tr '\n' ' ')"
+
+# (5) ...and it STAYS cleared. The rollout that reported the spent window is still on
+# disk and the scan re-reads its tail on every launch, so without the `.client-limit-
+# cleared` watermark the clear achieves nothing: the very next `codex` rewrites the same
+# park, once per 15-minute pass, forever. Two launches, because the first would already
+# have re-marked.
+{ [ -f "$CD/acct-02/.client-limit-cleared" ] && { cx_shim; cx_shim; true; } \
+  && [ ! -f "$CD/acct-02/.limited" ]; } \
+  && t_ok "codex: the cleared 5h marker is not re-written from the same rollout (watermark)" \
+  || t_fail "codex client-limit watermark" \
+     "watermark=$([ -f "$CD/acct-02/.client-limit-cleared" ] && echo yes || echo MISSING) bucket=$(cx_bucket "$CD/acct-02")"
+
+# (6) That decision reaches selection: the weekly-parked account stays out while the
+# freed one comes back and takes every pick (acct-03 sits 36 points outside the band, so
+# "acct-02 is eligible again" is the only thing that can produce this).
+cdl 9 5 9 > "$CD/acct-02/limits.json"
+cdl 45 10 45 > "$CD/acct-03/limits.json"
+rm -f "$CD/.pick-seq" "$CD"/acct-0*/.last-pick
+: > "$CD/selection.log"
+cw_hits=0; cw2_hits=0
+for _ in $(seq 1 6); do
+  case "$(CODEX_ACCOUNTS_ROOT="$CD" codex 2>&1)" in
+    *CFG=acct-01*) cw_hits=$((cw_hits+1)) ;;
+    *CFG=acct-02*) cw2_hits=$((cw2_hits+1)) ;;
+  esac
+done
+{ [ "$cw_hits" = "0" ] && [ "$cw2_hits" = "6" ] \
+  && [ "$(cx_bucket "$CD/acct-01")" = "client:7d" ]; } \
+  && t_ok "codex: the weekly rejection keeps its account out while the cleared 5h one returns (0 vs 6 of 6)" \
+  || t_fail "codex marker selection" \
+     "acct-01=$cw_hits acct-02=$cw2_hits of 6; 7d marker=$(cx_bucket "$CD/acct-01")"
+
+# (7) The watermark is a brake, not a mute: a rejection recorded AFTER the clear is news,
+# and parks the account again. (Stamped five seconds past the watermark the writer
+# actually wrote, so this cannot pass by clock luck.)
+cx_wm="$(head -1 "$CD/acct-02/.client-limit-cleared" 2>/dev/null)"
+cx_ts_new="$(python3 -c 'import sys, time; print(time.strftime("%Y-%m-%dT%H:%M:%S.120Z", time.gmtime(int(sys.argv[1]) + 5)))' "${cx_wm:-$cx_now}")"
+cx_rollout "$CD/acct-02" "96.0" "$cx_sreset" 300 "$cx_ts_new"
+cx_shim
+{ [ "$(cx_bucket "$CD/acct-02")" = "client:5h" ] \
+  && grep -q 'percent=96' "$CD/acct-02/.limited"; } \
+  && t_ok "codex: a rejection recorded after the clear parks the account again (a brake, not a mute)" \
+  || t_fail "codex watermark is not a mute" \
+     "bucket=$(cx_bucket "$CD/acct-02") line: $(sed -n 2p "$CD/acct-02/.limited" 2>/dev/null)"
+
+# (8) A report that names no window at all keeps the raw key name — unknown window stays
+# CLEARABLE, the #22 fail-open direction, and its own reset epoch still bounds it. It
+# must clear on an informative pass and stay cleared like any other 5h-class marker.
+rm -f "$CD/acct-03/.limited" "$CD/acct-03/.client-limit-cleared"
+cx_rollout "$CD/acct-03" "97.0" "$cx_sreset" - "$cx_ts_old"
+cx_shim
+cx_nw_bucket="$(cx_bucket "$CD/acct-03")"
+cdlimits0 "$WORK/cx-usage-low.json" --quiet >/dev/null
+cx_shim
+{ [ "$cx_nw_bucket" = "client:primary" ] && [ ! -f "$CD/acct-03/.limited" ] \
+  && [ -f "$CD/acct-03/.client-limit-cleared" ]; } \
+  && t_ok "codex: a report with no window_minutes keeps the raw key name and stays clearable" \
+  || t_fail "codex windowless marker" \
+     "marked=$cx_nw_bucket now=$(cx_bucket "$CD/acct-03") watermark=$([ -f "$CD/acct-03/.client-limit-cleared" ] && echo yes || echo no)"
+
+# (9) The same holds for a marker written by an OLDER version and still on disk: it names
+# `primary`/`secondary`, which is no window, so it keeps its pre-2026-09-04 clearable
+# behavior rather than being promoted to a weekly park by accident. (Passes on the
+# pre-fix tree too — deliberately: it is the guard against reading the new guard as
+# "anything ambiguous sticks".)
+rm -rf "$CD/acct-03/sessions"
+rm -f "$CD/acct-03/.client-limit-cleared"
+cx_mark "$CD/acct-03" client:secondary 345600 2020-01-01T00:00:00Z
+cdlimits0 "$WORK/cx-usage-low.json" --quiet >/dev/null
+[ ! -f "$CD/acct-03/.limited" ] \
+  && t_ok "codex: a legacy client:secondary marker (no window in its name) is still clearable" \
+  || t_fail "codex legacy marker" "bucket=$(cx_bucket "$CD/acct-03") survived an informative pass"
+
+# (10) The confirm delay, which is what stops a cached usage response from erasing a
+# rejection the client was handed seconds ago. The shim writes marked_at=NOW, so the
+# marker below is genuinely fresh: the default 300s must keep it, and the same pass with
+# the window closed clears it — same env var, clamp and semantics as the claude writer.
+rm -f "$CD/acct-02/.limited" "$CD/acct-02/.client-limit-cleared"
+cx_rollout "$CD/acct-02" "99.0" "$cx_sreset" 300 "$cx_ts_old"
+cx_shim
+out="$(cdlimits "$WORK/cx-usage-low.json")"
+{ [ "$(cx_bucket "$CD/acct-02")" = "client:5h" ] \
+  && ! printf '%s' "$out" | grep -q "acct-02: marker cleared"; } \
+  && t_ok "codex: the default 300s confirm delay keeps a rejection handed over seconds ago" \
+  || t_fail "codex confirm delay" \
+     "bucket=$(cx_bucket "$CD/acct-02") log: $(printf '%s' "$out" | grep acct-02 | tr '\n' ' ')"
+out="$(cdlimits0 "$WORK/cx-usage-low.json")"
+{ [ ! -f "$CD/acct-02/.limited" ] \
+  && printf '%s' "$out" | grep -q "acct-02: marker cleared (max 9%)"; } \
+  && t_ok "codex: past the confirm delay the same 5h rejection clears on a real reading" \
+  || t_fail "codex confirm delay expiry" \
+     "bucket=$(cx_bucket "$CD/acct-02") log: $(printf '%s' "$out" | grep acct-02 | tr '\n' ' ')"
+
+# (11) error-cooldown is untouched by all of the above: the account failed a real call
+# moments ago, and no usage reading disproves that. (This one holds on origin/main too —
+# it is the guard against the rewritten branch quietly dropping a case.)
+rm -rf "$CD"/acct-0*/sessions
+printf '%s\nbucket=error-cooldown percent=? reason=error-cooldown\n' "$(( $(date +%s) + 600 ))" \
+  > "$CD/acct-01/.limited"
+cdlimits "$WORK/cx-usage-low.json" --quiet >/dev/null
+[ -f "$CD/acct-01/.limited" ] \
+  && t_ok "codex: an error-cooldown marker still survives an informative clean pass" \
+  || t_fail "codex cooldown vs limits" "the cooldown marker was cleared"
+rm -f "$CD"/acct-0*/.limited "$CD"/acct-0*/.client-limit-cleared "$CD"/acct-0*/.client-scan
+rm -rf "$CD"/acct-0*/sessions
+
+# ---- C13d. codex parity: each ranking signal comes from a window of its OWN kind -----
+# The claude writer's second 2026-09-04 defect, mirrored here: weekly_percent fell back
+# to the overall peak and session_percent to a flat 0, so a payload where only the 5h
+# window said anything was recorded as a WEEKLY reading, and one where only the 7d window
+# spoke walked through the session gate on a zero nobody reported. A signal no window
+# reported must be ABSENT — the shim needs both readings to call an account known.
+cat > "$WORK/cx-usage-session-only.json" <<EOF
+{"email":"nd@cx","plan_type":"pro",
+ "rate_limit":{"allowed":true,"limit_reached":false,
+   "primary_window":{"used_percent":40,"limit_window_seconds":18000,"reset_at":$((now+3600))},
+   "secondary_window":{"used_percent":0,"limit_window_seconds":604800}},
+ "additional_rate_limits":[]}
+EOF
+cdlimits "$WORK/cx-usage-session-only.json" --quiet >/dev/null
+python3 - "$CD/acct-01/limits.json" <<'EOF'
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert 'no_data' not in d, d                     # one window DID report: this is a reading
+assert (d['session_percent'], d['max_percent']) == (40, 40), d
+# The 7d window reported no reset_at and 0%. Recording 40 here (the overall peak) or 0
+# (max over a silent window) both invent the number the weekly band ranks on.
+assert 'weekly_percent' not in d, d
+EOF
+[ $? -eq 0 ] && t_ok "codex: a session-only reading records session+max and NO weekly_percent" \
+  || t_fail "codex session-only signals" "see $CD/acct-01/limits.json"
+cdl 30 10 30 > "$CD/acct-02/limits.json"
+cdl 30 10 30 > "$CD/acct-03/limits.json"
+rm -f "$CD/.pick-seq" "$CD"/acct-0*/.last-pick "$CD"/acct-0*/.limited
+: > "$CD/selection.log"
+cs_hits=0
+for _ in $(seq 1 10); do
+  case "$(CODEX_ACCOUNTS_ROOT="$CD" codex 2>&1)" in *CFG=acct-01*) cs_hits=$((cs_hits+1)) ;; esac
+done
+[ "$cs_hits" = "0" ] \
+  && t_ok "codex: an account with no weekly reading never enters the band (0 of 10 picks)" \
+  || t_fail "codex session-only ranking" "the weekly-less account took $cs_hits of 10 picks"
+
+cat > "$WORK/cx-usage-weekly-only.json" <<EOF
+{"email":"nd@cx","plan_type":"pro",
+ "rate_limit":{"allowed":true,"limit_reached":false,
+   "primary_window":{"used_percent":0,"limit_window_seconds":18000},
+   "secondary_window":{"used_percent":37,"limit_window_seconds":604800,"reset_at":$((now+90000))}},
+ "additional_rate_limits":[]}
+EOF
+cdlimits "$WORK/cx-usage-weekly-only.json" --quiet >/dev/null
+python3 - "$CD/acct-01/limits.json" <<'EOF'
+import json, sys
+d = json.load(open(sys.argv[1]))
+assert 'no_data' not in d, d
+assert (d['weekly_percent'], d['max_percent']) == (37, 37), d
+assert 'session_percent' not in d, d             # the 5h window reported nothing at all
+EOF
+[ $? -eq 0 ] && t_ok "codex: a weekly-only reading records weekly+max and NO session_percent" \
+  || t_fail "codex weekly-only signals" "see $CD/acct-01/limits.json"
+# ...and the rivals are WORSE on weekly (80 against 37) and still take every pick,
+# because they are the only ones that can clear the session gate — which is exactly what
+# a fabricated `session_percent: 0` would have handed the silent account for free.
+cdl 80 10 80 > "$CD/acct-02/limits.json"
+cdl 80 10 80 > "$CD/acct-03/limits.json"
+rm -f "$CD/.pick-seq" "$CD"/acct-0*/.last-pick
+: > "$CD/selection.log"
+cwk_hits=0
+for _ in $(seq 1 6); do
+  case "$(CODEX_ACCOUNTS_ROOT="$CD" codex 2>&1)" in *CFG=acct-01*) cwk_hits=$((cwk_hits+1)) ;; esac
+done
+[ "$cwk_hits" = "0" ] \
+  && t_ok "codex: an unknown session reading never clears the gate, even with the better weekly (0 of 6)" \
+  || t_fail "codex weekly-only gate" "the session-less account cleared the gate $cwk_hits of 6 times"
+grep -q "band=30 band-count=2 session-gate=50 session-ok=2" "$CD/selection.log" \
+  && t_ok "codex: the log shows exactly the two accounts that reported a session bucket" \
+  || t_fail "codex weekly-only gate log" "$(tail -1 "$CD/selection.log" 2>/dev/null)"
+rm -f "$CD"/acct-0*/.limited
+
 # ---- C14. oauth refresh via the token endpoint --------------------------------------
 # expired bearer, missing endpoint: fail open with backoff
 mk_cx_auth "$CX/acct-01/auth.json" a@cx 1000
@@ -4616,13 +6087,22 @@ check "import refuses to land the same email in a second slot" "already register
 [ "$rc" != "0" ] && t_ok "conflicting-id import exits nonzero" || t_fail "conflicting id" "exited 0"
 
 # ---- 20c. instance isolation: the shim resolves the same root as the CLI ------------
+# The leak assertion is a BEFORE/AFTER of the default pool, taken around the instance
+# run. It used to grep $ACC/selection.log for "acct-01" — a line some earlier, unrelated
+# test had to have left there, and since picks are random that line is not guaranteed:
+# the check flaked once in five runs while proving nothing about isolation either way.
+# Nothing but bin/claude writes selection.log, and this section runs no default-pool
+# shim, so an unchanged line count is exactly "the instance run stayed in its own pool".
+iso_before="$(wc -l < "$ACC/selection.log" 2>/dev/null || echo 0)"
 out="$(CLAUDE_ACCOUNTS_ROOT="$JP2" claude 2>&1)"
 check "shim honors CLAUDE_ACCOUNTS_ROOT (instance pool)" "CFG=acct-01" "$out"
 [ -f "$JP2/selection.log" ] && t_ok "instance pool records its own selection log" \
   || t_fail "instance selection log" "missing at $JP2/selection.log"
-grep -q "acct-01" "$ACC/selection.log" && ! grep -q "portable@test" "$ACC/accounts.json" \
+iso_after="$(wc -l < "$ACC/selection.log" 2>/dev/null || echo 0)"
+{ [ "$iso_before" = "$iso_after" ] && ! grep -q "portable@test" "$ACC/accounts.json"; } \
   && t_ok "the default pool was untouched by the instance run" \
-  || t_fail "pool isolation" "the instance run leaked into $ACC"
+  || t_fail "pool isolation" \
+     "the instance run leaked into $ACC (selection.log $iso_before -> $iso_after lines)"
 
 # ---- 20d. sync target: overridable, and a local-only mode that pushes nowhere -------
 out="$(CLAUDE_ACCOUNTS_ROOT="$JP" CLAUDE_MULTIACC_NO_SYNC=0 claude-accounts sync --no-server 2>&1)"