claude-multiacc 2.0.60 → 2.0.64

package/tests/test_autoresume_cwd_handoff.py

@@ -0,0 +1,92 @@
+"""A Codex handoff binds the saved directory and history to one validated snapshot."""
+
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest import mock
+
+import test_autoresume as fixtures
+from autoresume_cross_unit_support import scenario
+import autoresume_cross as cross
+import autoresume_handoff as handoff
+
+
+class CodexDirectoryHandoffTests(unittest.TestCase):
+    def setUp(self):
+        temporary = tempfile.TemporaryDirectory(prefix="ar-cwd-handoff-")
+        self.addCleanup(temporary.cleanup)
+        self.home = Path(temporary.name).resolve()
+        self.initial = self.home / "initial"
+        self.saved = self.home / "saved project"
+        self.initial.mkdir()
+        self.saved.mkdir()
+        self.path = self.home / ("rollout-test-" + fixtures.CX_SID + ".jsonl")
+        self.meta = fixtures.cx_meta(1000, cwd=str(self.initial))
+
+    def write(self, records):
+        self.path.write_text("".join(json.dumps(row) + "\n" for row in [self.meta] + records))
+
+    def validate(self, cwd=None):
+        return handoff.validate_source("codex", fixtures.CX_SID, str(self.path), str(cwd or self.saved))
+
+    def test_changed_directory_from_turn_or_settings_replaces_initial_directory(self):
+        turn = {"type": "turn_context", "payload": {"cwd": str(self.saved)}}
+        settings = fixtures.cx_event(1001, {"type": "thread_settings_applied", "thread_id": fixtures.CX_SID,
+                                            "thread_settings": {"cwd": str(self.saved)}})
+        for record in (turn, settings):
+            with self.subTest(kind=record["type"]):
+                self.write([record])
+                history = self.validate()
+                self.assertEqual(history["cwd"], str(self.saved))
+                self.assertEqual(history["offset"], self.path.stat().st_size)
+                self.assertIsNone(self.validate(self.initial))
+
+    def test_foreign_settings_cannot_authorize_unrelated_directory(self):
+        settings = fixtures.cx_event(1001, {"type": "thread_settings_applied", "thread_id": fixtures.CX_SID2,
+                                            "thread_settings": {"cwd": str(self.saved)}})
+        self.write([settings])
+        self.assertIsNone(self.validate())
+        self.assertIsNotNone(self.validate(self.initial))
+
+    def test_saved_directory_after_large_history_is_read_beyond_initial_prefix(self):
+        self.write([{"type": "response_item", "payload": {"text": "x" * handoff.MAX_SOURCE_BYTES}},
+                    {"type": "turn_context", "payload": {"cwd": str(self.saved)}}])
+        self.assertEqual(self.validate()["cwd"], str(self.saved))
+
+    def test_appended_settings_after_snapshot_do_not_change_snapshot_directory(self):
+        self.write([{ "type": "turn_context", "payload": {"cwd": str(self.saved)}}])
+        offset = self.path.stat().st_size
+        original = handoff.codex_resume_cwd
+        later = {"type": "turn_context", "payload": {"cwd": str(self.initial)}}
+        with mock.patch.object(handoff, "codex_resume_cwd", side_effect=lambda *args, **kwargs: (
+                fixtures.append(self.path, [later]), original(*args, **kwargs))[1]):
+            history = self.validate()
+        self.assertEqual((history["cwd"], history["offset"]), (str(self.saved), offset))
+        self.assertIsNone(self.validate())
+
+    def test_replacement_during_directory_read_is_rejected(self):
+        self.write([{"type": "turn_context", "payload": {"cwd": str(self.saved)}}])
+        replacement = self.path.with_suffix(".replacement")
+        replacement.write_bytes(self.path.read_bytes())
+        original = handoff.codex_resume_cwd
+        with mock.patch.object(handoff, "codex_resume_cwd", side_effect=lambda *args, **kwargs: (
+                replacement.replace(self.path), original(*args, **kwargs))[1]):
+            self.assertIsNone(self.validate())
+
+    def test_cross_provider_plan_probes_in_latest_saved_directory(self):
+        case, watcher, runner, history, _ = scenario(self, "codex")
+        saved = case.tmp / "saved project"
+        saved.mkdir()
+        fixtures.append(history, [{"type": "turn_context", "payload": {"cwd": str(saved)}}])
+        plan = cross.plan_fallback(watcher, watcher.tracker.pending, "")
+        self.assertIsNotNone(plan)
+        self.assertEqual(plan["history"]["cwd"], str(saved))
+        self.assertEqual(runner.target_probes[-1]["cwd"], str(saved))
+        self.assertTrue(cross.revalidate(watcher, plan))
+        fixtures.append(history, [{"type": "turn_context", "payload": {"cwd": str(case.work)}}])
+        self.assertFalse(cross.revalidate(watcher, plan))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_cwd_reader.py

