claude-dev-env 2.10.0 → 2.11.0

package/_shared/advisor/scripts/tests/test_codex_sol_advisor.py

@@ -0,0 +1,474 @@
+"""Behavioral tests for the executable Codex Sol advisor path."""
+
+import io
+import importlib.util
+import json
+import subprocess
+import sys
+from collections.abc import Callable
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+_ProcessRunner = Callable[..., subprocess.CompletedProcess[str]]
+
+
+def _load_sol_module() -> ModuleType:
+    scripts_root = Path(__file__).parent.parent
+    config_root = scripts_root / "config"
+    sys.path.insert(0, str(config_root))
+    specification = importlib.util.spec_from_file_location(
+        "codex_sol_advisor", scripts_root / "codex_sol_advisor.py"
+    )
+    assert specification is not None and specification.loader is not None
+    module = importlib.util.module_from_spec(specification)
+    sys.modules[specification.name] = module
+    specification.loader.exec_module(module)
+    return module
+
+
+sol_advisor = _load_sol_module()
+SCRIPTS_ROOT = Path(__file__).parent.parent
+USAGE_PROBE_PATH = (
+    SCRIPTS_ROOT.parents[2]
+    / "skills"
+    / "codex-review"
+    / "scripts"
+    / "codex_usage_probe.py"
+)
+
+
+def _probe_process(
+    payload: object,
+    returncode: int = 0,
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.CompletedProcess(
+        [sys.executable, str(USAGE_PROBE_PATH)],
+        returncode,
+        json.dumps(payload),
+        "",
+    )
+
+
+def _event_stream(
+    session_id: str = "thread-1",
+    guidance: str = "PLAN\ninspect the change",
+) -> str:
+    return "\n".join(
+        [
+            json.dumps({"type": "thread.started", "thread_id": session_id}),
+            json.dumps(
+                {
+                    "type": "item.completed",
+                    "item": {
+                        "type": "agent_message",
+                        "text": guidance,
+                    },
+                }
+            ),
+        ]
+    )
+
+
+def _two_step_process_runner(calls: list[list[str]], guidance: str) -> _ProcessRunner:
+    def process_runner(
+        arguments: list[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[str]:
+        calls.append(arguments)
+        if len(calls) == 1:
+            return _probe_process({"percent_left": 90})
+        return subprocess.CompletedProcess(
+            arguments, 0, _event_stream(guidance=guidance), ""
+        )
+
+    return process_runner
+
+
+def test_sol_flag_accepts_documented_truthy_values() -> None:
+    assert sol_advisor.is_sol_advisor_enabled({"ADVISOR_SOL_XHIGH": "yes"})
+    assert not sol_advisor.is_sol_advisor_enabled({"ADVISOR_SOL_XHIGH": "0"})
+
+
+def test_resolve_usage_probe_path_uses_supplied_home_directory(tmp_path: Path) -> None:
+    probe_path = sol_advisor.resolve_usage_probe_path(tmp_path)
+
+    assert probe_path == (
+        tmp_path
+        / ".claude"
+        / "skills"
+        / "codex-review"
+        / "scripts"
+        / "codex_usage_probe.py"
+    )
+
+
+def test_argument_parser_accepts_bind_and_resume_modes() -> None:
+    parser = sol_advisor.build_argument_parser()
+
+    bind_arguments = parser.parse_args(["--bind", "--cwd", "."])
+    resume_arguments = parser.parse_args(
+        ["--resume", "thread-1", "--cwd", "."]
+    )
+
+    assert bind_arguments.bind
+    assert bind_arguments.resume is None
+    assert resume_arguments.resume == "thread-1"
+
+
+def test_main_serializes_stable_result_field(monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]) -> None:
+    monkeypatch.setattr(
+        sol_advisor,
+        "run_codex_sol_advisor",
+        lambda **kwargs: sol_advisor.CodexSolAdvisorReply(
+            session_id="thread-1",
+            guidance="PLAN\ninspect",
+            successful=True,
+            reason=None,
+            is_fallback=False,
+            signal="PLAN",
+            sol_enabled=True,
+        selected_tier=sol_advisor.ADVISOR_MODEL_TIER,
+        outcome=sol_advisor.CODEX_BIND_SUCCESS_TOKEN,
+        ),
+    )
+    monkeypatch.setattr(sys, "stdin", io.StringIO("first consult"))
+
+    exit_code = sol_advisor.main(["--bind", "--cwd", "."])
+    payload = json.loads(capsys.readouterr().out)
+
+    assert exit_code == 0
+    assert payload["result"] == "codex"
+    assert "outcome" not in payload
+    assert payload["sol_enabled"] is True
+
+
+def test_bind_and_resume_arguments_match_installed_codex_interface() -> None:
+    expected_common_arguments = [
+        "codex",
+        "exec",
+        "--model",
+        sol_advisor.ADVISOR_CODEX_MODEL_ID,
+        "--config",
+        'model_reasoning_effort="xhigh"',
+        "--sandbox",
+        "read-only",
+        "--json",
+    ]
+    assert sol_advisor.build_codex_arguments() == [
+        *expected_common_arguments,
+        "-",
+    ]
+    assert sol_advisor.build_codex_arguments("thread-1") == [
+        *expected_common_arguments,
+        "resume",
+        "thread-1",
+        "-",
+    ]
+
+
+def test_successful_probe_requires_finite_meter_above_configured_gate() -> None:
+    def probe_runner(arguments: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:
+        return _probe_process({"percent_left": 90})
+
+    preflight = sol_advisor.run_sol_preflight(USAGE_PROBE_PATH, probe_runner)
+
+    assert preflight.eligible
+    assert preflight.percent_left == 90
+
+
+@pytest.mark.parametrize("percent_left", [10, 10.0, 10.000])
+def test_meter_at_configured_threshold_falls_back(
+    percent_left: float,
+) -> None:
+    def probe_runner(arguments: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:
+        return _probe_process({"percent_left": percent_left})
+
+    preflight = sol_advisor.run_sol_preflight(USAGE_PROBE_PATH, probe_runner)
+
+    assert not preflight.eligible
+    assert preflight.percent_left == percent_left
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        {"percent_left": None},
+        {"percent_left": "90"},
+        {"percent_left": True},
+        {"percent_left": float("nan")},
+        ["percent_left", 90],
+    ],
+)
+def test_unknown_and_malformed_meter_falls_back(payload: object) -> None:
+    def probe_runner(arguments: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:
+        return _probe_process(payload)
+
+    preflight = sol_advisor.run_sol_preflight(USAGE_PROBE_PATH, probe_runner)
+
+    assert not preflight.eligible
+    assert preflight.percent_left is None
+
+
+def test_malformed_probe_json_falls_back() -> None:
+    def probe_runner(arguments: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:
+        return subprocess.CompletedProcess(arguments, 0, "{broken", "")
+
+    preflight = sol_advisor.run_sol_preflight(USAGE_PROBE_PATH, probe_runner)
+
+    assert not preflight.eligible
+
+
+def test_probe_nonzero_exit_falls_back() -> None:
+    def probe_runner(arguments: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:
+        return _probe_process({"percent_left": 90}, returncode=2)
+
+    preflight = sol_advisor.run_sol_preflight(USAGE_PROBE_PATH, probe_runner)
+
+    assert not preflight.eligible
+
+
+def test_probe_timeout_falls_back() -> None:
+    def probe_runner(arguments: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:
+        raise subprocess.TimeoutExpired(arguments, 30)
+
+    preflight = sol_advisor.run_sol_preflight(USAGE_PROBE_PATH, probe_runner)
+
+    assert not preflight.eligible
+    assert "timed out" in preflight.reason
+
+
+@pytest.mark.parametrize("signal", ["ENDORSE", "CORRECTION", "PLAN", "STOP"])
+def test_jsonl_parser_accepts_each_exact_guidance_signal(signal: str) -> None:
+    reply = sol_advisor.parse_codex_jsonl_reply(
+        _event_stream(guidance=f"{signal}\nadditional guidance"),
+        existing_session_id=None,
+        is_sol_enabled=True,
+    )
+
+    assert reply.successful
+    assert not reply.is_fallback
+    assert reply.session_id == "thread-1"
+    assert reply.guidance == f"{signal}\nadditional guidance"
+
+
+@pytest.mark.parametrize(
+    "jsonl_text",
+    [
+        "{broken",
+        json.dumps({"type": "thread.started", "thread_id": "thread-1"}),
+        _event_stream(session_id="", guidance="PLAN\ninspect"),
+        _event_stream(guidance="ENDORSE: ready"),
+        _event_stream(guidance="\n  unknown signal\nmore"),
+        json.dumps(
+            {
+                "type": "item.completed",
+                "item": {"type": "agent_message", "text": "PLAN"},
+            }
+        ),
+    ],
+)
+def test_jsonl_parser_returns_typed_fallback_for_invalid_reply(
+    jsonl_text: str,
+) -> None:
+    reply = sol_advisor.parse_codex_jsonl_reply(
+        jsonl_text,
+        existing_session_id=None,
+        is_sol_enabled=True,
+    )
+
+    assert not reply.successful
+    assert reply.is_fallback
+    assert reply.session_id is None
+    assert reply.guidance is None
+    assert reply.reason
+
+
+def test_bind_runs_probe_then_codex_with_read_only_xhigh_settings() -> None:
+    calls: list[tuple[list[str], dict[str, object]]] = []
+
+    def process_runner(
+        arguments: list[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[str]:
+        calls.append((arguments, kwargs))
+        if len(calls) == 1:
+            return _probe_process({"percent_left": 90})
+        return subprocess.CompletedProcess(
+            arguments, 0, _event_stream(guidance="PLAN\ninspect"), ""
+        )
+
+    reply = sol_advisor.run_codex_sol_advisor(
+        prompt="reply only",
+        working_directory=Path("."),
+        preflight=None,
+        probe_path=USAGE_PROBE_PATH,
+        session_id=None,
+        process_runner=process_runner,
+        setting_by_name={"ADVISOR_SOL_XHIGH": "1"},
+    )
+
+    assert reply.successful
+    assert len(calls) == 2
+    assert calls[1][0] == sol_advisor.build_codex_arguments()
+    assert calls[1][1]["cwd"] == "."
+    assert calls[1][1]["shell"] is False
+    assert calls[1][1]["timeout"]
+
+
+def test_team_advisor_path_preserves_sol_routing_fields() -> None:
+    team_advisor_path = SCRIPTS_ROOT.parents[2] / "skills" / "team-advisor" / "SKILL.md"
+    sol_rung_path = SCRIPTS_ROOT.parent / "reference" / "sol-rung.md"
+    assert "advisor-protocol.md" in team_advisor_path.read_text(encoding="utf-8")
+    sol_rung = sol_rung_path.read_text(encoding="utf-8")
+    assert "codex_sol_advisor.py" in sol_rung
+    assert "--resume <session_id>" in sol_rung
+    calls: list[list[str]] = []
+
+    reply = sol_advisor.run_codex_sol_advisor(
+        prompt="first consult",
+        working_directory=Path("."),
+        preflight=None,
+        probe_path=USAGE_PROBE_PATH,
+        session_id=None,
+        process_runner=_two_step_process_runner(calls, guidance="PLAN\ninspect"),
+        setting_by_name={"ADVISOR_SOL_XHIGH": "1"},
+    )
+
+    assert reply.successful
+    assert reply.sol_enabled
+    assert reply.selected_tier == sol_advisor.ADVISOR_MODEL_TIER
+    assert reply.outcome == sol_advisor.CODEX_BIND_SUCCESS_TOKEN
+    assert reply.signal == "PLAN"
+    assert reply.guidance == "PLAN\ninspect"
+
+
+def test_team_advisor_path_uses_fable_result_when_sol_gate_is_closed() -> None:
+    calls: list[list[str]] = []
+
+    def process_runner(
+        arguments: list[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[str]:
+        calls.append(arguments)
+        return _probe_process({"percent_left": 10})
+
+    reply = sol_advisor.run_codex_sol_advisor(
+        prompt="first consult",
+        working_directory=Path("."),
+        preflight=None,
+        probe_path=USAGE_PROBE_PATH,
+        session_id=None,
+        process_runner=process_runner,
+        setting_by_name={"ADVISOR_SOL_XHIGH": "1"},
+    )
+
+    assert not reply.successful
+    assert reply.is_fallback
+    assert reply.sol_enabled
+    assert reply.selected_tier == sol_advisor.ADVISOR_FALLBACK_TIER
+    assert reply.outcome == sol_advisor.ADVISOR_FALLBACK_RESULT
+    assert len(calls) == 1
+
+
+def test_disabled_flag_uses_default_optional_routing_inputs() -> None:
+    reply = sol_advisor.run_codex_sol_advisor(
+        prompt="first consult",
+        working_directory=Path("."),
+        preflight=sol_advisor.SolPreflight(
+            eligible=True,
+            percent_left=90,
+            reason="test preflight",
+        ),
+        probe_path=None,
+        setting_by_name=None,
+        session_id=None,
+        process_runner=subprocess.run,
+    )
+
+    assert reply.is_fallback
+    assert reply.reason == "Sol advisor flag is disabled"
+
+
+def test_resume_runs_the_usage_gate_before_codex() -> None:
+    calls: list[list[str]] = []
+
+    reply = sol_advisor.run_codex_sol_advisor(
+        prompt="resume",
+        working_directory=Path("."),
+        preflight=None,
+        session_id="thread-1",
+        probe_path=USAGE_PROBE_PATH,
+        process_runner=_two_step_process_runner(calls, guidance="ENDORSE\nready"),
+        setting_by_name={"ADVISOR_SOL_XHIGH": "1"},
+    )
+
+    assert reply.successful
+    assert calls == [
+        [sys.executable, str(USAGE_PROBE_PATH)],
+        sol_advisor.build_codex_arguments("thread-1"),
+    ]
+
+
+@pytest.mark.parametrize(
+    "codex_failure",
+    [
+        "nonzero",
+        "timeout",
+        "malformed_jsonl",
+        "missing_session",
+        "missing_guidance",
+        "invalid_signal",
+    ],
+)
+def test_codex_failure_modes_always_return_fallback(
+    codex_failure: str,
+) -> None:
+    def process_runner(
+        arguments: list[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[str]:
+        if len(arguments) == 2:
+            return _probe_process({"percent_left": 90})
+        if codex_failure == "timeout":
+            raise subprocess.TimeoutExpired(arguments, 30)
+        if codex_failure == "nonzero":
+            return subprocess.CompletedProcess(
+                arguments, 3, _event_stream(guidance="PLAN"), ""
+            )
+        if codex_failure == "malformed_jsonl":
+            return subprocess.CompletedProcess(arguments, 0, "{broken", "")
+        if codex_failure == "missing_session":
+            return subprocess.CompletedProcess(
+                arguments,
+                0,
+                json.dumps(
+                    {
+                        "type": "item.completed",
+                        "item": {"type": "agent_message", "text": "PLAN"},
+                    }
+                ),
+                "",
+            )
+        if codex_failure == "missing_guidance":
+            return subprocess.CompletedProcess(
+                arguments,
+                0,
+                json.dumps({"type": "thread.started", "thread_id": "thread-1"}),
+                "",
+            )
+        return subprocess.CompletedProcess(
+            arguments, 0, _event_stream(guidance="PLAN: inspect"), ""
+        )
+
+    reply = sol_advisor.run_codex_sol_advisor(
+        prompt="bind",
+        working_directory=Path("."),
+        preflight=None,
+        probe_path=USAGE_PROBE_PATH,
+        session_id=None,
+        process_runner=process_runner,
+        setting_by_name={"ADVISOR_SOL_XHIGH": "1"},
+    )
+
+    assert not reply.successful
+    assert reply.is_fallback
+    assert reply.session_id is None
+    assert reply.guidance is None

package/_shared/advisor/scripts/tests/test_model_tier_run_validator.py

@@ -33,6 +33,8 @@ main = model_tier_run_validator.main
 load_model_tier_run_from_json_path = (
     model_tier_run_validator.load_model_tier_run_from_json_path
 )
+ADVISOR_MODEL_TIER = model_tier_run_validator.ADVISOR_MODEL_TIER
+CODEX_BIND_SUCCESS_TOKEN = model_tier_run_validator.CODEX_BIND_SUCCESS_TOKEN
 
 
 def test_clean_single_spawn_at_top_of_slice_passes() -> None:
@@ -45,6 +47,66 @@ def test_clean_single_spawn_at_top_of_slice_passes() -> None:
     assert validate_model_tier_run(run) is None
 
 
+def test_sol_codex_bind_is_first_success_when_enabled() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=[ADVISOR_MODEL_TIER, "Fable", "Opus"],
+        attempts=[{"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN}],
+        selected_tier=ADVISOR_MODEL_TIER,
+        is_sol_enabled=True,
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_sol_failure_falls_through_to_fable_when_enabled() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=[ADVISOR_MODEL_TIER, "Fable", "Opus"],
+        attempts=[
+            {"tier": ADVISOR_MODEL_TIER, "result": "unavailable"},
+            {"tier": "Fable", "result": "spawned"},
+        ],
+        selected_tier="Fable",
+        is_sol_enabled=True,
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_sol_rung_precedes_third_party_cli_floor_when_enabled() -> None:
+    run = ModelTierRun(
+        own_tier="ThirdParty",
+        candidate_tiers=[ADVISOR_MODEL_TIER, "Fable", "Opus"],
+        attempts=[{"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN}],
+        selected_tier=ADVISOR_MODEL_TIER,
+        is_sol_enabled=True,
+    )
+
+    assert validate_model_tier_run(run) is None
+
+
+def test_sol_codex_result_requires_sol_candidate() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[{"tier": "Fable", "result": CODEX_BIND_SUCCESS_TOKEN}],
+        selected_tier="Fable",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_sol_spawned_result_does_not_count_as_codex_success() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=[ADVISOR_MODEL_TIER, "Fable", "Opus"],
+        attempts=[{"tier": ADVISOR_MODEL_TIER, "result": "spawned"}],
+        selected_tier=ADVISOR_MODEL_TIER,
+        is_sol_enabled=True,
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
 def test_fallthrough_to_floor_tier_passes() -> None:
     run = ModelTierRun(
         own_tier="Opus",
@@ -223,6 +285,23 @@ def test_cli_validates_json_log_file(tmp_path: Path) -> None:
     assert loaded_run.selected_tier == "Fable"
 
 
+def test_cli_rejects_non_boolean_sol_enabled(tmp_path: Path) -> None:
+    log_path = tmp_path / "invalid-sol-enabled.json"
+    log_path.write_text(
+        json.dumps(
+            {
+                "own_tier": "Opus",
+                "candidate_tiers": ["Fable", "Opus"],
+                "attempts": [{"tier": "Fable", "result": "spawned"}],
+                "selected_tier": "Fable",
+                "sol_enabled": "false",
+            }
+        ),
+        encoding="utf-8",
+    )
+    assert main([str(log_path)]) == 2
+
+
 def test_cli_rejects_incomplete_fallback_log(tmp_path: Path) -> None:
     log_path = tmp_path / "incomplete-walk.json"
     log_path.write_text(

package/_shared/advisor/scripts/tests/test_tier_model_ids.py

@@ -10,6 +10,26 @@ from types import ModuleType
 import pytest
 
 
+constants_root = Path(__file__).parent.parent / "config"
+if str(constants_root) not in sys.path:
+    sys.path.insert(0, str(constants_root))
+
+from advisor_scripts_constants.model_tier_run_validator_constants import (  # noqa: E402
+    ADVISOR_SENDMESSAGE_REPLY_WAIT_SECONDS,
+    ALL_CLI_MODEL_ID_BY_TIER,
+    ALL_KNOWN_TIER_NAMES,
+    ALL_MODEL_TIERS,
+    HOST_PROFILE_CLAUDE,
+    HOST_PROFILE_THIRD_PARTY,
+    THIRD_PARTY_MODEL_TIER,
+)
+from advisor_scripts_constants.advisor_route_constants import (  # noqa: E402
+    ADVISOR_CODEX_MODEL_ID,
+    ADVISOR_MODEL_TIER,
+    ALL_CODEX_MODEL_ID_BY_TIER,
+)
+
+
 def _load_tier_model_ids_module() -> ModuleType:
     scripts_root = Path(__file__).parent.parent
     module_path = scripts_root / "tier_model_ids.py"
@@ -26,21 +46,9 @@ def _load_tier_model_ids_module() -> ModuleType:
 
 tier_model_ids = _load_tier_model_ids_module()
 resolve_cli_model_id = tier_model_ids.resolve_cli_model_id
+resolve_codex_model_id = tier_model_ids.resolve_codex_model_id
 canonical_tier_name = tier_model_ids.canonical_tier_name
 detect_host_profile = tier_model_ids.detect_host_profile
-constants_root = Path(__file__).parent.parent / "config"
-if str(constants_root) not in sys.path:
-    sys.path.insert(0, str(constants_root))
-
-from advisor_scripts_constants.model_tier_run_validator_constants import (  # noqa: E402
-    ADVISOR_SENDMESSAGE_REPLY_WAIT_SECONDS,
-    ALL_CLI_MODEL_ID_BY_TIER,
-    ALL_KNOWN_TIER_NAMES,
-    ALL_MODEL_TIERS,
-    HOST_PROFILE_CLAUDE,
-    HOST_PROFILE_THIRD_PARTY,
-    THIRD_PARTY_MODEL_TIER,
-)
 
 SCRIPTS_ROOT = Path(__file__).parent.parent
 DOCUMENTED_RESOLVE_ONE_LINER = (
@@ -94,14 +102,28 @@ def test_sendmessage_reply_wait_is_positive_bound() -> None:
     assert ADVISOR_SENDMESSAGE_REPLY_WAIT_SECONDS == 120
 
 
+def test_resolve_codex_model_id_maps_sol() -> None:
+    assert resolve_codex_model_id(f" {ADVISOR_MODEL_TIER.lower()} ") == (
+        ADVISOR_CODEX_MODEL_ID
+    )
+
+
+def test_resolve_codex_model_id_rejects_claude_tier() -> None:
+    with pytest.raises(ValueError, match="not a known model tier"):
+        resolve_codex_model_id("Opus")
+
+
 def test_cli_model_alias_map_keys_match_known_tiers() -> None:
-    assert set(ALL_CLI_MODEL_ID_BY_TIER) == set(ALL_KNOWN_TIER_NAMES)
+    all_cli_tiers = (*ALL_MODEL_TIERS, THIRD_PARTY_MODEL_TIER)
+    assert set(ALL_CLI_MODEL_ID_BY_TIER) == set(all_cli_tiers)
     assert set(ALL_MODEL_TIERS).issubset(set(ALL_KNOWN_TIER_NAMES))
+    assert ADVISOR_MODEL_TIER in ALL_KNOWN_TIER_NAMES
     assert THIRD_PARTY_MODEL_TIER in ALL_KNOWN_TIER_NAMES
     assert THIRD_PARTY_MODEL_TIER not in ALL_MODEL_TIERS
-    assert all(
-        ALL_CLI_MODEL_ID_BY_TIER[each_tier] for each_tier in ALL_KNOWN_TIER_NAMES
-    )
+    assert all(ALL_CLI_MODEL_ID_BY_TIER[each_tier] for each_tier in all_cli_tiers)
+    assert ALL_CODEX_MODEL_ID_BY_TIER == {
+        ADVISOR_MODEL_TIER: ADVISOR_CODEX_MODEL_ID,
+    }
 
 
 def test_canonical_tier_name_strips_and_normalizes() -> None:

package/_shared/advisor/scripts/tier_model_ids.py

@@ -45,6 +45,9 @@ from advisor_scripts_constants.model_tier_run_validator_constants import (  # no
     UNKNOWN_HOST_PROFILE_ERROR,
     UNKNOWN_LADDER_NAME_ERROR,
 )
+from advisor_scripts_constants.advisor_route_constants import (  # noqa: E402
+    ALL_CODEX_MODEL_ID_BY_TIER,
+)
 
 
 def canonical_tier_name(tier_name: str) -> str | None:
@@ -111,6 +114,27 @@ def resolve_cli_model_id(tier: str) -> str:
     return maybe_model_alias
 
 
+def resolve_codex_model_id(tier: str) -> str:
+    """Return the dated Codex model id for a Codex-backed advisor tier.
+
+    Args:
+        tier: Ladder tier name whose Codex model id should be resolved.
+
+    Returns:
+        The configured Codex model id.
+
+    Raises:
+        ValueError: When ``tier`` is not a known Codex-backed tier.
+    """
+    maybe_canonical_tier = canonical_tier_name(tier)
+    if maybe_canonical_tier is None:
+        raise ValueError(UNKNOWN_LADDER_NAME_ERROR.format(tier))
+    maybe_model_id = ALL_CODEX_MODEL_ID_BY_TIER.get(maybe_canonical_tier)
+    if maybe_model_id is None:
+        raise ValueError(UNKNOWN_LADDER_NAME_ERROR.format(tier))
+    return maybe_model_id
+
+
 def detect_host_profile(
     setting_by_name: Mapping[str, str] | None = None,
 ) -> str:

package/docs/references/CLAUDE.md

@@ -10,7 +10,8 @@ Pointer documents to external sources, standard terminology, and internal tool o
 | `code-review-enforcement.md` | How the code-review gates work: the two required efforts (push at low, PR creation at xhigh), the stamp bound to the branch-surface hash, the single sanctioned minter, the two-layer stamp-directory guard, and the bypass surfaces the gates leave open |
 | `prose-style-enforcement.md` | How `CLAUDE_PROSE_STYLE_ENFORCEMENT` arms opinionated prose gates (default off) while AskUserQuestion lean-block stays always on |
 | `advisor-tool.md` | Canonical consult bones for any stronger reviewer: when to call, hard rule before first write, how to treat advice; maps to the Anthropic advisor tool |
-| `team-advisor-skill.md` | `/team-advisor` map: sole-consumer warm bind, ref index, and how it pairs with `advisor()` |
+| `team-advisor-skill.md` | `/team-advisor` map: sole-consumer warm bind, ref index, and advisor selection |
+| `weak-executor-advisor.md` | Consult profile a below-advisor-tier executor (Sonnet, Haiku) follows on top of `advisor-tool.md`: spawn-prompt steering, context packaging, two-timing rule, consult budget, failure branches |
 
 ## Role