claude-multiacc 2.0.12 → 2.0.14

package/bin/claude

@@ -280,6 +280,48 @@ sel_score_of() { # $1 = acct dir
   printf '%s\n' $((w * 1000 + s))
 }
 
+# The .limited marker's own fields (line 1: reset epoch; line 2: "bucket=…
+# percent=… … reason=…"). All tolerant: an unreadable or bare marker answers
+# "unknown", never an error — these feed the all-limited fallback only.
+limited_reset_of() { # $1 acct dir -> the marker's reset epoch, or 0 (unknown)
+  local m="$1/.limited" r=""
+  [ -f "$m" ] && { IFS= read -r r < "$m" 2>/dev/null || r=""; }
+  if num_ok "$r"; then printf '%s\n' "$r"; else printf '0\n'; fi
+}
+
+limited_percent_of() { # $1 acct dir -> the marked bucket's percent, or -1 (unknown)
+  local m="$1/.limited" line=""
+  [ -f "$m" ] && line="$(sed -n 2p "$m" 2>/dev/null)"
+  case "$line" in
+    *percent=*) line="${line#*percent=}"; line="${line%% *}" ;;
+    *) line="" ;;
+  esac
+  if num_ok "$line"; then printf '%s\n' "$line"; else printf '%s\n' "-1"; fi
+}
+
+# Rejected RIGHT NOW, not merely near the threshold: the marked bucket is exhausted
+# (100%), or the marker records a real client rejection (a 429 the server sent).
+# A bucket at 90-99% still answers requests — the difference the all-limited
+# fallback lives on, because "degraded service beats a hard failure" only holds
+# for an account that can actually serve.
+limited_hard_blocked() { # $1 acct dir
+  local m="$1/.limited" line="" p
+  if [ -f "$m" ]; then
+    line="$(sed -n 2p "$m" 2>/dev/null)"
+    case "$line" in *reason=client-rate-limit*|*reason=error-cooldown*) return 0 ;; esac
+    p="$(limited_percent_of "$1")"
+    if [ "$p" -ge 0 ] 2>/dev/null; then
+      [ "$p" -ge 100 ]
+      return
+    fi
+    return 1
+  fi
+  # No marker (the over-threshold backstop put it in valid-but-not-eligible):
+  # fresh telemetry's peak decides; stale/unknown reads as still serving.
+  p="$(cutoff_field "$1" max_percent)" || return 1
+  [ "$p" -ge 100 ]
+}
+
 # Peak of ALL buckets (session included) — the EXCLUSION signal. Stale/unknown => 50.
 util_of() {
   local v
@@ -682,6 +724,30 @@ expired_marked() { # $1 = acct dir
   local m="$1/.expired" mt f soft reason
   [ -f "$m" ] || return 1
   reason="$(LC_ALL=C sed -n 's/.*reason=\([A-Za-z0-9._-][A-Za-z0-9._-]*\).*/\1/p' "$m" 2>/dev/null | head -1)"
+  if [ "$reason" = "setup-token-invalid" ]; then
+    # A TOKEN-scoped park: it says the portable token is dead and nothing about the
+    # login beside it. Only a NEW token heals it — a login refresh rewrites
+    # .credentials.json / the Keychain item every few hours and used to lift it, so the
+    # next session that had to use the token exported the dead one, got 401 and parked
+    # it again (2026-08-29). And it only EXCLUDES the account from a session that would
+    # authenticate by that token: one that can use a live login here (a GUI terminal,
+    # the runner's LaunchAgent) runs the account on the login, token park or not.
+    mt="$(file_mtime "$m")"
+    if [ -f "$1/server.token" ] && [ "$(file_mtime "$1/server.token")" -gt "$mt" ]; then
+      rm -f "$m" 2>/dev/null
+      return 1
+    fi
+    if has_oauth "$1" && ! creds_dead "$1"; then
+      return 1                                      # the login carries this session
+    fi
+    soft="$(LC_ALL=C sed -n 's/.*soft_until=\([0-9][0-9]*\).*/\1/p' "$m" 2>/dev/null | head -1)"
+    case "$soft" in
+      ''|*[!0-9]*) return 0 ;;
+      *) [ "$now" -lt "$soft" ] && return 0
+         rm -f "$m" 2>/dev/null
+         return 1 ;;
+    esac
+  fi
   # CREDENTIAL-scoped parks clear the moment a newer credential lands — that is the
   # evidence they were about. A POLICY park (org-blocked) is about the account, not the
   # credential: refreshing its token does not re-enable Claude Code for it. Letting a
@@ -985,19 +1051,50 @@ if [ "${#eligible[@]}" -gt 0 ]; then
     pick_best "${eligible[@]}"
   fi
 else
