claude-multiacc 2.0.58 → 2.0.59

package/tests/test_autoresume_handoff_argv.py

@@ -1,12 +1,24 @@
-"""Fresh provider conversations retain source history and conservative permission intent."""
+"""Fresh provider conversations retain source history, conservative permission intent and the
+same-level model and effort the source history recorded."""
 
 import json
 from pathlib import Path
 import tempfile
 import unittest
+from unittest import mock
 
 import test_autoresume as fixtures
 import autoresume_handoff as handoff
+import model_catalog
+import model_match
+import session_settings
+
+READ_ONLY = ["--sandbox", "read-only", "--ask-for-approval", "on-request"]
+# Codex gpt-6-astra at ultra -> Claude opus at max; Claude opus 5.5 [1m] at xhigh -> Codex astra
+# at xhigh (the operator's map). The shipped catalog decides the newest listed model of a family.
+CLAUDE_FLAGS = ["--model", "claude-opus-5-5", "--effort", "max"]
+CODEX_FLAGS = ["-m", "gpt-6-astra", "-c", "model_reasoning_effort=xhigh"]
+SOURCE = {"codex": ("gpt-6-astra", "ultra"), "claude": ("claude-opus-5-5[1m]", "xhigh")}
 
 
 class HandoffArgvTests(unittest.TestCase):
@@ -16,31 +28,122 @@ class HandoffArgvTests(unittest.TestCase):
         self.home = Path(temporary.name).resolve()
         self.cwd = self.home / 'workspace "quoted" $literal'
         self.cwd.mkdir()
+        # Empty pool roots: the shipped catalog alone, never this machine's live CLI caches.
+        self.roots = {"claude": str(self.home / "claude-pool"), "codex": str(self.home / "codex-pool")}
+
+    def settings_record(self, provider, model, effort):
+        """The session's own model record: Codex's turn context, Claude's main-thread reply."""
+        if provider == "codex":
+            return {"timestamp": fixtures.iso(1001), "type": "turn_context",
+                    "payload": {"cwd": str(self.cwd), "approval_policy": "on-request", "model": model,
+                                "effort": effort}}
+        return fixtures.cc_reply(1001, cwd=str(self.cwd), requestedModel=model, effort=effort)
 
-    def history(self, provider):
+    def history(self, provider, settings=None):
         sid = fixtures.SID if provider == "claude" else fixtures.CX_SID
         name = sid + ".jsonl" if provider == "claude" else "rollout-fixture-" + sid + ".jsonl"
         path = self.home / name
         record = fixtures.cc_user(1000, "PRIVATE_SOURCE_TEXT_SENTINEL", cwd=str(self.cwd)) \
             if provider == "claude" else fixtures.cx_meta(1000, cwd=str(self.cwd))
-        path.write_text(json.dumps(record) + "\n")
+        records = [record] + ([self.settings_record(provider, *settings)] if settings else [])
+        path.write_text(fixtures.jl(records))
         return handoff.validate_source(provider, sid, str(path), str(self.cwd))
 
-    def test_fresh_target_drops_source_session_model_effort_and_original_prompt(self):
+    def test_history_without_model_records_keeps_the_exact_unpinned_argv(self):
         cases = (("claude", "codex", ["--model", "source-only-model", "--effort", "high",
-                                      "--resume", fixtures.SID, "Original user request"]),
+                                      "--resume", fixtures.SID, "Original user request"], READ_ONLY),
                  ("codex", "claude", ["resume", "--no-daemon", "--model", "source-only-model",
-                                      fixtures.CX_SID, "Original user request"]))
-        for source, target, original in cases:
+                                      fixtures.CX_SID, "Original user request"], ["--permission-mode", "default"]))
+        for source, target, original, expected in cases:
             with self.subTest(source=source):
                 history = self.history(source)
-                argv = handoff.handoff_argv(source, target, original, history)
+                argv = handoff.handoff_argv(source, target, original, history, roots=self.roots)
                 self.assertIsNotNone(argv)