@@ -0,0 +1,105 @@
+"""Read only a bound Codex thread's saved cwd, even across chunk and restart boundaries."""
+
+import json
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "lib"))
+from codex_resume_cwd import codex_resume_cwd  # noqa: E402
+import session_settings  # noqa: E402
+
+SID = "01a13956-95c9-7d41-9a8b-b3e5ff79d3b2"
+OTHER = "0aaaaaaa-0000-7000-8000-000000000000"
+
+
+def line(kind, **payload):
+    return json.dumps({"type": kind, "payload": payload}, ensure_ascii=False)
+
+
+class CodexCwdReaderTests(unittest.TestCase):
+    def setUp(self):
+        directory = tempfile.TemporaryDirectory(prefix="codex-cwd-reader-")
+        self.addCleanup(directory.cleanup)
+        self.path = Path(directory.name) / "rollout.jsonl"
+        self.meta = line("session_meta", id=SID, cwd="/initial project")
+
+    def write(self, records):
+        self.path.write_text("\n".join(records) + "\n", encoding="utf-8")
+        return self.path
+
+    def test_bound_id_is_checked_before_any_saved_context(self):
+        path = self.write([self.meta, line("turn_context", cwd="/latest")])
+        self.assertEqual(codex_resume_cwd(path, SID), "/latest")
+        self.assertEqual(codex_resume_cwd(path), "/latest")
+        self.assertIsNone(codex_resume_cwd(path, OTHER))
+        boundary = path.stat().st_size
+        with path.open("a", encoding="utf-8") as output:
+            output.write(line("turn_context", cwd="/after-snapshot") + "\n")
+        self.assertEqual(codex_resume_cwd(path, SID), "/after-snapshot")
+        self.assertEqual(codex_resume_cwd(path, SID, upto=boundary), "/latest")
+
+    def test_missing_or_unreadable_history_has_no_directory(self):
+        for path in (None, self.path, self.path.parent):
+            with self.subTest(path=path):
+                self.assertIsNone(codex_resume_cwd(path, SID))
+        self.write([self.meta])
+        with mock.patch("builtins.open", side_effect=PermissionError("denied")):
+            self.assertIsNone(codex_resume_cwd(self.path, SID))
+
+    def test_invalid_metadata_cannot_bind_a_later_context(self):
+        bad = ["{", "[]", "null", json.dumps({"type": "session_meta", "payload": []}),
+               line("session_meta", id=None, cwd="/initial"),
+               line("turn_context", id=SID, cwd="/initial")]
+        for first in bad:
+            with self.subTest(first=first):
+                path = self.write([first, line("turn_context", cwd="/latest")])
+                self.assertIsNone(codex_resume_cwd(path, SID))
+
+    def test_malformed_and_invalid_later_records_preserve_last_valid_cwd(self):
+        bad = ["{", '[]', '{"payload":{"cwd":',
+               json.dumps({"type": "turn_context", "payload": None}),
+               line("event_msg", type="thread_settings_applied", thread_settings=[])]
+        bad.extend(line("turn_context", cwd=value)
+                   for value in (None, 7, {}, "relative", "/bad\npath", "/bad\rpath", "/bad\0path"))
+        path = self.write([self.meta, line("turn_context", cwd="/saved ü")] + bad)
+        self.assertEqual(codex_resume_cwd(path, SID), "/saved ü")
+
+    def test_foreign_settings_and_subagent_context_do_not_change_main_cwd(self):
+        path = self.write([
+            self.meta,
+            line("event_msg", type="thread_settings_applied", thread_id=OTHER,
+                 thread_settings={"cwd": "/foreign"}),
+            line("turn_context", thread_id=OTHER, cwd="/foreign-context"),
+            line("turn_context", turn_id="child", root_turn_id="parent", cwd="/subagent"),
+            line("response_item", type="function_call", cwd="/tool", arguments='{"cwd":"/quoted"}'),
+            line("session_meta", id=OTHER, cwd="/copied-parent"),
+        ])
+        self.assertEqual(codex_resume_cwd(path, SID), "/initial project")
+
+    def test_reverse_chunks_reassemble_long_records_and_keep_latest_settings(self):
+        saved = "/saved " + "é" * 200
+        path = self.write([
+            self.meta, line("turn_context", cwd="/older"),
+            line("event_msg", type="thread_settings_applied", thread_id=SID,
+                 thread_settings={"cwd": saved}),
+            line("response_item", type="message", text="padding" * 100),
+        ])
+        with mock.patch.object(session_settings, "CHUNK", 127):
+            self.assertEqual(codex_resume_cwd(path, SID), saved)
+
+    def test_initial_metadata_remains_fallback_beyond_reverse_scan_limit(self):
+        large_meta = line("session_meta", id=SID, cwd="/initial project", base_instructions="x" * (1 << 20))
+        path = self.write([large_meta, line("session_meta", id=OTHER, cwd="/copied-parent"),
+                           line("response_item", type="message", text="padding" * 100)])
+        self.assertEqual(codex_resume_cwd(path, SID), "/initial project")
+        with mock.patch.object(session_settings, "CHUNK", 128), \
+                mock.patch.object(session_settings, "SCAN_LIMIT", 128):
+            self.assertEqual(codex_resume_cwd(path, SID), "/initial project")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_cwd_tmux.py

