claude-dev-env 2.16.0 → 2.18.0

package/_shared/advisor/scripts/model_tier_run_validator.py

@@ -8,23 +8,29 @@ from data, not inferred from a transcript.
 
     ladder_walk = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
-        attempts=[
-            {"tier": "Fable", "result": "unavailable"},
-            {"tier": "Opus", "result": "spawned"},
-        ],
-        selected_tier="Opus",
+        candidate_tiers=["Fable"],
+        attempts=[{"tier": "Fable", "result": "spawned"}],
+        selected_tier="Fable",
     )
     validate_model_tier_run(ladder_walk)  # ok: returns None, raises nothing
 
     cli_bind = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable"],
         attempts=[{"tier": "Fable", "result": "cli"}],
         selected_tier="Fable",
     )
     validate_model_tier_run(cli_bind)  # ok: third-party-host CLI Claude-chain bind
 
+    codex_bind = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Sol"],
+        attempts=[{"tier": "Sol", "result": "spawned"}],
+        selected_tier="Sol",
+        host_profile="Codex",
+    )
+    validate_model_tier_run(codex_bind)  # ok: Codex in-session Sol spawn
+
 A run whose selected_tier is not the first successful bind fails.
 On any broken invariant, validate_model_tier_run raises ModelTierRunError.
 