-                for value in ("resume", "--resume", "--last", "--continue", "--model", "--effort",
-                              "source-only-model", "Original user request", history["sid"]):
-                    self.assertNotIn(value, argv[:-1])
+                self.assertEqual(argv[:-1], expected)
+                self.assertFalse(any("source-only-model" in arg or "Original user request" in arg for arg in argv))
+                self.assertIn(history["sid"], argv[-1])
+                self.assertNotIn("Source model:", argv[-1])
+
+    def test_recorded_model_and_effort_pin_the_same_level_target_before_the_prompt(self):
+        cases = (("codex", "claude", [], ["--permission-mode", "default"] + CLAUDE_FLAGS),
+                 ("codex", "claude", ["--yolo", "-m", "source-only-model"],
+                  ["--dangerously-skip-permissions"] + CLAUDE_FLAGS),
+                 ("claude", "codex", [], READ_ONLY + CODEX_FLAGS),
+                 ("claude", "codex", ["--dangerously-skip-permissions", "--model", "source-only-model"],
+                  ["--dangerously-bypass-approvals-and-sandbox"] + CODEX_FLAGS))
+        for source, target, original, expected in cases:
+            with self.subTest(source=source, original=original):
+                history = self.history(source, SOURCE[source])
+                argv = handoff.handoff_argv(source, target, original, history, roots=self.roots)
+                self.assertEqual(argv[:-1], expected)
                 self.assertIn(history["sid"], argv[-1])
