claude-multiacc 2.0.58 → 2.0.60

package/tests/test_autoresume_sidechain_tmux.py

@@ -0,0 +1,79 @@
+"""A workflow agent's five-hour limit moves a claude session: actual tmux, shell, production
+shim and watcher, with the cross-provider suite's disposable fake Claude TUI."""
+
+import json
+from pathlib import Path
+import signal
+import time
+import unittest
+
+from autoresume_cross_tmux_support import CrossScenario, TMUX
+
+AGENT = "a33659a7131e55067"
+AGENT2 = "ab12cd34ef56a7890"
+
+
+def stamp(now):
+    """A transcript timestamp to the millisecond, as claude 2.1.303 writes them."""
+    return time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime(now)) + ".%03dZ" % int(now % 1 * 1000)
+
+
+@unittest.skipUnless(TMUX, "real tmux is unavailable")
+class SidechainTmuxTests(unittest.TestCase):
+    def test_a_workflow_agents_limit_resumes_the_idle_session_on_another_account(self):
+        # The suite's short grace (0.4 s): the relaunch starts a second or two after the
+        # rejection, and one more agent is rejected as the client is stopped (the fake TUI
+        # records it on SIGTERM). The relaunched watcher reads both in the same agent
+        # transcripts and must act on neither: they are the replaced process's.
+        case = CrossScenario(CLAUDE_MULTIACC_AR_SUBAGENT_SCAN="0.2",
+                             FAKE_AGENT_LIMIT_ON_TERM=AGENT2)
+        self.addCleanup(case.close)
+        case.start("claude")
+        ready = case.records("ready")[0]
+        # this launch's own agents start a second after it at the soonest
+        state = case.pools["claude"] / "tmp" / "autoresume" / ("%d.state" % ready["pid"])
+        launched = int(dict(line.split("=", 1) for line in state.read_text().splitlines()
+                            if "=" in line)["launched"])
+        time.sleep(max(0.0, launched + 1.05 - time.time()))
+        # the main transcript stays quiet; only the workflow's agent records the limit
+        agent = (Path(ready["path"]).with_suffix("") / "subagents" / "workflows" / "wf_e2e"
+                 / ("agent-%s.jsonl" % AGENT))
+        agent.parent.mkdir(parents=True)
+        reset = int(time.time()) + 3600
+        agent.write_text(json.dumps({
+            "type": "assistant", "isSidechain": True, "agentId": AGENT, "sessionId": ready["sid"],
+            "timestamp": stamp(time.time()),
+            "isApiErrorMessage": True, "error": "rate_limit", "apiError": "usage_limit_reached",
+            "apiErrorStatus": 429, "quotaLimits": {"status": "rejected", "resetsAt": reset,
+                                                   "rateLimitType": "five_hour",
+                                                   "overageStatus": "rejected"},
+            "message": {"model": "<synthetic>", "role": "assistant", "content": [
+                {"type": "text", "text": "You've hit your session limit"}]}}, separators=(",", ":"))
+            + "\n")
+        case.wait(lambda: len(case.records("ready")) >= 2, "same session resumed on another account")
+        case.wait(lambda: "autoresume switch" in case.logs("claude"), "watcher confirms switch")
+        first, second = case.records("launch")[:2]
+        self.assertEqual([first["provider"], second["provider"]], ["claude", "claude"])
+        self.assertEqual((first["account"], second["account"]), ("acct-01", "acct-02"))
+        self.assertEqual(first["sid"], second["sid"])
+        self.assertEqual(second["argv"][second["argv"].index("--resume") + 1], first["sid"])
+        self.assertIn("Continue", second["argv"][-1])
+        self.assertIn("class=quota code=rate_limit sid=%s acct=acct-01 reset=%d src=sidechain agent=%s"
+                      % (first["sid"], reset, AGENT), case.logs("claude"))
+        self.assertEqual(case.records("keys"), [], "no keystroke may reach either TUI")
+        self.assertEqual(case.records("signal")[0]["signal"], signal.SIGTERM)
+        self.assertEqual([row["agent"] for row in case.records("agent-limit")], [AGENT2])
+        marker = (case.pools["claude"] / "acct-01" / ".limited").read_text().split("\n")
+        self.assertEqual(marker[0], str(reset))
+        self.assertIn("bucket=client:five_hour", marker[1])
+        # the relaunched session's watcher reads the same agent transcripts, and lets them be
+        case.wait(lambda: case.logs("claude").count("autoresume watch") == 2, "second watcher")
+        time.sleep(1)
+        self.assertEqual(case.logs("claude").count("autoresume detect"), 1)
+        self.assertEqual(len(case.records("launch")), 2)
+        self.assertFalse((case.pools["claude"] / "acct-02" / ".limited").exists(),
+                         "the account the session moved to is never parked")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_trust_tmux.py

