claude-multiacc 2.0.42 → 2.0.43

package/tests/test_keychain.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 from pathlib import Path
 import subprocess
 import sys
@@ -19,49 +20,20 @@ import unittest
 REPO = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(REPO / 'lib'))
 
-FAKE_SECURITY = r'''#!/usr/bin/env bash
-KC="${FAKE_KEYCHAIN_DIR:-/nonexistent-keychain}"
-cmd="${1:-}"; shift || true
-svc=""; acct=""; want_pw=0; hexdata=""
-while [ $# -gt 0 ]; do
-  case "$1" in
-    -s) svc="$2"; shift 2 ;;
-    -a) acct="$2"; shift 2 ;;
-    -w) want_pw=1; shift ;;
-    -X) hexdata="$2"; shift 2 ;;
-    *) shift ;;
-  esac
-done
-case "$cmd" in
-  find-generic-password)
-    [ -f "$KC/$svc" ] || exit 44
-    if [ "$want_pw" = "1" ]; then
-      [ -n "${FAKE_KEYCHAIN_LOCKED:-}" ] && exit 36
-      cat "$KC/$svc"; exit 0
-    fi
-    a="tester"; [ -f "$KC/$svc.acct" ] && a="$(cat "$KC/$svc.acct")"
-    printf 'attributes:\n    "acct"<blob>="%s"\n' "$a"
-    printf '    "mdat"<timedate>=0x00  "20260828043137Z\\000"\n'
-    printf '    "svce"<blob>="%s"\n' "$svc"
-    exit 0 ;;
-  add-generic-password)
-    [ -n "${FAKE_KEYCHAIN_LOCKED:-}" ] && exit 36
-    mkdir -p "$KC"
-    printf '%s' "$hexdata" | python3 -c 'import sys;sys.stdout.buffer.write(bytes.fromhex(sys.stdin.read().strip()))' > "$KC/$svc"
-    printf '%s' "${acct:-tester}" > "$KC/$svc.acct"
-    exit 0 ;;
-  delete-generic-password)
-    [ -f "$KC/$svc" ] || exit 44
-    rm -f "$KC/$svc" "$KC/$svc.acct"; exit 0 ;;
-  *) exit 1 ;;
-esac
-'''
+FAKE_SECURITY = (REPO / 'tests' / 'fake_security.sh').read_text()
 
 DOC = {'claudeAiOauth': {'accessToken': 'sk-ant-oat01-x', 'refreshToken': 'r',
                          'expiresAt': 9999999999999,
                          'refreshTokenExpiresAt': 9999999999999}}
 
 
+DEAD = {'claudeAiOauth': {'accessToken': 'sk-ant-oat01-dead', 'refreshToken': 'r',
+                          'expiresAt': 1000, 'refreshTokenExpiresAt': 1000}}
+LIVE = {'claudeAiOauth': {'accessToken': 'sk-ant-oat01-live', 'refreshToken': 'r',
+                          'expiresAt': 9999999999999,
+                          'refreshTokenExpiresAt': 9999999999999}}
+
+
 class KeychainTests(unittest.TestCase):
     def setUp(self):
         self.work = tempfile.TemporaryDirectory()
@@ -74,11 +46,17 @@ class KeychainTests(unittest.TestCase):
         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_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)
         os.environ.pop('FAKE_KEYCHAIN_LOCKED', None)
+        os.environ.pop('FAKE_KEYCHAIN_MDAT', None)
+        os.environ.pop('FAKE_SECURITY_LOG', None)
+        self.calllog = work / 'security.log'
+        # The canonical name follows USER; pin it so the layout below is deterministic.
+        os.environ['USER'] = 'gas'
         # (re)load with the fake in place
         import importlib
         import keychain
@@ -86,6 +64,7 @@ class KeychainTests(unittest.TestCase):
         self.root = work / 'accounts'
         (self.root / 'acct-01').mkdir(parents=True)
         (self.root / 'acct-01' / 'tmp').mkdir(exist_ok=True)
+        self.d = str(self.root / 'acct-01')
 
     def tearDown(self):
         for key, value in self.saved.items():
@@ -95,6 +74,34 @@ class KeychainTests(unittest.TestCase):
                 os.environ[key] = value
         self.work.cleanup()
 