@@ -0,0 +1,54 @@
+"""A quota restart restores the saved directory before Codex checks directory and trust."""
+
+import json
+import time
+import unittest
+
+from autoresume_tmux_support import SID, TMUX, TmuxScenario
+
+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 CodexCwdTmuxTests(unittest.TestCase):
+    def test_quota_restart_restores_latest_directory_before_trust_and_prompt(self):
+        self.check_restart("turn_context")
+
+    def test_settings_change_restores_directory_before_the_next_turn(self):
+        self.check_restart("thread_settings_applied")
+
+    def check_restart(self, record_type):
+        case = TmuxScenario(FAKE_REQUIRE_RESUME_CWD="1", FAKE_REQUIRE_TRUST="1")
+        self.addCleanup(case.close)
+        saved = case.home / "saved project Ω"
+        saved.mkdir()
+        source = case.pool / "acct-01/config.toml"
+        target = case.pool / "acct-02/config.toml"
+        source.write_text("# The original account stays unchanged.\n")
+        case.start()
+        context = {"timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                   "type": "turn_context", "payload": {"cwd": str(saved)}}
+        if record_type == "thread_settings_applied":
+            context.update(type="event_msg", payload={"type": record_type, "thread_id": SID,
+                                                     "thread_settings": {"cwd": str(saved)}})
+        with case.rollout.open("a") as stream:
+            stream.write(json.dumps(context) + "\n")
+        case.append(QUOTA)
+        case.wait(lambda: "autoresume switch" in case.log.read_text(), "restart in saved directory confirmed")
+        first, second = case.records("launch")
+        self.assertEqual([first["cwd"], second["cwd"]], [str(case.work), str(saved)])
+        self.assertEqual([first["account"], second["account"]], ["acct-01", "acct-02"])
+        self.assertIn(SID, second["argv"])
+        self.assertEqual([row["matches"] for row in case.records("resume-cwd")], [True])
+        self.assertEqual([(row["trusted"], row["cwd"]) for row in case.records("trust")], [(True, str(saved))])
+        self.assertIn('[projects.' + json.dumps(str(saved), ensure_ascii=False) + ']', target.read_text())
+        self.assertNotIn(str(case.work), target.read_text())
+        self.assertEqual(source.read_text(), "# The original account stays unchanged.\n")
+        self.assertEqual(len(case.records("prompt")), 1)
+        self.assertEqual(case.log.read_text().count("autoresume switch"), 1)
+        self.assertEqual(case.records("keys"), [], "neither TUI receives a keystroke")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_codex_exec_stdin.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""Exercise finite Node pipe prompts against the real shim and fake native Codex."""
+
+import base64
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+
+REPO = Path(__file__).resolve().parents[1]
+SHIM = os.environ.get('MULTIACC_TEST_SHIM', str(REPO / 'bin/codex'))
+NODE = shutil.which('node')
+PROMPT = b'Original image brief\nUnicode: \xf0\x9f\x8c\xb1\nBinary fidelity: \x00\xff\n'
+FAKE = '''import base64, json, os, pathlib, sys
+root = pathlib.Path(os.environ['FAKE_ROOT'])
+account = pathlib.Path(os.environ['CODEX_HOME']).name
+args = sys.argv[1:]
+data = sys.stdin.buffer.read() if args[-1:] == ['-'] and os.environ.get('FAKE_READ', '1') == '1' else b''
+with (root / 'calls.jsonl').open('a') as handle:
+    handle.write(json.dumps({'account': account, 'argv': args,
+                            'selected_home': os.environ.get('CODEX_MULTIACC_SELECTED_HOME'),
+                            'stdin': base64.b64encode(data).decode()}) + '\\n')
+mode = os.environ.get('FAKE_MODE', 'quota')
+if mode == 'ordinary':
+    print('ordinary failure', file=sys.stderr)
+    sys.exit(7)
+if mode == 'all-quota' or (account == 'acct-01' and mode in ('quota', 'auth')):
+    print(json.dumps({'type': 'turn.failed', 'partial': account}))
+    print('ERROR: You’ve hit your usage limit.' if mode != 'auth' else
+          'Error: token expired. Please run codex login again', file=sys.stderr)
+    sys.exit(1)
+print(json.dumps({'type': 'turn.completed', 'account': account}))
+'''
+LAUNCH = '''const {spawn} = require('node:child_process');
+const child = spawn(process.env.TEST_SHIM, JSON.parse(process.env.TEST_ARGS),
+  {stdio: ['pipe', 'pipe', 'pipe']});
+child.stdout.pipe(process.stdout); child.stderr.pipe(process.stderr);
+child.stdin.on('error', error => { if (error.code !== 'EPIPE') throw error; });
+if (process.env.TEST_KEEP_OPEN !== '1') {
+  child.stdin.end(Buffer.from(process.env.TEST_INPUT, 'base64'));
+}
+child.on('close', code => { child.stdin.destroy(); process.exitCode = code; });
+'''
+
+
+@unittest.skipUnless(NODE, 'Node is required for the actual child-process transport')
+class CodexExecStdinTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory(prefix='multiacc-exec-stdin-')
+        self.addCleanup(self.tmp.cleanup)
+        self.root = Path(self.tmp.name)
+        self.pool = self.root / 'pool'
+        self.pool.mkdir()
+        (self.pool / 'accounts.json').write_text('{"threshold":90,"accounts":[]}')
+        (self.pool / '.limits-kick').touch()
+        for index in (1, 2):
+            account = self.pool / f'acct-{index:02d}'
+            account.mkdir()
+            (account / 'auth.json').write_text('{"access_token":"fake-offline-only"}')
+            (account / 'limits.json').write_text(json.dumps({
+                'fetched_at': int(time.time()), 'weekly_percent': index * 10,
+                'session_percent': 5, 'max_percent': index * 10, 'buckets': []}))
+        fakebin = self.root / 'bin'
+        fakebin.mkdir()
+        fake = fakebin / 'codex'
+        fake.write_text(f'#!{sys.executable}\n' + FAKE)
+        fake.chmod(0o755)
+        self.env = {
+            'HOME': str(self.root), 'PATH': f'{fakebin}:/usr/bin:/bin:/usr/sbin:/sbin',
+            'CODEX_ACCOUNTS_ROOT': str(self.pool), 'CODEX_MULTIACC_HEADROOM_BAND': '0',
+            'CODEX_MULTIACC_MCP': '0', 'CODEX_MULTIACC_AUTO_RESET': '0',
+            'CODEX_MULTIACC_MODEL_CATALOG': '0', 'CLAUDE_MULTIACC_PATH_PROBE': '0',
+            'FAKE_ROOT': str(self.root), 'TEST_SHIM': SHIM,
+            'TEST_INPUT': base64.b64encode(PROMPT).decode(), 'LANG': 'en_US.UTF-8',
+        }
+        self.args = ['exec', '-C', str(self.root), '--skip-git-repo-check', '--ephemeral',
+                     '--ignore-user-config', '--json', '--color', 'never', '-s', 'workspace-write',
+                     '-c', 'model_reasoning_effort=medium', '-c', 'project_doc_max_bytes=0', '-']
+
+    def run_node(self, args=None, **changes):
+        env = {**self.env, 'TEST_ARGS': json.dumps(args or self.args), **changes}
+        result = subprocess.run([NODE, '-e', LAUNCH], env=env, capture_output=True, timeout=15)
+        calls = self.root / 'calls.jsonl'
+        rows = [json.loads(line) for line in calls.read_text().splitlines()] if calls.exists() else []
+        return result, rows
+
+    def test_quota_retries_exact_node_image_prompt_with_identical_bytes(self):
+        result, calls = self.run_node()
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual([row['account'] for row in calls], ['acct-01', 'acct-02'])
+        self.assertTrue(all(base64.b64decode(row['stdin']) == PROMPT for row in calls))
+        self.assertTrue(all(row['argv'] == self.args for row in calls))
+        self.assertTrue(all(row['selected_home'] == str(self.pool / row['account']) for row in calls))
+        self.assertNotIn(b'turn.failed', result.stdout)
+        self.assertNotIn(b'usage limit', result.stderr)
+        self.assertIn('error-cooldown', (self.pool / 'acct-01/.limited').read_text())
+        self.assertIn('retry from=acct-01 to=acct-02', (self.pool / 'selection.log').read_text())
+
+    def test_auth_failure_rotates_and_parks_only_rejected_account(self):
+        result, calls = self.run_node(FAKE_MODE='auth')
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertEqual(len(calls), 2)
+        self.assertIn('reason=auth-error', (self.pool / 'acct-01/.expired').read_text())
+        self.assertFalse((self.pool / 'acct-02/.expired').exists())
+
+    def test_success_and_ordinary_failure_never_replay(self):
+        for mode, expected in [('success', 0), ('ordinary', 7)]:
+            with self.subTest(mode=mode):
+                (self.root / 'calls.jsonl').unlink(missing_ok=True)
+                result, calls = self.run_node(FAKE_MODE=mode)
+                self.assertEqual(result.returncode, expected, result.stderr)
+                self.assertEqual(len(calls), 1)
+                self.assertFalse((self.pool / 'acct-01/.limited').exists())
+
+    def test_two_exhausted_accounts_return_actual_final_failure_once(self):
+        result, calls = self.run_node(FAKE_MODE='all-quota')
+        self.assertEqual(result.returncode, 1)
+        self.assertEqual(len(calls), 2)
+        self.assertEqual(result.stderr.count(b'usage limit'), 1)
+        self.assertNotIn(b'turn.completed', result.stdout)
+        self.assertEqual(json.loads(result.stdout)['partial'], 'acct-02')
+
+    def test_explicit_pins_and_disable_keep_the_existing_passthrough_contract(self):
+        for changes in [{'CODEX_HOME': str(self.pool / 'acct-01')},
+                        {'CODEX_ACCOUNT': 'acct-01'}, {'CODEX_SHIM_RETRY': '0'}]:
+            with self.subTest(changes=changes):
+                (self.root / 'calls.jsonl').unlink(missing_ok=True)
+                result, calls = self.run_node(**changes)
+                self.assertEqual(result.returncode, 1, result.stderr)
+                self.assertEqual(len(calls), 1)
+                self.assertEqual(calls[0]['account'], 'acct-01')
+
+    def test_nonconsuming_open_pipe_is_not_buffered(self):
+        commands = [['exec', 'prompt supplied in argv'], ['exec', '--image', '-'],
+                    ['exec', '--config', '--json', '-'], ['exec', '--full-auto', '-'],
+                    ['exec', '--help', '-'], ['exec', '-o', '-'], ['exec', '--future-option', '-']]
+        for args in commands:
+            with self.subTest(args=args):
+                (self.root / 'calls.jsonl').unlink(missing_ok=True)
+                result, calls = self.run_node(args, TEST_KEEP_OPEN='1', FAKE_MODE='success', FAKE_READ='0')
+                self.assertEqual(result.returncode, 0, result.stderr)
+                self.assertEqual(len(calls), 1)
+
+    def test_auto_selection_provenance_does_not_turn_explicit_pins_into_pool_requests(self):
+        selected = str(self.pool / 'acct-01')
+        scenarios = [({}, selected), ({'CODEX_HOME': selected}, None),
+                     ({'CODEX_ACCOUNT': 'acct-01', 'CODEX_MULTIACC_SELECTED_HOME': selected}, None),
+                     ({'CODEX_HOME': str(self.pool / 'acct-02'),
+                       'CODEX_MULTIACC_SELECTED_HOME': selected}, selected)]
+        for changes, expected in scenarios:
+            with self.subTest(changes=changes):
+                (self.root / 'calls.jsonl').unlink(missing_ok=True)
+                result, calls = self.run_node(FAKE_MODE='success', **changes)
+                self.assertEqual(result.returncode, 0, result.stderr)
+                self.assertEqual(len(calls), 1)
+                self.assertEqual(calls[0]['selected_home'], expected)
+
+    def test_parser_only_accepts_explicit_prompt_not_option_values_or_early_exits(self):
+        parser = ['bash', str(REPO / 'lib/codex_exec_stdin.sh')]
+        accepted = [self.args, ['--no-daemon', 'e', '--image', 'one.png', 'two.png', '-'],
+                    ['exec', '--', '-'], ['--model=gpt-6.1-sol', 'exec', '-']]
+        rejected = [['exec', '-o', '-'], ['exec', '--color', '-'], ['exec', '--help', '-'],
+                    ['exec', '--future-option', '-'], ['exec', 'resume', '-'],
+                    ['mcp', 'add', 'exec', '-'], ['exec', 'text'], ['exec', '--image', 'one.png'],
+                    ['exec', '--image', '-'], ['exec', '--config', '--json', '-'], ['exec', '--full-auto', '-']]
+        for args in accepted + rejected:
+            with self.subTest(args=args):
+                result = subprocess.run(parser + args, capture_output=True)
+                self.assertEqual(result.returncode, 0 if args in accepted else 1)
+
+
+if __name__ == '__main__':
+    unittest.main()

package/tests/test_codex_mcp_oauth.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""Native-layout synthetic tests; no real pool, credentials, keyring, or network."""
+import fcntl
+import json
+import multiprocessing
+import os
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'lib'))
+import codex_mcp_oauth as M
+from codex_mcp_oauth_store import PLACEHOLDER, SENTINEL
+
+KEY = 'motionsites|1234567890abcdef'
+ENTRY = {'server_name': 'motionsites', 'server_url': 'https://example.invalid/mcp',
+         'issuer': 'https://example.invalid', 'client_id': 'fake-client', 'access_token': 'fake-access',
+         'refresh_token': 'fake-refresh', 'expires_at': 1900000000000, 'scopes': ['read']}
+
+
+def native_update(account, key, entry):
+    """Mirror native O_NOFOLLOW, aggregate flock, truncate-in-place, empty unlink."""
+    lock = account / 'mcp-oauth-locks' / 'file-store.lock'
+    with lock.open('a') as handle:
+        fcntl.flock(handle, fcntl.LOCK_EX)
+        path = account / '.credentials.json'
+        doc = json.loads(path.read_text())
+        if entry is None:
+            doc.pop(key, None)
+        else:
+            doc[key] = entry
+        if not doc:
+            path.unlink()
+            return
+        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_NOFOLLOW, 0o600)
+        with os.fdopen(fd, 'w') as stream:
+            stream.truncate(0)
+            json.dump(doc, stream)
+
+
+class SharedStoreTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.root = Path(self.temp.name)
+        self.accounts = [self.root / 'acct-01', self.root / 'acct-02']
+        for path in self.accounts:
+            path.mkdir()
+            (path / 'auth.json').write_text('subscription-login-must-stay-byte-identical')
+        (self.root / 'accounts.json').write_text(json.dumps({'accounts': [{'id': p.name} for p in self.accounts]}))
+        self.shared = self.root / M.SHARED_DIR
+
+    def seed(self, account=0, entry=None):
+        path = self.accounts[account] / '.credentials.json'
+        path.write_text(json.dumps({KEY: ENTRY if entry is None else entry}))
+        return path
+
+    def test_share_native_refresh_and_last_logout_without_resurrection(self):
+        source = self.seed()
+        inode = source.stat().st_ino
+        self.assertTrue(M.ensure(self.root))
+        for account in self.accounts:
+            self.assertEqual((account / '.credentials.json').stat().st_ino, inode)
+            self.assertEqual((account / 'auth.json').read_text(), 'subscription-login-must-stay-byte-identical')
+        native_update(self.accounts[1], KEY, dict(ENTRY, access_token='rotated-fake'))
+        self.assertEqual(json.loads(source.read_text())[KEY]['access_token'], 'rotated-fake')
+        native_update(self.accounts[1], KEY, None)
+        self.assertTrue(M.ensure(self.root))
+        for account in self.accounts:
+            self.assertEqual(json.loads((account / '.credentials.json').read_text()), {SENTINEL: PLACEHOLDER})
+        self.assertEqual(source.stat().st_mode & 0o777, 0o600)
+        before = source.stat().st_mtime_ns
+        receipt_before = (self.shared / 'managed.json').stat().st_mtime_ns
+        self.assertTrue(M.ensure(self.root))
+        self.assertEqual(source.stat().st_mtime_ns, before)
+        self.assertEqual((self.shared / 'managed.json').stat().st_mtime_ns, receipt_before)
+
+    def test_empty_and_disabled_pools_have_no_auth_state(self):
+        self.assertFalse(M.ensure(self.root))
+        self.assertFalse(self.shared.exists())
+        self.seed()
+        with patch.dict(os.environ, {'CODEX_MULTIACC_MCP_OAUTH': '0'}):
+            self.assertFalse(M.ensure(self.root))
+        self.assertFalse(self.shared.exists())
+        self.assertTrue(M.ensure(self.root, initialize=True))
+
+    def test_conflicting_grants_and_scoped_credentials_are_untouched(self):
+        first = self.seed()
+        second = self.seed(1, dict(ENTRY, refresh_token='different-grant'))
+        before = [first.read_bytes(), second.read_bytes()]
+        self.assertFalse(M.ensure(self.root))
+        self.assertEqual([first.read_bytes(), second.read_bytes()], before)
+        self.assertFalse(self.shared.exists())
+        second.unlink()
+        for update in ({'executor_owned': True}, {'server_name': 'ema-idp:private'}):
+            self.seed(entry=dict(ENTRY, **update))
+            self.assertFalse(M.ensure(self.root))
+            self.assertFalse(self.shared.exists())
+
+    def test_native_lock_contention_defers_and_preserves_owner_inode(self):
+        self.seed()
+        directory = self.accounts[0] / 'mcp-oauth-locks'
+        directory.mkdir()
+        file_lock = directory / 'file-store.lock'
+        file_lock.touch()
+        file_inode = file_lock.stat().st_ino
+        path = directory / ('a' * 64 + '.lock')
+        with path.open('w') as handle:
+            inode = path.stat().st_ino
+            fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            self.assertFalse(M.ensure(self.root))
+            self.assertFalse((self.accounts[1] / '.credentials.json').exists())
+        self.assertTrue(M.ensure(self.root))
+        self.assertEqual((self.shared / 'locks' / path.name).stat().st_ino, inode)
+        self.assertEqual((self.shared / 'locks' / 'file-store.lock').stat().st_ino, file_inode)
+        with (self.accounts[0] / 'mcp-oauth-locks' / path.name).open('a') as handle:
+            fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            other = os.open(self.accounts[1] / 'mcp-oauth-locks' / path.name, os.O_RDWR)
+            try:
+                with self.assertRaises(BlockingIOError):
+                    fcntl.flock(other, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            finally:
+                os.close(other)
+
+    def test_concurrent_native_writers_preserve_both_servers(self):
+        self.seed()
+        self.assertTrue(M.ensure(self.root))
+        processes = []
+        context = multiprocessing.get_context('fork')
+        for index, account in enumerate(self.accounts):
+            name = 'server' + str(index)
+            process = context.Process(target=native_update, args=(account, name, dict(ENTRY, server_name=name)))
+            process.start()
+            processes.append(process)
+        for process in processes:
+            process.join(5)
+            self.assertEqual(process.exitcode, 0)
+        doc = json.loads((self.shared / 'credentials.json').read_text())
+        self.assertIn('server0', doc)
+        self.assertIn('server1', doc)
+
+
+if __name__ == '__main__':
+    unittest.main()