@@ -0,0 +1,63 @@
+"""Folder trust must be in place before a resumed Codex can submit its prompt."""
+
+import json
+import re
+import unittest
+
+from autoresume_tmux_support import TMUX, TmuxScenario
+from autoresume_cross_tmux_support import CrossScenario
+
+QUOTA = {"type": "task_complete", "error": {"message": "You've hit your usage limit.",
+                                           "codex_error_info": "usage_limit_exceeded"}}
+
+
+@unittest.skipUnless(TMUX, "real tmux is unavailable")
+class CodexTrustTmuxTests(unittest.TestCase):
+    def test_quota_restart_trusts_only_destination_before_prompt(self):
+        case = TmuxScenario(FAKE_REQUIRE_TRUST="1")
+        self.addCleanup(case.close)
+        source = case.pool / "acct-01/config.toml"
+        target = case.pool / "acct-02/config.toml"
+        source.write_text('# Source account stays unchanged.\n')
+        target.write_text('[projects.' + json.dumps(str(case.work)) + ']\ntrust_level = "untrusted"\n')
+        case.start()
+        self.assertEqual(source.read_text(), '# Source account stays unchanged.\n')
+        self.assertIn('"untrusted"', target.read_text())
+        case.append(QUOTA)
+        case.wait(lambda: "autoresume switch" in case.log.read_text(), "trusted restart confirmed")
+        self.assertTrue(case.records("trust")[0]["trusted"])
+        self.assertEqual(len(case.records("prompt")), 1)
+        self.assertEqual(case.records("keys"), [])
+        self.assertEqual(source.read_text(), '# Source account stays unchanged.\n')
+
+    def test_quota_restart_fails_open_when_the_trust_write_is_refused(self):
+        case = TmuxScenario(FAKE_REQUIRE_TRUST="1")
+        self.addCleanup(case.close)
+        target = case.pool / "acct-02/config.toml"
+        # A bare [projects] table is a layout lib/codex_trust.py refuses to edit.
+        target.write_text('[projects]\n' + json.dumps(str(case.work)) + ' = { trust_level = "untrusted" }\n')
+        before = target.read_bytes()
+        case.start()
+        case.append(QUOTA)
+        case.wait(lambda: case.records("trust"), "relaunched TUI on its trust screen")
+        self.assertEqual(re.findall(r" autoresume trust-failed chain=\w+ acct=(\S+)$", case.log.read_text(), re.M),
+                         ["acct-02"])
+        self.assertEqual([row["account"] for row in case.records("launch")], ["acct-01", "acct-02"])
+        self.assertEqual([row["trusted"] for row in case.records("trust")], [False])
+        self.assertEqual(target.read_bytes(), before)
+
+    def test_cross_provider_handoff_trusts_codex_destination(self):
+        case = CrossScenario(FAKE_REQUIRE_TRUST="1")
+        self.addCleanup(case.close)
+        case.start("claude")
+        case.park("claude")
+        case.quota()
+        case.wait(lambda: "autoresume switch" in case.logs("claude"), "trusted Codex handoff confirmed")
+        self.assertTrue(case.records("trust")[0]["trusted"])
+        self.assertEqual(case.records("prompt")[0]["provider"], "codex")
+        self.assertEqual(case.records("keys"), [])
+        self.assertFalse((case.pools["codex"] / "acct-02/config.toml").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_claude_client_error.py

@@ -79,14 +79,17 @@ class ClaudeClientErrorTests(unittest.TestCase):
         del without_sidechain["isSidechain"]
         self.assertEqual(errors.newest_error([json.dumps(without_sidechain)], CLAIM), ("org-blocked", LATER))
 
-    def test_organization_recovery_watermark_does_not_clear_authentication(self):
+    def test_verified_access_supersedes_every_error_recorded_before_it(self):
+        # A verify that reached the account proves the credential it runs on authenticates
+        # for an organization that admits Claude Code: an older authentication failure is
+        # as stale as an older org refusal, and must not re-park what that PASS lifted.
         at = errors.iso_epoch(LATER)
-        org = json.dumps(api_record())
-        self.assertIsNone(errors.newest_error([org], CLAIM, at))
-        self.assertIsNone(errors.newest_error([org], CLAIM, at + 1))
-        self.assertEqual(errors.newest_error([org], CLAIM, at - 0.001), ("org-blocked", LATER))
-        auth = json.dumps(api_record("authentication_failed"))
-        self.assertEqual(errors.newest_error([auth], CLAIM, at + 100), ("auth", LATER))
+        for code, slug in errors.ERRORS.items():
+            with self.subTest(code=code):
+                record = json.dumps(api_record(code))
+                self.assertIsNone(errors.newest_error([record], CLAIM, at))
+                self.assertIsNone(errors.newest_error([record], CLAIM, at + 100))
+                self.assertEqual(errors.newest_error([record], CLAIM, at - 0.001), (slug, LATER))
 
     def test_latest_in_class_wins_and_auth_cannot_downgrade_org_refusal(self):
         latest = "2026-09-30T13:30:02.000+03:00"

package/tests/test_claude_org_block.py

@@ -74,6 +74,7 @@ class ClaudeOrganizationBlockIntegrationTests(unittest.TestCase):
             CLAUDE_MULTIACC_KEYCHAIN="0", CLAUDE_MULTIACC_PATH_PROBE="0", CLAUDE_MULTIACC_MCP="0",
             CLAUDE_MULTIACC_AUTORESUME="0", CLAUDE_MULTIACC_AUTO_RESET="0", CLAUDE_MULTIACC_HEADROOM_BAND="0",
             CLAUDE_MULTIACC_CLIENT_SCAN_TTL="0", CLAUDE_MULTIACC_NO_SYNC="1", CLAUDE_MULTIACC_NO_DISTRIBUTE="1",
+            CLAUDE_MULTIACC_MCP_OAUTH="0",  # the detached MCP OAuth sync must not outlive a test
             CLAUDE_MULTIACC_USAGE_URL=f"file://{self.home}/missing-usage.json",
             CLAUDE_MULTIACC_TOKEN_URL=f"file://{self.home}/missing-token.json",
             CLAUDE_MULTIACC_TOKEN_IDENTITY_URL=f"file://{self.home}/missing-identity.json",

package/tests/test_claude_pool_prepare.py

@@ -28,8 +28,11 @@ class ClaudePoolPrepareTests(unittest.TestCase):
         }))
 
     def run_prepare(self, verb):