-  # Every account is limit-marked: degraded service beats a hard failure (100% rule).
-  assess_telemetry "${valid[@]}"
-  [ "$degraded" = 1 ] && SEL_DEGRADED=1
-  pick_best "${valid[@]}"
+  # Every account is limit-marked: degraded service beats a hard failure (100% rule) —
+  # but not every limited account is equally dead. A bucket at 90-99% still answers;
+  # one at 100% (or a real client 429) rejects every request until its reset. Ranking
+  # the fallback on weekly headroom alone handed out a session-exhausted account
+  # (weekly=7%, session=100%) over one still serving at weekly 99% — a guaranteed
+  # rejection chosen over a working session (operator report, 2026-08-29).
+  soft=()
+  hard=()
+  for d in "${valid[@]}"; do
+    if limited_hard_blocked "$d"; then hard+=("$d"); else soft+=("$d"); fi
+  done
+  if [ "${#soft[@]}" -gt 0 ]; then
+    assess_telemetry "${soft[@]}"
+    [ "$degraded" = 1 ] && SEL_DEGRADED=1
+    pick_best "${soft[@]}"
+  else
+    # Every account is exhausted RIGHT NOW: nothing serves, so hand out the one
+    # that unblocks first — its rejection window is the shortest.
+    assess_telemetry "${valid[@]}"
+    [ "$degraded" = 1 ] && SEL_DEGRADED=1
+    PICK_DIR=""
+    best_reset=0
+    for d in "${hard[@]}"; do
+      r="$(limited_reset_of "$d")"
+      if [ -z "$PICK_DIR" ]; then
+        PICK_DIR="$d"; best_reset="$r"; continue
+      fi
+      if [ "$r" -gt 0 ] && { [ "$best_reset" -eq 0 ] || [ "$r" -lt "$best_reset" ]; }; then
+        PICK_DIR="$d"; best_reset="$r"
+      fi
+    done
+    sel_log "all-limited fallback=$(basename "$PICK_DIR") all-exhausted resets_in=$((best_reset > now ? best_reset - now : 0))s"
+  fi
   # Report the number this fallback ACTUALLY ranked on. Asking fresh_field here printed
   # `weekly=?%` even when the pick was made on a perfectly good stale reading, so anyone
   # reading only this event concluded the choice had no usage input at all.
-  if [ "$degraded" = 1 ]; then
-    sel_log "all-limited fallback=$(basename "$PICK_DIR") weekly=$(stale_weekly "$PICK_DIR" || echo '?')% ranking=DEGRADED"
-  elif [ "$blind" = 1 ]; then
-    sel_log "all-limited fallback=$(basename "$PICK_DIR") weekly=?% ranking=BLIND"
-  else
-    sel_log "all-limited fallback=$(basename "$PICK_DIR") weekly=$(fresh_field "$PICK_DIR" weekly_percent || echo '?')%"
+  if [ "${#soft[@]}" -gt 0 ]; then
+    if [ "$degraded" = 1 ]; then
+      sel_log "all-limited fallback=$(basename "$PICK_DIR") weekly=$(stale_weekly "$PICK_DIR" || echo '?')% ranking=DEGRADED"
+    elif [ "$blind" = 1 ]; then
+      sel_log "all-limited fallback=$(basename "$PICK_DIR") weekly=?% ranking=BLIND"
+    else
+      sel_log "all-limited fallback=$(basename "$PICK_DIR") weekly=$(fresh_field "$PICK_DIR" weekly_percent || echo '?')%"
+    fi
   fi
 fi
 pick="$PICK_DIR"

package/bin/claude-accounts