@@ -48,7 +54,6 @@ if _scripts_directory not in sys.path:
     sys.path.insert(0, _scripts_directory)
 
 from advisor_scripts_constants.model_tier_run_validator_constants import (  # noqa: E402
-    ALL_MODEL_TIERS,
     ATTEMPT_ORDER_MISMATCH_MESSAGE,
     ATTEMPT_TIER_OUT_OF_SLICE_MESSAGE,
     CANDIDATE_TIERS_MISMATCH_MESSAGE,
@@ -57,15 +62,20 @@ from advisor_scripts_constants.model_tier_run_validator_constants import (  # no
     CLI_SUCCESS_EXIT_CODE,
     CLI_USAGE_MESSAGE,
     CLI_VALIDATION_FAILURE_EXIT_CODE,
+    HOST_PROFILE_CLAUDE,
+    HOST_PROFILE_CODEX,
+    HOST_PROFILE_JSON_KEY,
+    HOST_PROFILE_MUST_BE_STRING_MESSAGE,
     INCOMPLETE_FALLBACK_WALK_MESSAGE,
     MISSING_FALLBACK_REASON_MESSAGE,
     SELECTED_TIER_MISMATCH_MESSAGE,
     SELECTED_TIER_NOT_NULL_MESSAGE,
-    THIRD_PARTY_CLI_ADVISOR_FLOOR_TIER,
     THIRD_PARTY_MODEL_TIER,
+    UNKNOWN_HOST_PROFILE_ERROR,
     UNKNOWN_OWN_TIER_MESSAGE,
 )
 from advisor_scripts_constants.advisor_route_constants import (  # noqa: E402
+    ADVISOR_FALLBACK_TIER,
     ADVISOR_MODEL_TIER,
     CODEX_BIND_SUCCESS_TOKEN,
     CLI_BIND_SUCCESS_TOKEN,
@@ -73,7 +83,7 @@ from advisor_scripts_constants.advisor_route_constants import (  # noqa: E402
     SPAWN_SUCCESS_TOKEN,
     TIER_KEY,
 )
-from tier_model_ids import canonical_tier_name  # noqa: E402
+from tier_model_ids import canonical_host_profile, canonical_tier_name  # noqa: E402
 
 
 @dataclass(frozen=True)
@@ -84,6 +94,7 @@ class ModelTierRun:
     selected_tier: str | None
     fallback_reason: str | None = None
     is_sol_enabled: bool = False
+    host_profile: str = HOST_PROFILE_CLAUDE
 
 
 class ModelTierRunError(ValueError):
@@ -101,30 +112,39 @@ def _canonical_tier_list(all_tier_names: list[str]) -> list[str] | None:
 
 
 def _expected_candidate_tiers(
-    own_tier: str, is_sol_enabled: bool = False
+    own_tier: str,
+    is_sol_enabled: bool = False,
+    host_profile: str = HOST_PROFILE_CLAUDE,
 ) -> list[str]:
     maybe_canonical_own_tier = canonical_tier_name(own_tier)
     if maybe_canonical_own_tier is None:
         raise ModelTierRunError(f"{UNKNOWN_OWN_TIER_MESSAGE}: {own_tier!r}")
     if maybe_canonical_own_tier == ADVISOR_MODEL_TIER:
         raise ModelTierRunError(f"{UNKNOWN_OWN_TIER_MESSAGE}: {own_tier!r}")
-    if maybe_canonical_own_tier == THIRD_PARTY_MODEL_TIER:
-        floor_index = ALL_MODEL_TIERS.index(THIRD_PARTY_CLI_ADVISOR_FLOOR_TIER)
-    else:
-        floor_index = ALL_MODEL_TIERS.index(maybe_canonical_own_tier)
-    all_expected_candidates = list(ALL_MODEL_TIERS[: floor_index + 1])
+    maybe_canonical_host = canonical_host_profile(host_profile)
+    if maybe_canonical_host is None:
+        raise ModelTierRunError(UNKNOWN_HOST_PROFILE_ERROR.format(host_profile))
+    if maybe_canonical_host == HOST_PROFILE_CODEX:
+        return [ADVISOR_MODEL_TIER]
+    all_expected_candidates = [ADVISOR_FALLBACK_TIER]
     if is_sol_enabled:
-        all_expected_candidates.insert(0, ADVISOR_MODEL_TIER)
+        all_expected_candidates.append(ADVISOR_MODEL_TIER)
     return all_expected_candidates
 
 
 def _is_successful_attempt_outcome(
     canonical_tier: str,
     outcome_token: str,
+    host_profile: str = HOST_PROFILE_CLAUDE,
 ) -> bool:
+    maybe_canonical_host = canonical_host_profile(host_profile)
     if canonical_tier == THIRD_PARTY_MODEL_TIER:
         return False
     if canonical_tier == ADVISOR_MODEL_TIER:
+        if maybe_canonical_host == HOST_PROFILE_CODEX:
+            if outcome_token == SPAWN_SUCCESS_TOKEN:
+                return True
+            return outcome_token == CODEX_BIND_SUCCESS_TOKEN
         return outcome_token == CODEX_BIND_SUCCESS_TOKEN
     if outcome_token == CODEX_BIND_SUCCESS_TOKEN:
         return False
@@ -144,12 +164,13 @@ def validate_model_tier_run(run: ModelTierRun) -> None:
         validate_model_tier_run(cli_bind)     # ok: CLI Claude-chain bind
         validate_model_tier_run(broken_log)   # flag: ModelTierRunError
 
-    Candidate tiers must match the floor slice. ``own_tier=ThirdParty`` maps to
-    the third-party-host CLI advisor floor (Fable → Opus). Tries walk that
-    slice in order;
-    early stop only after ``spawned`` or ``cli``. A null selected_tier requires
-    a full walk plus fallback_reason (fail-closed on a third-party host when
-    the chain cannot serve).
+    Candidate tiers are Fable, plus Sol when ``is_sol_enabled`` is true, on
+    Claude and ThirdParty hosts. A Codex host walks Sol only. Consumer
+    ``own_tier`` is recorded and must be a known tier; it does not add Opus
+    to the advisor walk. Tries walk that list in order. Early stop only
+    after ``spawned``, ``cli``, or Sol ``codex`` (and Sol ``spawned`` on a
+    Codex host). A null selected_tier requires a full walk plus
+    fallback_reason.
 
     Args:
         run: The structured spawn-walk log to check.
@@ -163,6 +184,7 @@ def validate_model_tier_run(run: ModelTierRun) -> None:
     all_expected_candidates = _expected_candidate_tiers(
         run.own_tier,
         is_sol_enabled=run.is_sol_enabled,
+        host_profile=run.host_profile,
     )
     maybe_canonical_candidates = _canonical_tier_list(run.candidate_tiers)
     if maybe_canonical_candidates != all_expected_candidates:
@@ -199,6 +221,7 @@ def _validate_selected_tier(
         if _is_successful_attempt_outcome(
             canonical_tier=each_tier,
             outcome_token=each_attempt[SPAWN_OUTCOME_KEY],
+            host_profile=run.host_profile,
         )
     ]
     if all_bound_tiers:
@@ -237,6 +260,9 @@ def load_model_tier_run_from_json_path(from_path: Path) -> ModelTierRun:
     raw_sol_enabled = parsed_payload.get("sol_enabled", False)
     if not isinstance(raw_sol_enabled, bool):
         raise TypeError("sol_enabled must be a boolean")
+    raw_host_profile = parsed_payload.get(HOST_PROFILE_JSON_KEY, HOST_PROFILE_CLAUDE)
+    if not isinstance(raw_host_profile, str):
+        raise TypeError(HOST_PROFILE_MUST_BE_STRING_MESSAGE)
     return ModelTierRun(
         own_tier=parsed_payload["own_tier"],
         candidate_tiers=list(parsed_payload["candidate_tiers"]),
@@ -244,6 +270,7 @@ def load_model_tier_run_from_json_path(from_path: Path) -> ModelTierRun:
         selected_tier=parsed_payload.get("selected_tier"),
         fallback_reason=parsed_payload.get("fallback_reason"),
         is_sol_enabled=raw_sol_enabled,
+        host_profile=raw_host_profile,
     )
 
 

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

@@ -97,8 +97,35 @@ def _two_step_process_runner(calls: list[list[str]], guidance: str) -> _ProcessR
 
 
 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"})
+    assert sol_advisor.is_sol_advisor_enabled({"ADVISOR_SOL": "yes"})
+    assert not sol_advisor.is_sol_advisor_enabled({"ADVISOR_SOL": "0"})
+    assert not sol_advisor.is_sol_advisor_enabled({"ADVISOR_SOL_XHIGH": "1"})
+
+
+def test_resolve_advisor_effort_defaults_and_accepts_documented_levels() -> None:
+    assert sol_advisor.resolve_advisor_effort({}) == "low"
+    assert sol_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "MEDIUM"}) == "medium"
+    assert sol_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "nope"}) == "low"
+    assert sol_advisor.resolve_advisor_effort({"ADVISOR_SOL_EFFORT": "high"}) == "low"
+
+
+@pytest.mark.parametrize(
+    "reasoning_effort",
+    ["low", "medium", "high", "xhigh", "max"],
+)
+def test_codex_arguments_use_selected_sol_reasoning_effort(
+    reasoning_effort: str,
+) -> None:
+    command_arguments = sol_advisor.build_codex_arguments(
+        "codex",
+        reasoning_effort=reasoning_effort,
+    )
+    config_flag_index = command_arguments.index("--config")
+
+    assert (
+        command_arguments[config_flag_index + 1]
+        == f'model_reasoning_effort="{reasoning_effort}"'
+    )
 
 
 def test_resolve_usage_probe_path_uses_supplied_home_directory(tmp_path: Path) -> None:
@@ -162,7 +189,7 @@ def test_bind_and_resume_arguments_match_installed_codex_interface() -> None:
         "--model",
         sol_advisor.ADVISOR_CODEX_MODEL_ID,
         "--config",
-        'model_reasoning_effort="xhigh"',
+        'model_reasoning_effort="low"',
         "--sandbox",
         "read-only",
         "--json",
@@ -326,6 +353,40 @@ def test_enable_sol_flag_opens_the_rung_without_an_environment_flag(
     assert payload["fallback_kind"] == sol_advisor.SOL_FALLBACK_KIND_DECLINED
 
 
+def test_effort_cli_flag_overrides_environment_effort(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    captured_settings: dict[str, str] = {}
+
+    def fake_advisor(**kwargs: object) -> object:
+        captured_settings.update(dict(kwargs["setting_by_name"]))  # type: ignore[arg-type]
+        return sol_advisor._reply_fallback(
+            "probe declined",
+            True,
+            fallback_kind=sol_advisor.SOL_FALLBACK_KIND_DECLINED,
+        )
+
+    monkeypatch.setattr(sol_advisor, "run_codex_sol_advisor", fake_advisor)
+    monkeypatch.setenv("ADVISOR_EFFORT", "high")
+    monkeypatch.setattr(sys, "stdin", io.StringIO("first consult"))
+
+    exit_code = sol_advisor.main(
+        [
+            "--bind",
+            "--cwd",
+            ".",
+            sol_advisor.SOL_ENABLE_FLAG,
+            sol_advisor.SOL_EFFORT_FLAG,
+            "medium",
+        ]
+    )
+    payload = json.loads(capsys.readouterr().out)
+
+    assert exit_code == 1
+    assert captured_settings["ADVISOR_EFFORT"] == "medium"
+    assert payload["fallback_kind"] == sol_advisor.SOL_FALLBACK_KIND_DECLINED
+
+
 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})