+    # -- helpers: items placed the way a client would, read straight off the fake --
+    def put(self, text, account, mdat, d=None):
+        """An item under <account>, as a client whose FA() said <account> writes it."""
+        if not isinstance(text, str):
+            text = json.dumps(text)
+        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, d=None):
+        svc = self.kcdir / self.keychain.service_name(d or self.d)
+        return sorted(p.name for p in svc.iterdir()) if svc.is_dir() else []
+
+    def secret(self, account, d=None):
+        svc = self.kcdir / self.keychain.service_name(d or self.d)
+        return json.loads((svc / account / 'secret').read_text())
+
+    def calls(self, fn, *args):
+        """(result, [one line per `security` call]) — verb, -a name, secret asked."""
+        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()
+
     # -- the layout facts this whole feature stands on ------------------------------
     def test_service_name_matches_the_client(self):
         # Observed live 2026-08-28 (Claude Code 2.1.250, my-mini): this config dir's
@@ -104,49 +111,308 @@ class KeychainTests(unittest.TestCase):
             self.keychain.service_name('/Users/gas/.claude-accounts/acct-16'),
             'Claude Code-credentials-4219e2b1')
 
+    def test_fake_models_the_real_tool(self):
+        # What every rule below stands on (verified live on my-mini, 2026-09-24): no -a
+        # answers with the OLDEST item, -a picks its own, add -U updates in place.
+        self.put(DEAD, 'gas', '20260910173739')
+        self.put(LIVE, 'unknown', '20260924095747')
+        svc = self.keychain.service_name(self.d)
+        out = subprocess.run(['security', 'find-generic-password', '-s', svc, '-w'],
+                             capture_output=True, text=True).stdout
+        self.assertEqual(json.loads(out), DEAD)
+        out = subprocess.run(['security', 'find-generic-password', '-a', 'unknown',
+                              '-s', svc, '-w'], capture_output=True, text=True).stdout
+        self.assertEqual(json.loads(out), LIVE)
+        rc = subprocess.run(['security', 'add-generic-password', '-a', 'gas', '-s', svc,
+                             '-X', '00']).returncode
+        self.assertEqual(rc, 45)
+
     def test_absent_then_present_roundtrip(self):
-        d = str(self.root / 'acct-01')
+        d = self.d
         self.assertEqual(self.keychain.probe(d)['state'], 'absent')
-        self.assertTrue(self.keychain.write(d, DOC, account='gas'))
+        self.assertTrue(self.keychain.write(d, DOC, account='someone-else'))
         res = self.keychain.probe(d)
         self.assertEqual(res['state'], 'present')
         self.assertEqual(res['doc'], DOC)
-        # -U update path keeps a single item and the account name it was made with
+        # the account argument is ignored: writes land under the canonical name
+        self.assertEqual((res['account'], res['canonical']), ('gas', 'gas'))
+        # -U update path keeps a single item
         doc2 = {'claudeAiOauth': dict(DOC['claudeAiOauth'], accessToken='sk-ant-oat01-y')}
         self.assertTrue(self.keychain.write(d, doc2))
         again = self.keychain.probe(d)
         self.assertEqual(again['doc']['claudeAiOauth']['accessToken'], 'sk-ant-oat01-y')
+        self.assertEqual(self.items(), ['gas'])
         self.assertTrue(self.keychain.delete(d))
         self.assertEqual(self.keychain.probe(d)['state'], 'absent')
         self.assertTrue(self.keychain.delete(d))     # deleting a missing item is fine
 
     def test_locked_is_distinguished_from_absent(self):
-        d = str(self.root / 'acct-01')
-        self.keychain.write(d, DOC, account='tester')
+        d = self.d
+        self.keychain.write(d, DOC)
         os.environ['FAKE_KEYCHAIN_LOCKED'] = '1'
         res = self.keychain.probe(d)
         self.assertEqual(res['state'], 'locked')
         self.assertIsNone(res['doc'])
-        self.assertEqual(res['account'], 'tester')
+        self.assertEqual(res['account'], 'gas')
         self.assertGreater(self.keychain.item_mtime(d), 0)
         # an id with NO item is still absent, not locked
         self.assertEqual(self.keychain.probe(d + '-other')['state'], 'absent')
 
     def test_corrupt_item(self):
