claude-multiacc 2.0.33 → 2.0.34

package/bin/claude-accounts

@@ -2305,6 +2305,28 @@ for acct in manifest.get('accounts', []):
     maxp = max([b['percent'] for b in live] or [0])
     weeklyp = max(weekly) if weekly else None
     sessionp = max(session) if session else None
+    # ...but only the WEEKLY half of that rule is about a missing answer. The two kinds
+    # of bucket go silent for opposite reasons, and 2026-09-22 cost a day of picks to
+    # the difference. A weekly window always exists — it is a fixed calendar week,
+    # running whether or not the account is — so a weekly bucket with nothing to say is
+    # an endpoint that DECLINED, and inventing a number for it is the 2026-09-04 bug.
+    # The 5h SESSION window only exists while it is OPEN: leave an account alone for
+    # five hours and there is no window left to describe, so the endpoint answers
+    # `percent: 0, resets_at: null` — not silence but "nothing has been used". An
+    # exhausted session is never silent: a spent 5h bucket ALWAYS carries the window it
+    # resets in (the live pool on 2026-09-22 — every session bucket above 0% had a real
+    # resets_at, every silent one belonged to an idle account), so a silent session
+    # cannot be hiding a full one. Recording it as UNKNOWN is what broke selection:
+    # pick_best's quota_known rule needs BOTH readings, so an IDLE account — precisely
+    # the one with the most headroom — was scored weekly=100 and dropped out of the
+    # band, leaving only the busy accounts that still held an open 5h window. From
+    # selection.log at 2026-09-22T12:37:36Z: band-count=1, and that one band member was
+    # acct-17 at 95% weekly, while acct-13 and acct-14 sat at 0% and unrankable.
+    # So: a session bucket that said nothing inside a document that DID answer reads 0.
+    # A document where NOTHING answered still writes no signals at all (see below) —
+    # the 2026-09-04 all-zero shape stays unknown, which is the whole point.
+    if sessionp is None and live:
+        sessionp = 0
     # How long weekly_percent keeps meaning something. A weekly bucket only ever RISES
     # until its reset, so before that moment a stale percent is still a valid lower
     # bound and the shim can rank on it when nothing fresher exists; after it, the

package/bin/codex-accounts

@@ -1585,6 +1585,22 @@ for acct in manifest.get('accounts', []):
     maxp = max([b['percent'] for b in live] or [0])
     weeklyp = max(weekly) if weekly else None
     sessionp = max(session) if session else None
+    # ...but only the WEEKLY half of that rule is about a missing answer — same
+    # asymmetry the claude writer documents, and codex feels it harder. A durable
+    # window always exists, so a silent one is an endpoint that DECLINED. A ~5h session
+    # window only exists while it is OPEN, and codex does not even keep a placeholder
+    # for a closed one: an idle account's payload carries the 7d window and NO session
+    # window whatsoever, so `session` here is empty for every quiet account. That made
+    # session_percent permanently absent across this pool, and pick_best's quota_known
+    # rule needs BOTH readings — so EVERY codex account scored unknown, bestw never left
+    # 101, and the band degenerated to the all-gated tie: codex has been picking
+    # uniformly at RANDOM rather than by headroom (selection.log: `session=?%` on every
+    # ranked line). A session window that is closed has nothing in it, and an exhausted
+    # one is never silent — it reports at/near 100% with the reset it is waiting on.
+    # So a missing or silent session reads 0 whenever the payload answered at all; a
+    # payload where NOTHING answered still writes no signals and stays unknown below.
+    if sessionp is None and live:
+        sessionp = 0
     try:
         reset_result, reset_view = refresh_reset_credits(d, aid, maxp, data, url, headers, say, int(now))
     except Exception as e:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-multiacc",