@@ -474,6 +535,50 @@ def test_bind_runs_probe_then_codex_with_read_only_xhigh_settings() -> None:
     assert calls[1][1]["timeout"]
 
 
+def test_protocol_docs_name_shared_effort_and_fable_sol_ladder() -> None:
+    sol_rung_path = SCRIPTS_ROOT.parent / "reference" / "sol-rung.md"
+    protocol_path = SCRIPTS_ROOT.parent / "advisor-protocol.md"
+    third_party_bind_path = SCRIPTS_ROOT.parent / "reference" / "third-party-bind.md"
+    advisor_block_path = SCRIPTS_ROOT.parent / "reference" / "advisor-block.md"
+    sol_rung = sol_rung_path.read_text(encoding="utf-8")
+    protocol_text = protocol_path.read_text(encoding="utf-8")
+    third_party_bind_text = third_party_bind_path.read_text(encoding="utf-8")
+    advisor_block_text = advisor_block_path.read_text(encoding="utf-8")
+
+    assert 'model_reasoning_effort="low"' in sol_rung
+    assert "out of usage" in protocol_text
+    assert "ADVISOR_EFFORT" in protocol_text
+    assert "ADVISOR_EFFORT" in sol_rung
+    assert "ADVISOR_EFFORT" in third_party_bind_text
+    assert "ADVISOR_SOL=1" in protocol_text
+    assert "ADVISOR_SOL_EFFORT" not in protocol_text
+    assert "ADVISOR_SOL_EFFORT" not in sol_rung
+    assert "ADVISOR_SOL_XHIGH" not in protocol_text
+    assert "ADVISOR_SOL_XHIGH" not in sol_rung
+    assert "--effort xhigh" not in third_party_bind_text
+    assert "--effort medium" not in third_party_bind_text
+    assert "then Opus" not in protocol_text
+    assert "then Claude Opus" not in advisor_block_text
+    assert 'candidate_tiers = ["Fable", "Opus"]' not in protocol_text
+    assert 'candidate_tiers = ["Fable", "Sol", "Opus"]' not in protocol_text
+    team_advisor_text = (
+        SCRIPTS_ROOT.parents[2] / ".agents" / "skills" / "team-advisor" / "SKILL.md"
+    ).read_text(encoding="utf-8")
+    orchestrator_text = (
+        SCRIPTS_ROOT.parents[2] / ".agents" / "skills" / "orchestrator" / "SKILL.md"
+    ).read_text(encoding="utf-8")
+    refresh_text = (
+        SCRIPTS_ROOT.parents[2]
+        / ".agents"
+        / "skills"
+        / "orchestrator-refresh"
+        / "SKILL.md"
+    ).read_text(encoding="utf-8")
+    assert "then Opus" not in team_advisor_text
+    assert "then Opus" not in orchestrator_text
+    assert "then Opus xhigh" not in refresh_text
+
+
 def test_team_advisor_path_preserves_sol_routing_fields() -> None:
     team_advisor_path = SCRIPTS_ROOT.parents[2] / ".agents" / "skills" / "team-advisor" / "SKILL.md"
     sol_rung_path = SCRIPTS_ROOT.parent / "reference" / "sol-rung.md"