claude-multiacc 2.0.58 → 2.0.60

package/tests/test_autoresume_catalog_cli.py

@@ -0,0 +1,185 @@
+"""`<provider>-accounts model-catalog` and the limits-pass backstop, against temporary pools.
+
+The pools, the CLIs' model caches and the provider executables are synthetic and live in a
+temporary HOME. The caller's own pool variables are dropped, so no real pool root is ever
+named, and no request is sent: the catalog reads files only (lib/model_catalog.py).
+"""
+
+import json
+import os
+from pathlib import Path
+import stat
+import subprocess
+import tempfile
+import time
+import unittest
+
+REPO = Path(__file__).resolve().parents[1]
+LEVELS = ["low", "medium", "high", "xhigh", "max"]
+OVERLAY = "model-catalog.json"
+
+
+class ModelCatalogCliTests(unittest.TestCase):
+    def setUp(self):
+        work = tempfile.TemporaryDirectory(prefix="multiacc-catalog-cli-")
+        self.addCleanup(work.cleanup)
+        self.home = Path(work.name).resolve()
+        fakebin = self.home / "bin"
+        fakebin.mkdir()
+        for name in ("claude", "codex", "security", "curl"):
+            script = fakebin / name
+            script.write_text('#!/bin/sh\nprintf "%s\\n" "$0 $*" >> "$HOME/unexpected-calls"\nexit 79\n')
+            script.chmod(0o755)
+        self.env = {k: v for k, v in os.environ.items()
+                    if not k.startswith(("CLAUDE_", "CODEX_", "MULTIACC_", "ANTHROPIC_", "OPENAI_"))
+                    and k not in ("TMUX", "TMUX_PANE")}
+        missing = "file://" + str(self.home / "missing-endpoint.json")
+        self.env.update(HOME=str(self.home), PATH=f"{fakebin}:{os.environ['PATH']}", PYTHONDONTWRITEBYTECODE="1",
+                        CLAUDE_MULTIACC_CLI_VERSION="2.1.280", CLAUDE_MULTIACC_NO_DISTRIBUTE="1",
+                        CLAUDE_MULTIACC_MCP_OAUTH="0")  # no detached MCP OAuth sync outliving a test
+        self.roots = {}
+        for provider in ("claude", "codex"):
+            root = self.home / (provider + "-pool")
+            (root / "acct-01").mkdir(parents=True)
+            (root / "accounts.json").write_text(json.dumps({"version": 1, "server": "none", "threshold": 90,
+                                                            "accounts": []}))
+            self.roots[provider] = root
+            up = provider.upper()
+            self.env.update({up + "_ACCOUNTS_ROOT": str(root), up + "_MULTIACC_NO_SYNC": "1",
+                             up + "_MULTIACC_USAGE_URL": missing, up + "_MULTIACC_TOKEN_URL": missing})
+            for key in ("KEYCHAIN", "MCP", "AUTORESUME", "AUTO_RESET", "PATH_PROBE"):
+                self.env[up + "_MULTIACC_" + key] = "0"
+        self.seed_caches()
+
+    def seed_caches(self):
+        """One Codex models_cache.json and one Claude served catalog, newer than the shipped file."""
+        codex = {"fetched_at": "2099-01-01T00:00:00.000000Z", "etag": "fixture", "client_version": "0.162.1",
+                 "models": [{"slug": "gpt-9-astra", "visibility": "list", "default_reasoning_level": "high",
+                             "supported_reasoning_levels": [{"effort": e} for e in LEVELS + ["ultra"]],
+                             "upgrade": None}]}
+        (self.roots["codex"] / "acct-01" / "models_cache.json").write_text(json.dumps(codex))
+        rows = [{"id": "claude-fable-9", "section": "main",
+                 "thinking": {"type": "effort", "effort_options": [{"id": e} for e in LEVELS]}}]
+        state = {"thinking_by_model": [{"id": "claude-fable-9", "thinking": {"effort": "xhigh"}}]}
+        claude = {"version": 2, "fetchedAt": 4102444800000,
+                  "catalog": {"surface": "cc", "config": {"id": "cc", "models": rows}, "state": state}}
+        cache = self.roots["claude"] / "acct-01" / "cache" / "model-catalog"
+        cache.mkdir(parents=True)
+        (cache / "fixture-cc.json").write_text(json.dumps(claude))
+
+    def cli(self, provider, *args, **env):
+        return subprocess.run([str(REPO / "bin" / (provider + "-accounts")), *args], env={**self.env, **env},
+                              cwd=str(self.home), capture_output=True, text=True, timeout=60)
+
+    def copies(self):
+        return {provider: root / OVERLAY for provider, root in self.roots.items()}
+
+    def assert_nothing_written(self):
+        self.assertEqual([p for p in self.copies().values() if p.exists()], [])
+
+    def test_refresh_writes_both_pools_from_the_clis_own_caches(self):
+        result = self.cli("claude", "model-catalog", "refresh")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        copies = sorted(str(path) for path in self.copies().values())
+        self.assertEqual(sorted(result.stdout.split()), copies)
+        for path in copies:
+            doc = json.loads(Path(path).read_text())
+            self.assertEqual(doc["schema"], 1)
+            self.assertIn("generated_at", doc)
+            self.assertEqual(doc["codex"]["fetched_at"], "2099-01-01T00:00:00Z")
+            self.assertEqual(doc["codex"]["models"]["gpt-9-astra"]["efforts"], LEVELS + ["ultra"])
+            self.assertEqual(doc["codex"]["models"]["gpt-9-astra"]["default_effort"], "high")
+            self.assertEqual(doc["claude"]["fetched_at"], "2100-01-01T00:00:00Z")
+            self.assertEqual(doc["claude"]["models"]["claude-fable-9"]["default_effort"], "xhigh")
+            self.assertEqual(doc["claude"]["families"]["fable"], 5)  # structure: the shipped file's
+            self.assertEqual(stat.S_IMODE(os.stat(path).st_mode), 0o644)
+        self.assertEqual(sorted(os.listdir(str(self.roots["codex"]))), ["accounts.json", "acct-01", OVERLAY])
+        self.assertFalse((self.home / "unexpected-calls").exists())
+
+    def test_show_prints_the_merged_catalog_and_writes_nothing(self):
+        result = self.cli("codex", "model-catalog", "show")
+        self.assertEqual(result.returncode, 0, result.stderr)
+        doc = json.loads(result.stdout)
+        self.assertEqual(sorted(doc["codex"]["models"]), ["gpt-9-astra"])
+        self.assertEqual(sorted(doc["claude"]["models"]), ["claude-fable-9"])
+        self.assert_nothing_written()
+
+    def test_quiet_prints_nothing_and_if_stale_leaves_a_fresh_copy_alone(self):
+        quiet = self.cli("codex", "model-catalog", "refresh", "--quiet")
+        self.assertEqual((quiet.returncode, quiet.stdout, quiet.stderr), (0, "", ""))
+        copy = self.copies()["claude"]
+        inode = copy.stat().st_ino
+        fresh = self.cli("claude", "model-catalog", "refresh", "--if-stale")
+        self.assertEqual((fresh.returncode, fresh.stdout), (0, ""), fresh.stderr)
+        self.assertEqual(copy.stat().st_ino, inode)
+        os.utime(str(copy), (0, 0))
+        stale = self.cli("claude", "model-catalog", "--if-stale")
+        self.assertEqual((stale.returncode, stale.stdout.split()), (0, [str(copy)]), stale.stderr)
+        self.assertNotEqual(copy.stat().st_ino, inode)
+
+    def test_kill_switches_write_nothing_and_say_so(self):
+        for switches in ({"CLAUDE_MULTIACC_MODEL_CATALOG": "0", "CODEX_MULTIACC_MODEL_CATALOG": "off"},
+                         {"MULTIACC_MODEL_CATALOG": "false"}):
+            for provider in ("claude", "codex"):
+                with self.subTest(provider=provider, switches=switches):
+                    result = self.cli(provider, "model-catalog", "refresh", **switches)
+                    self.assertEqual((result.returncode, result.stdout), (0, ""), result.stderr)
+                    for pool in ("claude", "codex"):
+                        self.assertIn(f"model catalog refresh is off for the {pool} pool", result.stderr)
+                    self.assert_nothing_written()
+                    quiet = self.cli(provider, "model-catalog", "--quiet", **switches)
+                    self.assertEqual((quiet.returncode, quiet.stdout, quiet.stderr), (0, "", ""))
+        # One pool off leaves the other refreshed; the provider's own spelling wins when set.
+        result = self.cli("claude", "model-catalog", MULTIACC_MODEL_CATALOG="0", CODEX_MULTIACC_MODEL_CATALOG="1")
+        self.assertEqual((result.returncode, result.stdout.split()), (0, [str(self.copies()["codex"])]))
+        self.assertIn("claude pool (MULTIACC_MODEL_CATALOG=0)", result.stderr)
+        self.assertFalse(self.copies()["claude"].exists())
+
+    def test_help_and_bad_arguments_touch_nothing(self):
+        for provider in ("claude", "codex"):
+            for args in (["--help"], ["refresh", "--help"], ["show", "-h"]):
+                result = self.cli(provider, "model-catalog", *args)
+                self.assertEqual(result.returncode, 0, result.stderr)
+                self.assertIn(f"{provider}-accounts model-catalog [refresh|show]", result.stdout)
+            for args in (["bogus"], ["refresh", "show"], ["--force"]):
+                self.assertNotEqual(self.cli(provider, "model-catalog", *args).returncode, 0, args)
+        self.assert_nothing_written()
+
+    def test_a_refresh_with_no_pool_root_fails_unless_it_only_asked_for_stale_copies(self):
+        env = {"CLAUDE_ACCOUNTS_ROOT": str(self.home / "absent-1"), "CODEX_ACCOUNTS_ROOT": str(self.home / "absent-2")}
+        result = self.cli("codex", "model-catalog", "refresh", **env)
+        self.assertEqual(result.returncode, 1)
+        self.assertIn("no pool root could take the model catalog", result.stderr)
+        self.assertEqual(self.cli("codex", "model-catalog", "--if-stale", "--quiet", **env).returncode, 0)
+
+    def test_a_limits_pass_keeps_its_own_pool_copy_fresh_and_never_the_other(self):
+        for provider, other in (("claude", "codex"), ("codex", "claude")):
+            with self.subTest(provider=provider):
+                own, theirs = self.copies()[provider], self.copies()[other]
+                for path in (own, theirs):
+                    if path.exists():
+                        path.unlink()
+                self.assertEqual(self.cli(provider, "limits", "--quiet").returncode, 0)
+                self.assertTrue(own.exists())      # in line: written before the pass returned
+                self.assertFalse(theirs.exists())  # a pass never writes the other provider's pool
+                self.assertIn("gpt-9-astra" if provider == "codex" else "claude-fable-9", own.read_text())
+                inode = own.stat().st_ino
+                self.assertEqual(self.cli(provider, "limits", "--quiet").returncode, 0)
+                self.assertEqual(own.stat().st_ino, inode)  # younger than an hour: left alone
+                os.utime(str(own), (0, 0))
+                self.assertEqual(self.cli(provider, "limits", "--quiet").returncode, 0)
+                self.assertNotEqual(own.stat().st_ino, inode)
+                self.assertGreater(own.stat().st_mtime, time.time() - 600)
+        self.assertFalse((self.home / "unexpected-calls").exists())
+
+    def test_a_limits_pass_honours_the_kill_switch(self):
+        for provider in ("claude", "codex"):
+            for switch in ({provider.upper() + "_MULTIACC_MODEL_CATALOG": "0"}, {"MULTIACC_MODEL_CATALOG": "no"}):
+                with self.subTest(provider=provider, switch=switch):
+                    result = self.cli(provider, "limits", "--quiet", **switch)
+                    self.assertEqual(result.returncode, 0, result.stderr)
+                    self.assert_nothing_written()
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_codex_records.py

