claude-multiacc 2.0.24 → 2.0.26

package/README.md

@@ -384,6 +384,14 @@ Codex-specific notes:
   minutes even if the usage summary still says zero credits. A newly granted reset
   is redeemed during that pass and clears the old limit; no-credit results are
   checked again next pass, without waiting for the weekly reset date.
+  All authenticated accounts also report `usage.reset_credits_available` and
+  `usage.reset_credits_fetched_at` (ISO 8601) in `list/status/limits --json`.
+  The count comes from the credit endpoint, including below 95% used and with
+  automatic redemption disabled. The scheduled usage cadence bounds these reads.
+  Redemption shares that read, then reads back the remaining count after a POST;
+  no subtraction or embedded usage summary substitutes for provider evidence.
+  Zero means no available resets; missing fields mean the read was unavailable.
+  Credit identifiers remain local and selection does not use these fields.
 - **API-key logins are rejected** — ChatGPT subscription accounts only, matching the
   addon's no-API-keys rule.
 

package/bin/claude-accounts

@@ -1434,7 +1434,21 @@ limits_distribute() {
   sync_is_replica && return 0
   command -v rsync >/dev/null 2>&1 || return 0
   [ "${CLAUDE_MULTIACC_NO_DISTRIBUTE:-0}" = "1" ] && return 0
-  ( limits_distribute_now >/dev/null 2>&1 & ) >/dev/null 2>&1
+  # In its OWN session, not merely backgrounded. launchd tears down the job's
+  # whole process group the moment `limits` exits, and a `( … & )` subshell is
+  # still in that group: every scheduled pass spawned its push and launchd killed
+  # it before one rsync had finished, with nothing logged — while this machine
+  # refreshed every 15 minutes, the seven runner Macs ranked on readings last
+  # pushed at 21:13Z until 01:10Z on 2026-09-09 (a foreground pass delivered them
+  # in seconds). setsid puts the push outside the group; install.sh also marks
+  # the agent AbandonProcessGroup, and either one alone is enough.
+  "$PYBIN" -c '
+import os, sys
+if os.fork():
+    sys.exit(0)
+os.setsid()
+os.execv(sys.argv[1], [sys.argv[1], "limits-distribute-now"])
+' "$BIN_DIR/claude-accounts" >/dev/null 2>&1 </dev/null &
   return 0
 }
 
@@ -1472,21 +1486,26 @@ limits_distribute_now() {
   done
   if [ ! -s "$list" ]; then rm -f "$list"; return 0; fi
 
+  local pushed=0 failed=0
   server="$(sync_target)"
   sroot="$(sync_target_root)"
   if [ -n "$server" ] && ! sync_target_is_local "$server" \
      && valid_ssh_target "$server" && valid_remote_path "$sroot"; then
-    limits_push_to "$server" "$sroot" "$list"
+    if limits_push_to "$server" "$sroot" "$list"; then pushed=$((pushed + 1)); else failed=$((failed + 1)); fi
   fi
   # Peers are the OTHER Macs — the ones actually running tasks, and so the ones
-  # whose selection goes blind without this.
-  manifest_peers | while IFS="$(printf '\t')" read -r pt pr pp; do
+  # whose selection goes blind without this. Read through process substitution,
+  # not a pipe: the counters below must survive the loop.
+  while IFS="$(printf '\t')" read -r pt pr pp; do
     [ "$pt" = "MALFORMED" ] && continue
     [ -n "$pt" ] && [ -n "$pr" ] || continue
     valid_ssh_target "$pt" || continue
     valid_remote_path "$pr" || continue
-    limits_push_to "$pt" "$pr" "$list"
-  done
+    if limits_push_to "$pt" "$pr" "$list"; then pushed=$((pushed + 1)); else failed=$((failed + 1)); fi
+  done < <(manifest_peers)
+  # Every pass writes its outcome: a silent push is indistinguishable from a
+  # killed one, which is exactly how the 2026-09-08 outage went unnoticed.
+  log_to sync.log "limits distributed to $pushed target(s), $failed failed"
   rm -f "$list"
   rmdir "$lock" 2>/dev/null || true
   trap - EXIT
@@ -1497,8 +1516,7 @@ limits_push_to() { # $1 target, $2 remote root, $3 file list
   rsync -az --timeout=20 \
     -e 'ssh -o BatchMode=yes -o ConnectTimeout=10 -o StrictHostKeyChecking=accept-new' \
     --files-from="$3" "$ACC_ROOT/" "$1:$2/" >>"$ACC_ROOT/sync.log" 2>&1 \
-    || log_to sync.log "limits push to $1 failed (telemetry there will age)"
-  return 0
+    || { log_to sync.log "limits push to $1 failed (telemetry there will age)"; return 1; }
 }
 
 cmd_limits() {
@@ -2956,6 +2974,8 @@ case "${1:-help}" in
   sync) shift; cmd_sync "$@" ;;
   verify) shift; cmd_verify "$@" ;;
   limits) shift; cmd_limits "$@" ;;
