claude-multiacc 2.0.43 → 2.0.44

package/lib/claude_token_identity.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""Bind a portable Claude token to its slot using authenticated response headers.
+
+An inference may be quota-rejected and still identify the token's organization.
+This receipt proves organization identity only, never remaining quota or token validity.
+No credentials or response bodies are written to the receipt or diagnostic output.
+"""
+
+from __future__ import annotations
+
+import argparse
+import fcntl
+import hashlib
+import json
+import os
+from pathlib import Path
+import sys
+import tempfile
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+
+from claude_reset import cli_version, user_agent
+
+RECEIPT = ".server-token-identity.json"
+LOCK_FILE = ".server-token-identity.lock"
+ENDPOINT = "https://api.anthropic.com/v1/messages?beta=true"
+MODEL = "claude-haiku-4-5-20251001"
+UNKNOWN_BACKOFF = 60
+TIMEOUT = 10
+
+
+class NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+def _org(value):
+    try:
+        return str(uuid.UUID(value)) if isinstance(value, str) else ""
+    except ValueError:
+        return ""
+
+
+def _load(path):
+    try:
+        with path.open(encoding="utf-8") as handle:
+            value = json.load(handle)
+        return value if isinstance(value, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _context(account_dir, token, now, expected_email=None):
+    account = Path(account_dir)
+    result = {"status": "unknown", "reason": "token_unavailable", "checked_at": now}
+    try:
+        if token is None:
+            with (account / "server.token").open(encoding="utf-8") as handle:
+                token = handle.read(4097)
+        token = token.strip()
+    except (OSError, ValueError, AttributeError):
+        return result, ""
+    if not token.startswith("sk-ant-oat") or len(token) > 4096 or not all(33 <= ord(c) <= 126 for c in token):
+        return dict(result, reason="invalid_token"), ""
+    digest = hashlib.sha256(token.encode()).hexdigest()
+    config = _load(account / ".claude.json")
+    profile = config.get("oauthAccount")
+    profile = profile if isinstance(profile, dict) else {}
+    rows = _load(account.parent / "accounts.json").get("accounts", [])
+    rows = rows if isinstance(rows, list) else []
+    row = next((r for r in rows if isinstance(r, dict) and r.get("id") == account.name), {})
+    email = str(row.get("email") or "").strip().lower()
+    profile_email = str(profile.get("emailAddress") or profile.get("email") or "").strip().lower()
+    result.update(token_digest=digest, account_id=account.name, account_email=email, manifest_bound=bool(row))
+    if expected_email is not None and not (profile_email or email):
+        return dict(result, reason="missing_profile_email"), ""
+    if ((email and profile_email and email != profile_email)
+            or (expected_email is not None and str(expected_email).strip().lower() != (profile_email or email))):
+        return dict(result, status="mismatch", reason="profile_manifest_mismatch"), ""
+    receipt = _load(account / RECEIPT)
+    bound = all(receipt.get(key) == result[key] for key in
+                ("token_digest", "account_id", "account_email", "manifest_bound"))
+    expected = _org(profile.get("organizationUuid"))
+    if not expected and "oauthAccount" not in config and bound and row:
+        expected = _org(receipt.get("expected_org"))
+    if not expected:
+        return dict(result, reason="missing_expected_organization"), ""
+    result.update(expected_org=expected, reason="unchecked")
+    actual, status = _org(receipt.get("actual_org")), receipt.get("status")
+    checked = receipt.get("checked_at")
+    reusable = ((status == "match" and actual == expected)
+                or (status == "mismatch" and actual and actual != expected)
+                or (status == "unknown" and isinstance(checked, (int, float))
+                    and 0 <= now - checked < UNKNOWN_BACKOFF))
+    if bound and receipt.get("expected_org") == expected and reusable:
+        return dict(receipt, cached=True), ""
+    return result, token
+
+
+def _probe(token, endpoint, model, version):
+    try:
+        url = urllib.parse.urlsplit(endpoint)
+    except ValueError:
+        return {"status": "unknown", "actual_org": "", "reason": "invalid_endpoint"}
+    official = url.scheme == "https" and url.netloc == "api.anthropic.com"
+    local = url.scheme == "http" and url.hostname in {"127.0.0.1", "::1", "localhost"}
+    if not (official or local) or url.username or url.password or url.fragment:
+        return {"status": "unknown", "actual_org": "", "reason": "invalid_endpoint"}
+    betas = ["oauth-2025-04-20", "prompt-caching-scope-2026-01-05"]
+    if "haiku" not in model.lower():
+        betas.append("claude-code-20250219")
+    body = {"model": model, "max_tokens": 1, "messages": [{"role": "user", "content": "quota"}]}
+    request = urllib.request.Request(endpoint, data=json.dumps(body).encode(), headers={
+        "Authorization": f"Bearer {token}", "anthropic-version": "2023-06-01",
+        "anthropic-beta": ",".join(betas), "Content-Type": "application/json",
+        "User-Agent": user_agent(version), "x-app": "cli"})
+    opener = urllib.request.build_opener(NoRedirect())
+    try:
+        try:
+            response = opener.open(request, timeout=TIMEOUT)
+        except urllib.error.HTTPError as error:
+            response = error
+        with response:
+            code = response.code
+            values = response.headers.get_all("anthropic-organization-id", [])
+            actual = _org(values[0]) if len(values) == 1 else ""
+        if 300 <= code < 400:
+            return {"status": "unknown", "actual_org": "", "reason": "redirect"}
+        reason = "organization_header" if actual else "missing_organization"
+        if not actual and code in {401, 403}:
+            reason = "auth_failed"
+        return {"actual_org": actual, "http_status": code, "reason": reason}
+    except (OSError, ValueError, urllib.error.URLError):
+        return {"status": "unknown", "actual_org": "", "reason": "request_failed"}
+
+
+def _save(account, receipt):
+    path = None
+    try:
+        fd, path = tempfile.mkstemp(prefix=RECEIPT + ".", dir=account)
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            json.dump(receipt, handle, sort_keys=True)
+            handle.write("\n")
+        os.replace(path, account / RECEIPT)
+    except OSError:
+        pass
+    finally:
+        try:
+            if path:
+                os.unlink(path)
+        except OSError:
+            pass
+
+
+def _result(receipt):
+    result = {"state": receipt.get("status", "unknown"), "cached": receipt.get("cached", False),
+              "token_digest": receipt.get("token_digest", ""), "reason": receipt.get("reason", "unchecked")}
+    if "http_status" in receipt:
+        result["http_status"] = receipt["http_status"]
+    return result
+
+
+def cached_identity(account_dir, token=None, *, now=None):
+    """Return identity already proved for this token and slot, without HTTP."""
+    receipt, _ = _context(account_dir, token, time.time() if now is None else now)
+    return _result(receipt)
+
+
+def check_identity(account_dir, token=None, *, endpoint=None, model=None, version=None, now=None,
+                   persist=True, expected_email=None):
+    """Check this exact token, or only the requested account's server.token file.
+
+    Match/mismatch receipts survive indefinitely because a token cannot change its
+    organization. Changing either the token or configured organization invalidates
+    them; an inconclusive request backs off for one minute. Authentication preflight
+    remains independent, including for an identity-matched but later revoked token.
+    A persistent lock prevents a delayed unknown result from replacing proof written
+    by another launch. Read-only callers still receive independently proved mismatches.
+    """
+    lock = None
+    try:
+        lock = os.fdopen(os.open(Path(account_dir) / LOCK_FILE, os.O_CREAT | os.O_RDWR, 0o600), "w")
+        fcntl.flock(lock, fcntl.LOCK_EX)
+    except OSError:
+        if lock:
+            lock.close()
+        lock = None
+    try:
+        receipt, token = _context(account_dir, token, time.time() if now is None else now, expected_email)
+        if not token:
+            return _result(receipt)
+        endpoint = endpoint or os.environ.get("CLAUDE_MULTIACC_TOKEN_IDENTITY_URL") or ENDPOINT
+        receipt.update(_probe(token, endpoint, model or MODEL, version))
+        actual = receipt["actual_org"]
+        receipt["status"] = ("match" if actual == receipt["expected_org"] else "mismatch") if actual else "unknown"
+        if not lock and not actual:
+            current, _ = _context(account_dir, token, time.time() if now is None else now, expected_email)
+            if current["status"] in {"match", "mismatch"}:
+                return _result(current)
+        if persist and lock:
+            _save(Path(account_dir), receipt)
+        return _result(receipt)
+    finally:
+        if lock:
+            lock.close()
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("command", choices=["check", "cached"])
+    parser.add_argument("account_dir")
+    parser.add_argument("--token-stdin", action="store_true", help="use the exact token read from stdin")
+    parser.add_argument("--real", help="installed Claude executable, used only to learn its version")
+    parser.add_argument("--model", default=MODEL)
+    parser.add_argument("--format", choices=["json", "state"], default="json")
+    parser.add_argument("--no-store", action="store_true", help="check a candidate without replacing the receipt")
+    parser.add_argument("--expected-email", help="named account email for a candidate not yet in the manifest")
+    args = parser.parse_args()
+    token = sys.stdin.read(4097) if args.token_stdin else None
+    if args.command == "cached":
+        result = cached_identity(args.account_dir, token)
+    else:
+        result = check_identity(args.account_dir, token, model=args.model,
+                                version=cli_version(args.real), persist=not args.no_store,
+                                expected_email=args.expected_email)
+    print(result["state"] if args.format == "state" else json.dumps(result, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

package/lib/common.sh

@@ -441,7 +441,9 @@ EOF
   fi
   local d="$ACC_ROOT/$target_id"
   seed_account_dir "$d"
-  "$PYBIN" "$CREDENTIAL_PY" install "$MULTIACC_PROVIDER" "$stage" "$d" >/dev/null \
+  local identity_cli=""
+  [ "$MULTIACC_PROVIDER" != "claude" ] || identity_cli="$(find_real_claude "${_self:-$0}" 2>/dev/null)" || true
+  "$PYBIN" "$CREDENTIAL_PY" install "$MULTIACC_PROVIDER" "$stage" "$d" "$identity_cli" >/dev/null \
     || fail_locked "could not install the credential into $d — nothing registered"
   manifest_add_account "$target_id" "$bemail" "$home" "$badded" \
     || fail_locked "manifest update failed — $target_id was seeded but NOT registered (re-run import-credential)"

package/lib/credential.py

@@ -12,7 +12,7 @@ Run (all paths absolute; the blob never passes through argv):
       class, id, email, home, added_at, cred_type. The separator is deliberately NOT
       whitespace: bash collapses runs of IFS whitespace, which would silently shift
       an empty field (a blob with no `home`) into the next one.
-  python3 lib/credential.py install <provider> <blob-file> <dest-dir>
+  python3 lib/credential.py install <provider> <blob-file> <dest-dir> [real-claude]
       writes the credential material into <dest-dir> (0600, atomic); no-op for an
       identity-only blob. Prints the file it wrote (or nothing).
 
@@ -315,7 +315,7 @@ def cmd_inspect(argv):
 
 def cmd_install(argv):
     if len(argv) < 3:
-        die('usage: credential.py install <provider> <blob-file> <dest-dir>')
+        die('usage: credential.py install <provider> <blob-file> <dest-dir> [real-claude]')
     provider, path, dest = argv[0], argv[1], argv[2]
     blob, cclass, _aid, _email, _home, _added, _type = _validate(provider, path)
     if cclass == 'identity':
@@ -325,6 +325,13 @@ def cmd_install(argv):
             f'write a credential through it', 2)
     if not os.path.isdir(dest):
         die(f'destination is not a directory: {dest}')
+    from claude_reset import cli_version
+    from claude_token_identity import check_identity
+    identity = check_identity(dest, blob['credential']['value'].strip(), persist=False,
+                              version=cli_version(argv[3] if len(argv) > 3 else None), expected_email=_email)
+    if identity['state'] == 'mismatch':
+        die('the token organization does not match the destination account — nothing installed; '
+            'mint a token for the named account', 5)
     out = os.path.join(dest, 'server.token')
     _write_secure(out, blob['credential']['value'].strip(), nofollow_dir=True)
     print(out)

package/package.json

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

package/tests/run-tests.sh

@@ -367,6 +367,9 @@ export CLAUDE_MULTIACC_TOKEN_URL="file://$WORK/token-endpoint-missing.json"
 # (every explicit limits test overrides the URL inline). The pre-armed .limits-kick
 # throttle keeps those background kicks from racing explicit limits runs.
 export CLAUDE_MULTIACC_USAGE_URL="file://$WORK/usage-endpoint-missing.json"
+# Organization checks must never send synthetic tokens to a real provider. The
+# dedicated identity suite overrides this with its loopback HTTP contract server.
+export CLAUDE_MULTIACC_TOKEN_IDENTITY_URL="file://$WORK/identity-endpoint-missing.json"
 : > "$ACC/.limits-kick"
 # Keychain lookups are OFF for the legacy sections (their pools are file-based and the
 # extra `security` process per account would only slow them down); section 17 turns
@@ -7672,12 +7675,12 @@ check "mint refuses an unregistered account dir" "unknown account: acct-77" "$ou
   || t_fail "mint orphan dir" "server.token was written to an unregistered slot"
 rm -rf "$ACC/acct-77"
 
-# mint must NAME the account it is about to bind a token to (the only guard there is).
+# mint must NAME the account even when no saved organization is available to check.
 printf 'sk-ant-oat01-MINTNAMEDMINTNAMEDMINTNAMEDMINTNAMEDMINTNAMED\n' \
   | claude-accounts mint acct-01 --paste > "$WORK/mint-named.out" 2>&1
 out="$(cat "$WORK/mint-named.out")"
 check "mint --paste names the account in its prompt" "for acct-01" "$out"
-check "mint warns that a setup token carries no identity" "carries no identity" "$out"
+check "mint reports an unavailable organization check" "organization could not be checked" "$out"
 
 # ---- 47. every known verb answers --help with exit 0 (app-robot probes with it) ----
 # app-robot's runner asks `<verb> --help` to decide whether a Mac's build has the verb;
@@ -9021,6 +9024,12 @@ else
   t_fail "auto-resume watcher unit suite" "see unittest output above"
 fi
 
+if python3 -m unittest discover -s "$REPO_DIR/tests" -p 'test_*token_identity*.py'; then
+  t_ok "claude: portable token organization identity suite"
+else
+  t_fail "claude portable token identity suite" "see unittest output above"
+fi
+
 # ---- summary ---------------------------------------------------------------------
 echo
 echo "passed: $PASS  failed: $FAIL"

package/tests/test_claude_token_identity.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""Organization binding uses fake tokens and a loopback Messages endpoint only."""
+
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+from functools import partial
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+import hashlib
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import threading
+import unittest
+from unittest.mock import patch
+
+REPO = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(REPO / "lib"))
+import claude_token_identity as identity
+
+ORG = "11111111-2222-4333-8444-555555555555"
+OTHER = "99999999-8888-4777-8666-555555555555"
+TOKEN = "sk-ant-oat01-sandbox-token-a"
+SECOND = "sk-ant-oat01-sandbox-token-b"
+EMAIL = "sandbox@example.invalid"
+NOW = 1790292600
+
+
+class IdentityHandler(BaseHTTPRequestHandler):
+    def do_POST(self):
+        state = self.server.state
+        size = int(self.headers.get("Content-Length", 0))
+        state["requests"].append({"path": self.path, "body": self.rfile.read(size).decode(),
+                                  "headers": dict(self.headers), "method": self.command})
+        code, org = state["code"], state.get("org")
+        if state.get("serialize_test"):
+            if len(state["requests"]) == 1:
+                state["first_seen"].set()
+                state["second_seen"].wait(0.2)
+                code, org = 429, OTHER
+            else:
+                state["second_seen"].set()
+                state["allow_second"].wait(2)
+                code, org = 200, None
+        self.send_response(code)
+        if org is not None:
+            self.send_header("anthropic-organization-id", org)
+        if state.get("location"):
+            self.send_header("Location", state["location"])
+        self.send_header("Content-Length", "0")
+        self.end_headers()
+
+    do_GET = do_POST
+
+    def log_message(self, _format, *_args):
+        pass
+
+
+class TokenIdentityTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory(prefix="multiacc-token-identity-")
+        self.account = Path(self.temp.name) / "acct-01"
+        self.account.mkdir()
+        (self.account / "server.token").write_text(TOKEN)
+        self.manifest = self.account.parent / "accounts.json"
+        self.manifest.write_text(json.dumps({"accounts": [{"id": "acct-01", "email": EMAIL}]}))
+        self.config = self.account / ".claude.json"
+        self.config.write_text(json.dumps({"oauthAccount": {"organizationUuid": ORG, "emailAddress": EMAIL}}))
+        self.server = ThreadingHTTPServer(("127.0.0.1", 0), IdentityHandler)
+        self.server.state = {"code": 200, "org": ORG, "requests": []}
+        self.thread = threading.Thread(target=self.server.serve_forever, daemon=True)
+        self.thread.start()
+        self.url = f"http://127.0.0.1:{self.server.server_port}/v1/messages?beta=true"
+        self.check = partial(identity.check_identity, self.account, endpoint=self.url, version="2.1.282")
+        self.env = patch.dict(os.environ, {"HOME": self.temp.name, "PATH": os.defpath}, clear=True)
+        self.env.start()
+
+    def tearDown(self):
+        self.env.stop()
+        self.server.shutdown()
+        self.server.server_close()
+        self.thread.join(timeout=5)
+        self.temp.cleanup()
+
+    def test_match_is_bound_and_legacy_auth_receipt_cannot_skip_probe(self):
+        (self.account / ".server-token-verified").write_text(hashlib.sha256(TOKEN.encode()).hexdigest())
+        result = self.check(now=NOW)
+        self.assertEqual(result["state"], "match")
+        self.assertFalse(result["cached"])
+        self.assertEqual(identity.cached_identity(self.account, now=NOW)["state"], "match")
+        self.assertTrue(self.check(now=NOW + 86400)["cached"])
+        requests = self.server.state["requests"]
+        self.assertEqual(len(requests), 1)
+        request = requests[0]
+        self.assertEqual(request["path"], "/v1/messages?beta=true")
+        self.assertEqual(json.loads(request["body"]), {
+            "model": identity.MODEL, "max_tokens": 1, "messages": [{"role": "user", "content": "quota"}]})
+        self.assertLess(len(request["body"]), 256)
+        headers = {k.lower(): v for k, v in request["headers"].items()}
+        self.assertEqual(headers["authorization"], "Bearer " + TOKEN)
+        self.assertIn("oauth-2025-04-20", headers["anthropic-beta"])
+        self.assertEqual(headers["user-agent"], "claude-cli/2.1.282 (external, cli, client-app/claude-multiacc)")
+        receipt = self.account / identity.RECEIPT
+        self.assertEqual(receipt.stat().st_mode & 0o777, 0o600)
+        self.assertNotIn(TOKEN, receipt.read_text())
+        self.assertNotIn(ORG, json.dumps(result))
+        self.assertEqual(json.loads(receipt.read_text())["expected_org"], ORG)
+
+    def test_quota_rejection_identifies_mismatch_and_persists(self):
+        self.config.write_text(json.dumps({"oauthAccount": {"organizationUuid": ORG, "emailAddress": EMAIL},
+                                           "projects": {"sandbox": {"history": "x" * 32768}}}))
+        self.assertGreater(self.config.stat().st_size, 16384)
+        self.server.state.update(code=429, org=OTHER)
+        with patch.object(identity.os, "replace", side_effect=PermissionError):
+            result = self.check(now=NOW, model="claude-opus-4-6")
+        self.assertEqual(result["state"], "mismatch")
+        self.assertFalse((self.account / identity.RECEIPT).exists())
+        headers = {k.lower(): v for k, v in self.server.state["requests"][0]["headers"].items()}
+        self.assertIn("claude-code-20250219", headers["anthropic-beta"])
+        with patch.object(identity.os, "open", side_effect=PermissionError):
+            self.assertEqual(self.check(now=NOW)["state"], "mismatch")
+        self.assertFalse((self.account / identity.RECEIPT).exists())
+        result = self.check(now=NOW)
+        self.assertEqual(result["state"], "mismatch")
+        self.assertEqual(result["http_status"], 429)
+        self.server.state.update(code=200, org=ORG)
+        self.assertEqual(self.check(now=NOW + 365 * 86400)["state"], "mismatch")
+        self.assertEqual(len(self.server.state["requests"]), 3)
+        stored = json.loads((self.account / identity.RECEIPT).read_text())
+        self.assertEqual(stored["actual_org"], OTHER)
+        self.assertNotIn(OTHER, json.dumps(result))
+        self.config.write_text("{}")
+        candidate = self.check(expected_email=EMAIL, persist=False, now=NOW)
+        self.assertEqual(candidate["state"], "mismatch")
+        self.assertTrue(candidate["cached"])
+        conflict = self.check(expected_email="different@example.invalid", persist=False, now=NOW)
+        self.assertEqual((conflict["state"], conflict["reason"]), ("mismatch", "profile_manifest_mismatch"))
+        self.assertEqual(len(self.server.state["requests"]), 3)
+
+    def test_token_and_expected_organization_changes_invalidate_cache(self):
+        self.assertEqual(self.check(now=NOW)["state"], "match")
+        receipt_before = (self.account / identity.RECEIPT).read_bytes()
+        self.server.state["org"] = OTHER
+        self.assertEqual(self.check(SECOND, now=NOW, persist=False)["state"], "mismatch")
+        self.assertEqual((self.account / identity.RECEIPT).read_bytes(), receipt_before)
+        self.assertEqual(identity.cached_identity(self.account, now=NOW)["state"], "match")
+        self.server.state["org"] = ORG
+        (self.account / "server.token").write_text(SECOND)
+        self.assertFalse(self.check(now=NOW + 1)["cached"])
+        self.config.write_text(json.dumps({"oauthAccount": {"organizationUuid": OTHER}}))
+        self.assertEqual(self.check(now=NOW + 2)["state"], "mismatch")
+        self.config.write_text(json.dumps({"oauthAccount": {"organizationUuid": ORG.upper()}}))
+        self.assertEqual(self.check(now=NOW + 3)["state"], "match")
+        self.assertEqual(len(self.server.state["requests"]), 5)
+        stored = json.loads((self.account / identity.RECEIPT).read_text())
+        self.assertEqual(stored["token_digest"], hashlib.sha256(SECOND.encode()).hexdigest())
+        self.config.write_text("{}")
+        self.assertEqual(identity.cached_identity(self.account, now=NOW + 4)["state"], "match")
+        self.assertTrue(self.check(now=NOW + 4)["cached"])
+        self.manifest.write_text(json.dumps({"accounts": [{"id": "acct-01", "email": "changed@example.invalid"}]}))
+        self.assertEqual(identity.cached_identity(self.account, now=NOW + 5)["state"], "unknown")
+        moved = self.account.parent / "acct-02"
+        self.account.rename(moved)
+        self.manifest.write_text(json.dumps({"accounts": [{"id": "acct-02", "email": EMAIL}]}))
+        self.assertEqual(identity.cached_identity(moved, now=NOW + 6)["state"], "unknown")
+        self.assertEqual(len(self.server.state["requests"]), 5)
+
+    def test_unknown_and_auth_failures_back_off_then_retry(self):
+        for code, org, reason in [(200, None, "missing_organization"), (401, None, "auth_failed"),
+                                  (403, None, "auth_failed"), (429, "bad-id", "missing_organization")]:
+            with self.subTest(code=code, org=org):
+                (self.account / identity.RECEIPT).unlink(missing_ok=True)
+                self.server.state.update(code=code, org=org)
+                result = self.check(now=NOW)
+                self.assertEqual((result["state"], result["reason"]), ("unknown", reason))
+                count = len(self.server.state["requests"])
+                self.server.state.update(code=200, org=ORG)
+                self.assertTrue(self.check(now=NOW + 59)["cached"])
+                self.assertEqual(len(self.server.state["requests"]), count)
+                self.assertEqual(self.check(now=NOW + 60)["state"], "match")
+        (self.account / identity.RECEIPT).unlink()
+        with patch.object(identity.urllib.request.OpenerDirector, "open", side_effect=TimeoutError) as opened:
+            result = self.check(now=NOW)
+        self.assertEqual((result["state"], result["reason"]), ("unknown", "request_failed"))
+        self.assertEqual(opened.call_count, 1)
+        self.assertEqual(opened.call_args.kwargs["timeout"], 10)
+        (self.account / identity.RECEIPT).unlink()
+        self.server.state.update(serialize_test=True, requests=[], first_seen=threading.Event(),
+                                 second_seen=threading.Event(), allow_second=threading.Event())
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            first = executor.submit(self.check, now=NOW)
+            self.assertTrue(self.server.state["first_seen"].wait(2))
+            second = executor.submit(self.check, now=NOW)
+            first_result = first.result(timeout=3)
+            self.server.state["allow_second"].set()
+            second_result = second.result(timeout=3)
+        self.assertEqual([first_result["state"], second_result["state"]], ["mismatch", "mismatch"])
+        self.assertEqual(len(self.server.state["requests"]), 1)
+        self.assertEqual(identity.cached_identity(self.account, now=NOW)["state"], "mismatch")
+
+    def test_redirects_never_forward_the_token(self):
+        for url in ("https://example.invalid/v1/messages", "http://[invalid"):
+            (self.account / identity.RECEIPT).unlink(missing_ok=True)
+            result = identity.check_identity(self.account, endpoint=url, now=NOW)
+            self.assertEqual((result["state"], result["reason"]), ("unknown", "invalid_endpoint"))
+        self.assertEqual(len(self.server.state["requests"]), 0)
+        for code in (301, 302, 303, 307, 308):
+            with self.subTest(code=code):
+                (self.account / identity.RECEIPT).unlink(missing_ok=True)
+                self.server.state.update(code=code, org=OTHER, location=self.url + "&redirected=1")
+                count = len(self.server.state["requests"])
+                result = self.check(now=NOW)
+                self.assertEqual((result["state"], result["reason"]), ("unknown", "redirect"))
+                self.assertEqual(len(self.server.state["requests"]), count + 1)
+
+    def test_cli_exact_stdin_and_missing_config_are_safe(self):
+        env = dict(os.environ, CLAUDE_MULTIACC_TOKEN_IDENTITY_URL=self.url,
+                   CLAUDE_MULTIACC_CLI_VERSION="2.1.282")
+        done = subprocess.run([sys.executable, str(REPO / "lib/claude_token_identity.py"),
+                               "check", str(self.account), "--token-stdin"],
+                              input=SECOND, text=True, capture_output=True, env=env, timeout=15)
+        self.assertEqual(done.returncode, 0, done.stderr)
+        result = json.loads(done.stdout)
+        self.assertEqual(result["state"], "match")
+        self.assertEqual(result["token_digest"], hashlib.sha256(SECOND.encode()).hexdigest())
+        self.assertNotIn(SECOND, done.stdout + done.stderr)
+        self.assertNotIn(ORG, done.stdout + done.stderr)
+        self.assertEqual(self.server.state["requests"][0]["headers"]["Authorization"], "Bearer " + SECOND)
+        cached = subprocess.run([sys.executable, str(REPO / "lib/claude_token_identity.py"),
+                                 "cached", str(self.account), "--token-stdin", "--format", "state"],
+                                input=SECOND, text=True, capture_output=True, env=env, timeout=15)
+        self.assertEqual(cached.stdout, "match\n")
+        for document in ("not-json", "[]", "{}"):
+            self.config.write_text(document)
+            self.assertEqual(self.check(now=NOW)["reason"], "missing_expected_organization")
+        self.assertEqual(len(self.server.state["requests"]), 1)
+        self.config.write_text(json.dumps({"oauthAccount": {
+            "organizationUuid": ORG, "emailAddress": "different@example.invalid"}}))
+        conflict = identity.cached_identity(self.account)
+        self.assertEqual((conflict["state"], conflict["reason"]), ("mismatch", "profile_manifest_mismatch"))
+        self.assertEqual(self.check()["state"], "mismatch")
+        self.assertEqual(len(self.server.state["requests"]), 1)
+        self.manifest.write_text('{"accounts": []}')
+        candidate = subprocess.run([sys.executable, str(REPO / "lib/claude_token_identity.py"),
+                                    "check", str(self.account), "--token-stdin", "--no-store",
+                                    "--expected-email", EMAIL, "--format", "state"],
+                                   input=SECOND, text=True, capture_output=True, env=env, timeout=15)
+        self.assertEqual(candidate.stdout, "mismatch\n")
+        self.config.write_text(json.dumps({"oauthAccount": {"organizationUuid": ORG}}))
+        result = self.check(expected_email=EMAIL, persist=False)
+        self.assertEqual((result["state"], result["reason"]), ("unknown", "missing_profile_email"))
+        self.assertEqual(len(self.server.state["requests"]), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()