@@ -38,6 +38,22 @@ class CurrentCodexRecordsTests(unittest.TestCase):
         self.assertEqual(runner.signals, [(pool.PID, signal.SIGTERM)])
         self.assertEqual(pool.events(), ["watch", "detect", "switch"])
 
+    def test_current_turn_context_pins_the_sessions_model_and_effort(self):
+        pool = self.pool
+        records, _ = self.records()
+        context = {"timestamp": fixtures.iso(pool.t0 - 3), "ordinal": 4, "type": "turn_context", "payload": {
+            "turn_id": "01a135db-f14d-7a60-b656-d5ff72abd71d", "root_turn_id": "01a135db-f14d-7a60-b656-d5ff72abd71d",
+            "cwd": str(pool.work), "approval_policy": "never", "approvals_reviewer": "user",
+            "sandbox_policy": {"type": "danger-full-access"}, "permission_profile": {"type": "disabled"},
+            "model": "gpt-6-astra", "multi_agent_version": "v2", "realtime_active": False, "effort": "ultra",
+            "summary": "none"}}
+        rc, _, runner, _ = pool.run_codex(["resume", fixtures.CX_SID], records[:1] + [context] + records[1:])
+        self.assertEqual(rc, 0)
+        _, argv = pool.relaunch_of(runner)
+        self.assertEqual(argv, ["resume", "-m", "gpt-6-astra", "-c", "model_reasoning_effort=ultra",
+                                fixtures.CX_SID, fixtures.ar.resume_prompt("quota")])
+        self.assertTrue(pool.log_lines()[-1].endswith(" model=gpt-6-astra effort=ultra"))
+
     def test_paginated_user_turn_cancels_before_restart(self):
         pool = self.pool
         records, _ = self.records()