+  # Internal: the detached telemetry push `limits` starts in its own session.
+  limits-distribute-now) shift; limits_distribute_now ;;
   post-sync) shift; cmd_post_sync "$@" ;;
   health) shift; cmd_health "$@" ;;
   self-update) shift; cmd_self_update "$@" ;;

package/bin/codex-accounts

@@ -1068,7 +1068,7 @@ import base64, datetime, json, os, sys, time, urllib.request
 root, threshold, quiet, url, force, lib_dir = (sys.argv[1], int(sys.argv[2]),
     sys.argv[3] == '1', sys.argv[4], sys.argv[5] == '1', sys.argv[6])
 sys.path.insert(0, lib_dir)
-from codex_reset import try_auto_redeem
+from codex_reset_telemetry import refresh_reset_credits
 now = time.time()
 # Don't re-fetch an account whose data is younger than this (endpoint rate-limits).
 MIN_FETCH_INTERVAL = int(os.environ.get('CODEX_MULTIACC_MIN_FETCH', '240'))
@@ -1564,15 +1564,17 @@ for acct in manifest.get('accounts', []):
     weeklyp = max(weekly) if weekly else None
     sessionp = max(session) if session else None
     try:
-        reset_result = try_auto_redeem(d, aid, maxp, data, url, headers, say, int(now))
+        reset_result, reset_view = refresh_reset_credits(d, aid, maxp, data, url, headers, say, int(now))
     except Exception as e:
         say(f'{aid}: usage reset automation failed unexpectedly ({type(e).__name__}); failing open')
         reset_result = {'status': 'error'}
+        reset_view = {}
     # Internal only (see win_bucket): limits.json keeps the bucket shape every reader
     # — the shim, lib/report.py, app-robot — already knows.
     for b in buckets:
         b.pop('_reset_known', None)
     out = {'fetched_at': int(now), 'source': 'chatgpt'}
+    out.update(reset_view)
     if live:
         out['max_percent'] = maxp
     if weeklyp is not None:

package/install.sh

@@ -183,6 +183,9 @@ mac_schedule_install() {
   </array>
 $(plist_env_block)  <key>StartInterval</key><integer>900</integer>
   <key>RunAtLoad</key><true/>
+  <!-- The pass hands its readings to the peers from a detached push; launchd
+       must not kill that push with the job's process group. -->
+  <key>AbandonProcessGroup</key><true/>
   <key>StandardOutPath</key><string>/dev/null</string>
   <key>StandardErrorPath</key><string>/dev/null</string>
 </dict></plist>
@@ -238,6 +241,7 @@ EOF
   </array>
 $(plist_env_block)  <key>StartInterval</key><integer>300</integer>
   <key>RunAtLoad</key><true/>
+  <key>AbandonProcessGroup</key><true/>
   <key>StandardOutPath</key><string>/dev/null</string>
   <key>StandardErrorPath</key><string>/dev/null</string>
 </dict></plist>

package/lib/codex_reset.py

@@ -111,7 +111,7 @@ def _redeem_request_id(account_id: str, usage: dict, headers: dict, now: int) ->
 
 def try_auto_redeem(account_dir: str, account_id: str, used_percent: int,
                     usage: dict, usage_url: str, headers: dict, say,
-                    now: int | None = None) -> dict:
+                    now: int | None = None, credit_details: dict | None = None) -> dict:
     """Redeem one available reset and return a non-secret outcome document."""
     current = int(now if now is not None else time.time())
     finished, _ = reset_windows(usage, RESET_AT_USED_PERCENT)
