claude-multiacc 2.0.58 → 2.0.60

package/tests/test_autoresume_memory_tmux.py

@@ -0,0 +1,94 @@
+"""A claude client at critical memory, end to end: an isolated tmux server of its own, an
+interactive shell, the production shim and watcher, and the cross-provider suite's disposable
+fake TUI drawing the client's critical-memory banner in its footer -- and ignoring SIGTERM, as
+the 8.3GB client of 2026-10-20 did. No provider CLI, credential or network."""
+
+import os
+import signal
+import subprocess
+import time
+import unittest
+
+from autoresume_cross_tmux_support import CrossScenario, TMUX
+
+
+def teardown(case):
+    """Strict, whatever failed: the watchers told to stop, every fake TUI the case launched
+    killed (by pid, and only while its command line is still this case's), then the case's
+    tmux server and whatever is left of its watchers (CrossScenario.close)."""
+    try:
+        for pool in case.pools.values():
+            (pool / "autoresume.off").touch()
+        for row in case.records("launch"):
+            try:
+                args = subprocess.run(["ps", "-o", "args=", "-p", str(row["pid"])],
+                                      capture_output=True, text=True, timeout=5).stdout
+            except (OSError, subprocess.SubprocessError):
+                continue
+            if str(case.home) in args:
+                try:
+                    os.kill(row["pid"], signal.SIGKILL)
+                except OSError:
+                    pass
+    finally:
+        case.close()
+
+
+def gone(pid):
+    """Neither running nor a zombie left unreaped."""
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return True
+    state = subprocess.run(["ps", "-o", "stat=", "-p", str(pid)], capture_output=True,
+                           text=True, timeout=5).stdout.strip()
+    return not state or state.startswith("Z")
+
+
+@unittest.skipUnless(TMUX, "real tmux is unavailable")
+class MemoryTmuxTests(unittest.TestCase):
+    def test_the_banner_restarts_the_client_in_place_even_one_deaf_to_sigterm(self):
+        # MEMORY_MIN_UPTIME 0 here (900 s for real) and a scan every 0.2 s
+        case = CrossScenario(FAKE_MEMORY_BANNER="claude", FAKE_IGNORE_TERM="claude",
+                             CLAUDE_MULTIACC_AR_MEMORY_MIN_UPTIME="0",
+                             CLAUDE_MULTIACC_AR_MEMORY_SCAN="0.2")
+        self.addCleanup(teardown, case)
+        case.start("claude")
+        case.wait(lambda: len(case.records("ready")) >= 2, "same session resumed", timeout=90)
+        case.wait(lambda: "autoresume switch" in case.logs("claude"), "watcher confirms switch",
+                  timeout=30)
+        first, second = case.records("launch")[:2]
+        self.assertEqual([first["provider"], second["provider"]], ["claude", "claude"])
+        self.assertEqual(first["sid"], second["sid"])
+        self.assertEqual(second["argv"][second["argv"].index("--resume") + 1], first["sid"])
+        self.assertIn("because the previous process reached critical memory usage (8.3GB).",
+                      second["argv"][-1])
+        log = case.logs("claude")
+        self.assertIn("class=memory code=critical_memory sid=%s acct=%s reset=- size=8.3GB "
+                      "src=pane" % (first["sid"], first["account"]), log)
+        self.assertRegex(log, r"autoresume switch provider=claude chain=\w+ from=%s class=memory "
+                         r"sid=%s depth=1 probe=acct-0[12] size=8\.3GB" % (first["account"],
+                                                                          first["sid"]))
+        self.assertRegex(log, r"autoresume relaunch chain=\w+ from=%s class=memory depth=1\n"
+                         % first["account"])
+        # it took the TERM and stayed; the KILL after TERM_GRACE ended it, and the relaunch
+        # still came: typed into the shell, never a key into either TUI
+        self.assertEqual([row["signal"] for row in case.records("signal")
+                          if row["pid"] == first["pid"]], [signal.SIGTERM])
+        self.assertTrue(gone(first["pid"]))
+        self.assertEqual(case.records("keys"), [], "no keystroke may reach either TUI")
+        for name in ("acct-01", "acct-02"):
+            for marker in (".limited", ".expired"):
+                self.assertFalse((case.pools["claude"] / name / marker).exists(), name + marker)
+        # the relaunched client's own footer has no banner: it is left running
+        self.assertEqual([row["banner"] for row in case.records("screen")], [True, False])
+        case.wait(lambda: case.logs("claude").count("autoresume watch") == 2, "second watcher",
+                  timeout=30)
+        time.sleep(2)
+        self.assertEqual(case.logs("claude").count("autoresume switch"), 1)
+        self.assertEqual(len(case.records("launch")), 2)
+        self.assertFalse(gone(second["pid"]))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_probe.py