package/tests/test_autoresume_codex_trust.py

@@ -0,0 +1,247 @@
+"""lib/codex_trust.py: folder trust for a Codex account's config.toml, never through its TUI."""
+
+import json
+import os
+from pathlib import Path
+import shutil
+import stat
+import subprocess
+import sys
+import tempfile
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+SCRIPT = ROOT / "lib" / "codex_trust.py"
+sys.path.insert(0, str(ROOT / "lib"))
+import codex_trust  # noqa: E402
+
+try:
+    import tomllib
+except ImportError:  # pragma: no cover - python < 3.11
+    tomllib = None
+
+OTHER = ('# operator notes\nmodel = "gpt-6"\n\n[projects."/elsewhere"]\ntrust_level = "trusted"\n\n'
+         '[mcp_servers.demo]\ncommand = "demo"\nargs = ["-I", "[x]", "serve"]\n'
+         'env = { A = "1" }\nstartup_timeout_sec = 60\n')
+
+
+def section(path):
+    return '[projects.%s]\ntrust_level = "trusted"\n' % json.dumps(str(path))
+
+
+class CodexTrustTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = Path(os.path.realpath(tempfile.mkdtemp(prefix="cx-trust-")))
+        self.addCleanup(shutil.rmtree, str(self.tmp), True)
+        self.acct = self.tmp / "acct-02"
+        self.acct.mkdir()
+        self.conf = self.acct / "config.toml"
+        self.work = self.tmp / "work"
+        self.work.mkdir()
+
+    def run_trust(self, *args):
+        return subprocess.run([sys.executable, "-I", str(SCRIPT), *args], capture_output=True,
+                              text=True, timeout=30)
+
+    def trust(self, cwd=None, acct=None, code=0):
+        out = self.run_trust("--acct-dir", str(acct or self.acct), "--cwd", str(cwd or self.work))
+        self.assertEqual((out.returncode, out.stdout, out.stderr), (code, "", ""))
+
+    def only_config(self):
+        self.assertEqual(sorted(p.name for p in self.acct.iterdir()), ["config.toml"])
+
+    def test_a_missing_config_is_created_holding_just_the_trust(self):
+        self.trust()
+        self.assertEqual(self.conf.read_text(), section(self.work))
+        self.assertEqual(stat.S_IMODE(self.conf.stat().st_mode), 0o600)
+        self.only_config()
+        if tomllib:
+            self.assertEqual(tomllib.loads(self.conf.read_text()),
+                             {"projects": {str(self.work): {"trust_level": "trusted"}}})
+
+    def test_an_existing_config_keeps_every_other_byte_and_its_mode(self):
+        self.conf.write_text(OTHER)
+        self.conf.chmod(0o640)
+        self.trust()
+        self.assertEqual(self.conf.read_text(), OTHER + "\n" + section(self.work))
+        self.assertEqual(stat.S_IMODE(self.conf.stat().st_mode), 0o640)
+        self.only_config()
+        # no trailing newline: the new table still starts on a line of its own
+        self.conf.write_text('model = "gpt-6"')
+        self.trust()
+        self.assertEqual(self.conf.read_text(), 'model = "gpt-6"\n\n' + section(self.work))
+
+    def test_an_untrusted_or_incomplete_table_is_completed_in_place(self):
+        key = json.dumps(str(self.work))
+        self.conf.write_text('[projects.%s]\nnotes = "kept"\ntrust_level = "untrusted" # by hand\n\n'
+                             '[projects."/other"]\ntrust_level = "untrusted"\n' % key)
+        self.trust()
+        self.assertEqual(self.conf.read_text(),
+                         '[projects.%s]\nnotes = "kept"\ntrust_level = "trusted"\n\n'
+                         '[projects."/other"]\ntrust_level = "untrusted"\n' % key)
+        # a table without the key gets it right under its header; a literal-string key counts
+        self.conf.write_text("[projects.'%s']\nnotes = \"kept\"" % self.work)
+        self.trust()  # the file's own missing final newline is not the edit's to add
+        self.assertEqual(self.conf.read_text(),
+                         "[projects.'%s']\ntrust_level = \"trusted\"\nnotes = \"kept\"" % self.work)
+        self.conf.write_text("[projects.%s]" % key)
+        self.trust()
+        self.assertEqual(self.conf.read_text(), section(self.work))
+        # spacing and a comment around the header are accepted
+        self.conf.write_text('[ projects . %s ]  # here\ntrust_level = "untrusted"\n' % key)
+        self.trust()
+        self.assertEqual(self.conf.read_text(), '[ projects . %s ]  # here\ntrust_level = "trusted"\n' % key)
+
+    def test_an_already_trusted_directory_rewrites_nothing(self):
+        for text in (section(self.work),
+                     "[projects.%s]\ntrust_level = 'trusted'  # single quotes\n" % json.dumps(str(self.work)),
+                     OTHER + "\n" + section(self.work) + "\n[projects.\"/z\"]\ntrust_level = \"untrusted\"\n"):
+            self.conf.write_text(text)
+            before = self.conf.stat()
+            os.utime(str(self.conf), (before.st_atime, before.st_mtime - 100))
+            mtime = self.conf.stat().st_mtime_ns
+            self.trust()
+            self.assertEqual((self.conf.read_text(), self.conf.stat().st_mtime_ns), (text, mtime))
+        self.only_config()
+
+    def test_the_logical_and_the_physical_path_are_both_trusted(self):
+        link = self.tmp / "link to work"
+        os.symlink(str(self.work), str(link))
+        self.trust(cwd=link)
+        self.assertEqual(self.conf.read_text(), section(link) + "\n" + section(self.work))
+        # the physical one already trusted: only the logical one is added, after it
+        self.conf.write_text(section(self.work))
+        self.trust(cwd=link)
+        self.assertEqual(self.conf.read_text(), section(self.work) + "\n" + section(link))
+
+    def test_paths_needing_escapes_round_trip(self):
+        odd = self.tmp / 'quote " and \\ backslash'
+        odd.mkdir()
+        self.trust(cwd=odd)
+        text = self.conf.read_text()
+        self.assertEqual(text, section(odd))
+        if tomllib:
+            self.assertEqual(list(tomllib.loads(text)["projects"]), [str(odd)])
+        self.trust(cwd=odd)  # read back as the same key: nothing to add
+        self.assertEqual(self.conf.read_text(), text)
+
+    def test_layouts_the_edit_could_corrupt_are_refused(self):
+        for text in ('projects = { "/x" = { trust_level = "trusted" } }\n',
+                     'projects."/x".trust_level = "untrusted"\n',
+                     '[projects]\n"/x" = { trust_level = "trusted" }\n',
+                     '[projects."/x"]\ntrust_level = "trusted"\n' * 2,
+                     '[projects."/x"]\ntrust_level = "trusted"\n[projects]\n'):
+            self.conf.write_text(text)
+            self.trust(code=1)
+            self.assertEqual(self.conf.read_text(), text)
+        self.only_config()
+        # a `projects` key inside another table is not the projects table
+        self.conf.write_text('[other]\nprojects = 1\n')
+        self.trust()
+        self.assertEqual(self.conf.read_text(), '[other]\nprojects = 1\n\n' + section(self.work))
+
+    def test_unreadable_or_invalid_configs_are_left_alone(self):
+        self.conf.write_bytes(b"\xff\xfe not utf-8\n")
+        self.trust(code=1)
+        self.assertEqual(self.conf.read_bytes(), b"\xff\xfe not utf-8\n")
+        if tomllib:
+            for text in ("model = \n", '[projects."/x"]\ntrust_level = "a" "b"\n', "[broken\n"):
+                self.conf.write_text(text)
+                self.trust(code=1)
+                self.assertEqual(self.conf.read_text(), text)
+        self.only_config()
+
+    def test_a_config_rewritten_meanwhile_is_not_overwritten(self):
+        self.conf.write_text(OTHER)
+        raced = OTHER + '\n[projects."/raced"]\ntrust_level = "trusted"\n'
+        real_mkstemp = codex_trust.tempfile.mkstemp
+
+        def sneaky(**kwargs):
+            self.conf.write_text(raced)
+            return real_mkstemp(**kwargs)
+
+        codex_trust.tempfile.mkstemp = sneaky
+        try:
+            self.assertEqual(codex_trust.trust(str(self.acct), str(self.work)), 1)
+        finally:
+            codex_trust.tempfile.mkstemp = real_mkstemp
+        self.assertEqual(self.conf.read_text(), raced)
+        self.only_config()
+
+    def test_a_symlinked_config_is_edited_through_the_link(self):
+        target = self.tmp / "shared-config.toml"
+        target.write_text(OTHER)
+        self.conf.symlink_to(target)
+        self.trust()
+        self.assertTrue(self.conf.is_symlink())
+        self.assertEqual(target.read_text(), OTHER + "\n" + section(self.work))
+
+    def test_non_ascii_paths_and_unicode_line_separators_stay_valid_toml(self):
+        odd = self.tmp / "emoji \U0001f600 dir"
+        odd.mkdir()
+        other = '[other]\nnotes = "a\u2028b\u0085c"\n'  # line separators TOML does not break on
+        self.conf.write_text(other)
+        self.trust(cwd=odd)
+        text = self.conf.read_text()
+        self.assertEqual(text, other + '\n[projects."%s"]\ntrust_level = "trusted"\n' % odd)
+        if tomllib:
+            self.assertEqual(tomllib.loads(text)["projects"][str(odd)], {"trust_level": "trusted"})
+        self.trust(cwd=odd)  # read back as the same key
+        self.assertEqual(self.conf.read_text(), text)
+
+    def test_the_text_edit_alone_is_valid_toml_without_a_parser(self):
+        # the stock macOS python has no tomllib: the edit must stand without the check
+        odd = self.tmp / 'emoji \U0001f600 " \\ \x7f dir'
+        odd.mkdir()
+        self.conf.write_text(OTHER)
+        real_verify = codex_trust._verify
+        codex_trust._verify = lambda *args: True
+        try:
+            self.assertEqual(codex_trust.trust(str(self.acct), str(odd)), 0)
+        finally:
+            codex_trust._verify = real_verify
+        text = self.conf.read_text()
+        self.assertTrue(text.startswith(OTHER))
+        if tomllib:
+            self.assertEqual(tomllib.loads(text)["projects"][str(odd)], {"trust_level": "trusted"})
+
+    def test_a_byte_order_mark_is_kept(self):
+        self.conf.write_text("\ufeff" + OTHER)
+        self.trust()
+        self.assertEqual(self.conf.read_text(), "\ufeff" + OTHER + "\n" + section(self.work))
+        self.trust()
+        self.assertEqual(self.conf.read_text(), "\ufeff" + OTHER + "\n" + section(self.work))
+
+    @unittest.skipUnless(hasattr(os, "mkfifo"), "needs mkfifo")
+    def test_a_fifo_named_config_does_not_hang(self):
+        os.mkfifo(str(self.conf))
+        self.trust(code=1)
+
+    def test_the_on_disk_spelling_is_trusted_too(self):
+        upper = self.tmp / "Work Dir"
+        upper.mkdir()
+        lower = Path(str(upper).lower())
+        keys = codex_trust.spellings(str(lower))
+        self.assertEqual(keys[0], str(lower))
+        if lower.exists() and str(lower) != str(upper):  # a case-insensitive volume (macOS)
+            self.assertIn(str(upper), keys)
+            self.trust(cwd=lower)
+            self.assertEqual(self.conf.read_text(), section(lower) + "\n" + section(upper))
+        else:
+            self.assertEqual(keys, [str(lower)])
+
+    def test_usage_and_argument_errors(self):
+        for args in ((), ("--acct-dir", str(self.acct)), ("--cwd", str(self.work)),
+                     ("--acct-dir", str(self.acct), "--cwd", str(self.work), "extra"),
+                     ("--acct-dir", str(self.acct), "--cwd"),
+                     ("--acct-dir", str(self.acct), "--acct-dir", str(self.acct))):
+            out = self.run_trust(*args)
+            self.assertEqual(out.returncode, 2, args)
+            self.assertIn("usage", out.stderr)
+        self.trust(cwd="relative/dir", code=1)
+        self.trust(acct=self.tmp / "acct-09", code=1)
+        self.assertFalse(self.conf.exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_cross_guards.py

@@ -4,11 +4,20 @@ from pathlib import Path
 import unittest
 from unittest import mock
 
+import test_autoresume as fixtures
 from autoresume_cross_receipt_support import TOKEN
 from autoresume_cross_unit_support import scenario
 import autoresume as ar
 import autoresume_cross as cross
 from autoresume_probe import cross_env, handoff_settings
+import model_match
+
+
+def settings_record(case, provider):
+    if provider == "codex":
+        return {"timestamp": fixtures.iso(case.t0 - 1), "type": "turn_context",
+                "payload": {"cwd": str(case.work), "model": "gpt-6-astra", "effort": "ultra"}}
+    return fixtures.cc_reply(case.t0 - 1, cwd=str(case.work), effort="xhigh")
 
 
 class CrossProviderGuardsTests(unittest.TestCase):
@@ -109,6 +118,25 @@ class CrossProviderGuardsTests(unittest.TestCase):
                 self.assertEqual(history.stat().st_ino, inode)
                 self.assertFalse(cross.revalidate(watcher, plan))
 
+    def test_mapped_plan_revalidates_and_a_failed_mapping_still_plans_unpinned(self):
+        pins = {"--model", "--effort", "-m", "-c"}
+        for provider in ("claude", "codex"):
+            with self.subTest(provider=provider):
+                case, watcher, runner, history, _ = scenario(self, provider)
+                fixtures.append(str(history), [settings_record(case, provider)])
+                plan = cross.plan_fallback(watcher, watcher.tracker.pending, "")
+                self.assertTrue(pins & set(plan["argv"][:-1]))
+                self.assertEqual(runner.target_probes[-1]["argv"][1:], plan["argv"])
+                fixtures.append(str(history), [{"type": "progress", "data": "later source state"}])
+                self.assertTrue(cross.revalidate(watcher, plan))
+                with mock.patch.object(model_match, "resume_settings", side_effect=RuntimeError("catalog")):
+                    unpinned = cross.plan_fallback(watcher, watcher.tracker.pending, "")
+                self.assertIsNotNone(unpinned)
+                self.assertFalse(pins & set(unpinned["argv"][:-1]))
+                self.assertEqual(unpinned["models"]["flags"], [])
+                self.assertEqual(runner.target_probes[-1]["argv"][1:], unpinned["argv"])
+                self.assertTrue(cross.revalidate(watcher, unpinned))
+
     def test_target_environment_cannot_inherit_source_auth_pins_or_relaunch_tokens(self):
         roots = {"claude": "/tmp/fixture-claude", "codex": "/tmp/fixture-codex"}
         private = {key: "TEST_ONLY_SENTINEL" for key in (

package/tests/test_autoresume_cross_tmux.py

@@ -7,6 +7,19 @@ import unittest
 
 from autoresume_cross_tmux_support import CrossScenario, TMUX
 
+# The fake CLIs record Codex gpt-6-astra at ultra and Claude claude-fable-5-1 at max (or the pins
+# they were launched with); the shipped catalog maps each to the other provider's same level
+# (the operator's map: astra -> opus, fable -> astra).
+MAPPED = {"claude": ["--model", "claude-opus-5-5", "--effort", "max"],
+          "codex": ["-m", "gpt-6-astra", "-c", "model_reasoning_effort=max"]}
+SENTENCE = {"claude": "Source model: gpt-6-astra (effort ultra). This conversation runs the matching claude "
+                      "model claude-opus-5-5 (effort max).",
+            "codex": "Source model: claude-fable-5-1 (effort max). This conversation runs the matching codex "
+                     "model gpt-6-astra (effort max)."}
+BYPASS = {"claude": ["--dangerously-skip-permissions"], "codex": ["--dangerously-bypass-approvals-and-sandbox"]}
+CONSERVATIVE = {"claude": ["--permission-mode", "default"],
+                "codex": ["--sandbox", "read-only", "--ask-for-approval", "on-request"]}
+
 
 @unittest.skipUnless(TMUX, "real tmux is unavailable")
 class CrossProviderTmuxTests(unittest.TestCase):
@@ -16,7 +29,15 @@ class CrossProviderTmuxTests(unittest.TestCase):
         case.start(provider, args)
         return case
 
-    def assert_handoff(self, case, source, target):
+    def assert_mapped_launch(self, launch, permissions, prompt):
+        """Permission options, then the same-level model pins, then the exact handoff prompt."""
+        argv = list(launch["argv"])
+        if launch["provider"] == "codex":
+            self.assertEqual(argv.count("--no-daemon"), 1)
+            argv.remove("--no-daemon")
+        self.assertEqual(argv, permissions + MAPPED[launch["provider"]] + [prompt])
+
+    def assert_handoff(self, case, source, target, permissions=None):
         case.wait(lambda: len(case.records("ready")) >= 2, "target TUI ready")
         case.wait(lambda: "autoresume switch" in case.logs(source), "source confirms target prompt")
         first, second = case.records("launch")[:2]
@@ -37,6 +58,8 @@ class CrossProviderTmuxTests(unittest.TestCase):
         self.assertEqual(case.records("keys"), [], "no keystroke may reach a TUI")
         self.assertEqual(case.records("signal")[0]["signal"], signal.SIGTERM)
         self.assertEqual(list(case.home.glob("*-pool/tmp/autoresume/r-*")), [])
+        self.assert_mapped_launch(second, BYPASS[target] if permissions is None else permissions, prompt["text"])
+        self.assertIn(SENTENCE[target], prompt["text"])
         return first, second
 
     def test_codex_pool_exhausted_continues_in_claude_with_source_identity(self):
@@ -104,7 +127,7 @@ class CrossProviderTmuxTests(unittest.TestCase):
                 case = self.scenario(source, args=[])
                 case.park(source)
                 case.quota()
-                _first, second = self.assert_handoff(case, source, target)
+                _first, second = self.assert_handoff(case, source, target, CONSERVATIVE[target])
                 if target == "claude":
                     self.assertEqual(second["argv"][:2], ["--permission-mode", "default"])
                 else:
@@ -129,6 +152,8 @@ class CrossProviderTmuxTests(unittest.TestCase):
         third = case.records("launch")[2]
         self.assertEqual((third["provider"], third["account"]), ("codex", "acct-02"))
         self.assertNotEqual(third["sid"], first["sid"])
+        # The return hop maps the Claude session's recorded model and effort back to Codex.
+        self.assert_mapped_launch(third, BYPASS["codex"], case.records("prompt")[1]["text"])
         chains = re.findall(r"autoresume watch provider=\w+ chain=(\w+)", case.logs())
         self.assertEqual(len(chains), 3)
         self.assertEqual(len(set(chains)), 1)

package/tests/test_autoresume_cross_tokens.py

@@ -12,10 +12,24 @@ from autoresume_cross_unit_support import scenario
 import autoresume_cross as cross
 import autoresume_cross_dispatch as dispatch
 
+# Source model records and the same-level target pins they map to through the shipped catalog.
+MAPPED = {"claude": ("claude-opus-5-5[1m]", "xhigh", ["-m", "gpt-6-astra", "-c", "model_reasoning_effort=xhigh"]),
+          "codex": ("gpt-6-astra", "ultra", ["--model", "claude-opus-5-5", "--effort", "max"])}
+
+
+def settings_record(case, provider):
+    model, effort, _ = MAPPED[provider]
+    if provider == "codex":
+        return {"timestamp": fixtures.iso(case.t0 - 1), "type": "turn_context",
+                "payload": {"cwd": str(case.work), "model": model, "effort": effort}}
+    return fixtures.cc_reply(case.t0 - 1, cwd=str(case.work), requestedModel=model, effort=effort)
+
 
 class CrossProviderTokenTests(unittest.TestCase):
-    def prepared(self, provider):
-        case, watcher, runner, _, root = scenario(self, provider)
+    def prepared(self, provider, settings=False):
+        case, watcher, runner, history, root = scenario(self, provider)
+        if settings:
+            fixtures.append(str(history), [settings_record(case, provider)])
         target = "codex" if provider == "claude" else "claude"
         watcher.st["depth"] = 3
         watcher.st["avoid_" + target] = "acct-02:%d" % (case.t0 + 3600)
@@ -52,6 +66,22 @@ class CrossProviderTokenTests(unittest.TestCase):
                 self.assertIn(watcher.st["self"], typed)
                 self.assertNotIn(plan["argv"][-1], typed)
 
+    def test_only_the_target_argv_carries_the_mapped_model_and_effort(self):
+        for provider in ("claude", "codex"):
+            with self.subTest(provider=provider):
+                case, watcher, runner, plan, keys, paths = self.prepared(provider, settings=True)
+                model, _, flags = MAPPED[provider]
+                self.assertEqual(plan["argv"][-len(flags) - 1:-1], flags)
+                self.assertEqual(runner.target_probes[-1]["argv"], [runner.target] + plan["argv"])
+                target = Path(plan["root"]) / "tmp/autoresume" / ("r-" + TOKEN + ".argv")
+                self.assertEqual(fixtures.ar.decode_argv(target.read_bytes()), plan["argv"])
+                self.assertEqual(plan["models"]["flags"], flags)
+                typed = next(key[-1] for key in keys if "-l" in key)
+                metadata = [typed] + [Path(path).read_text() for path in paths if not path.endswith(".argv")]
+                for text in metadata:
+                    for value in (model, flags[1], "--effort", "model_reasoning_effort"):
+                        self.assertNotIn(value, text)
+
     def test_dispatch_payload_is_exact_installation_metadata_without_auth_or_prompt(self):
         for provider in ("claude", "codex"):
             with self.subTest(provider=provider):