@@ -125,7 +125,8 @@ def try_auto_redeem(account_dir: str, account_id: str, used_percent: int,
         # Newly granted credits can precede the usage response's embedded summary.
         # The scheduled usage cadence bounds these reads, including spent accounts.
         try:
-            available_count, credit_id = _credit_to_redeem(_request(list_url, headers))
+            details = credit_details if credit_details is not None else _request(list_url, headers)
+            available_count, credit_id = _credit_to_redeem(details)
         except Exception as error:
             say(f"{account_id}: usage reset availability failed ({type(error).__name__}); failing open")
             return {"status": "error"}

package/lib/codex_reset_telemetry.py

@@ -0,0 +1,34 @@
+"""Observe reset allowances at the usage cadence, independently of redemption eligibility."""
+
+import time
+
+from codex_reset import _request, _reset_urls, try_auto_redeem
+
+
+def _read_credits(url, headers, account_id, say):
+    try:
+        details = _request(url, headers)
+        count = details.get("available_count")
+        if type(count) is not int or not 0 <= count <= 1_000_000:
+            raise ValueError("invalid reset allowance")
+        return details, {"reset_credits_available": count,
+                         "reset_credits_fetched_at": int(time.time())}
+    except Exception as error:
+        say(f"{account_id}: usage reset availability failed ({type(error).__name__})")
+        return {}, {}
+
+
+def refresh_reset_credits(account_dir, account_id, used_percent, usage, usage_url, headers, say, now):
+    """Read all accounts, share the GET with redemption, then read back after a mutation.
+
+    Failed reads omit the count; neither an embedded summary nor subtraction proves
+    the remaining allowance after another machine may have redeemed a credit.
+    Disabling automatic redemption still permits this read-only telemetry.
+    """
+    list_url, _ = _reset_urls(usage_url)
+    details, view = _read_credits(list_url, headers, account_id, say)
+    result = try_auto_redeem(account_dir, account_id, used_percent, usage, usage_url,
+                             headers, say, now, credit_details=details)
+    if result.get("status") not in {"not_eligible", "cooldown", "no_credit", "error"}:
+        _, view = _read_credits(list_url, headers, account_id, say)
+    return result, view

package/lib/report.py

@@ -242,6 +242,10 @@ def _usage(d, stale_after):
     out = {'fetched_at': _iso(fetched), 'source': lim.get('source'),
            'max_percent': lim.get('max_percent'), 'weekly_percent': lim.get('weekly_percent'),
            'session_percent': lim.get('session_percent'), 'buckets': buckets}
+    reset_count = lim.get('reset_credits_available')
+    reset_stamp = _iso(lim.get('reset_credits_fetched_at'))
+    if type(reset_count) is int and 0 <= reset_count <= 1_000_000 and reset_stamp:
+        out.update(reset_credits_available=reset_count, reset_credits_fetched_at=reset_stamp)
     try:
         out['age_seconds'] = max(0, int(time.time() - float(fetched)))
     except (TypeError, ValueError):

package/package.json

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

package/tests/run-tests.sh

@@ -3759,6 +3759,7 @@ mkdir -p "$RSFAKE"
 cat > "$RSFAKE/rsync" <<'EOF'
 #!/usr/bin/env bash
 printf 'RSYNC %s\n' "$*" >> "${RSLOG:?}"
+printf 'PGID %s\n' "$(ps -o pgid= -p $$ | tr -d ' ')" >> "$RSLOG"
 for a in "$@"; do
   case "$a" in
     --files-from=*)
@@ -3795,6 +3796,23 @@ for peer in gas@mini-3 gas@mini-4; do
     && t_ok "telemetry is pushed to manifest peer $peer" \
     || t_fail "limits distribute peer" "$peer never received a push: $(grep '^RSYNC' "$RSLOG")"
 done