@@ -507,7 +507,7 @@ cmd_add() {
   if [ "$token" = "1" ]; then
     # Portable setup-token variant (works on Mac AND server; needs a recent sign-in).
     echo "Preparing $id for $elabel (portable token) — NOTHING is registered until sign-in completes."
-    run_token_ceremony "$d" || die "sign-in failed or aborted — nothing was created"
+    run_token_ceremony "$d" || die "sign-in failed or aborted — nothing was created${CEREMONY_LAST_WORDS:+ — the client said: $CEREMONY_LAST_WORDS}${CEREMONY_TRANSCRIPT:+ (transcript: $CEREMONY_TRANSCRIPT)}"
     commit_ceremony_token "$d" "$CEREMONY_TOKEN" "$id"
     got="$(token_email "$CEREMONY_TOKEN")"
   else
@@ -907,12 +907,17 @@ ceremony_token_check() { # $1 = token
 # token Claude rejects is never saved, uploaded, or distributed. $1 = acct dir,
 # $2 = token, $3 = acct id (messages only).
 commit_ceremony_token() {
-  local d="$1" tok="$2" id="$3" rc=0
+  local d="$1" tok="$2" id="$3" src="${4:-captured}" rc=0
   ceremony_token_check "$tok" || rc=$?
-  # A short capture is a wrapped one unless Claude itself has just answered with it:
+  # A short token is an incomplete one unless Claude itself has just answered with it:
   # the length alone convicts it, so an inconclusive probe (429, network) must not let
   # it through as merely "unverified" — that is the exact token the fleet then rejects.
+  # The cause named depends on where the token came from: a CAPTURED one was wrapped by
+  # the ceremony's terminal; a PASTED one was cut before it reached the clipboard.
   if [ "$rc" -ne 0 ] && [ "${#tok}" -lt "$SETUP_TOKEN_FULL_LEN" ]; then
+    if [ "$src" = "pasted" ]; then
+      die "the pasted token is ${#tok} characters and a complete setup-token is $SETUP_TOKEN_FULL_LEN (${CEREMONY_CHECK_DETAIL:-not proven by a real call}) — it was cut before it reached the clipboard (a narrow terminal wraps the token when it is shown). Nothing saved for $id. Copy the WHOLE token and paste again."
+    fi
     die "the captured token is ${#tok} characters and a complete setup-token is $SETUP_TOKEN_FULL_LEN (${CEREMONY_CHECK_DETAIL:-not proven by a real call}): the sign-in terminal wrapped it and only its first line was captured. Nothing saved for $id. Mint again from a terminal at least $CEREMONY_TTY_MIN_COLS columns wide, or from an updated panel."
   fi
   if [ "$rc" -eq 1 ]; then
@@ -929,9 +934,47 @@ commit_ceremony_token() {
   fi
 }
 
+# When a ceremony ends without a token, the CLIENT said why — "Your account is on
+# hold", a policy refusal, a subscription it could not find — and that sentence is
+# the only thing that lets anyone fix it. It used to vanish with the capture file,
+# leaving "no token captured" (operator, 2026-08-29). The last visible lines are
+# kept (ANSI-stripped, spinners/logo/URL/prompt dropped, any sk-ant-… redacted) and
+# the whole redacted transcript is written beside the pool for a closer look.
+CEREMONY_LAST_WORDS=""
+CEREMONY_TRANSCRIPT=""
+ceremony_debrief() { # $1 = capture file, $2 = redacted transcript to write; prints the last words
+  "$PYBIN" - "$1" "$2" <<'PYEOF'
+import os, re, sys
+raw = open(sys.argv[1], 'rb').read().decode('utf-8', 'ignore')
+txt = re.sub(r'\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)', '', raw)      # OSC (hyperlink payloads)
+txt = re.sub(r'\x1b\[[0-9;?]*[A-Za-z]', '', txt)                  # CSI (colour, cursor)
+txt = re.sub(r'\x1b[()][A-Z0-9]', '', txt).replace('\r', '\n')
+txt = re.sub(r'sk-ant-[A-Za-z0-9]+-[A-Za-z0-9_-]+', 'sk-ant-***', txt)
+lines = []
+for ln in txt.splitlines():
+    ln = ln.strip()
+    if not ln or re.fullmatch(r'[\W_]+', ln):          # spinner frames, logo art
+        continue
+    if 'https://' in ln or re.search(r'Paste\s*code\s*here', ln):   # the sign-in link, the paste prompt
+        continue
+    if lines and lines[-1] == ln:
+        continue
+    lines.append(ln)
+try:
+    fd = os.open(sys.argv[2], os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, 'w') as f:
+        f.write('\n'.join(lines) + '\n')
+except OSError:
+    pass
+print(' | '.join(lines[-3:])[:400])
+PYEOF
+}
+
 CEREMONY_TOKEN=""
 run_token_ceremony() { # $1 = config dir
   CEREMONY_TOKEN=""
+  CEREMONY_LAST_WORDS=""
+  CEREMONY_TRANSCRIPT=""
   local d="$1" real cap old_umask
   real="$(find_real_claude "$_self")" || { warn "real claude binary not found"; return 1; }
   mkdir -p "$ACC_ROOT/tmp"
@@ -973,8 +1016,16 @@ TIP
   # frame rendered while the terminal was still narrow holds a wrapped fragment.
   CEREMONY_TOKEN="$(grep -aoE 'sk-ant-oat[0-9]{2}-[A-Za-z0-9_-]{40,}' "$cap" \
     | awk '{ if (length($0) > length(best)) best = $0 } END { if (best != "") print best }')"
+  if [ -z "$CEREMONY_TOKEN" ]; then
+    CEREMONY_TRANSCRIPT="$ACC_ROOT/tmp/mint-failed.$(date -u +%Y%m%dT%H%M%SZ).log"
+    CEREMONY_LAST_WORDS="$(ceremony_debrief "$cap" "$CEREMONY_TRANSCRIPT" 2>/dev/null)"
+    [ -s "$CEREMONY_TRANSCRIPT" ] || CEREMONY_TRANSCRIPT=""
+    rm -f "$cap"
+    [ -n "$CEREMONY_LAST_WORDS" ] && warn "the sign-in ended without a token — the client said: $CEREMONY_LAST_WORDS"
+    [ -n "$CEREMONY_TRANSCRIPT" ] && warn "redacted transcript kept at $CEREMONY_TRANSCRIPT"
+    return 1
+  fi
   rm -f "$cap"
-  [ -n "$CEREMONY_TOKEN" ] || return 1
   valid_subscription_token "$CEREMONY_TOKEN" || {
     CEREMONY_TOKEN=""
     warn "captured credential is not a subscription setup-token"
@@ -1092,7 +1143,7 @@ cmd_mint() {
     tok="$(printf '%s' "$tok" | tr -d '[:space:]')"
   else
     echo "Running 'claude setup-token' for $id — approve in a browser signed in as ${email:-THIS account}."
-    run_token_ceremony "$d" || die "no token captured — mint failed"
+    run_token_ceremony "$d" || die "no token captured — mint failed${CEREMONY_LAST_WORDS:+ — the client said: $CEREMONY_LAST_WORDS}${CEREMONY_TRANSCRIPT:+ (transcript: $CEREMONY_TRANSCRIPT)}"
     tok="$CEREMONY_TOKEN"
   fi
   [ -n "$tok" ] || die "no token captured — mint failed"
@@ -1102,7 +1153,7 @@ cmd_mint() {
   if [ -n "$got" ] && [ -n "$email" ] && [ "$got" != "$email" ]; then
     die "that token authenticates as $got but $id is $email — nothing saved"
   fi
-  commit_ceremony_token "$d" "$tok" "$id"
+  commit_ceremony_token "$d" "$tok" "$id" "$([ "$paste" = "1" ] && echo pasted || echo captured)"
   clear_auth_markers "$d"
   log_to ops.log "mint $id"
   echo "Token saved to $d/server.token"
@@ -1134,7 +1185,7 @@ cmd_login() {
   if [ "$token" = "1" ]; then
     trap 'restore_ceremony_tty; exit 130' INT TERM
     trap 'restore_ceremony_tty' EXIT
-    run_token_ceremony "$d" || die "sign-in failed or aborted — nothing changed"
+    run_token_ceremony "$d" || die "sign-in failed or aborted — nothing changed${CEREMONY_LAST_WORDS:+ — the client said: $CEREMONY_LAST_WORDS}${CEREMONY_TRANSCRIPT:+ (transcript: $CEREMONY_TRANSCRIPT)}"
     got="$(token_email "$CEREMONY_TOKEN")"
     if [ -n "$got" ] && [ "$got" != "$email" ] && [ "$force" != "1" ]; then
       die "you signed in as $got but $id is $email — nothing saved (use --force to override)"
@@ -1153,7 +1204,7 @@ cmd_login() {
     if [ -z "$got" ] && [ "$force" != "1" ]; then
       die "signed in, but the account identity could not be read back — refusing to call $id fixed (retry, or pass --force)"
     fi
-    clear_auth_markers "$d"
+    clear_auth_markers "$d" keep-token-park
     if [ -s "$d/.credentials.json" ]; then
       echo "$id login saved (.credentials.json, this machine, auto-refreshing)."
     else
@@ -1518,12 +1569,20 @@ def mark_expired(d, slug, detail=''):
 
 def clear_expired(d):
     """A usage fetch that succeeded PROVES the bearer works — drop any dead-auth mark.
-    EXCEPT an org-blocked one: those accounts authenticate perfectly (telemetry works),
-    they are just barred from Claude Code inference, so telemetry says nothing about
-    them. Only a passing `verify` (a real call) or a re-login lifts that."""
+    EXCEPT:
+    - org-blocked: those accounts authenticate perfectly (telemetry works), they are
+      just barred from Claude Code inference, so telemetry says nothing about them.
+    - setup-token-invalid: the bearer behind a usage fetch or a refresh grant is the
+      machine-local OAUTH login, and its success says nothing about the PORTABLE
+      token a real inference rejected. On the one Mac holding both, this probe
+      un-parked every dead-token account minutes after the shim parked it, and every
+      fresh `claude` walked back into the same 401 all day (2026-08-29). Only a NEW
+      token (the shim's newer-file rule) or a real call that used the token lifts it.
+    Only a passing `verify` (a real call) or a re-login lifts the excepted ones."""
     mpath = os.path.join(d, '.expired')
     try:
-        if 'reason=org-blocked' in open(mpath, errors='replace').read():
+        body = open(mpath, errors='replace').read()
+        if 'reason=org-blocked' in body or 'reason=setup-token-invalid' in body:
             return False
     except OSError:
         return False
@@ -2306,11 +2365,20 @@ for acct in manifest.get('accounts', []):
     dt = time.time() - t0
     out = (r.stdout or '').strip()
     if r.returncode == 0 and 'ok' in out.lower():
-        # A real call succeeded: this account is definitively alive.
+        # A real call succeeded: this account is definitively alive — but WHICH
+        # credential answered matters. A pass on the OAuth login says nothing about a
+        # portable token a real call rejected; clearing that park here re-opened the
+        # 401 loop the marker exists to stop (the shim re-picked the account, exported
+        # the dead token, parked it again — 2026-08-29).
         try:
-            os.remove(os.path.join(d, '.expired'))
+            marker = open(os.path.join(d, '.expired'), errors='replace').read()
         except OSError:
-            pass
+            marker = ''
+        if uses_token or 'reason=setup-token-invalid' not in marker:
+            try:
+                os.remove(os.path.join(d, '.expired'))
+            except OSError:
+                pass
         if uses_token:
             try:
                 digest = hashlib.sha256(open(tpath, 'rb').read().strip()).hexdigest()

package/lib/audit.py

@@ -83,7 +83,16 @@ def expired_marked(d, now=None):
     if not os.path.isfile(mpath):
         return False
     detail = marker_reason(mpath)
-    if marker_slug(detail) != 'org-blocked':
+    slug = marker_slug(detail)
+    if slug == 'setup-token-invalid':
+        # A TOKEN park heals only when a NEW token lands (bin/claude expired_marked):
+        # a login refresh rewriting .credentials.json or the Keychain item says
+        # nothing about the portable token.
+        mt = _mtime(mpath)
+        p = os.path.join(d, 'server.token')
+        if os.path.isfile(p) and _mtime(p) > mt:
+            return False
+    elif slug != 'org-blocked':
         mt = _mtime(mpath)
         for name in ('.credentials.json', 'server.token'):
             p = os.path.join(d, name)
@@ -277,6 +286,17 @@ def audit_account(root, acct, now=None, machine=None, require_verified_token=Fal
             row['reason'] = ('this account\'s organization has disabled Claude Code '
                              'subscription access')
         elif slug == 'setup-token-invalid':
+            login = oauth_login(d, now)
+            if login['state'] == 'ok':
+                # A token park says nothing about the working login beside it: the
+                # shim runs this account on the login here (bin/claude
+                # expired_marked), so this machine reads it as usable — while the
+                # token stays unproven for the fleet (token_verified False).
+                row['store'] = login['store']
+                row['state'] = 'ok'
+                row['reason'] = (f"{login['reason']}; portable setup-token was rejected "
+                                 "here and is not used")
+                return done(row)
             row['state'] = 'token-invalid'
             row['reason'] = 'portable setup-token was rejected by a real inference'
         else:

package/lib/common.sh

@@ -491,7 +491,15 @@ mark_expired() { # mark_expired <acct dir> <reason-slug> [detail]
 # Called wherever fresh auth lands (login/add/mint, successful usage fetch): the
 # account is provably alive again, so both the dead-auth marker and any refresh
 # backoff must go, or it would stay parked until the next re-login.
-clear_auth_markers() { # $1 = acct dir
+clear_auth_markers() { # $1 = acct dir, $2 = "keep-token-park" after a LOGIN-only ceremony
+  # A fresh login proves the login; it says nothing about a portable token a real
+  # call rejected, so that park outlives it — only a new token (mint / login --token)
+  # or a real call through the token lifts it.
+  if [ "${2:-}" = "keep-token-park" ] \
+      && grep -q 'reason=setup-token-invalid' "$1/.expired" 2>/dev/null; then
+    rm -f "$1/.oauth-refresh.json" 2>/dev/null || true
+    return 0
+  fi
   rm -f "$1/.expired" "$1/.oauth-refresh.json" 2>/dev/null || true
 }
 

package/package.json

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

package/tests/run-tests.sh

@@ -73,7 +73,7 @@ if [ "${1:-}" = "auth" ] && [ "${2:-}" = "login" ]; then
 fi
 if [ "${1:-}" = "setup-token" ]; then
   echo "Open this sign-in link: https://claude.ai/oauth/authorize?fake=1"
-  [ -n "${FAKE_TOKEN_FAIL:-}" ] && { echo "sign-in aborted" >&2; exit 1; }
+  [ -n "${FAKE_TOKEN_FAIL:-}" ] && { echo "${FAKE_TOKEN_FAIL_MSG:-sign-in aborted}" >&2; exit 1; }
   if [ -n "${FAKE_TOKEN_FULL:-}" ]; then
     # The real client's shape: a 108-character token that the TUI HARD-WRAPS at the
     # terminal's width — an unsized pty (0 columns) renders as 80, and a 79-character
@@ -436,6 +436,88 @@ 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"
 
+# ---- 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
+# the reset. Ranking on headroom alone handed out the guaranteed rejection
+# (operator report 2026-08-29: "claude keeps starting on an out-of-limits account").
+printf '%s\nbucket=weekly_scoped:Fable percent=99 marked_at=x reason=limits\n' "$((now+3600))" > "$ACC/acct-01/.limited"
+printf '%s\nbucket=session percent=100 marked_at=x reason=limits\n' "$((now+600))" > "$ACC/acct-02/.limited"
+printf '{"fetched_at":%s,"max_percent":99,"weekly_percent":99,"session_percent":10,"buckets":[]}' "$now" > "$ACC/acct-01/limits.json"
+printf '{"fetched_at":%s,"max_percent":100,"weekly_percent":7,"session_percent":100,"buckets":[]}' "$now" > "$ACC/acct-02/limits.json"
+out="$(claude 2>&1)"
+check "a still-serving limited account beats an exhausted one with more headroom" "CFG=acct-01" "$out"
+# A real client rejection (a 429 the server sent) is exhausted whatever percent says.
+printf '%s\nbucket=five_hour marked_at=x reason=client-rate-limit\n' "$((now+600))" > "$ACC/acct-02/.limited"
+out="$(claude 2>&1)"
+check "a client-rejected account is not the fallback while another still serves" "CFG=acct-01" "$out"
+# Every account exhausted RIGHT NOW: hand out the one that unblocks first.
+printf '%s\nbucket=session percent=100 marked_at=x reason=limits\n' "$((now+7200))" > "$ACC/acct-01/.limited"
+printf '%s\nbucket=session percent=100 marked_at=x reason=limits\n' "$((now+600))" > "$ACC/acct-02/.limited"
+out="$(claude 2>&1)"
+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"
+
+# ---- 9a3. a token park is credential-scoped ----------------------------------------
+# A dead portable token beside a LIVE login: this session runs the account on the
+# login — the park neither excludes it nor exports the token. Only a session that
+# would have to use the token is kept away, and only a NEW token heals the park (a
+# login refresh rewriting the credential must not — that rewrite happened every few
+# hours and re-opened the 401 loop, 2026-08-29).
+rm -rf "$WORK/bak01"; mkdir -p "$WORK/bak01"
+for f in server.token .credentials.json .expired .server-token-verified limits.json; do
+  [ -e "$ACC/acct-01/$f" ] && cp -p "$ACC/acct-01/$f" "$WORK/bak01/$f"
+done
+printf '%s\nx\n' "$((now+3600))" > "$ACC/acct-02/.limited"         # acct-01 is the only free one
+printf '{"fetched_at":%s,"max_percent":10,"weekly_percent":10,"session_percent":5,"buckets":[]}' "$now" > "$ACC/acct-01/limits.json"
+printf '{"claudeAiOauth":{"accessToken":"sk-ant-oat01-live","refreshToken":"r","expiresAt":9999999999999,"refreshTokenExpiresAt":9999999999999}}' > "$ACC/acct-01/.credentials.json"
+printf 'sk-ant-oat01-REVOKEDREVOKEDREVOKEDREVOKEDREVOKEDREVOKED' > "$ACC/acct-01/server.token"
+touch -t 202001010000 "$ACC/acct-01/server.token"                 # older than the park
+rm -f "$ACC/acct-01/.server-token-verified"
+printf '%s\nreason=setup-token-invalid marked_at=x detail=portable OAuth token rejected\n' "$now" > "$ACC/acct-01/.expired"
+out="$(claude 2>&1)"
+check "a live login runs the account despite a token park" "CFG=acct-01" "$out"
+check "the parked token is not exported beside a live login" "TOK=none" "$out"
+[ -f "$ACC/acct-01/.expired" ] && t_ok "the token park stays on record for token-only sessions" \
+  || t_fail "token park record" "marker removed"
+out="$(claude-accounts list --json 2>/dev/null | python3 -c '
+import json, sys
+rows = {a["id"]: a for a in json.load(sys.stdin)["accounts"]}
+print(rows["acct-01"]["status"], rows["acct-01"].get("token_verified"))')"
+[ "$out" = "active False" ] && t_ok "the audit reads a live login beside a parked token as usable, token unproven" \
+  || t_fail "audit token park" "expected 'active False', got '$out'"
+# The login dies: now the token would carry the session, and the park excludes it.
+printf '{"claudeAiOauth":{"accessToken":"sk-ant-oat01-dead","refreshToken":"r","expiresAt":1000000000000,"refreshTokenExpiresAt":1000000000000}}' > "$ACC/acct-01/.credentials.json"
+touch -t 202101010000 "$ACC/acct-01/.expired"                     # the credential above is NEWER
+rm -f "$ACC/acct-02/.limited"
+out="$(claude 2>&1)"
+check "a dead login makes the token park bite" "CFG=acct-02" "$out"
+[ -f "$ACC/acct-01/.expired" ] && t_ok "a newer credential does not heal a token park" \
+  || t_fail "credential heal" "the login refresh lifted the token park"
+out="$(claude-accounts list --json 2>/dev/null | python3 -c '
+import json, sys
+rows = {a["id"]: a for a in json.load(sys.stdin)["accounts"]}
+print(rows["acct-01"]["status"])')"
+[ "$out" = "token-invalid" ] && t_ok "the audit reads a parked token beside a dead login as token-invalid" \
+  || t_fail "audit token-invalid" "got '$out'"
+# A NEW token heals it — and the healed account is selected again, on the token.
+printf 'sk-ant-oat01-%s' "$(printf '%95s' '' | tr ' ' N)" > "$ACC/acct-01/server.token"
+printf '%s\nx\n' "$((now+3600))" > "$ACC/acct-02/.limited"
+out="$(claude 2>&1)"
+check "a new token heals the park" "CFG=acct-01" "$out"
+check "the healed account runs on its new token" "TOK=sk-ant-oat01-NNN" "$out"
+[ ! -f "$ACC/acct-01/.expired" ] && t_ok "the healed park is gone" || t_fail "healed park" "marker still present"
+# Hand acct-01 back exactly as it was.
+rm -f "$ACC/acct-02/.limited" "$ACC/acct-01/server.token" "$ACC/acct-01/.credentials.json" \
+  "$ACC/acct-01/.expired" "$ACC/acct-01/.server-token-verified" "$ACC/acct-01/limits.json"
+for f in server.token .credentials.json .expired .server-token-verified limits.json; do
+  [ -e "$WORK/bak01/$f" ] && cp -p "$WORK/bak01/$f" "$ACC/acct-01/$f"
+done
+
 # ---- 9b. codex-review regressions: auth/marker/threshold hardening -------------
 # empty .credentials.json must NOT count as auth (interrupted write)
 mkdir -p "$ACC/acct-06"
@@ -1333,6 +1415,24 @@ check "the inconclusive save says so" "saved as UNVERIFIED" "$out"
 [ ! -f "$ACC/acct-04/.server-token-verified" ] && t_ok "an unproven save records no proof" \
   || t_fail "unproven proof marker" "marker present"
 printf '%s' "$orig" > "$ACC/acct-04/server.token"
+# The client ended the ceremony without a token and said why: that sentence must
+# reach the operator (the panel shows the mint's own error line), and the redacted
+# transcript must be kept for a closer look — "no token captured" alone left an
+# operator with nothing to act on (2026-08-29).
+out="$(FAKE_TOKEN_FAIL=1 FAKE_TOKEN_FAIL_MSG="Your account is on hold. You can close this window." claude-accounts mint acct-04 2>&1 </dev/null)"
+rc=$?
+[ "$rc" != "0" ] && t_ok "a ceremony that ends without a token fails the mint" || t_fail "no-token mint rc" "rc=0"
+check "the mint error carries the client's last words" "the client said: Your account is on hold" "$out"
+check "the mint error names the kept transcript" "transcript: $ACC/tmp/mint-failed." "$out"
+tr="$(printf '%s' "$out" | sed -n 's/.*transcript: \([^)]*\)).*/\1/p' | head -1)"
+[ -n "$tr" ] && [ -s "$tr" ] && t_ok "the redacted transcript exists" || t_fail "transcript file" "missing: '$tr'"
+grep -q 'Your account is on hold' "$tr" 2>/dev/null && t_ok "the transcript holds the client's words" \
+  || t_fail "transcript content" "message missing"
+# (python, not stat: GNU stat reads -f as "file system" and answers something else)
+[ "$(python3 -c 'import os, sys; print(oct(os.stat(sys.argv[1]).st_mode & 0o777))' "$tr")" = "0o600" ] \
+  && t_ok "the transcript is private" || t_fail "transcript mode" "not 0600"
+[ "$(cat "$ACC/acct-04/server.token")" = "$orig" ] && t_ok "a ceremony without a token saves nothing" \
+  || t_fail "no-token save" "server.token was overwritten"
 # A pasted token gets the same proof: a revoked one is refused, not saved.
 # (A complete-length token, so the verdict is the rejection itself and not the
 # length rule that catches wrapped fragments first.)
@@ -1342,6 +1442,18 @@ rc=$?
 check "the paste refusal says Claude rejected it" "Claude rejected the captured token" "$out"
 [ "$(cat "$ACC/acct-04/server.token")" = "$orig" ] && t_ok "a rejected paste saves nothing" \
   || t_fail "rejected paste" "server.token was overwritten"
+# A SHORT rejected paste blames the paste — not a ceremony terminal this command
+# never opened.
+out="$(printf 'sk-ant-oat01-REVOKEDREVOKEDREVOKEDREVOKEDREVOKEDREVOKED' | claude-accounts mint acct-04 --paste 2>&1)"
+rc=$?
+[ "$rc" != "0" ] && t_ok "a short rejected paste is refused" || t_fail "short paste rc" "rc=0"
+check "the short-paste refusal blames the paste" "cut before it reached the clipboard" "$out"
+case "$out" in
+  *"sign-in terminal wrapped it"*) t_fail "short paste must not blame the ceremony terminal" "wrong provenance" ;;
+  *) t_ok "short paste must not blame the ceremony terminal" ;;
+esac
+[ "$(cat "$ACC/acct-04/server.token")" = "$orig" ] && t_ok "a short rejected paste saves nothing" \
+  || t_fail "short paste" "server.token was overwritten"
 
 # ---- 15c1b. the ceremony widens an unsized pty, so the whole token is captured ------
 # The panel drives the ceremony over a pty it never sized (0x0 -> the TUI renders 80
@@ -1438,9 +1550,15 @@ check "wrong-account sign-in skips (already added)" "a@test is already added as
 
 # ---- 15f. login command completes auth for an existing auth-less account -------------
 claude-accounts import pending@test --id acct-08 --no-sync >/dev/null 2>&1
+# A parked (dead) token beside the account: a LOGIN-only ceremony must not lift that
+# park — it proves the login, not the token.
+printf 'sk-ant-oat01-REVOKEDREVOKEDREVOKEDREVOKEDREVOKEDREVOKED' > "$ACC/acct-08/server.token"
+printf '%s\nreason=setup-token-invalid marked_at=x detail=portable OAuth token rejected\n' "$now" > "$ACC/acct-08/.expired"
 out="$(CLAUDE_MULTIACC_FORCE_TTY=1 FAKE_EMAIL=pending@test claude-accounts login acct-08 2>&1)"
 check "login completes existing account (full login)" "acct-08 login saved" "$out"
 [ -f "$ACC/acct-08/.credentials.json" ] && t_ok "login writes .credentials.json" || t_fail "login creds" "missing"
+[ -f "$ACC/acct-08/.expired" ] && t_ok "a login-only ceremony keeps the token park" \
+  || t_fail "login keeps token park" "marker removed"
 out="$(CLAUDE_MULTIACC_FORCE_TTY=1 FAKE_EMAIL=other@test claude-accounts login acct-08 2>&1)"
 rc=$?
 check "login email mismatch refused" "nothing saved" "$out"
@@ -1449,6 +1567,7 @@ check "login email mismatch refused" "nothing saved" "$out"
 out="$(CLAUDE_MULTIACC_FORCE_TTY=1 FAKE_EMAIL=pending@test claude-accounts login acct-08 --token 2>&1)"
 check "login --token saves a portable token" "acct-08 token saved" "$out"
 [ -s "$ACC/acct-08/server.token" ] && t_ok "login --token writes server.token" || t_fail "login token" "missing"
+[ ! -f "$ACC/acct-08/.expired" ] && t_ok "a new token lifts the token park" || t_fail "token lifts park" "marker still present"
 claude-accounts remove acct-08 --yes >/dev/null 2>&1
 
 # ---- 15f2. expired: the re-login worklist, and relogin fixes it ----------------------
@@ -2645,6 +2764,49 @@ out="$(claude-accounts verify 2>&1)"
 check "verify calls a rejected setup-token what it is" "portable setup-token is invalid" "$out"
 check "verify recommends replacing a rejected setup-token" \
   "claude-accounts login acct-01 --token" "$out"
+
+# ---- 17c. a login-proven pass never lifts a TOKEN park -------------------------------
+# One Mac can hold both credentials: a working OAuth login beside a dead portable
+# token. The limits probe's bearer is the LOGIN, and its success used to clear the
+# token's park ("dead-auth marker cleared") — the next selection exported the dead
+# token, got 401, parked it again, all day (2026-08-29).
+printf '{"claudeAiOauth":{"accessToken":"sk-ant-oat01-live","refreshToken":"r","expiresAt":9999999999999,"refreshTokenExpiresAt":9999999999999}}' > "$ACC/acct-01/.credentials.json"
+printf 'sk-ant-oat01-REVOKED%s' "$(printf '%88s' '' | tr ' ' R)" > "$ACC/acct-01/server.token"
+printf '%s\nreason=setup-token-invalid marked_at=x detail=portable OAuth token rejected\n' "$now" > "$ACC/acct-01/.expired"
+out="$(CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-low.json" claude-accounts limits 2>&1)"
+case "$out" in
+  *"acct-01: dead-auth marker cleared"*) t_fail "limits probe must not lift a token park" "the login's success cleared the token's marker" ;;
+  *) t_ok "limits probe must not lift a token park" ;;
+esac
+[ -f "$ACC/acct-01/.expired" ] && grep -q 'setup-token-invalid' "$ACC/acct-01/.expired" \
+  && t_ok "the token park survives a login-proven probe" || t_fail "token park survival" ".expired gone"
+# ...but an ordinary login park IS lifted — a working bearer proves exactly that.
+printf '%s\nreason=auth-error marked_at=x detail=a real call came back not-authenticated\n' "$now" > "$ACC/acct-01/.expired"
+out="$(CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-low.json" claude-accounts limits 2>&1)"
+check "an auth-error park is still lifted by a working bearer" "dead-auth marker cleared" "$out"
+[ ! -f "$ACC/acct-01/.expired" ] && t_ok "the login park was lifted" || t_fail "login park" "still present"
+# verify: a PASS on the LOGIN keeps the token park; a PASS on the TOKEN lifts it.
+printf '%s\nreason=setup-token-invalid marked_at=x detail=portable OAuth token rejected\n' "$now" > "$ACC/acct-01/.expired"
+out="$(claude-accounts verify 2>&1)"
+case "$out" in *"acct-01 a@test: PASS"*) t_ok "verify passes on the login" ;; \
+  *) t_fail "verify login pass" "$(printf '%s' "$out" | grep acct-01 | head -1)" ;; esac
+[ -f "$ACC/acct-01/.expired" ] && t_ok "a login pass does not lift the token park" \
+  || t_fail "verify token park" ".expired gone"
+# A dead login beside a fresh valid token: the pass rides the TOKEN and lifts its park.
+printf '{"claudeAiOauth":{"accessToken":"sk-ant-oat01-dead","refreshToken":"r","expiresAt":1000000000000,"refreshTokenExpiresAt":1000000000000}}' > "$ACC/acct-01/.credentials.json"
+printf 'sk-ant-oat01-%s' "$(printf '%95s' '' | tr ' ' G)" > "$ACC/acct-01/server.token"
+rm -f "$ACC/acct-01/.server-token-verified"
+out="$(claude-accounts verify 2>&1)"
+case "$out" in *"acct-01 a@test: PASS"*) t_ok "verify passes on the token" ;; \
+  *) t_fail "verify token pass" "$(printf '%s' "$out" | grep acct-01 | head -1)" ;; esac
+[ ! -f "$ACC/acct-01/.expired" ] && t_ok "a token pass lifts the token park" \
+  || t_fail "token pass park" "still present"
+# Hand back the state the next checks expect: a dead login beside a REVOKED token,
+# parked and unproven — exactly where 17b left acct-01.
+printf '{"claudeAiOauth":{"accessToken":"sk-ant-oat01-dead","refreshToken":"r","expiresAt":1000000000000,"refreshTokenExpiresAt":1000000000000}}' > "$ACC/acct-01/.credentials.json"
+printf 'sk-ant-oat01-REVOKEDREVOKEDREVOKEDREVOKEDREVOKEDREVOKED' > "$ACC/acct-01/server.token"
+rm -f "$ACC/acct-01/.server-token-verified"
+printf '%s\nreason=setup-token-invalid marked_at=x detail=portable setup-token failed a real inference\n' "$now" > "$ACC/acct-01/.expired"
 out="$(claude-accounts expired 2>&1)"
 check "verify marker retains setup-token classification" "TOKEN INVALID" "$out"
 check "verify marker retains setup-token recovery" \