-                self.assertNotIn("Original user request", argv[-1])
+                self.assertTrue(argv[-1].startswith(handoff.PROMPT_PREFIX))
+
+    def test_prompt_names_source_and_matched_settings_before_the_operator_instruction(self):
+        sentences = {"codex": "Source model: gpt-6-astra (effort ultra). This conversation runs the matching "
+                              "claude model claude-opus-5-5 (effort max).",
+                     "claude": "Source model: claude-opus-5-5[1m] (effort xhigh). This conversation runs the "
+                               "matching codex model gpt-6-astra (effort xhigh)."}
+        for source, target in (("codex", "claude"), ("claude", "codex")):
+            with self.subTest(source=source):
+                history = self.history(source, SOURCE[source])
+                prompt = handoff.handoff_argv(source, target, [], history, prompt_override="Keep the plan.",
+                                              roots=self.roots)[-1]
+                self.assertTrue(prompt.endswith(
+                    "completed work. " + sentences[source] + " Additional continuation instruction: Keep the plan."))
+                self.assertEqual(handoff.handoff_argv(source, target, [], history, roots=self.roots)[-1],
+                                 prompt[:prompt.index(" Additional continuation instruction:")])
+
+    def test_settings_come_only_from_the_validated_snapshot(self):
+        history = self.history("codex", SOURCE["codex"])
+        with open(history["path"], "a") as stream:
+            stream.write(json.dumps(self.settings_record("codex", "gpt-6.1-sol", "low")) + "\n")
+        argv = handoff.handoff_argv("codex", "claude", [], history, roots=self.roots)
+        self.assertEqual(argv[:-1], ["--permission-mode", "default"] + CLAUDE_FLAGS)
+        later = handoff.validate_source("codex", history["sid"], history["path"], history["cwd"])
+        self.assertGreater(later["offset"], history["offset"])
+        argv = handoff.handoff_argv("codex", "claude", [], later, roots=self.roots)
+        self.assertEqual(argv[:-1], ["--permission-mode", "default", "--model", "claude-sonnet-5-5", "--effort", "low"])
+
+    def test_unsafe_unknown_or_failing_settings_never_block_the_handoff(self):
+        unpinned = ["--permission-mode", "default"]
+        for settings, expected in ((("--dangerously-skip-permissions", "max"), unpinned),
+                                   (("gpt 6 astra", "max"), unpinned), (("gpt-6-astra\nx", "max"), unpinned),
+                                   (("mystery-model", "turbo"), unpinned),
+                                   (("gpt-6-astra", "--effort"), unpinned + CLAUDE_FLAGS[:2]),
+                                   (("gpt-6-astra", "hyper"), unpinned + CLAUDE_FLAGS[:2])):
+            with self.subTest(settings=settings):
+                argv = handoff.handoff_argv("codex", "claude", [], self.history("codex", settings), roots=self.roots)
+                self.assertEqual(argv[:-1], expected)
+        history = self.history("codex", SOURCE["codex"])
+        for module, name in ((session_settings, "session_settings"), (model_catalog, "load"),
+                             (model_match, "resume_settings"), (model_match, "settings_flags")):
+            with self.subTest(failing=name), mock.patch.object(module, name, side_effect=RuntimeError("boom")):
+                result = handoff.build_handoff("codex", "claude", [], history["sid"], history["path"],
+                                               history["cwd"], roots=self.roots)
+                self.assertEqual(result["argv"][:-1], unpinned)
+                self.assertEqual(result["models"]["flags"], [])
+                self.assertNotIn("Source model:", result["argv"][-1])
+
+    def test_build_handoff_threads_pool_roots_into_the_catalog(self):
+        history = self.history("codex", SOURCE["codex"])
+        result = handoff.build_handoff("codex", "claude", [], history["sid"], history["path"], history["cwd"],
+                                       roots=self.roots)
+        self.assertEqual(result["argv"][:-1], ["--permission-mode", "default"] + CLAUDE_FLAGS)
+        overlay = Path(self.roots["claude"])
+        overlay.mkdir()
+        efforts = ["low", "medium", "high", "xhigh", "max"]
+        (overlay / model_catalog.OVERLAY).write_text(json.dumps({"schema": 1, "claude": {
+            "fetched_at": "2999-01-01T00:00:00Z", "models": {"claude-opus-6": {
+                "family": "opus", "version": [6], "efforts": efforts, "default_effort": "high",
+                "listed": True, "upgrade": None}}}}))
+        result = handoff.build_handoff("codex", "claude", [], history["sid"], history["path"], history["cwd"],
+                                       roots=self.roots)
+        self.assertEqual(result["argv"][:-1], ["--permission-mode", "default", "--model", "claude-opus-6",
+                                               "--effort", "max"])
+        self.assertEqual(result["models"], {"source": {"model": "gpt-6-astra", "effort": "ultra"},
+                                            "target": {"model": "claude-opus-6", "effort": "max"},
+                                            "flags": ["--model", "claude-opus-6", "--effort", "max"]})
 
     def test_default_and_allow_bypass_only_keep_conservative_target_permissions(self):
         cases = (("claude", "codex", [], ["--sandbox", "read-only", "--ask-for-approval", "on-request"]),
@@ -82,11 +185,12 @@ class HandoffArgvTests(unittest.TestCase):
             self.assertIsNone(handoff.handoff_argv("codex", "claude", original, self.history("codex")))
 
     def test_custom_prompt_cannot_remove_exact_history_and_continuation_instructions(self):
-        for source, target in (("claude", "codex"), ("codex", "claude")):
-            with self.subTest(source=source):
-                history = self.history(source)
+        for source, target, settings in (("claude", "codex", None), ("codex", "claude", None),
+                                         ("claude", "codex", SOURCE["claude"]), ("codex", "claude", SOURCE["codex"])):
+            with self.subTest(source=source, settings=settings):
+                history = self.history(source, settings)
                 original = Path(history["path"]).read_bytes()
-                argv = handoff.handoff_argv(source, target, [], history,
+                argv = handoff.handoff_argv(source, target, [], history, roots=self.roots,
                                            prompt_override="Preserve the operator's extra instruction.")
                 prompt = argv[-1]
                 for value in (source, history["sid"], json.dumps(history["path"]), json.dumps(history["cwd"]),

package/tests/test_autoresume_handoff_origins.py

@@ -35,6 +35,20 @@ class HandoffOriginTests(unittest.TestCase):
                 self.assertEqual(argv[:-1], ["--dangerously-skip-permissions"])
                 self.assertIn(fixtures.CX_SID, argv[-1])
 
+    def test_vscode_history_maps_only_its_own_thread_settings(self):
+        roots = {"claude": str(self.cwd / "claude-pool"), "codex": str(self.cwd / "codex-pool")}
+        for thread, expected in ((fixtures.CX_SID, ["--model", "claude-opus-5-5", "--effort", "max"]),
+                                 (fixtures.CX_SID2, [])):
+            with self.subTest(thread=thread):
+                self.history(source="vscode")
+                settings = {"model": "gpt-6-astra", "reasoning_effort": "ultra"}
+                event = fixtures.cx_event(1001, {"type": "thread_settings_applied", "thread_id": thread,
+                                                 "thread_settings": settings})
+                fixtures.append(str(self.path), [event])
+                history = handoff.validate_source("codex", fixtures.CX_SID, str(self.path), str(self.cwd))
+                argv = handoff.handoff_argv("codex", "claude", ["--yolo"], history, roots=roots)
+                self.assertEqual(argv[:-1], ["--dangerously-skip-permissions"] + expected)
+
     def test_exec_unknown_and_subagent_transports_remain_rejected(self):
         for source in ("exec", "unknown", "app-server", {"subagent": "spawn"}):
             with self.subTest(source=source):