+# The push must run OUTSIDE the calling job's process group: launchd kills that group
+# the moment `limits` exits, and a `( … & )` subshell is still in it — on 2026-09-08 the
+# source Mac refreshed every 15 minutes while every scheduled push died before its first
+# rsync, and the seven runner Macs ranked on 21:13Z readings until 01:10Z the next day.
+own_pgid="$(ps -o pgid= -p $$ | tr -d ' ')"
+push_pgids="$(grep '^PGID ' "$RSLOG" | sort -u | sed 's/^PGID //' | tr '\n' ' ')"
+case " $push_pgids " in
+  *" $own_pgid "*) t_fail "detached push session" "a push ran inside the caller's process group $own_pgid (launchd would kill it)" ;;
+  *) [ -n "$push_pgids" ] && t_ok "the telemetry push runs in its own session, outside the job's process group" \
+       || t_fail "detached push session" "no push recorded a process group" ;;
+esac
+grep -q "limits distributed to 3 target(s), 0 failed" "$DPOOL/sync.log" \
+  && t_ok "every distribute pass records its outcome in sync.log" \
+  || t_fail "distribute summary" "sync.log: $(tail -3 "$DPOOL/sync.log" 2>/dev/null | tr '\n' '|')"
+[ "$(grep -c '<key>AbandonProcessGroup</key><true/>' "$REPO_DIR/install.sh")" = "2" ] \
+  && t_ok "install.sh abandons the process group of both limits agents" \
+  || t_fail "AbandonProcessGroup" "expected both limits plists to carry AbandonProcessGroup"
 # ...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" ] \

package/tests/test_codex_reset.py

@@ -50,6 +50,10 @@ class ResetHandler(BaseHTTPRequestHandler):
         length = int(self.headers.get("Content-Length") or 0)
         state["posts"].append(json.loads(self.rfile.read(length)))
         status, body = state["responses"].pop(0)
+        if status == 200 and body.get("code") == "reset":
+            state["credits"]["available_count"] -= 1
+        if "credits_after_post" in state:
+            state["credits"] = state["credits_after_post"]
         encoded = json.dumps(body).encode()
         self.send_response(status)
         self.send_header("Content-Type", "application/json")
@@ -144,7 +148,7 @@ class CodexResetIntegrationTest(CodexPoolSandbox, unittest.TestCase):
             "rate_limit_reset_credits": {"available_count": 1}}
         result = self.run_limits()
         self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertEqual(self.server.state["credit_gets"], 0)
+        self.assertEqual(self.server.state["credit_gets"], 1)
         self.assertEqual(self.server.state["posts"], [])
         self.assertFalse((self.pool / "acct-01/.usage-reset.json").exists())
 
@@ -167,7 +171,7 @@ class CodexResetIntegrationTest(CodexPoolSandbox, unittest.TestCase):
         self.assertEqual(len(self.server.state["posts"]), 2)
         keys = [request["redeem_request_id"] for request in self.server.state["posts"]]
         self.assertEqual(keys[0], keys[1])
-        self.assertEqual(self.server.state["credit_gets"], 1)
+        self.assertEqual(self.server.state["credit_gets"], 4)
 
 
 class CodexMarkerNamesOneBucketTest(CodexPoolSandbox, unittest.TestCase):

package/tests/test_codex_reset_polling.py

@@ -57,7 +57,7 @@ class ResetPollingTest(fixtures.CodexPoolSandbox, unittest.TestCase):
         self.grant_credit()
         self.next_pass()
         self.run_scheduled()
-        self.assertEqual(self.server.state["credit_gets"], 3)
+        self.assertEqual(self.server.state["credit_gets"], 4)
         self.assertEqual(self.server.state["posts"][0]["credit_id"], "newly-granted")
         self.assertFalse(marker.exists())
         receipt = json.loads((self.pool / "acct-01/.usage-reset.json").read_text())
@@ -79,13 +79,13 @@ class ResetPollingTest(fixtures.CodexPoolSandbox, unittest.TestCase):
         self.grant_credit()
         self.next_pass()
         self.run_scheduled()
-        self.assertEqual(self.server.state["credit_gets"], 2)
+        self.assertEqual(self.server.state["credit_gets"], 3)
         self.assertFalse((self.pool / "acct-01/.limited").exists())
 
-    def test_disabled_automation_does_not_query_or_spend_credits(self):
+    def test_disabled_automation_reports_without_spending_credits(self):
         self.grant_credit()
         self.run_scheduled(enabled="0")
-        self.assertEqual(self.server.state["credit_gets"], 0)
+        self.assertEqual(self.server.state["credit_gets"], 1)
         self.assertEqual(self.server.state["posts"], [])
         self.assertTrue((self.pool / "acct-01/.limited").exists())
 

package/tests/test_codex_reset_reporting.py