+        # Run from inside a pooled session, the environment names the REAL pool root; the
+        # repair must only ever see this test's --home.
+        env = {k: v for k, v in os.environ.items() if k != "CLAUDE_ACCOUNTS_ROOT"}
         return subprocess.run([sys.executable, str(SCRIPT), verb, "--home", str(self.home)],
-                              capture_output=True, text=True)
+                              capture_output=True, text=True, env=env)
 
     def test_fresh_pool_starts_shared_and_bypassed(self):
         self.assertEqual(self.run_prepare("check").returncode, 1)

package/tests/test_claude_reset.py

@@ -163,6 +163,9 @@ class ClaudePoolSandbox:
         env.update({
             "CLAUDE_ACCOUNTS_DIR": str(self.pool), "CLAUDE_MULTIACC_NO_SYNC": "1",
             "CLAUDE_MULTIACC_NO_DISTRIBUTE": "1", "CLAUDE_MULTIACC_MIN_FETCH": "0",
+            # No detached child may outlive the pass and write into the pool as tearDown
+            # removes it: the MCP OAuth sync (lib/mcp_oauth.py) the pass spawns, like the push.
+            "CLAUDE_MULTIACC_MCP_OAUTH": "0",
             "CLAUDE_MULTIACC_KEYCHAIN": "0", "CLAUDE_MULTIACC_PATH_PROBE": "0",
             "CLAUDE_MULTIACC_AUTO_RESET": "1", "CLAUDE_MULTIACC_CLI_VERSION": "2.1.280",
             "PYTHONDONTWRITEBYTECODE": "1",

package/tests/test_keychain_nologin.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""A credentials document holding no Claude login is no login (lib/keychain.py,
+lib/audit.py, lib/report.py, lib/credential.py).
+
+Claude Code 2.1.303 keeps its MCP servers' OAuth state (``mcpOAuth``,
+``mcpOAuthClientConfig``) in the same document as the login, and from a session that
+cannot open the Keychain (ssh/tmux) it writes a ``.credentials.json`` holding ONLY that.
+Counted as the login, such accounts were picked with no token exported and every run said
+"Not logged in" (2026-10-19). Runs everywhere: a fake ``security`` on PATH serves items
+from a temp dir, and CLAUDE_MULTIACC_KEYCHAIN=1 forces the lookup on off-macOS.
+"""
+
+from __future__ import annotations
+
+import calendar
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+
+REPO = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(REPO / 'lib'))
+
+FAKE_SECURITY = (REPO / 'tests' / 'fake_security.sh').read_text()
+KEY = 'higgsfield|0123456789abcdef'
+ENTRY = {'serverName': 'higgsfield', 'serverUrl': 'https://mcp.higgsfield.ai/mcp',
+         'accessToken': 'mcp-access-fixture', 'refreshToken': 'mcp-refresh-fixture',
+         'expiresAt': 9999999999999, 'scope': 'openid', 'issuer': 'https://clerk.higgsfield.ai',
+         'clientId': 'https://claude.ai/oauth/claude-code-client-metadata',
+         'redirectUri': 'http://localhost:1/callback',
+         'discoveryState': {'authorizationServerUrl': 'https://clerk.higgsfield.ai',
+                            'oauthMetadataFound': True}}
+MCP_ONLY = {'mcpOAuth': {KEY: ENTRY}}
+LIVE = {'claudeAiOauth': {'accessToken': 'sk-ant-oat01-live', 'refreshToken': 'r',
+                          'expiresAt': 9999999999999, 'refreshTokenExpiresAt': 9999999999999}}
+DEAD = {'claudeAiOauth': {'accessToken': 'sk-ant-oat01-dead', 'refreshToken': 'r',
+                          'expiresAt': 1000, 'refreshTokenExpiresAt': 1000}}
+# An expired login with no refresh token, beside an MCP entry that is alive and has one:
+# the shape whose greedy scrape read the entry's numbers as the login's.
+DEAD_BESIDE_MCP = {'claudeAiOauth': {'accessToken': 'sk-ant-oat01-old', 'expiresAt': 1000},
+                   'mcpOAuth': {KEY: ENTRY}}
+
+
+class Fixture(unittest.TestCase):
+    """A fake keychain, a pool with one account dir, and the modules reloaded."""
+
+    def setUp(self):
+        self.work = tempfile.TemporaryDirectory()
+        work = Path(self.work.name)
+        fakebin = work / 'bin'
+        fakebin.mkdir()
+        tool = fakebin / 'security'
+        tool.write_text(FAKE_SECURITY)
+        tool.chmod(0o755)
+        self.kcdir = work / 'keychain'
+        self.saved = {k: os.environ.get(k) for k in
+                      ('PATH', 'CLAUDE_MULTIACC_KEYCHAIN', 'FAKE_KEYCHAIN_DIR',
+                       'FAKE_KEYCHAIN_LOCKED', 'FAKE_KEYCHAIN_MDAT', 'FAKE_SECURITY_LOG',
+                       'USER')}
+        os.environ['PATH'] = f"{fakebin}:{os.environ['PATH']}"
+        os.environ['CLAUDE_MULTIACC_KEYCHAIN'] = '1'
+        os.environ['FAKE_KEYCHAIN_DIR'] = str(self.kcdir)
+        for key in ('FAKE_KEYCHAIN_LOCKED', 'FAKE_KEYCHAIN_MDAT', 'FAKE_SECURITY_LOG'):
+            os.environ.pop(key, None)
+        os.environ['USER'] = 'gas'
+        self.calllog = work / 'security.log'
+        import importlib
+        import keychain
+        self.keychain = importlib.reload(keychain)
+        self.root = work / 'accounts'
+        self.acct = self.root / 'acct-01'
+        self.acct.mkdir(parents=True)
+        self.d = str(self.acct)
+        self.cpath = self.acct / '.credentials.json'
+
+    def tearDown(self):
+        for key, value in self.saved.items():
+            if value is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = value
+        self.work.cleanup()
+
+    def put(self, doc, account='gas', mdat='20261019000000', d=None):
+        """An item under <account>, written the way a client whose FA() said so writes it."""
+        text = doc if isinstance(doc, str) else json.dumps(doc)
+        subprocess.run(['security', 'add-generic-password', '-U', '-a', account, '-s',
+                        self.keychain.service_name(d or self.d), '-X',
+                        text.encode('utf-8').hex()],
+                       check=True, env=dict(os.environ, FAKE_KEYCHAIN_MDAT=mdat))
+
+    def items(self):
+        svc = self.kcdir / self.keychain.service_name(self.d)
+        return sorted(p.name for p in svc.iterdir()) if svc.is_dir() else []
+
+    def secret(self, account='gas'):
+        svc = self.kcdir / self.keychain.service_name(self.d)
+        return json.loads((svc / account / 'secret').read_text())
+
+    def calls(self, fn, *args):
+        self.calllog.write_text('')
+        os.environ['FAKE_SECURITY_LOG'] = str(self.calllog)
+        try:
+            result = fn(*args)
+        finally:
+            os.environ.pop('FAKE_SECURITY_LOG', None)
+        return result, self.calllog.read_text().splitlines()
+
+    def write_file(self, doc, mtime=None):
+        self.cpath.write_text(doc if isinstance(doc, str) else json.dumps(doc))
+        if mtime is not None:
+            os.utime(self.cpath, (mtime, mtime))
+
+    def manifest(self, home='mac'):
+        (self.root / 'accounts.json').write_text(json.dumps({
+            'version': 1, 'server': 'root@203.0.113.1', 'threshold': 90,
+            'accounts': [{'id': 'acct-01', 'email': 'mcp@test', 'home': home,
+                          'added_at': '2026-10-19T00:00:00Z'}]}))
+
+
+class KeychainNoLoginTests(Fixture):
+    def test_an_mcp_only_item_is_nologin_never_present(self):
+        self.put(MCP_ONLY)
+        res, log = self.calls(self.keychain.probe, self.d)
+        self.assertEqual((res['state'], res['account'], res['doc']), ('nologin', 'gas', MCP_ONLY))
+        self.assertEqual(log, ['find-generic-password a=gas w=1'])   # still ONE call
+        # with a null login beside it, too; a secret that is no JSON object stays corrupt
+        self.put({'claudeAiOauth': None, 'mcpOAuth': {KEY: ENTRY}})
+        self.assertEqual(self.keychain.probe(self.d)['state'], 'nologin')
+        self.put('[1, 2]')
+        self.assertEqual(self.keychain.probe(self.d)['state'], 'corrupt')
+        self.put(dict(LIVE, **MCP_ONLY))
+        self.assertEqual(self.keychain.probe(self.d)['state'], 'present')
+
+    def test_legacy_looks_past_an_mcp_only_canonical_item_for_a_stranded_login(self):
+        # A USER-less sign-in filed the login under "unknown"; a later client, USER set and
+        # logged in by a token, saved MCP state under the canonical name.
+        self.put(LIVE, 'unknown', '20261001000000')
+        self.put(MCP_ONLY, 'gas', '20261019000000')
+        self.assertEqual(self.keychain.probe(self.d)['state'], 'nologin')
+        res = self.keychain.probe(self.d, legacy=True)
+        self.assertEqual((res['state'], res['doc'], res['canonical']), ('present', LIVE, 'gas'))
+        self.assertNotEqual(res['account'], res['canonical'])
+        # the no -a first match is the OLDEST item: when that is the MCP-only canonical one,
+        # the canonical verdict stands
+        other = self.d + '-x'
+        self.put(MCP_ONLY, 'gas', '20261001000000', d=other)
+        self.put(LIVE, 'unknown', '20261019000000', d=other)
+        res = self.keychain.probe(other, legacy=True)
+        self.assertEqual((res['state'], res['account'], res['doc']), ('nologin', 'gas', MCP_ONLY))
+
+    def test_write_lands_into_the_item_keeping_its_mcp_state(self):
+        config = {KEY: {'clientId': 'cid'}}
+        self.put({'mcpOAuth': {KEY: ENTRY}, 'mcpOAuthClientConfig': config})
+        self.assertTrue(self.keychain.write(self.d, LIVE))
+        self.assertEqual(self.secret(), {'mcpOAuth': {KEY: ENTRY}, 'mcpOAuthClientConfig': config,
+                                         'claudeAiOauth': LIVE['claudeAiOauth']})
+        rotated = {'claudeAiOauth': dict(LIVE['claudeAiOauth'], accessToken='sk-ant-oat01-rot')}
+        self.assertTrue(self.keychain.write(self.d, rotated))
+        doc = self.secret()
+        self.assertEqual(doc['claudeAiOauth']['accessToken'], 'sk-ant-oat01-rot')
+        self.assertEqual((doc['mcpOAuth'], doc['mcpOAuthClientConfig']), ({KEY: ENTRY}, config))
+        self.assertEqual(self.keychain.probe(self.d)['state'], 'present')
+
+    def test_write_never_lands_blind_on_an_item_it_cannot_read(self):
+        self.put(MCP_ONLY)
+        os.environ['FAKE_KEYCHAIN_LOCKED'] = '1'
+        self.assertFalse(self.keychain.write(self.d, LIVE))
+        os.environ.pop('FAKE_KEYCHAIN_LOCKED')
+        self.assertEqual(self.secret(), MCP_ONLY)
+
+    def test_write_never_sweeps_a_sibling_carrying_mcp_state(self):
+        self.put(DEAD, 'olduser', '20260901000000')             # the oldest: a spent login alone
+        self.put(dict(DEAD, **MCP_ONLY), 'unknown', '20261001000000')   # spent login + MCP
+        self.put(MCP_ONLY, 'claude-code-user', '20261002000000')        # MCP state alone
+        self.assertTrue(self.keychain.write(self.d, LIVE))
+        self.assertEqual(self.items(), ['claude-code-user', 'gas', 'unknown'])
+        self.assertEqual(self.secret('claude-code-user'), MCP_ONLY)
+        self.assertEqual(self.secret('unknown'), dict(DEAD, **MCP_ONLY))
+
+    def test_prune_keeps_siblings_carrying_mcp_state(self):
+        self.put(DEAD, 'olduser', '20260901000000')             # the oldest: the no -a match
+        self.put(LIVE, 'gas', '20261019000000')
+        self.put(MCP_ONLY, 'unknown', '20261001000000')
+        (ok, line), log = self.calls(self.keychain.prune, self.d)
+        self.assertTrue(ok, line)
+        self.assertEqual(line, 'pruned: kept gas and MCP state under unknown, removed olduser')
+        self.assertEqual(self.items(), ['gas', 'unknown'])
+        self.assertFalse([c for c in log if c.startswith('add-generic-password')], log)
+        self.assertEqual(self.keychain.prune(self.d),
+                         (True, 'ok: the login under gas and MCP state under unknown'))
+
+    def test_prune_skips_an_mcp_only_canonical_item(self):
+        self.put(MCP_ONLY, 'gas', '20261019000000')
+        self.put(LIVE, 'unknown', '20261001000000')
+        self.assertEqual(self.keychain.prune(self.d),
+                         (True, 'skip: the item under gas holds no login (MCP state only)'))
+        self.assertEqual(self.items(), ['gas', 'unknown'])
+
+    def test_cli_probe_names_nologin_and_keeps_tokens_off_stdout(self):
+        self.put(MCP_ONLY)
+        out = subprocess.run([sys.executable, str(REPO / 'lib' / 'keychain.py'), 'probe', self.d],
+                             capture_output=True, text=True, check=True).stdout
+        self.assertNotIn('mcp-', out)
+        doc = json.loads(out)
+        self.assertEqual((doc['state'], doc['has_refresh_token'], doc['expires_at']),
+                         ('nologin', False, None))
+
+
+class AuditNoLoginTests(Fixture):
+    def setUp(self):
+        super().setUp()
+        import importlib
+        import audit
+        self.audit = importlib.reload(audit)
+
+    def test_an_mcp_only_file_is_no_login(self):
+        self.write_file(MCP_ONLY)
+        self.assertFalse(self.audit.file_has_login(str(self.cpath)))
+        login = self.audit.oauth_login(self.d, time.time())
+        self.assertEqual((login['store'], login['state'], login['doc']), (None, None, None))
+        self.assertIn('claudeAiOauth', login['reason'])
+        for doc in ({'claudeAiOauth': None, 'mcpOAuth': {}}, {'claudeAiOauth': 'x'}, {}, ''):
+            self.write_file(doc)
+            self.assertFalse(self.audit.file_has_login(str(self.cpath)), doc)
+
+    def test_the_keychain_decides_beside_an_mcp_only_file(self):
+        self.write_file(MCP_ONLY)
+        self.put(LIVE)
+        login = self.audit.oauth_login(self.d, time.time())
+        self.assertEqual((login['store'], login['state']), ('keychain', 'ok'))
+        os.environ['FAKE_KEYCHAIN_LOCKED'] = '1'
+        self.assertEqual(self.audit.oauth_login(self.d, time.time())['state'], 'locked')
+        os.environ.pop('FAKE_KEYCHAIN_LOCKED')
+        self.put(MCP_ONLY)                 # MCP state in both places: no login anywhere
+        login = self.audit.oauth_login(self.d, time.time())
+        self.assertEqual((login['store'], login['state']), (None, None))
+
+    def test_expiry_is_read_from_the_login_object_alone(self):
+        now = time.time()
+        self.write_file(DEAD_BESIDE_MCP)
+        self.assertTrue(self.audit.file_has_login(str(self.cpath)))
+        self.assertEqual(self.audit.creds_state(str(self.cpath), now)[0], 'expired')
+        # truncated mid-write, in either key order: still the login's own numbers
+        text = json.dumps(DEAD_BESIDE_MCP, separators=(',', ':'))
+        self.write_file(text[:-30])
+        self.assertTrue(self.audit.file_has_login(str(self.cpath)))
+        self.assertEqual(self.audit.creds_state(str(self.cpath), now)[0], 'expired')
+        mcp_first = json.dumps({'mcpOAuth': {KEY: ENTRY},
+                                'claudeAiOauth': DEAD_BESIDE_MCP['claudeAiOauth']},
+                               separators=(',', ':'))
+        self.write_file(mcp_first[:-3])
+        self.assertEqual(self.audit.creds_state(str(self.cpath), now)[0], 'expired')
+        # a truncated live login stays in the pool (lenient, as the shim is)...
+        live = json.dumps(dict(LIVE, **MCP_ONLY), separators=(',', ':'))
+        self.write_file(live[:-20])
+        self.assertEqual(self.audit.creds_state(str(self.cpath), now)[0], 'ok')
+        # ...and a truncated document that never opens a login is no login at all
+        self.write_file(json.dumps(MCP_ONLY)[:-10])
+        self.assertFalse(self.audit.file_has_login(str(self.cpath)))
+
+    def test_audit_account_reads_mcp_state_as_no_login(self):
+        acct = {'id': 'acct-01', 'email': 'mcp@test', 'home': 'mac'}
+        self.write_file(MCP_ONLY)
+        row = self.audit.audit_account(str(self.root), acct, machine='mac')
+        self.assertEqual((row['state'], row['store']), ('missing', None))
+        self.assertIn('no Claude login', row['reason'])
+        (self.acct / 'server.token').write_text('sk-ant-oat01-' + 'T' * 60)
+        row = self.audit.audit_account(str(self.root), acct, machine='mac')
+        self.assertEqual((row['state'], row['store']), ('ok', None))
+        (self.acct / 'server.token').unlink()
+        self.write_file(DEAD_BESIDE_MCP)
+        row = self.audit.audit_account(str(self.root), acct, machine='mac')
+        self.assertEqual((row['state'], row['store']), ('expired', 'file'))
+
+    def test_a_park_heals_on_a_newer_login_never_on_newer_mcp_state(self):
+        marker = self.acct / '.expired'
+        marked = calendar.timegm((2026, 10, 1, 0, 0, 0, 0, 0, 0))
+        marker.write_text(f'{marked}\nreason=auth-error marked_at=t detail=test\n')
+        os.utime(marker, (marked, marked))
+        self.write_file(MCP_ONLY, mtime=marked + 3600)
+        self.assertTrue(self.audit.expired_marked(self.d))
+        self.write_file(dict(LIVE, **MCP_ONLY), mtime=marked + 7200)
+        self.assertFalse(self.audit.expired_marked(self.d))
+        # the Keychain: an item this session reads is judged by what it holds
+        self.cpath.unlink()
+        self.put(MCP_ONLY, mdat='20261002000000')
+        self.assertTrue(self.audit.expired_marked(self.d))
+        os.environ['FAKE_KEYCHAIN_LOCKED'] = '1'      # cannot read it: its stamp decides
+        self.assertFalse(self.audit.expired_marked(self.d))
+        os.environ.pop('FAKE_KEYCHAIN_LOCKED')
+        self.put(dict(LIVE, **MCP_ONLY), mdat='20261003000000')
+        self.assertFalse(self.audit.expired_marked(self.d))
+        # an MCP-only file beside it hides nothing: the Keychain login still heals it
+        self.write_file(MCP_ONLY, mtime=marked + 60)
+        self.assertFalse(self.audit.expired_marked(self.d))
+
+
+class ReportAndExportTests(Fixture):
+    def test_report_never_calls_mcp_state_an_oauth_login(self):
+        import importlib
+        import report
+        report = importlib.reload(report)
+        self.write_file(MCP_ONLY)
+        cclass, detail = report._claude_credentials(self.d)
+        self.assertEqual((cclass, detail['oauth'], detail['oauth_store'], detail['keychain']),
+                         ('none', False, None, None))
+        (self.acct / 'server.token').write_text('sk-ant-oat01-' + 'T' * 60)
+        cclass, detail = report._claude_credentials(self.d)
+        self.assertEqual((cclass, detail['oauth'], detail['oauth_store']), ('portable', False, None))
+        (self.acct / 'server.token').unlink()
+        self.cpath.unlink()
+        self.put(MCP_ONLY)
+        cclass, detail = report._claude_credentials(self.d)
+        self.assertEqual((cclass, detail['oauth'], detail['keychain']), ('none', False, None))
+        self.write_file(dict(LIVE, **MCP_ONLY))
+        cclass, detail = report._claude_credentials(self.d)
+        self.assertEqual((cclass, detail['oauth'], detail['oauth_store'], detail['oauth_alive']),
+                         ('machine-local', True, 'file', True))
+
+    def test_export_finds_no_credential_material_in_mcp_state(self):
+        self.manifest()
+        self.write_file(MCP_ONLY)
+        cli = [sys.executable, str(REPO / 'lib' / 'credential.py'), 'export', str(self.root),
+               'claude', 'acct-01']
+        res = subprocess.run(cli, capture_output=True, text=True)
+        self.assertEqual(res.returncode, 4, res.stderr)
+        self.assertIn('no credential material', res.stderr)
+        self.write_file(dict(LIVE, **MCP_ONLY))
+        res = subprocess.run(cli, capture_output=True, text=True)
+        self.assertEqual(res.returncode, 3, res.stderr)
+        self.assertIn('.credentials.json', res.stderr)
+
+
+if __name__ == '__main__':
+    unittest.main()