claude-dev-env 2.17.0 → 2.19.0

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

@@ -40,46 +40,61 @@ CODEX_BIND_SUCCESS_TOKEN = model_tier_run_validator.CODEX_BIND_SUCCESS_TOKEN
 def test_clean_single_spawn_at_top_of_slice_passes() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable"],
         attempts=[{"tier": "Fable", "result": "spawned"}],
         selected_tier="Fable",
     )
     assert validate_model_tier_run(run) is None
 
 
-def test_sol_codex_bind_is_first_success_when_enabled() -> None:
+def test_sol_codex_bind_succeeds_after_fable_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}],
+        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
+        attempts=[
+            {"tier": "Fable", "result": "unavailable"},
+            {"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:
+def test_fable_success_with_sol_enabled_stops_before_sol() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=[ADVISOR_MODEL_TIER, "Fable", "Opus"],
-        attempts=[
-            {"tier": ADVISOR_MODEL_TIER, "result": "unavailable"},
-            {"tier": "Fable", "result": "spawned"},
-        ],
+        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
+        attempts=[{"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:
+def test_sol_first_walk_raises_when_sol_is_enabled() -> None:
     run = ModelTierRun(
-        own_tier="ThirdParty",
-        candidate_tiers=[ADVISOR_MODEL_TIER, "Fable", "Opus"],
+        own_tier="Opus",
+        candidate_tiers=[ADVISOR_MODEL_TIER, "Fable"],
         attempts=[{"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN}],
         selected_tier=ADVISOR_MODEL_TIER,
         is_sol_enabled=True,
     )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_sol_rung_follows_fable_on_third_party_cli_floor_when_enabled() -> None:
+    run = ModelTierRun(
+        own_tier="ThirdParty",
+        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
+        attempts=[
+            {"tier": "Fable", "result": "unavailable"},
+            {"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
 
@@ -87,7 +102,7 @@ def test_sol_rung_precedes_third_party_cli_floor_when_enabled() -> None:
 def test_sol_codex_result_requires_sol_candidate() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable"],
         attempts=[{"tier": "Fable", "result": CODEX_BIND_SUCCESS_TOKEN}],
         selected_tier="Fable",
     )
@@ -98,8 +113,11 @@ def test_sol_codex_result_requires_sol_candidate() -> None:
 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"}],
+        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
+        attempts=[
+            {"tier": "Fable", "result": "unavailable"},
+            {"tier": ADVISOR_MODEL_TIER, "result": "spawned"},
+        ],
         selected_tier=ADVISOR_MODEL_TIER,
         is_sol_enabled=True,
     )
@@ -107,15 +125,13 @@ def test_sol_spawned_result_does_not_count_as_codex_success() -> None:
         validate_model_tier_run(run)
 
 
-def test_fallthrough_to_floor_tier_passes() -> None:
+def test_exhausted_fable_walk_fails_closed() -> None:
     run = 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": "unavailable"}],
+        selected_tier=None,
+        fallback_reason="Fable did not bind; no advisor",
     )
     assert validate_model_tier_run(run) is None
 
@@ -123,21 +139,18 @@ def test_fallthrough_to_floor_tier_passes() -> None:
 def test_fully_exhausted_walk_with_fallback_reason_passes() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
-        attempts=[
-            {"tier": "Fable", "result": "unavailable"},
-            {"tier": "Opus", "result": "unavailable"},
-        ],
+        candidate_tiers=["Fable"],
+        attempts=[{"tier": "Fable", "result": "unavailable"}],
         selected_tier=None,
-        fallback_reason="every candidate tier failed; CLI fallback took over",
+        fallback_reason="every candidate tier failed",
     )
     assert validate_model_tier_run(run) is None
 
 
-def test_candidate_tiers_shorter_than_ladder_slice_raises() -> None:
+def test_opus_candidate_on_advisor_walk_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable"],
+        candidate_tiers=["Fable", "Opus"],
         attempts=[{"tier": "Fable", "result": "spawned"}],
         selected_tier="Fable",
     )
@@ -148,7 +161,7 @@ def test_candidate_tiers_shorter_than_ladder_slice_raises() -> None:
 def test_attempt_tier_outside_candidate_slice_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable"],
         attempts=[{"tier": "Haiku", "result": "spawned"}],
         selected_tier="Haiku",
     )
@@ -159,12 +172,13 @@ def test_attempt_tier_outside_candidate_slice_raises() -> None:
 def test_attempts_out_of_ladder_order_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
         attempts=[
-            {"tier": "Opus", "result": "unavailable"},
-            {"tier": "Fable", "result": "spawned"},
+            {"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN},
+            {"tier": "Fable", "result": "unavailable"},
         ],
-        selected_tier="Fable",
+        selected_tier=ADVISOR_MODEL_TIER,
+        is_sol_enabled=True,
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
@@ -173,12 +187,13 @@ def test_attempts_out_of_ladder_order_raises() -> None:
 def test_selected_tier_not_first_spawned_attempt_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
         attempts=[
             {"tier": "Fable", "result": "unavailable"},
-            {"tier": "Opus", "result": "spawned"},
+            {"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN},
         ],
         selected_tier="Fable",
+        is_sol_enabled=True,
     )
     with pytest.raises(
         ModelTierRunError,
@@ -193,12 +208,9 @@ def test_selected_tier_not_first_spawned_attempt_raises() -> None:
 def test_exhausted_walk_with_non_null_selected_tier_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
-        attempts=[
-            {"tier": "Fable", "result": "unavailable"},
-            {"tier": "Opus", "result": "unavailable"},
-        ],
-        selected_tier="Opus",
+        candidate_tiers=["Fable"],
+        attempts=[{"tier": "Fable", "result": "unavailable"}],
+        selected_tier="Fable",
         fallback_reason="every candidate tier failed",
     )
     with pytest.raises(ModelTierRunError):
@@ -208,11 +220,8 @@ def test_exhausted_walk_with_non_null_selected_tier_raises() -> None:
 def test_exhausted_walk_missing_fallback_reason_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
-        attempts=[
-            {"tier": "Fable", "result": "unavailable"},
-            {"tier": "Opus", "result": "unavailable"},
-        ],
+        candidate_tiers=["Fable"],
+        attempts=[{"tier": "Fable", "result": "unavailable"}],
         selected_tier=None,
     )
     with pytest.raises(ModelTierRunError):
@@ -233,7 +242,7 @@ def test_unknown_own_tier_raises() -> None:
 def test_empty_attempts_with_null_selected_tier_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable"],
         attempts=[],
         selected_tier=None,
         fallback_reason="skipped straight to CLI fallback",
@@ -242,13 +251,14 @@ def test_empty_attempts_with_null_selected_tier_raises() -> None:
         validate_model_tier_run(run)
 
 
-def test_incomplete_fallback_walk_before_floor_raises() -> None:
+def test_incomplete_fallback_walk_before_sol_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
         attempts=[{"tier": "Fable", "result": "unavailable"}],
         selected_tier=None,
-        fallback_reason="stopped after Fable without trying Opus",
+        fallback_reason="stopped after Fable without trying Sol",
+        is_sol_enabled=True,
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
@@ -257,12 +267,9 @@ def test_incomplete_fallback_walk_before_floor_raises() -> None:
 def test_lowercase_own_tier_and_candidates_pass() -> None:
     run = 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",
     )
     assert validate_model_tier_run(run) is None
 
@@ -273,7 +280,7 @@ def test_cli_validates_json_log_file(tmp_path: Path) -> None:
         json.dumps(
             {
                 "own_tier": "Opus",
-                "candidate_tiers": ["Fable", "Opus"],
+                "candidate_tiers": ["Fable"],
                 "attempts": [{"tier": "Fable", "result": "spawned"}],
                 "selected_tier": "Fable",
             }
@@ -283,6 +290,24 @@ def test_cli_validates_json_log_file(tmp_path: Path) -> None:
     assert main([str(log_path)]) == 0
     loaded_run = load_model_tier_run_from_json_path(from_path=log_path)
     assert loaded_run.selected_tier == "Fable"
+    assert loaded_run.host_profile == "Claude"
+
+
+def test_cli_rejects_non_string_host_profile(tmp_path: Path) -> None:
+    log_path = tmp_path / "invalid-host-profile.json"
+    log_path.write_text(
+        json.dumps(
+            {
+                "own_tier": "Opus",
+                "candidate_tiers": ["Fable"],
+                "attempts": [{"tier": "Fable", "result": "spawned"}],
+                "selected_tier": "Fable",
+                "host_profile": 1,
+            }
+        ),
+        encoding="utf-8",
+    )
+    assert main([str(log_path)]) == 2
 
 
 def test_cli_rejects_non_boolean_sol_enabled(tmp_path: Path) -> None:
@@ -291,7 +316,7 @@ def test_cli_rejects_non_boolean_sol_enabled(tmp_path: Path) -> None:
         json.dumps(
             {
                 "own_tier": "Opus",
-                "candidate_tiers": ["Fable", "Opus"],
+                "candidate_tiers": ["Fable"],
                 "attempts": [{"tier": "Fable", "result": "spawned"}],
                 "selected_tier": "Fable",
                 "sol_enabled": "false",
@@ -308,10 +333,11 @@ def test_cli_rejects_incomplete_fallback_log(tmp_path: Path) -> None:
         json.dumps(
             {
                 "own_tier": "Opus",
-                "candidate_tiers": ["Fable", "Opus"],
+                "candidate_tiers": ["Fable", "Sol"],
                 "attempts": [{"tier": "Fable", "result": "unavailable"}],
                 "selected_tier": None,
                 "fallback_reason": "incomplete",
+                "sol_enabled": True,
             }
         ),
         encoding="utf-8",
@@ -326,14 +352,14 @@ def test_cli_missing_path_returns_usage_exit_code() -> None:
 def test_cli_bind_at_fable_passes() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable"],
         attempts=[{"tier": "Fable", "result": "cli"}],
         selected_tier="Fable",
     )
     assert validate_model_tier_run(run) is None
 
 
-def test_cli_bind_fallthrough_to_opus_passes() -> None:
+def test_cli_bind_fallthrough_to_opus_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
         candidate_tiers=["Fable", "Opus"],
@@ -343,13 +369,14 @@ def test_cli_bind_fallthrough_to_opus_passes() -> None:
         ],
         selected_tier="Opus",
     )
-    assert validate_model_tier_run(run) is None
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
 
 
-def test_third_party_own_tier_maps_to_fable_opus_cli_bind_passes() -> None:
+def test_third_party_own_tier_maps_to_fable_cli_bind_passes() -> None:
     run = ModelTierRun(
         own_tier="ThirdParty",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable"],
         attempts=[{"tier": "Fable", "result": "cli"}],
         selected_tier="Fable",
     )
@@ -359,7 +386,7 @@ def test_third_party_own_tier_maps_to_fable_opus_cli_bind_passes() -> None:
 def test_third_party_own_tier_lowercase_cli_bind_passes() -> None:
     run = ModelTierRun(
         own_tier="thirdparty",
-        candidate_tiers=["fable", "opus"],
+        candidate_tiers=["fable"],
         attempts=[{"tier": "fable", "result": "cli"}],
         selected_tier="fable",
     )
@@ -369,7 +396,7 @@ def test_third_party_own_tier_lowercase_cli_bind_passes() -> None:
 def test_self_token_is_not_bind_success_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable"],
         attempts=[{"tier": "Fable", "result": "self"}],
         selected_tier="Fable",
     )
@@ -380,7 +407,7 @@ def test_self_token_is_not_bind_success_raises() -> None:
 def test_third_party_self_token_is_not_bind_success_raises() -> None:
     run = ModelTierRun(
         own_tier="ThirdParty",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable"],
         attempts=[{"tier": "Fable", "result": "self"}],
         selected_tier="Fable",
     )
@@ -402,11 +429,8 @@ def test_third_party_host_legacy_single_tier_self_bind_raises() -> None:
 def test_third_party_cli_exhausted_fail_closed_passes() -> None:
     run = ModelTierRun(
         own_tier="ThirdParty",
-        candidate_tiers=["Fable", "Opus"],
-        attempts=[
-            {"tier": "Fable", "result": "unavailable"},
-            {"tier": "Opus", "result": "unavailable"},
-        ],
+        candidate_tiers=["Fable"],
+        attempts=[{"tier": "Fable", "result": "unavailable"}],
         selected_tier=None,
         fallback_reason=(
             "third-party host CLI Claude-chain exhausted; fail closed"
@@ -418,11 +442,8 @@ def test_third_party_cli_exhausted_fail_closed_passes() -> None:
 def test_third_party_cli_exhausted_without_fallback_reason_raises() -> None:
     run = ModelTierRun(
         own_tier="ThirdParty",
-        candidate_tiers=["Fable", "Opus"],
-        attempts=[
-            {"tier": "Fable", "result": "unavailable"},
-            {"tier": "Opus", "result": "unavailable"},
-        ],
+        candidate_tiers=["Fable"],
+        attempts=[{"tier": "Fable", "result": "unavailable"}],
         selected_tier=None,
     )
     with pytest.raises(ModelTierRunError):
@@ -432,7 +453,7 @@ def test_third_party_cli_exhausted_without_fallback_reason_raises() -> None:
 def test_third_party_cli_selected_tier_mismatch_raises() -> None:
     run = ModelTierRun(
         own_tier="ThirdParty",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable"],
         attempts=[{"tier": "Fable", "result": "cli"}],
         selected_tier="Opus",
     )
@@ -443,9 +464,77 @@ def test_third_party_cli_selected_tier_mismatch_raises() -> None:
 def test_claude_host_self_token_is_not_spawn_success_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Fable"],
         attempts=[{"tier": "Fable", "result": "self"}],
         selected_tier="Fable",
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
+
+
+def test_codex_host_sol_in_session_spawn_passes() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=[ADVISOR_MODEL_TIER],
+        attempts=[{"tier": ADVISOR_MODEL_TIER, "result": "spawned"}],
+        selected_tier=ADVISOR_MODEL_TIER,
+        host_profile="Codex",
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_codex_host_sol_codex_token_counts_as_success() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=[ADVISOR_MODEL_TIER],
+        attempts=[
+            {"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN}
+        ],
+        selected_tier=ADVISOR_MODEL_TIER,
+        host_profile="Codex",
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_codex_host_fable_then_sol_walk_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
+        attempts=[{"tier": ADVISOR_MODEL_TIER, "result": "spawned"}],
+        selected_tier=ADVISOR_MODEL_TIER,
+        is_sol_enabled=True,
+        host_profile="Codex",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_codex_host_exhausted_sol_fails_closed() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=[ADVISOR_MODEL_TIER],
+        attempts=[{"tier": ADVISOR_MODEL_TIER, "result": "unavailable"}],
+        selected_tier=None,
+        fallback_reason="Codex in-session Sol spawn did not bind",
+        host_profile="Codex",
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_cli_loads_codex_host_profile(tmp_path: Path) -> None:
+    log_path = tmp_path / "codex-host-walk.json"
+    log_path.write_text(
+        json.dumps(
+            {
+                "own_tier": "Opus",
+                "candidate_tiers": ["Sol"],
+                "attempts": [{"tier": "Sol", "result": "spawned"}],
+                "selected_tier": "Sol",
+                "host_profile": "Codex",
+            }
+        ),
+        encoding="utf-8",
+    )
+    assert main([str(log_path)]) == 0
+    loaded_run = load_model_tier_run_from_json_path(from_path=log_path)
+    assert loaded_run.host_profile == "Codex"

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

@@ -20,6 +20,7 @@ from advisor_scripts_constants.model_tier_run_validator_constants import (  # no
     ALL_KNOWN_TIER_NAMES,
     ALL_MODEL_TIERS,
     HOST_PROFILE_CLAUDE,
+    HOST_PROFILE_CODEX,
     HOST_PROFILE_THIRD_PARTY,
     THIRD_PARTY_MODEL_TIER,
 )
@@ -49,6 +50,8 @@ 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
+resolve_session_identity = tier_model_ids.resolve_session_identity
+canonical_host_profile = tier_model_ids.canonical_host_profile
 
 SCRIPTS_ROOT = Path(__file__).parent.parent
 DOCUMENTED_RESOLVE_ONE_LINER = (
@@ -183,6 +186,46 @@ def test_detect_host_profile_rejects_unknown_explicit_value() -> None:
         detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "Titan"})
 
 
+def test_canonical_host_profile_normalizes_known_names() -> None:
+    assert canonical_host_profile("codex") == HOST_PROFILE_CODEX
+    assert canonical_host_profile(" Claude ") == HOST_PROFILE_CLAUDE
+    assert canonical_host_profile("Titan") is None
+    assert canonical_host_profile("") is None
+
+
+def test_detect_host_profile_reads_codex_override() -> None:
+    assert (
+        detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "Codex"})
+        == HOST_PROFILE_CODEX
+    )
+    assert (
+        detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "codex"})
+        == HOST_PROFILE_CODEX
+    )
+
+
+def test_resolve_session_identity_maps_codex_text_to_codex() -> None:
+    assert resolve_session_identity("codex") == HOST_PROFILE_CODEX
+    assert resolve_session_identity("I am Codex") == HOST_PROFILE_CODEX
+    assert resolve_session_identity("Codex CLI") == HOST_PROFILE_CODEX
+
+
+def test_resolve_session_identity_maps_claude_text_to_claude() -> None:
+    assert resolve_session_identity("claude") == HOST_PROFILE_CLAUDE
+    assert resolve_session_identity("Claude Code") == HOST_PROFILE_CLAUDE
+
+
+def test_resolve_session_identity_maps_neither_to_third_party() -> None:
+    assert resolve_session_identity("grok") == HOST_PROFILE_THIRD_PARTY
+    assert resolve_session_identity("cursor") == HOST_PROFILE_THIRD_PARTY
+    assert resolve_session_identity("") == HOST_PROFILE_THIRD_PARTY
+    assert resolve_session_identity("   ") == HOST_PROFILE_THIRD_PARTY
+
+
+def test_resolve_session_identity_prefers_codex_when_both_tokens_appear() -> None:
+    assert resolve_session_identity("claude using Codex") == HOST_PROFILE_CODEX
+
+
 def test_documented_resolve_one_liner_runs_without_prior_path_pollution() -> None:
     clean_environment = {
         each_key: each_value

package/_shared/advisor/scripts/tier_model_ids.py

@@ -12,6 +12,12 @@
     detect_host_profile(
         setting_by_name={"ADVISOR_HOST_PROFILE": "Claude"}
     )  # ok: "Claude"
+    detect_host_profile(
+        setting_by_name={"ADVISOR_HOST_PROFILE": "Codex"}
+    )  # ok: "Codex"
+    resolve_session_identity("I am Codex")  # ok: "Codex"
+    resolve_session_identity("Claude Code")  # ok: "Claude"
+    resolve_session_identity("grok")  # ok: "ThirdParty"
 
 Values are stable short aliases (``opus``, ``sonnet``, ``third-party``), not dated
 full model IDs such as ``claude-opus-4-…``. The map lives in
@@ -25,6 +31,7 @@ Args and returns for the public helpers are documented on each function.
 from __future__ import annotations
 
 import os
+import re
 import sys
 from collections.abc import Mapping
 from pathlib import Path
@@ -43,8 +50,12 @@ from advisor_scripts_constants.model_tier_run_validator_constants import (  # no
     ALL_KNOWN_TIER_NAMES,
     ALL_THIRD_PARTY_TRUTHY_VALUES,
     HOST_PROFILE_CLAUDE,
+    HOST_PROFILE_CODEX,
     HOST_PROFILE_ENV_VAR,
     HOST_PROFILE_THIRD_PARTY,
+    SESSION_IDENTITY_CLAUDE_TOKEN,
+    SESSION_IDENTITY_CODEX_TOKEN,
+    SESSION_IDENTITY_WORD_PATTERN,
     THIRD_PARTY_ENV_VAR,
     UNKNOWN_HOST_PROFILE_ERROR,
     UNKNOWN_LADDER_NAME_ERROR,
@@ -139,6 +150,65 @@ def resolve_codex_model_id(tier: str) -> str:
     return maybe_model_id
 
 
+def canonical_host_profile(host_profile_name: str) -> str | None:
+    """Return the Title Case host profile for ``host_profile_name``, or ``None``.
+
+    ::
+
+        canonical_host_profile("codex")    # ok: "Codex"
+        canonical_host_profile(" Claude ") # ok: "Claude"
+        canonical_host_profile("Titan")    # ok: None
+        canonical_host_profile("")         # ok: None
+
+    Strips leading and trailing whitespace, then matches any letter case
+    against ``ALL_HOST_PROFILES``.
+
+    Args:
+        host_profile_name: Raw host profile text from env, a spawn log, or a
+            caller.
+
+    Returns:
+        The canonical Title Case host profile, or ``None`` when unknown.
+    """
+    stripped_host_profile_name = host_profile_name.strip()
+    if not stripped_host_profile_name:
+        return None
+    host_profile_by_lower_name = {
+        each_profile.lower(): each_profile for each_profile in ALL_HOST_PROFILES
+    }
+    return host_profile_by_lower_name.get(stripped_host_profile_name.lower())
+
+
+def resolve_session_identity(identity_text: str) -> str:
+    """Map a session's self-identified name to an advisor host profile.
+
+    ::
+
+        resolve_session_identity("I am Codex")   # ok: "Codex"
+        resolve_session_identity("Claude Code")  # ok: "Claude"
+        resolve_session_identity("grok")         # ok: "ThirdParty"
+        resolve_session_identity("")             # ok: "ThirdParty"
+
+    Split the text into letter-or-digit tokens. A ``codex`` token selects
+    Codex. A ``claude`` token selects Claude. Any other identity, including
+    empty text, selects ThirdParty. When both tokens appear, Codex wins.
+
+    Args:
+        identity_text: The session's named identity.
+
+    Returns:
+        ``HOST_PROFILE_CODEX``, ``HOST_PROFILE_CLAUDE``, or
+        ``HOST_PROFILE_THIRD_PARTY``.
+    """
+    identity_word_pattern = re.compile(SESSION_IDENTITY_WORD_PATTERN)
+    all_identity_tokens = identity_word_pattern.findall(identity_text.lower())
+    if SESSION_IDENTITY_CODEX_TOKEN in all_identity_tokens:
+        return HOST_PROFILE_CODEX
+    if SESSION_IDENTITY_CLAUDE_TOKEN in all_identity_tokens:
+        return HOST_PROFILE_CLAUDE
+    return HOST_PROFILE_THIRD_PARTY
+
+
 def detect_host_profile(
     setting_by_name: Mapping[str, str] | None = None,
 ) -> str:
@@ -148,6 +218,8 @@ def detect_host_profile(
 
         detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "ThirdParty"})
         # ok: "ThirdParty"
+        detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "Codex"})
+        # ok: "Codex"
         detect_host_profile(setting_by_name={"THIRD_PARTY": "1"})  # ok: "ThirdParty"
         detect_host_profile(setting_by_name={})                   # ok: "Claude"
         detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "X"})
@@ -163,7 +235,8 @@ def detect_host_profile(
         setting_by_name: Env name → setting text (defaults to ``os.environ``).
 
     Returns:
-        ``HOST_PROFILE_THIRD_PARTY`` or ``HOST_PROFILE_CLAUDE``.
+        ``HOST_PROFILE_CODEX``, ``HOST_PROFILE_THIRD_PARTY``, or
+        ``HOST_PROFILE_CLAUDE``.
 
     Raises:
         ValueError: When ``ADVISOR_HOST_PROFILE`` is set to an unknown name.
@@ -175,12 +248,7 @@ def detect_host_profile(
         HOST_PROFILE_ENV_VAR, ""
     ).strip()
     if explicit_host_profile:
-        host_profile_by_lower_name = {
-            each_profile.lower(): each_profile for each_profile in ALL_HOST_PROFILES
-        }
-        maybe_canonical_host = host_profile_by_lower_name.get(
-            explicit_host_profile.lower()
-        )
+        maybe_canonical_host = canonical_host_profile(explicit_host_profile)
         if maybe_canonical_host is None:
             raise ValueError(UNKNOWN_HOST_PROFILE_ERROR.format(explicit_host_profile))
         return maybe_canonical_host