-  "version": "2.0.33",
+  "version": "2.0.34",
   "description": "Unified Claude Code and OpenAI Codex subscription pooling with quota-aware selection.",
   "type": "module",
   "bin": {

package/tests/run-tests.sh

@@ -2458,10 +2458,18 @@ done
   && 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.
+# The mirror image — a weekly reading whose 5h bucket has nothing to say — is NOT the
+# same defect, and treating it as one broke selection on 2026-09-22. A weekly window
+# always exists (a fixed calendar week, running whether or not the account is), so a
+# silent weekly bucket is an endpoint that DECLINED. The 5h window only exists while it
+# is OPEN, so a silent session bucket is an account that has simply been IDLE — and an
+# exhausted session is never silent: a spent 5h bucket always reports ~100% with the
+# reset it is waiting on. Recording idle as UNKNOWN cost the pool its entire band,
+# because quota_known needs BOTH readings: the accounts with the MOST headroom
+# (acct-13/acct-14, 0% weekly) were scored 100 and dropped out, leaving acct-17 at 95%
+# weekly as the only band member — selection.log 2026-09-22T12:37:36Z, band-count=1,
+# four picks in a row onto an account already out of weekly headroom. A closed window
+# holds no usage: it reads 0.
 cat > "$WORK/usage-weekly-only.json" <<'EOF'
 {"limits":[
   {"kind":"session","group":"session","percent":0,"resets_at":null,"scope":null},
@@ -2476,10 +2484,33 @@ 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
+# The 5h window is CLOSED, not undocumented, so it holds no usage. max_percent is still
+# taken over the INFORMATIVE buckets only, so this idle 0 never becomes a bucket reading.
+assert d['session_percent'] == 0, d
 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"
+[ $? -eq 0 ] && t_ok "an idle 5h bucket beside a real weekly one records session_percent 0" \
+  || t_fail "idle-session signals" "see $ND/acct-01/limits.json"
+
+# A payload with NO session bucket at ALL is the same story told by omission — the shape
+# every codex account produces while it is quiet. It must rank, not vanish.
+cat > "$WORK/usage-no-session-bucket.json" <<'EOF'
+{"limits":[
+  {"kind":"weekly_all","group":"weekly","percent":37,"resets_at":"2099-01-05T00:00:00+00:00","scope":null}
+]}
+EOF
+ndlimits "$WORK/usage-no-session-bucket.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['weekly_percent'], d['session_percent'], d['max_percent']) == (37, 0, 37), d
+EOF
+[ $? -eq 0 ] && t_ok "a payload with no session bucket at all still records session_percent 0" \
+  || t_fail "absent-session signals" "see $ND/acct-01/limits.json"
+
+# ...and that account RANKS: idle plus the better weekly must beat a busier rival — the
+# pick the pool was losing. acct-02 is worse on weekly (80 vs 37) and clears the gate
+# too, so the band alone separates them.
 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"
@@ -2487,12 +2518,26 @@ 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)"
+[ "$nd_wk_hits" = "6" ] \
+  && t_ok "an idle account with the better weekly takes every pick (6 of 6)" \
+  || t_fail "idle-session ranking" "the idle account took $nd_wk_hits of 6"
+grep -q "acct-01 weekly=37% session=0% band=30 band-count=1 session-gate=50 session-ok=2" "$ND/selection.log" \
+  && t_ok "the log shows both clearing the gate and the idle account alone in the band" \
+  || t_fail "idle-session log" "$(tail -1 "$ND/selection.log" 2>/dev/null)"
+
+# The guard that must NOT move: a document where NOTHING answered is still unknown. The
+# all-zero 2026-09-04 shape has no informative bucket anywhere, so it writes no signals
+# at all and never picks up a fabricated session 0 on the way out.
+ndlimits "$WORK/usage-allzero.json" --quiet >/dev/null
+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
+for k in ('max_percent', 'weekly_percent', 'session_percent', 'weekly_resets_epoch'):
+    assert k not in d, (k, d)
+EOF
+[ $? -eq 0 ] && t_ok "an all-zero payload still writes no session_percent (2026-09-04 holds)" \
+  || t_fail "allzero still unknown" "see $ND/acct-01/limits.json"
 
 # ---- 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
@@ -5872,6 +5917,13 @@ done
   && 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"
 
+# The mirror image — a weekly reading whose ~5h window has nothing to say — is NOT the
+# same defect, and codex feels it hardest: an idle account's payload carries the 7d
+# window and no usable session window at all, so session_percent went permanently
+# absent across the whole pool. quota_known needs BOTH readings, so EVERY codex account
+# scored unknown, bestw never left 101, and the band collapsed into the all-gated tie —
+# codex picked uniformly at RANDOM instead of by headroom (selection.log 2026-09-22:
+# `session=?%` on every ranked line). A closed window holds no usage: it reads 0.
 cat > "$WORK/cx-usage-weekly-only.json" <<EOF
 {"email":"nd@cx","plan_type":"pro",
  "rate_limit":{"allowed":true,"limit_reached":false,
@@ -5885,13 +5937,32 @@ 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
+# The ~5h window is CLOSED, not undocumented, so it holds no usage. max_percent is still
+# taken over the INFORMATIVE windows only, so this idle 0 never becomes a reading.
+assert d['session_percent'] == 0, d
 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.
+[ $? -eq 0 ] && t_ok "codex: an idle 5h window beside a real weekly one records session_percent 0" \
+  || t_fail "codex idle-session signals" "see $CD/acct-01/limits.json"
+
+# The same story told by omission: no session window in the payload at all.
+cat > "$WORK/cx-usage-no-session.json" <<EOF
+{"email":"nd@cx","plan_type":"pro",
+ "rate_limit":{"allowed":true,"limit_reached":false,
+   "secondary_window":{"used_percent":37,"limit_window_seconds":604800,"reset_at":$((now+90000))}},
+ "additional_rate_limits":[]}
+EOF
+cdlimits "$WORK/cx-usage-no-session.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['session_percent'], d['max_percent']) == (37, 0, 37), d
+EOF
+[ $? -eq 0 ] && t_ok "codex: a payload with no session window at all records session_percent 0" \
+  || t_fail "codex absent-session signals" "see $CD/acct-01/limits.json"
+
+# ...and it RANKS: idle plus the better weekly (37) must beat busier rivals (80), which
+# is the pick this pool was losing on every single invocation.
 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
@@ -5900,12 +5971,25 @@ 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)"
+[ "$cwk_hits" = "6" ] \
+  && t_ok "codex: an idle account with the better weekly takes every pick (6 of 6)" \
+  || t_fail "codex idle-session ranking" "the idle account took $cwk_hits of 6"
+grep -q "acct-01 weekly=37% session=0% band=30 band-count=1 session-gate=50 session-ok=3" "$CD/selection.log" \
+  && t_ok "codex: all three clear the gate and the idle account is alone in the band" \
+  || t_fail "codex idle-session log" "$(tail -1 "$CD/selection.log" 2>/dev/null)"
+
+# The guard that must NOT move: a payload where NOTHING answered stays unknown, and
+# never picks up a fabricated session 0 on the way out.
+cdlimits "$WORK/cx-usage-allzero.json" --quiet >/dev/null
+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)
+EOF
+[ $? -eq 0 ] && t_ok "codex: an all-zero payload still writes no session_percent (2026-09-04 holds)" \
+  || t_fail "codex allzero still unknown" "see $CD/acct-01/limits.json"
 rm -f "$CD"/acct-0*/.limited
 
 # ---- C14. oauth refresh via the token endpoint --------------------------------------