-        d = str(self.root / 'acct-01')
-        svc = self.keychain.service_name(d)
-        self.kcdir.mkdir(exist_ok=True)
-        (self.kcdir / svc).write_text('not json at all')
-        self.assertEqual(self.keychain.probe(d)['state'], 'corrupt')
+        self.put('not json at all', 'gas', '20260924000000')
+        self.assertEqual(self.keychain.probe(self.d)['state'], 'corrupt')
 
     def test_kill_switch(self):
-        d = str(self.root / 'acct-01')
+        d = self.d
         self.keychain.write(d, DOC)
         os.environ['CLAUDE_MULTIACC_KEYCHAIN'] = '0'
         self.assertFalse(self.keychain.enabled())
         self.assertEqual(self.keychain.probe(d)['state'], 'absent')
         os.environ['CLAUDE_MULTIACC_KEYCHAIN'] = '1'
 
+    # -- several items per service: the 2026-09-24 incident ----------------------------
+    def test_the_canonical_item_answers_even_beside_a_newer_live_sibling(self):
+        # acct-02 on my-mini: the old login under the real name, and a fresh sign-in a
+        # USER-less client filed under Bun's "unknown". A client multiacc launches reads
+        # -a <canonical> and nothing else, so that is the item the pool must judge —
+        # reading the newer sibling would call an account alive that its client is not.
+        self.put(DEAD, 'gas', '20260910173739')
+        self.put(LIVE, 'unknown', '20260924095747')
+        res = self.keychain.probe(self.d)
+        self.assertEqual((res['state'], res['account'], res['canonical'], res['doc']),
+                         ('present', 'gas', 'gas', DEAD))
+        import calendar
+        self.assertEqual(self.keychain.item_mtime(self.d),
+                         calendar.timegm((2026, 9, 10, 17, 37, 39, 0, 0, 0)))
+        os.environ['FAKE_KEYCHAIN_LOCKED'] = '1'
+        res = self.keychain.probe(self.d)
+        self.assertEqual((res['state'], res['account']), ('locked', 'gas'))
+        self.assertEqual(res['modified'], calendar.timegm((2026, 9, 10, 17, 37, 39, 0, 0, 0)))
+
+    def test_the_canonical_item_answers_even_when_a_sibling_is_older(self):
+        # The reverse order: the stale sibling is the OLDEST item, so the old no -a
+        # lookup would have read it. The canonical item is what the client reads.
+        import calendar
+        self.put(DEAD, 'unknown', '20260901000000')
+        self.put(LIVE, 'gas', '20260924095747')
+        for legacy in (False, True):
+            res = self.keychain.probe(self.d, legacy=legacy)
+            self.assertEqual((res['state'], res['account'], res['doc']),
+                             ('present', 'gas', LIVE))
+        self.assertEqual(self.keychain.item_mtime(self.d),
+                         calendar.timegm((2026, 9, 24, 9, 57, 47, 0, 0, 0)))
+
+    def test_an_item_under_another_name_is_absent_unless_legacy_is_asked(self):
+        # acct-06/acct-21 on my-mini: the only item sits under "unknown". The client
+        # multiacc launches reads -a <canonical> and cannot see it, so every lookup that
+        # judges the account says absent; only the limits pass (which moves it) and
+        # dedupe ask for the old no -a first match.
+        self.put(LIVE, 'unknown', '20260924095747')
+        res = self.keychain.probe(self.d)
+        self.assertEqual((res['state'], res['doc'], res['account']), ('absent', None, None))
+        self.assertEqual(self.keychain.item_mtime(self.d), 0)
+        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'])
+        os.environ['FAKE_KEYCHAIN_LOCKED'] = '1'
+        self.assertEqual(self.keychain.probe(self.d)['state'], 'absent')
+        res = self.keychain.probe(self.d, legacy=True)
+        self.assertEqual((res['state'], res['account']), ('locked', 'unknown'))
+        os.environ.pop('FAKE_KEYCHAIN_LOCKED')
+        self.put('garbage', 'olduser', '20260101000000', d=self.d + '-x')
+        self.assertEqual(self.keychain.probe(self.d + '-x')['state'], 'absent')
+        self.assertEqual(self.keychain.probe(self.d + '-x', legacy=True)['state'], 'corrupt')
+
+    def test_a_lookup_costs_one_security_call(self):
+        # Operator rule: a fix must not add time. The canonical item answers in ONE
+        # call, exactly what the old no -a lookup cost; enumeration is for writes only.
+        self.put(LIVE, 'gas', '20260924095747')
+        self.put(DEAD, 'unknown', '20260924095748')
+        res, log = self.calls(self.keychain.probe, self.d)
+        self.assertEqual(res['state'], 'present')
+        self.assertEqual(log, ['find-generic-password a=gas w=1'])
+        res, log = self.calls(self.keychain.item_mtime, self.d)
+        self.assertGreater(res, 0)
+        self.assertEqual(log, ['find-generic-password a=gas w=0'])
+        os.environ['FAKE_KEYCHAIN_LOCKED'] = '1'
+        res, log = self.calls(self.keychain.probe, self.d)
+        self.assertEqual(res['state'], 'locked')
+        self.assertEqual(log, ['find-generic-password a=gas w=1',
+                               'find-generic-password a=gas w=0'])
+        os.environ.pop('FAKE_KEYCHAIN_LOCKED')
+        # No canonical item — a token-only or file-only account, or one whose item sits
+        # under another name: still ONE call, for the probe and the stamp alike. These
+        # run for every account on every list/status the panel's heartbeat asks for.
+        other = self.d + '-legacy'
+        self.put(LIVE, 'unknown', '20260924095747', d=other)
+        for d in (self.d + '-none', other):
+            res, log = self.calls(self.keychain.probe, d)
+            self.assertEqual(res['state'], 'absent')
+            self.assertEqual(log, ['find-generic-password a=gas w=1'])
+            res, log = self.calls(self.keychain.item_mtime, d)
+            self.assertEqual(res, 0)
+            self.assertEqual(log, ['find-generic-password a=gas w=0'])
+        # Only the migration read pays a second call, and only without a canonical item.
+        res, log = self.calls(self.keychain.probe, other, True)
+        self.assertEqual(res['state'], 'present')
+        self.assertEqual(log, ['find-generic-password a=gas w=1',
+                               'find-generic-password a=- w=1'])
+        res, log = self.calls(self.keychain.probe, self.d, True)
+        self.assertEqual(log, ['find-generic-password a=gas w=1'])
+
+    def test_write_lands_on_canonical_and_removes_spent_siblings(self):
+        self.put(DEAD, 'olduser', '20260101000000')        # the oldest, any name
+        self.put(DEAD, 'unknown', '20260910173739')
+        self.put('not a credential', 'claude-code-user', '20260911000000')
+        self.assertTrue(self.keychain.write(self.d, LIVE))
+        self.assertEqual(self.items(), ['gas'])
+        self.assertEqual(self.secret('gas'), LIVE)
+
+    def test_write_keeps_a_live_sibling_holding_another_grant(self):
+        # After a sign-in as the WRONG account the client itself put the intruder's
+        # grant under the canonical name, and the right account's live login may sit
+        # beside it (under "unknown", from a USER-less sign-in). Refreshing the intruder
+        # must not destroy it; the sibling still holding the grant the refresh started
+        # from is spent (the refresh rotated it) and goes.
+        intruder = {'claudeAiOauth': {'accessToken': 'sk-ant-oat01-intr', 'refreshToken': 'ri',
+                                      'expiresAt': 1000, 'refreshTokenExpiresAt': 9999999999999}}
+        right = {'claudeAiOauth': dict(LIVE['claudeAiOauth'], refreshToken='rr')}
+        self.put(intruder, 'gas', '20260924100000')
+        self.put(right, 'unknown', '20260924095747')
+        self.put(intruder, 'claude-code-user', '20260924090000')
+        rotated = {'claudeAiOauth': dict(intruder['claudeAiOauth'], accessToken='sk-ant-oat01-i2',
+                                         refreshToken='ri2', expiresAt=9999999999999)}
+        self.assertTrue(self.keychain.write(self.d, rotated, supersedes='ri'))
+        self.assertEqual(self.items(), ['gas', 'unknown'])
+        self.assertEqual(self.secret('unknown'), right)
+        self.assertEqual(self.secret('gas'), rotated)
+
+    def test_refresh_write_back_migrates_a_legacy_item(self):
+        # The limits pass reads a legacy "unknown" item, refreshes it and writes it back:
+        # it lands under the canonical name and, after the read-back, the sibling the
+        # refresh came from goes (its grant was rotated away).
+        self.put(LIVE, 'unknown', '20260924095747')
+        doc = self.keychain.probe(self.d, legacy=True)['doc']
+        rotated = {'claudeAiOauth': dict(doc['claudeAiOauth'], accessToken='sk-ant-oat01-rot',
+                                         refreshToken='r2')}
+        self.assertTrue(self.keychain.write(self.d, rotated, supersedes='r'))
+        self.assertEqual(self.items(), ['gas'])
+        self.assertEqual(self.secret('gas'), rotated)
+        self.assertEqual(self.keychain.probe(self.d)['account'], 'gas')
+        # moving it unchanged (no refresh) retires the legacy copy the same way
+        other = self.d + '-move'
+        self.put(LIVE, 'unknown', '20260924095747', d=other)
+        self.assertTrue(self.keychain.write(other, self.keychain.probe(other, legacy=True)['doc']))
+        self.assertEqual(self.items(other), ['gas'])
+        self.assertEqual(self.secret('gas', d=other), LIVE)
+
+    def test_write_keeps_siblings_without_a_good_readback(self):
+        self.put(DEAD, 'unknown', '20260910173739')
+        real_run = self.keychain._run
+
+        def lying_run(args, timeout=None):
+            # the canonical item reads back as something else (a client refreshed it
+            # in between, or the read failed): nothing may be deleted on that evidence
+            if args[:1] == ['find-generic-password'] and '-w' in args \
+                    and args[args.index('-a') + 1] == 'gas':
+                return 0, json.dumps(DEAD), ''
+            return real_run(args)
+
+        self.keychain._run = lying_run
+        try:
+            self.assertTrue(self.keychain.write(self.d, LIVE))
+        finally:
+            self.keychain._run = real_run
+        self.assertEqual(self.items(), ['gas', 'unknown'])
+
+    def test_delete_removes_every_duplicate(self):
+        self.put(DEAD, 'renamed-a', '20260101000000')      # oldest: the no -a match
+        self.put(DEAD, 'renamed-b', '20260102000000')      # a name nobody enumerates
+        self.put(LIVE, 'gas', '20260924000000')
+        self.put(DEAD, 'unknown', '20260923000000')
+        self.put(DEAD, 'claude-code-user', '20260922000000')
+        self.assertTrue(self.keychain.delete(self.d))
+        self.assertEqual(self.items(), [])
+        self.assertEqual(self.keychain.probe(self.d)['state'], 'absent')
+
+    def test_delete_reports_a_locked_keychain(self):
+        self.put(LIVE, 'gas', '20260924000000')
+        os.environ['FAKE_KEYCHAIN_LOCKED'] = '1'
+        self.assertFalse(self.keychain.delete(self.d))
+        os.environ.pop('FAKE_KEYCHAIN_LOCKED')
+        self.assertEqual(self.items(), ['gas'])
+
+    def test_canonical_account_mirrors_the_client(self):
+        import pwd
+        self.assertEqual(self.keychain.canonical_account(), 'gas')
+        # USER unset: the passwd name — never Bun's "unknown"
+        os.environ.pop('USER')
+        name = pwd.getpwuid(os.getuid()).pw_name
+        expect = name if re.fullmatch(r'[A-Za-z0-9._-]+', name) else 'claude-code-user'
+        self.assertEqual(self.keychain.canonical_account(), expect)
+        os.environ['USER'] = ''
+        self.assertEqual(self.keychain.canonical_account(), expect)
+        for bad in ('two words', 'ümlaut', 'a/b'):
+            os.environ['USER'] = bad
+            self.assertEqual(self.keychain.canonical_account(), 'claude-code-user')
+
+    def test_prune_keeps_a_live_canonical_item_and_drops_the_rest(self):
+        self.put(DEAD, 'olduser', '20260101000000')
+        self.put(LIVE, 'gas', '20260924095747')
+        self.put(DEAD, 'unknown', '20260924095748')
+        self.put(DEAD, 'claude-code-user', '20260924095749')
+        (ok, line), log = self.calls(self.keychain.prune, self.d)
+        self.assertTrue(ok, line)
+        self.assertEqual(line, 'pruned: kept gas, removed olduser,unknown,claude-code-user')
+        self.assertEqual(self.items(), ['gas'])
+        self.assertEqual(self.secret('gas'), LIVE)
+        # it never writes (no secret on argv) and never deletes the canonical item
+        self.assertFalse([c for c in log if c.startswith('add-generic-password')], log)
+        self.assertNotIn('delete-generic-password a=gas w=0', log)
+        self.assertEqual(self.keychain.prune(self.d), (True, 'ok: one item, under gas'))
+
+    def test_prune_refuses_unless_the_canonical_item_is_a_live_login(self):
+        # dead canonical: the live sibling may be the only working grant left
+        self.put(DEAD, 'gas', '20260910173739')
+        self.put(LIVE, 'unknown', '20260924095747')
+        ok, line = self.keychain.prune(self.d)
+        self.assertTrue(ok)
+        self.assertTrue(line.startswith('skip: the login under gas is expired'), line)
+        self.assertEqual(self.items(), ['gas', 'unknown'])
+        self.assertNotIn('sk-ant', line)
+        # locked: the canonical item cannot be judged from here
+        self.put(LIVE, 'gas', '20260924100000')
+        os.environ['FAKE_KEYCHAIN_LOCKED'] = '1'
+        self.assertEqual(self.keychain.prune(self.d),
+                         (True, 'skip: keychain locked for this session'))
+        os.environ.pop('FAKE_KEYCHAIN_LOCKED')
+        self.assertEqual(self.items(), ['gas', 'unknown'])
+        # corrupt canonical
+        self.put('garbage', 'gas', '20260924110000')
+        self.assertEqual(self.keychain.prune(self.d),
+                         (True, 'skip: the item under gas is not a credential'))
+        self.assertEqual(self.items(), ['gas', 'unknown'])
+        # absent canonical (the unknown-only shape): nothing is removed
+        other = self.d + '-u'
+        self.put(LIVE, 'unknown', '20260924095747', d=other)
+        self.assertEqual(self.keychain.prune(other), (True, 'skip: no item under gas'))
+        self.assertEqual(self.items(other), ['unknown'])
+
+    def test_cli_probe_and_prune_stay_non_secret(self):
+        self.put(LIVE, 'gas', '20260924095747')
+        self.put(DEAD, 'unknown', '20260910173739')
+        cli = [sys.executable, str(REPO / 'lib' / 'keychain.py')]
+        out = subprocess.run(cli + ['probe', self.d], capture_output=True, text=True,
+                             check=True).stdout
+        self.assertNotIn('sk-ant', out)
+        doc = json.loads(out)
+        self.assertEqual((doc['state'], doc['account'], doc['canonical']),
+                         ('present', 'gas', 'gas'))
+        out = subprocess.run(cli + ['prune', self.d], capture_output=True, text=True)
+        self.assertEqual(out.returncode, 0, out.stderr)
+        self.assertEqual(out.stdout.strip(), 'pruned: kept gas, removed unknown')
+        self.assertEqual(self.items(), ['gas'])
+
     # -- audit + report integration --------------------------------------------------
     def _manifest(self):
         (self.root / 'accounts.json').write_text(json.dumps({
@@ -174,6 +440,13 @@ class KeychainTests(unittest.TestCase):
         self.assertEqual(row['state'], 'locked')
         self.assertEqual(row['label'], 'KEYCHAIN LOCKED')
         os.environ.pop('FAKE_KEYCHAIN_LOCKED', None)
+        # a live login under a name the client does not read is no login here, exactly
+        # as the shim sees it (bin/claude kc_lookup -a "$KC_ACCOUNT")
+        self.keychain.delete(d)
+        self.put(LIVE, 'unknown', '20260924095747', d=d)
+        row = audit.audit_account(str(self.root), {'id': 'acct-01', 'email': 'kc@test',
+                                                   'home': 'mac'}, machine='mac')
+        self.assertEqual(row['state'], 'missing')
 
     def test_report_class_and_status(self):
         self._manifest()