@@ -38,7 +38,8 @@ class AutoresumeProbeTests(unittest.TestCase):
             root.mkdir()
             up = provider.upper()
             self.env[up + "_ACCOUNTS_ROOT"] = str(root)
-            for key in ("KEYCHAIN", "MCP", "AUTORESUME", "AUTO_RESET", "CLIENT_LIMITS", "PATH_PROBE"):
+            for key in ("KEYCHAIN", "MCP", "MCP_OAUTH", "AUTORESUME", "AUTO_RESET", "CLIENT_LIMITS",
+                        "PATH_PROBE"):
                 self.env[up + "_MULTIACC_" + key] = "0"
             self.env[up + "_MULTIACC_NO_SYNC"] = "1"
             self.env[up + "_MULTIACC_NO_DISTRIBUTE"] = "1"

package/tests/test_autoresume_relaunch_settings.py

@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+"""A same-provider relaunch runs with the model and effort the session itself last ran with.
+
+The watcher reads them from the session's own history when it decides (lib/session_settings.py),
+matches them through the pool's catalog (lib/model_match.py) and puts their flags in place of
+the launch's stale model/effort options; codex_argv_parse and bin/codex's gate let exactly that
+one ``-c`` override through. Sandboxed: temp pools and the fake runner of test_autoresume, plus
+the production shims with fake TUIs in real tmux where tmux exists. Python 3.9+.
+"""
+
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import time
+import unittest
+from unittest import mock
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import test_autoresume as fixtures  # noqa: E402
+from autoresume_cross_tmux_support import CrossScenario  # noqa: E402
+from autoresume_tmux_support import SID as TMUX_SID, TMUX, TmuxScenario  # noqa: E402
+
+ar = fixtures.ar
+ROOT = Path(__file__).resolve().parents[1]
+SID, SID2, CX_SID, CX_SID2 = fixtures.SID, fixtures.SID2, fixtures.CX_SID, fixtures.CX_SID2
+EFFORT = "model_reasoning_effort="
+QUOTA = {"type": "task_complete", "error": {"message": "You've hit your usage limit. Try again later.",
+                                            "codex_error_info": "usage_limit_exceeded"}}
+
+
+def claude_reply(ts, model, effort=None, requested=None, **extra):
+    """A main-thread reply as claude 2.1.299 writes it: its model, the requested one, the effort."""
+    rec = fixtures.cc_reply(ts, **extra)
+    rec["message"]["model"] = model
+    if requested:
+        rec["requestedModel"] = requested
+    if effort:
+        rec["effort"] = rec["perTurnEffort"] = effort
+    return rec
+
+
+def turn_context(ts, model, effort=None, cwd="/w"):
+    """A codex 0.162 turn_context (the fields the settings reader does not use trimmed)."""
+    payload = {"turn_id": "01a135db-f14d-7a60-b656-d5ff72abd71d", "cwd": cwd, "approval_policy": "never",
+               "sandbox_policy": {"type": "danger-full-access"}, "model": model, "summary": "none"}
+    if effort:
+        payload["effort"] = effort
+    return {"timestamp": fixtures.iso(ts), "ordinal": 4, "type": "turn_context", "payload": payload}
+
+
+def settings_applied(ts, model, effort, thread=CX_SID):
+    return fixtures.cx_event(ts, {"type": "thread_settings_applied", "thread_id": thread,
+                                  "thread_settings": {"model": model, "reasoning_effort": effort}})
+
+
+def write_overlay(root, provider, models):
+    """A pool's own catalog copy, fresher than the shipped one, so its models are the ones used."""
+    section = {"fetched_at": "2099-01-01T00:00:00Z", "source": "test", "models": models}
+    (root / "model-catalog.json").write_text(json.dumps({"schema": 1, provider: section}))
+
+
+def pool(test, kind):
+    case = (fixtures.CodexWatcherTests if kind == "codex" else fixtures.PoolCase)(methodName="runTest")
+    case.setUp()
+    test.addCleanup(case.tearDown)
+    return case
+
+
+def shell_gate():
+    """bin/codex's own ar_argv_ok with the helpers it calls, as one bash script."""
+    text = (ROOT / "bin" / "codex").read_text()
+    parts = [line for line in text.splitlines() if line.startswith(("AR_LOWER=", "AR_ALNUM=", "sess_id_ok() {"))]
+    for name in ("ar_uuid_ok", "ar_argv_ok"):
+        start = text.index("\n%s() {" % name) + 1
+        parts.append(text[start:text.index("\n}\n", start) + 2])
+    return "\n".join(parts) + '\nar_argv_ok "$@"\n'
+
+
+class RelaunchArgvSettingsTests(unittest.TestCase):
+    def rl(self, provider, argv, settings=None):
+        sid = SID if provider == "claude" else CX_SID
+        return ar.relaunch_argv(provider, argv, sid, "quota", None, settings)
+
+    def test_claude_pins_the_effort_and_drops_a_launch_model_the_session_left(self):
+        p = ar.resume_prompt("quota")
+        pins = {"model": "claude-opus-5-5", "effort": "max"}
+        # a /model since the launch: the launch's --model goes, and --resume restores the session's own
+        self.assertEqual(self.rl("claude", ["--model", "sonnet", "--effort", "low", "fix the tests now"], pins),
+                         ["--effort", "max", "--resume", SID, p])
+        self.assertEqual(self.rl("claude", ["--dangerously-skip-permissions", "--model=sonnet", "-r", SID2,
+                                            "--permission-mode", "plan"], pins),
+                         ["--dangerously-skip-permissions", "--permission-mode", "plan",
+                          "--effort", "max", "--resume", SID, p])
+        self.assertEqual(self.rl("claude", ["--model", "claude-opus-4-8"], pins),
+                         ["--effort", "max", "--resume", SID, p])
+        dated = {"model": "claude-haiku-4-5-20251001", "effort": "low"}
+        self.assertEqual(self.rl("claude", ["--model", "claude-haiku-4-5"], dated),
+                         ["--model", "claude-haiku-4-5", "--effort", "low", "--resume", SID, p])
+        # the model the session still runs is replayed as launched: [1m] lives only in that flag
+        for launch in ("claude-opus-5-5[1m]", "claude-opus-5-5[1M]", "opus[1m]", "opus", "best", "default"):
+            self.assertEqual(self.rl("claude", ["--model", launch], pins),
+                             ["--model", launch, "--effort", "max", "--resume", SID, p])
+        # a value the history did not record keeps the launch's own option for it
+        self.assertEqual(self.rl("claude", ["--effort", "low", "--model", "sonnet"], {"model": "claude-fable-5-1"}),
+                         ["--effort", "low", "--resume", SID, p])
+        self.assertEqual(self.rl("claude", ["--model", "sonnet"], {"model": None, "effort": "high"}),
+                         ["--model", "sonnet", "--effort", "high", "--resume", SID, p])
+
+    def test_codex_pins_both_or_nothing_right_before_the_session(self):
+        p = ar.resume_prompt("quota")
+        pins = {"model": "gpt-6-astra", "effort": "ultra"}
+        self.assertEqual(self.rl("codex", ["--yolo", "-m", "gpt-5.5", "resume", CX_SID2], pins),
+                         ["resume", "--yolo", "-m", "gpt-6-astra", "-c", EFFORT + "ultra", CX_SID, p])
+        self.assertEqual(self.rl("codex", ["--model=gpt-5", "-c", EFFORT + "low", "--no-daemon", "fix it now"], pins),
+                         ["resume", "--no-daemon", "-m", "gpt-6-astra", "-c", EFFORT + "ultra", CX_SID, p])
+        self.assertEqual(self.rl("codex", ["--model", "gpt-5", "resume", "--last"], pins),
+                         ["resume", "-m", "gpt-6-astra", "-c", EFFORT + "ultra", CX_SID, p])
+        # a model with no effort to pin beside it: the launch's own -m/-c go too (one alone would
+        # drop the thread's other saved value), and Codex restores both from the thread
+        for launch in (["--model", "gpt-5"], ["-c", EFFORT + "high"], ["-m", "gpt-5", "-c", EFFORT + "low"]):
+            self.assertEqual(self.rl("codex", launch, {"model": "gpt-6-sol"}), ["resume", CX_SID, p])
+        # an effort without a model pins nothing, and the launch's options stay as given
+        self.assertEqual(self.rl("codex", ["--model", "gpt-5"], {"effort": "high"}),
+                         ["resume", "--model", "gpt-5", CX_SID, p])
+
+    def test_no_or_unusable_settings_change_nothing(self):
+        argvs = {"claude": ["--dangerously-skip-permissions", "--model", "sonnet", "--effort", "low"],
+                 "codex": ["--yolo", "-m", "gpt-5.5", "-c", EFFORT + "low"]}
+        for provider, argv in argvs.items():
+            plain = self.rl(provider, argv)
+            for settings in (None, {}, "opus", {"model": None, "effort": None}, {"model": "-p", "effort": "MAX"},
+                             {"model": "claude opus", "effort": "x high"}, {"model": 5, "effort": ["max"]},
+                             {"model": "a" * 201, "effort": "max\n"}):
+                with self.subTest(provider=provider, settings=settings):
+                    self.assertEqual(self.rl(provider, argv, settings), plain)
+
+    def test_a_pinned_relaunch_is_itself_relaunchable(self):
+        p = ar.resume_prompt("quota")
+        first = self.rl("codex", ["--yolo"], {"model": "gpt-6-astra", "effort": "ultra"})
+        self.assertEqual(self.rl("codex", first, {"model": "gpt-6-sol", "effort": "max"}),
+                         ["resume", "--yolo", "-m", "gpt-6-sol", "-c", EFFORT + "max", CX_SID, p])
+        self.assertEqual(self.rl("codex", first), first)  # unknown next time: the last pins ride along
+        first = self.rl("claude", [], {"model": "claude-opus-5-5", "effort": "max"})
+        self.assertEqual(self.rl("claude", first, {"model": "claude-fable-5-1", "effort": "xhigh"}),
+                         ["--effort", "xhigh", "--resume", SID, p])
+        self.assertEqual(self.rl("claude", first), first)
+
+    def test_argv_settings_reads_what_an_argv_pins(self):
+        self.assertEqual(ar.argv_settings("claude", ["--model=a", "--model", "b[1m]", "--effort", "max", "--resume",
+                                                     SID, "go on now"]), {"model": "b[1m]", "effort": "max"})
+        self.assertEqual(ar.argv_settings("codex", ["resume", "-m", "gpt-6-astra", "-c", EFFORT + "ultra", CX_SID,
+                                                    "go on now"]), {"model": "gpt-6-astra", "effort": "ultra"})
+        self.assertEqual(ar.argv_settings("codex", ["--effort", "max", "-c", "model=o3", "x y"]), {})
+        self.assertEqual(ar.argv_settings("claude", ["-m", "x", "--model"]), {})
+
+
+class CodexEffortOverrideTests(unittest.TestCase):
+    ACCEPTED = (["-c", EFFORT + "high"], ["--yolo", "-c", EFFORT + "xhigh", "fix the build now"],
+                ["resume", "-m", "gpt-6-astra", "-c", EFFORT + "ultra", CX_SID, "keep going now"],
+                ["resume", CX_SID, "-c", EFFORT + "low", "-c", EFFORT + "max"], [], ["--yolo", "-m", "gpt-5.5"])
+    REFUSED = (["-c", "model=o3"], ["-c", EFFORT], ["-c", EFFORT + "High"], ["-c", EFFORT + "x-high"],
+               ["-c", EFFORT + "high now"], ["-c", EFFORT + "high\n"], ["-c", EFFORT + "h\u00efgh"],
+               ["-c", "sandbox_mode=danger-full-access"], ["-c"], ["-c", "-m"], ["--config", EFFORT + "high"],
+               ["-c" + EFFORT + "high"], ["-c", " " + EFFORT + "high"], ["exec", "do it now"])
+
+    def test_only_the_effort_override_is_accepted_and_kept(self):
+        self.assertEqual(ar.codex_argv_parse(["-c", EFFORT + "high", "resume", CX_SID]),
+                         (["-c", EFFORT + "high"], CX_SID))
+        for argv in self.ACCEPTED:
+            self.assertIsNotNone(ar.codex_argv_parse(argv), argv)
+        for argv in self.REFUSED:
+            self.assertIsNone(ar.codex_argv_parse(argv), argv)
+            self.assertIsNone(ar.relaunch_argv("codex", argv, CX_SID, "quota"), argv)
+
+    def test_the_shims_gate_agrees_with_the_parser(self):
+        script = shell_gate()
+        env = {"PATH": os.environ.get("PATH", "/usr/bin:/bin"), "LC_ALL": "C"}
+        for argv in self.ACCEPTED + self.REFUSED:
+            with self.subTest(argv=argv):
+                done = subprocess.run(["bash", "-c", script, "ar_argv_ok"] + list(argv), env=env,
+                                      capture_output=True, timeout=10)
+                self.assertEqual(done.stderr, b"")
+                self.assertEqual(done.returncode == 0, ar.codex_argv_parse(list(argv)) is not None)
+
+
+class WatcherSettingsTests(unittest.TestCase):
+    def claude_quota(self, case, argv, records, env=None):
+        state = case.write_state(argv)
+        case.registry()
+        case.transcript(records + [fixtures.cc_quota(case.t0 - 1, resets=int(case.t0) + 7200)])
+        return case.watcher(state, env)
+
+    def test_claude_relaunch_pins_the_latest_main_thread_settings(self):
+        case = pool(self, "claude")
+        watcher, runner = self.claude_quota(case, ["--dangerously-skip-permissions", "--model", "sonnet",
+                                                   "--effort", "low"], [
+            claude_reply(case.t0 - 30, "claude-sonnet-5-5", "low", "sonnet"),
+            claude_reply(case.t0 - 20, "claude-opus-5-5", "max", "claude-opus-5-5[1m]"),
+            claude_reply(case.t0 - 10, "claude-haiku-5-5", "low", isSidechain=True)])
+        self.assertEqual(watcher.run(), 0)
+        pinned = ["--dangerously-skip-permissions", "--effort", "max", "--resume", SID, ar.resume_prompt("quota")]
+        self.assertEqual(runner.probes[0]["argv"], [case.self_path] + pinned)
+        kv, argv = case.relaunch_of(runner)
+        self.assertEqual(argv, pinned)
+        # the model --resume restores rides in the relaunch file, for the shim's model-scoped fallback
+        self.assertEqual(kv["model"], "claude-opus-5-5[1m]")
+        line = case.log_lines()[-1]
+        self.assertEqual(line.split()[1:3], ["autoresume", "switch"])
+        self.assertTrue(line.endswith(" probe=acct-02 effort=max"), line)
+
+    def test_claude_effort_is_clamped_by_the_pools_own_catalog(self):
+        case = pool(self, "claude")
+        write_overlay(case.root, "claude", {"claude-test-9": {
+            "family": "opus", "version": [9], "efforts": ["low", "high"], "default_effort": "low", "listed": True}})
+        watcher, runner = self.claude_quota(case, [], [claude_reply(case.t0 - 20, "claude-test-9", "max")])
+        watcher.run()
+        self.assertEqual(case.relaunch_of(runner)[1][:2], ["--effort", "high"])
+
+    def test_codex_relaunch_pins_the_rollouts_latest_own_settings(self):
+        case = pool(self, "codex")
+        work = str(case.work)
+        rc, watcher, runner, _ = case.run_codex(["--yolo", "-m", "gpt-5.5", "resume", CX_SID], [
+            fixtures.cx_meta(case.launched - 600, cwd=work),
+            turn_context(case.launched - 500, "gpt-6-astra", "xhigh", work),
+            settings_applied(case.launched - 400, "gpt-6-astra", "ultra"),
+            settings_applied(case.launched - 300, "gpt-6-luna", "low", thread=CX_SID2),
+            fixtures.cx_error(case.t0 - 1, "usage_limit_exceeded")])
+        self.assertEqual(rc, 0)
+        pinned = ["resume", "--yolo", "-m", "gpt-6-astra", "-c", EFFORT + "ultra", CX_SID, ar.resume_prompt("quota")]
+        self.assertEqual(runner.probes[0]["argv"], [case.self_path] + pinned)
+        self.assertEqual(case.relaunch_of(runner)[1], pinned)
+        self.assertTrue(case.log_lines()[-1].endswith(" probe=acct-02 model=gpt-6-astra effort=ultra"))
+
+    def test_codex_absent_effort_takes_the_catalog_default_or_pins_nothing(self):
+        prompt = ar.resume_prompt("quota")
+        for known, expected in ((True, ["-m", "gpt-test-nova", "-c", EFFORT + "high"]), (False, [])):
+            with self.subTest(known=known):
+                case = pool(self, "codex")
+                if known:
+                    write_overlay(case.root, "codex", {"gpt-test-nova": {
+                        "family": "sol", "version": [9], "efforts": ["low", "high"], "default_effort": "high",
+                        "listed": True}})
+                rc, watcher, runner, _ = case.run_codex(["resume", CX_SID], [
+                    fixtures.cx_meta(case.launched - 600, cwd=str(case.work)),
+                    turn_context(case.launched - 500, "gpt-test-nova", None, str(case.work)),
+                    fixtures.cx_error(case.t0 - 1, "usage_limit_exceeded")])
+                self.assertEqual(case.relaunch_of(runner)[1], ["resume"] + expected + [CX_SID, prompt])
+
+    def test_settings_are_read_when_deciding_never_per_tick(self):
+        case = pool(self, "claude")
+        watcher, runner = self.claude_quota(case, [], [claude_reply(case.t0 - 20, "claude-opus-5-5", "max")],
+                                            {"CLAUDE_MULTIACC_AR_HOLD_REPROBE": "5"})
+        runner.probe_out = "pick=acct-01 tier=soft\n"
+        registry = case.root / "acct-01" / "sessions" / ("%d.json" % case.PID)
+        runner.at(case.t0 + 16.5, lambda: (registry.unlink(), runner.exit(case.PID)))
+        with mock.patch.object(ar, "session_settings", wraps=ar.session_settings) as read:
+            self.assertEqual(watcher.run(), 0)
+        self.assertEqual((len(runner.probes), read.call_count), (3, 3))
+        for probe in runner.probes:
+            self.assertEqual(probe["argv"][1:3], ["--effort", "max"])
+
+    def test_a_settings_failure_relaunches_with_the_launchs_own_options(self):
+        for name in ("session_settings", "load_catalog", "resume_settings"):
+            with self.subTest(fails=name):
+                case = pool(self, "claude")
+                watcher, runner = self.claude_quota(case, ["--model", "sonnet"],
+                                                    [claude_reply(case.t0 - 20, "claude-opus-5-5", "max")])
+                with mock.patch.object(ar, name, side_effect=RuntimeError("unreadable")):
+                    self.assertEqual(watcher.run(), 0)
+                kv, argv = case.relaunch_of(runner)
+                self.assertEqual(argv, ["--model", "sonnet", "--resume", SID, ar.resume_prompt("quota")])
+                self.assertEqual("model" in kv, name != "session_settings")
+                self.assertEqual(case.events(), ["watch", "detect", "switch"])
+                self.assertTrue(case.log_lines()[-1].endswith(" probe=acct-02 model=sonnet"))
+
+
+@unittest.skipUnless(TMUX, "real tmux is unavailable")
+class RealTmuxSettingsTests(unittest.TestCase):
+    """The production shims take a pinned relaunch argv, and the resumed session is supervised again."""
+
+    def test_codex_resume_carries_the_rollouts_pins_and_keeps_a_watcher(self):
+        case = TmuxScenario()
+        self.addCleanup(case.close)
+        case.start(["--yolo", "-m", "gpt-5.5"])
+        with case.rollout.open("a") as target:
+            target.write(json.dumps(turn_context(time.time(), "gpt-6-astra", "ultra", str(case.work))) + "\n")
+        case.append(QUOTA)
+        case.wait(lambda: "autoresume switch" in case.log.read_text(), "pinned resume confirmed")
+        case.wait(lambda: case.log.read_text().count("autoresume watch") == 2, "resumed session supervised")
+        second = [arg for arg in case.records("launch")[1]["argv"] if arg != "--no-daemon"]
+        self.assertEqual(second[:-1], ["resume", "--yolo", "-m", "gpt-6-astra", "-c", EFFORT + "ultra", TMUX_SID])
+        switch = [line for line in case.log.read_text().splitlines() if " autoresume switch " in line]
+        self.assertTrue(switch[0].endswith(" model=gpt-6-astra effort=ultra"), switch)
+
+    def test_claude_resume_carries_the_transcripts_pins_and_keeps_a_watcher(self):
+        case = CrossScenario()
+        self.addCleanup(case.close)
+        case.start("claude", ["--dangerously-skip-permissions", "--model", "sonnet", "--effort", "low"])
+        ready = case.records("ready")[-1]
+        reply = claude_reply(time.time(), "claude-opus-5-5", "xhigh", "claude-opus-5-5[1m]",
+                             sessionId=ready["sid"], cwd=str(case.work))
+        with Path(ready["path"]).open("a") as target:
+            target.write(json.dumps(reply) + "\n")
+        case.quota()
+        case.wait(lambda: "autoresume switch" in case.logs("claude"), "pinned resume confirmed")
+        case.wait(lambda: case.logs("claude").count("autoresume watch") == 2, "resumed session supervised")
+        first, second = case.records("launch")[:2]
+        self.assertEqual(second["argv"][:-1], ["--dangerously-skip-permissions", "--effort", "xhigh", "--resume",
+                                               first["sid"]])
+        switch = [line for line in case.logs("claude").splitlines() if " autoresume switch " in line]
+        self.assertTrue(switch[0].endswith(" probe=acct-02 effort=xhigh"), switch)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autoresume_settings.py

