claude-dev-env 2.17.0 → 2.18.0

package/_shared/advisor/scripts/codex_sol_advisor.py

@@ -1,4 +1,4 @@
-"""Bind and consult a read-only Codex CLI session at Sol xhigh."""
+"""Bind and consult a read-only Codex CLI session at Sol low effort."""
 
 from __future__ import annotations
 
@@ -22,6 +22,8 @@ if _config_directory_text not in sys.path:
 
 from advisor_scripts_constants.sol_advisor_constants import (  # noqa: E402
     ADVISOR_CODEX_EXECUTABLE_ENV_VAR,
+    ALL_SOL_TRUTHY_VALUES,
+    CLAUDE_CONFIG_DIRECTORY_NAME,
     CODEX_CONFIG_FLAG,
     CODEX_EXECUTABLE,
     CODEX_EXEC_SUBCOMMAND,
@@ -29,15 +31,15 @@ from advisor_scripts_constants.sol_advisor_constants import (  # noqa: E402
     CODEX_MODEL_FLAG,
     CODEX_PROMPT_FROM_STDIN,
     CODEX_READ_ONLY_SANDBOX,
-    CODEX_REASONING_CONFIG,
+    CODEX_REASONING_CONFIG_TEMPLATE,
     CODEX_RESUME_SUBCOMMAND,
     CODEX_SANDBOX_FLAG,
-    CLAUDE_CONFIG_DIRECTORY_NAME,
     SOL_BIND_FAILURE_REASON,
     SOL_CODEX_TIMEOUT_REASON,
     SOL_CODEX_TIMEOUT_SECONDS,
-    SOL_ENV_VAR,
+    SOL_EFFORT_FLAG,
     SOL_ENABLE_FLAG,
+    SOL_ENV_VAR,
     SOL_EXECUTABLE_NOT_FOUND_REASON,
     SOL_FALLBACK_KIND_BROKEN,
     SOL_FALLBACK_KIND_DECLINED,
@@ -48,14 +50,16 @@ from advisor_scripts_constants.sol_advisor_constants import (  # noqa: E402
     SOL_PROBE_TIMEOUT_REASON,
     SOL_REPLY_FAILURE_REASON,
     SOL_SESSION_ID_METAVAR,
-    ALL_SOL_TRUTHY_VALUES,
     SOL_USAGE_PROBE_TIMEOUT_SECONDS,
 )
 from advisor_scripts_constants.advisor_route_constants import (  # noqa: E402
     ADVISOR_CODEX_MODEL_ID,
+    ADVISOR_EFFORT_DEFAULT,
+    ADVISOR_EFFORT_ENV_VAR,
     ADVISOR_FALLBACK_RESULT,
     ADVISOR_FALLBACK_TIER,
     ADVISOR_MODEL_TIER,
+    ALL_ADVISOR_EFFORT_LEVELS,
     ALL_ADVISOR_GUIDANCE_SIGNALS,
     CODEX_BIND_SUCCESS_TOKEN,
     SPAWN_OUTCOME_KEY,
@@ -143,7 +147,7 @@ def _resolved_setting_by_name(
 def is_sol_advisor_enabled(
     setting_by_name: Mapping[str, str] | None,
 ) -> bool:
-    """Return whether the optional Sol xhigh rung is enabled.
+    """Return whether the optional Sol rung is enabled.
 
     Args:
         setting_by_name: Optional environment-like settings mapping.
@@ -158,6 +162,42 @@ def is_sol_advisor_enabled(
     )
 
 
+def resolve_advisor_effort(
+    setting_by_name: Mapping[str, str] | None,
+) -> str:
+    """Return the shared advisor effort from settings, or the default.
+
+    ::
+
+        resolve_advisor_effort({"ADVISOR_EFFORT": "medium"})
+        # ok: "medium"
+        resolve_advisor_effort({"ADVISOR_EFFORT": "MAX"})
+        # ok: "max"
+        resolve_advisor_effort({})
+        # ok: default low
+        resolve_advisor_effort({"ADVISOR_EFFORT": "nope"})
+        # ok: default low
+        resolve_advisor_effort({"ADVISOR_SOL_EFFORT": "high"})
+        # ok: default low
+
+    Fable and Sol both read this value. Unset and unrecognized values use
+    low. The Sol-only name does not set effort.
+
+    Args:
+        setting_by_name: Optional environment-like settings mapping.
+
+    Returns:
+        One of low, medium, high, xhigh, or max.
+    """
+    resolved_setting_by_name = _resolved_setting_by_name(setting_by_name)
+    requested_effort = (
+        resolved_setting_by_name.get(ADVISOR_EFFORT_ENV_VAR, "").strip().lower()
+    )
+    if requested_effort in ALL_ADVISOR_EFFORT_LEVELS:
+        return requested_effort
+    return ADVISOR_EFFORT_DEFAULT
+
+
 def resolve_usage_probe_path(home_directory: Path) -> Path:
     """Return the installed Codex weekly usage probe path.
 
@@ -290,12 +330,14 @@ def resolve_codex_executable(
 def build_codex_arguments(
     codex_executable: str,
     session_id: str | None = None,
+    reasoning_effort: str = ADVISOR_EFFORT_DEFAULT,
 ) -> list[str]:
     """Build the installed CLI's shell-free bind or resume argv.
 
     Args:
         codex_executable: Resolved executable name or path to invoke.
         session_id: Optional existing session to resume.
+        reasoning_effort: Codex model_reasoning_effort token.
 
     Returns:
         The shell-free Codex command argument vector.
@@ -306,7 +348,7 @@ def build_codex_arguments(
         CODEX_MODEL_FLAG,
         ADVISOR_CODEX_MODEL_ID,
         CODEX_CONFIG_FLAG,
-        CODEX_REASONING_CONFIG,
+        CODEX_REASONING_CONFIG_TEMPLATE.format(effort=reasoning_effort),
         CODEX_SANDBOX_FLAG,
         CODEX_READ_ONLY_SANDBOX,
         CODEX_JSON_FLAG,
@@ -435,7 +477,11 @@ def run_codex_sol_advisor(
         )
     try:
         completed_process = process_runner(
-            build_codex_arguments(codex_executable, session_id=session_id),
+            build_codex_arguments(
+                codex_executable,
+                session_id=session_id,
+                reasoning_effort=resolve_advisor_effort(setting_by_name),
+            ),
             cwd=str(working_directory),
             input=prompt,
             capture_output=True,
@@ -467,7 +513,7 @@ def build_argument_parser() -> argparse.ArgumentParser:
         The parser for the helper's bind and resume modes.
     """
     argument_parser = argparse.ArgumentParser(
-        description="Bind or consult a read-only Codex Sol xhigh advisor."
+        description="Bind or consult a read-only Codex Sol advisor."
     )
     mode_group = argument_parser.add_mutually_exclusive_group(required=True)
     mode_group.add_argument("--bind", action="store_true")
@@ -479,6 +525,13 @@ def build_argument_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Open the Sol rung for this invocation without an environment flag.",
     )
+    argument_parser.add_argument(
+        SOL_EFFORT_FLAG,
+        dest="sol_effort",
+        choices=ALL_ADVISOR_EFFORT_LEVELS,
+        default=None,
+        help="Shared advisor effort for this invocation.",
+    )
     return argument_parser
 
 
@@ -492,9 +545,11 @@ def main(all_cli_arguments: Sequence[str]) -> int:
         Zero for a successful Sol response, or one for an explicit fallback.
     """
     parsed_arguments = build_argument_parser().parse_args(list(all_cli_arguments))
-    setting_by_name: Mapping[str, str] = os.environ
+    setting_by_name: dict[str, str] = dict(os.environ)
     if parsed_arguments.is_sol_requested:
-        setting_by_name = {**os.environ, SOL_ENV_VAR: "1"}
+        setting_by_name[SOL_ENV_VAR] = "1"
+    if parsed_arguments.sol_effort is not None:
+        setting_by_name[ADVISOR_EFFORT_ENV_VAR] = parsed_arguments.sol_effort
     advisor_reply = run_codex_sol_advisor(
         prompt=sys.stdin.read(),
         working_directory=parsed_arguments.cwd,

package/_shared/advisor/scripts/config/advisor_scripts_constants/advisor_route_constants.py

@@ -6,6 +6,15 @@ ADVISOR_MODEL_TIER: str = "Sol"
 ADVISOR_CODEX_MODEL_ID: str = "gpt-5.6-sol"
 ADVISOR_FALLBACK_TIER: str = "Fable"
 ADVISOR_FALLBACK_RESULT: str = "fable"
+ADVISOR_EFFORT_ENV_VAR: str = "ADVISOR_EFFORT"
+ADVISOR_EFFORT_DEFAULT: str = "low"
+ALL_ADVISOR_EFFORT_LEVELS: tuple[str, ...] = (
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+)
 ALL_ADVISOR_GUIDANCE_SIGNALS: frozenset[str] = frozenset(
     {"ENDORSE", "CORRECTION", "PLAN", "STOP"}
 )

package/_shared/advisor/scripts/config/advisor_scripts_constants/model_tier_run_validator_constants.py

@@ -1,7 +1,7 @@
 """Constants for the model-tier-run validator and CLI / Agent alias map.
 
 They name the parts of a spawn-walk log: the tier ladder (strongest
-first), the two host profiles, and the validation messages. Shared log
+first), the three host profiles, and the validation messages. Shared log
 keys and bind-result tokens live in ``advisor_route_constants``.
 
 ::
@@ -11,9 +11,15 @@ The alias map turns each tier into its short CLI / Agent name (``opus``,
 
 Host-profile detection (see ``detect_host_profile``):
 
-- ``ADVISOR_HOST_PROFILE=ThirdParty`` or ``=Claude`` — explicit override
+- ``ADVISOR_HOST_PROFILE=ThirdParty``, ``=Claude``, or ``=Codex`` — explicit override
 - ``THIRD_PARTY=1`` (or ``true`` / ``yes``) — a third-party (non-Claude) harness
 - default when neither is set: Claude
+
+Session identity (see ``resolve_session_identity``):
+
+- a ``codex`` token maps to Codex
+- a ``claude`` token maps to Claude
+- any other identity maps to ThirdParty
 """
 
 from __future__ import annotations
@@ -24,11 +30,17 @@ from advisor_scripts_constants.advisor_route_constants import (
 )
 
 HOST_PROFILE_CLAUDE: str = "Claude"
+HOST_PROFILE_CODEX: str = "Codex"
 HOST_PROFILE_THIRD_PARTY: str = "ThirdParty"
 ALL_HOST_PROFILES: tuple[str, ...] = (
     HOST_PROFILE_CLAUDE,
+    HOST_PROFILE_CODEX,
     HOST_PROFILE_THIRD_PARTY,
 )
+SESSION_IDENTITY_CLAUDE_TOKEN: str = "claude"
+SESSION_IDENTITY_CODEX_TOKEN: str = "codex"
+SESSION_IDENTITY_WORD_PATTERN: str = r"[a-z0-9]+"
+HOST_PROFILE_JSON_KEY: str = "host_profile"
 
 ALL_MODEL_TIERS: tuple[str, ...] = (
     ADVISOR_FALLBACK_TIER,
@@ -42,7 +54,6 @@ ALL_KNOWN_TIER_NAMES: tuple[str, ...] = (
     *ALL_MODEL_TIERS,
     THIRD_PARTY_MODEL_TIER,
 )
-THIRD_PARTY_CLI_ADVISOR_FLOOR_TIER: str = "Opus"
 
 ADVISOR_SENDMESSAGE_REPLY_WAIT_SECONDS: int = 120
 
@@ -62,8 +73,9 @@ ALL_THIRD_PARTY_TRUTHY_VALUES: frozenset[str] = frozenset(
 UNKNOWN_OWN_TIER_MESSAGE: str = "own_tier is not a known model tier"
 UNKNOWN_LADDER_NAME_ERROR: str = "ladder name is not a known model tier: {!r}"
 UNKNOWN_HOST_PROFILE_ERROR: str = "host profile is not a known profile: {!r}"
+HOST_PROFILE_MUST_BE_STRING_MESSAGE: str = "host_profile must be a string"
 CANDIDATE_TIERS_MISMATCH_MESSAGE: str = (
-    "candidate_tiers does not match the ladder slice down to own_tier"
+    "candidate_tiers does not match the advisor walk for this host"
 )
 ATTEMPT_TIER_OUT_OF_SLICE_MESSAGE: str = (
     "a spawn try names a tier outside the candidate slice"

package/_shared/advisor/scripts/config/advisor_scripts_constants/sol_advisor_constants.py

@@ -1,4 +1,4 @@
-"""Constants for the optional Codex Sol xhigh advisor bind."""
+"""Constants for the optional Codex Sol advisor bind."""
 
 from __future__ import annotations
 
@@ -8,7 +8,7 @@ CODEX_READ_ONLY_SANDBOX: str = "read-only"
 CODEX_JSON_FLAG: str = "--json"
 CODEX_MODEL_FLAG: str = "--model"
 CODEX_CONFIG_FLAG: str = "--config"
-CODEX_REASONING_CONFIG: str = 'model_reasoning_effort="xhigh"'
+CODEX_REASONING_CONFIG_TEMPLATE: str = 'model_reasoning_effort="{effort}"'
 CODEX_PROMPT_FROM_STDIN: str = "-"
 CODEX_EXEC_SUBCOMMAND: str = "exec"
 CODEX_RESUME_SUBCOMMAND: str = "resume"
@@ -17,17 +17,18 @@ CLAUDE_CONFIG_DIRECTORY_NAME: str = ".claude"
 SOL_SESSION_ID_METAVAR: str = "SESSION_ID"
 SOL_CODEX_TIMEOUT_SECONDS: float = 120.0
 SOL_USAGE_PROBE_TIMEOUT_SECONDS: float = 30.0
-SOL_ENV_VAR: str = "ADVISOR_SOL_XHIGH"
+SOL_ENV_VAR: str = "ADVISOR_SOL"
 ALL_SOL_TRUTHY_VALUES: frozenset[str] = frozenset({"1", "true", "yes", "on"})
 SOL_PREFLIGHT_FAILURE_REASON: str = "sol preflight did not establish an eligible Codex meter"
-SOL_BIND_FAILURE_REASON: str = "Codex Sol xhigh bind failed"
-SOL_REPLY_FAILURE_REASON: str = "Codex Sol xhigh returned no advisor guidance"
+SOL_BIND_FAILURE_REASON: str = "Codex Sol bind failed"
+SOL_REPLY_FAILURE_REASON: str = "Codex Sol returned no advisor guidance"
 SOL_PROBE_TIMEOUT_REASON: str = "Codex Sol meter check timed out"
-SOL_CODEX_TIMEOUT_REASON: str = "Codex Sol xhigh request timed out"
-SOL_MALFORMED_JSONL_REASON: str = "Codex Sol xhigh returned malformed JSONL"
-SOL_MISSING_SESSION_REASON: str = "Codex Sol xhigh returned no session id"
-SOL_INVALID_SIGNAL_REASON: str = "Codex Sol xhigh returned an invalid guidance signal"
-SOL_EXECUTABLE_NOT_FOUND_REASON: str = "Codex Sol xhigh could not find the codex executable on PATH"
+SOL_CODEX_TIMEOUT_REASON: str = "Codex Sol request timed out"
+SOL_MALFORMED_JSONL_REASON: str = "Codex Sol returned malformed JSONL"
+SOL_MISSING_SESSION_REASON: str = "Codex Sol returned no session id"
+SOL_INVALID_SIGNAL_REASON: str = "Codex Sol returned an invalid guidance signal"
+SOL_EXECUTABLE_NOT_FOUND_REASON: str = "Codex Sol could not find the codex executable on PATH"
 SOL_FALLBACK_KIND_DECLINED: str = "declined"
 SOL_FALLBACK_KIND_BROKEN: str = "broken"
 SOL_ENABLE_FLAG: str = "--enable-sol"
+SOL_EFFORT_FLAG: str = "--effort"

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"