@@ -0,0 +1,82 @@
+"""The public pool report carries measured allowances for active and limited accounts."""
+
+import json
+import os
+import subprocess
+import time
+import unittest
+
+import test_codex_reset as fixtures
+
+
+class ResetReportingTest(fixtures.CodexPoolSandbox, unittest.TestCase):
+    def report(self, used=60, enabled="1"):
+        self.server.state["usage"] = {"rate_limit": {"allowed": True,
+            "primary_window": {"used_percent": used, "limit_window_seconds": 604800,
+                               "reset_at": int(time.time()) + 86400}},
+            "rate_limit_reset_credits": {"available_count": 0}}
+        base = f"http://127.0.0.1:{self.server.server_port}/wham"
+        env = dict(os.environ, CODEX_ACCOUNTS_ROOT=str(self.pool), CODEX_MULTIACC_NO_SYNC="1",
+                   CODEX_MULTIACC_AUTO_RESET=enabled, CODEX_MULTIACC_USAGE_URL=f"{base}/usage",
+                   PYTHONDONTWRITEBYTECODE="1")
+        for key in ("CODEX_MULTIACC_RESET_CREDITS_URL", "CODEX_MULTIACC_RESET_CONSUME_URL"):
+            env.pop(key, None)
+        result = subprocess.run([fixtures.REPO / "bin/codex-accounts", "limits", "--force", "--json"],
+                                capture_output=True, text=True, env=env, timeout=20, check=False)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertNotIn("private-credit", result.stdout)
+        return json.loads(result.stdout)["accounts"][0]
+
+    def test_active_account_reports_credits_without_redeeming(self):
+        self.server.state["credits"] = {"available_count": 3, "credits": [
+            {"id": "private-credit", "status": "available"}]}
+        account = self.report()
+        self.assertEqual(account["usage"]["reset_credits_available"], 3)
+        self.assertTrue(account["usage"]["reset_credits_fetched_at"].endswith("Z"))
+        self.assertEqual(self.server.state["credit_gets"], 1)
+        self.assertEqual(self.server.state["posts"], [])
+
+    def test_spent_account_reports_real_zero(self):
+        self.server.state["credits"] = {"available_count": 0, "credits": []}
+        account = self.report(100)
+        self.assertTrue(account["limited"])
+        self.assertEqual(account["usage"]["reset_credits_available"], 0)
+
+    def test_redemption_reports_readback_instead_of_pre_reset_allowance(self):
+        self.server.state["credits"] = {"available_count": 2, "credits": []}
+        self.server.state["responses"] = [(200, {"code": "reset", "windows_reset": 1})]
+        account = self.report(100)
+        self.assertEqual(account["usage"]["reset_credits_available"], 1)
+        self.assertTrue(account["usage"]["reset_credits_fetched_at"])
+        self.assertEqual(self.server.state["credit_gets"], 2)
+        self.assertEqual(len(self.server.state["posts"]), 1)
+
+    def test_failed_or_invalid_reads_clear_previous_allowance_without_hiding_usage(self):
+        self.server.state["credits"] = {"available_count": 2}
+        self.report()
+        for count in (None, "2", True, -1, 1.5, 1_000_001):
+            with self.subTest(count=count):
+                self.server.state["credits"] = {"available_count": count}
+                usage = self.report()["usage"]
+                self.assertNotIn("reset_credits_available", usage)
+                self.assertNotIn("reset_credits_fetched_at", usage)
+                self.assertEqual(usage["weekly_percent"], 60)
+        self.assertEqual(self.server.state["posts"], [])
+
+    def test_disabled_redemption_still_reports_allowance(self):
+        self.server.state["credits"] = {"available_count": 2}
+        self.assertEqual(self.report(100, enabled="0")["usage"]["reset_credits_available"], 2)
+        self.assertEqual(self.server.state["posts"], [])
+
+    def test_failed_readback_does_not_reuse_the_allowance_before_redemption(self):
+        self.server.state["credits"] = {"available_count": 2, "credits": []}
+        self.server.state["credits_after_post"] = []
+        self.server.state["responses"] = [(200, {"code": "reset", "windows_reset": 1})]
+        account = self.report(100)
+        self.assertFalse(account["limited"])
+        self.assertNotIn("reset_credits_available", account["usage"])
+        self.assertEqual(len(self.server.state["posts"]), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()