@@ -0,0 +1,135 @@
+"""lib/session_settings.py: the model and effort a session is running with, from its history."""
+
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "lib"))
+import session_settings as ss  # noqa: E402
+
+SID = "01a13956-95c9-7d41-9a8b-b3e5ff79d3b2"
+OTHER = "0aaaaaaa-0000-7000-8000-000000000000"
+
+
+def codex_line(kind, **payload):
+    return json.dumps({"timestamp": "2026-10-14T08:00:00Z", "type": kind, "payload": payload})
+
+
+def meta(sid=SID):
+    return codex_line("session_meta", id=sid, session_id=sid, cwd="/w")
+
+
+def turn(model, effort=None):
+    payload = {"turn_id": "t", "cwd": "/w", "model": model}
+    if effort is not None:
+        payload["effort"] = effort
+    return codex_line("turn_context", **payload)
+
+
+def applied(model, effort, thread=SID):
+    settings = {"model": model, "model_provider_id": "openai"}
+    if effort is not None:
+        settings["reasoning_effort"] = effort
+    return codex_line("event_msg", type="thread_settings_applied", thread_id=thread, thread_settings=settings)
+
+
+def claude_line(kind, **fields):
+    return json.dumps(dict({"type": kind, "sessionId": SID, "isSidechain": False}, **fields))
+
+
+def reply(model, effort=None, requested=None, **extra):
+    fields = dict({"message": {"role": "assistant", "model": model}}, **extra)
+    if effort is not None:
+        fields["effort"] = effort
+    if requested is not None:
+        fields["requestedModel"] = requested
+    return claude_line("assistant", **fields)
+
+
+class SessionSettingsTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp(prefix="ss-"))
+        self.addCleanup(shutil.rmtree, str(self.tmp), True)
+
+    def write(self, name, lines):
+        path = self.tmp / name
+        path.write_text("\n".join(lines) + ("\n" if lines else ""))
+        return str(path)
+
+    def test_codex_last_turn_context_or_own_settings_snapshot_wins(self):
+        path = self.write("r.jsonl", [meta(), turn("gpt-6-astra", "high"), codex_line("event_msg", type="task_started"),
+                                      turn("gpt-6-astra", "ultra")])
+        self.assertEqual(ss.session_settings("codex", path), {"model": "gpt-6-astra", "effort": "ultra"})
+        # an effort change inside a running turn writes only the settings snapshot: it wins
+        path = self.write("r.jsonl", [meta(), turn("gpt-6-astra", "max"), applied("gpt-6-astra", "ultra")])
+        self.assertEqual(ss.session_settings("codex", path), {"model": "gpt-6-astra", "effort": "ultra"})
+        # a /model switch recorded by a snapshot, then a turn on the new model
+        path = self.write("r.jsonl", [meta(), turn("gpt-6-astra", "ultra"), applied("gpt-reserve", "medium"),
+                                      turn("gpt-reserve", "medium")])
+        self.assertEqual(ss.session_settings("codex", path), {"model": "gpt-reserve", "effort": "medium"})
+        # another thread's snapshot (a forked subagent's parent copy) is not this session's
+        path = self.write("r.jsonl", [meta(), turn("gpt-6-astra", "ultra"), applied("gpt-6-luna", "low", thread=OTHER)])
+        self.assertEqual(ss.session_settings("codex", path), {"model": "gpt-6-astra", "effort": "ultra"})
+        # an absent effort is the model default, reported as None
+        path = self.write("r.jsonl", [meta(), turn("gpt-6.1-sol")])
+        self.assertEqual(ss.session_settings("codex", path), {"model": "gpt-6.1-sol", "effort": None})
+
+    def test_codex_bounds_and_junk(self):
+        lines = [meta(), turn("gpt-6-astra", "high")]
+        path = self.write("r.jsonl", lines)
+        boundary = os.path.getsize(path)
+        with open(path, "a") as fh:
+            fh.write("not json\n" + turn("gpt-6-astra", "ultra") + "\n")
+        self.assertEqual(ss.session_settings("codex", path), {"model": "gpt-6-astra", "effort": "ultra"})
+        self.assertEqual(ss.session_settings("codex", path, upto=boundary), {"model": "gpt-6-astra", "effort": "high"})
+        self.assertEqual(ss.session_settings("codex", self.write("e.jsonl", [meta(), "{", "[1]"])),
+                         {"model": None, "effort": None})
+        self.assertEqual(ss.session_settings("codex", str(self.tmp / "missing")), {"model": None, "effort": None})
+        self.assertEqual(ss.session_settings("gemini", path), {"model": None, "effort": None})
+        self.assertEqual(ss.session_settings("codex", None), {"model": None, "effort": None})
+
+    def test_claude_last_main_thread_reply(self):
+        path = self.write("c.jsonl", [claude_line("user", message={"role": "user", "content": "hi there"}),
+                                      reply("claude-opus-5-5", "medium"),
+                                      reply("claude-fable-5-1", "max", requested="claude-fable-5-1[1m]"),
+                                      reply("claude-haiku-5-5", "low", isSidechain=True),
+                                      reply("claude-sonnet-5-5", "high", isMeta=True),
+                                      reply("<synthetic>", perTurnEffort="xhigh", isApiErrorMessage=True)])
+        self.assertEqual(ss.session_settings("claude", path), {"model": "claude-fable-5-1[1m]", "effort": "max"})
+        path = self.write("c.jsonl", [reply("claude-opus-5-5", perTurnEffort="xhigh")])
+        self.assertEqual(ss.session_settings("claude", path), {"model": "claude-opus-5-5", "effort": "xhigh"})
+        path = self.write("c.jsonl", [reply("claude-opus-5-5")])
+        self.assertEqual(ss.session_settings("claude", path), {"model": "claude-opus-5-5", "effort": None})
+        self.assertEqual(ss.session_settings("claude", self.write("n.jsonl", [claude_line("progress")])),
+                         {"model": None, "effort": None})
+
+    def test_reverse_scan_crosses_chunk_boundaries(self):
+        filler = claude_line("progress", data="x" * 5000)
+        lines = [reply("claude-opus-5-5", "high")] + [filler] * 600
+        path = self.write("big.jsonl", lines)
+        self.assertGreater(os.path.getsize(path), 2 * ss.CHUNK)
+        self.assertEqual(ss.session_settings("claude", path), {"model": "claude-opus-5-5", "effort": "high"})
+        # no trailing newline on the last record
+        with open(path, "a") as fh:
+            fh.write(reply("claude-sonnet-5-5", "low"))
+        self.assertEqual(ss.session_settings("claude", path), {"model": "claude-sonnet-5-5", "effort": "low"})
+
+    def test_cli(self):
+        path = self.write("r.jsonl", [meta(), turn("gpt-6-astra", "ultra")])
+        out = subprocess.run([sys.executable, "-I", str(ROOT / "lib/session_settings.py"), "codex", path],
+                             capture_output=True, text=True)
+        self.assertEqual((out.returncode, json.loads(out.stdout)), (0, {"model": "gpt-6-astra", "effort": "ultra"}))
+        out = subprocess.run([sys.executable, "-I", str(ROOT / "lib/session_settings.py"), "codex"],
+                             capture_output=True, text=True)
+        self.assertEqual(out.returncode, 2)
+        self.assertIn("usage", out.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()