claude-dev-env 8.12.0 → 8.14.0

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

@@ -218,19 +218,19 @@ def test_non_object_evidence_reports_the_same_message_at_validate_and_load(
 def test_clean_single_spawn_at_top_of_slice_passes() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable"],
-        attempts=[{"tier": "Fable", "result": "spawned"}],
-        selected_tier="Fable",
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": "spawned"}],
+        selected_tier="Opus",
     )
     assert validate_model_tier_run(run) is None
 
 
-def test_astra_codex_bind_succeeds_after_fable_when_enabled() -> None:
+def test_astra_codex_bind_succeeds_after_opus_when_enabled() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
+        candidate_tiers=["Opus", ADVISOR_MODEL_TIER],
         attempts=[
-            {"tier": "Fable", "result": "unavailable"},
+            {"tier": "Opus", "result": "unavailable"},
             {"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN},
         ],
         selected_tier=ADVISOR_MODEL_TIER,
@@ -239,12 +239,12 @@ def test_astra_codex_bind_succeeds_after_fable_when_enabled() -> None:
     assert validate_model_tier_run(run) is None
 
 
-def test_fable_success_with_astra_enabled_stops_before_astra() -> None:
+def test_opus_success_with_astra_enabled_stops_before_astra() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
-        attempts=[{"tier": "Fable", "result": "spawned"}],
-        selected_tier="Fable",
+        candidate_tiers=["Opus", ADVISOR_MODEL_TIER],
+        attempts=[{"tier": "Opus", "result": "spawned"}],
+        selected_tier="Opus",
         is_astra_enabled=True,
     )
     assert validate_model_tier_run(run) is None
@@ -253,7 +253,7 @@ def test_fable_success_with_astra_enabled_stops_before_astra() -> None:
 def test_astra_first_walk_raises_when_astra_is_enabled() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=[ADVISOR_MODEL_TIER, "Fable"],
+        candidate_tiers=[ADVISOR_MODEL_TIER, "Opus"],
         attempts=[{"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN}],
         selected_tier=ADVISOR_MODEL_TIER,
         is_astra_enabled=True,
@@ -262,12 +262,12 @@ def test_astra_first_walk_raises_when_astra_is_enabled() -> None:
         validate_model_tier_run(run)
 
 
-def test_astra_rung_follows_fable_on_third_party_cli_floor_when_enabled() -> None:
+def test_astra_rung_follows_opus_on_third_party_cli_floor_when_enabled() -> None:
     run = ModelTierRun(
         own_tier="ThirdParty",
-        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
+        candidate_tiers=["Opus", ADVISOR_MODEL_TIER],
         attempts=[
-            {"tier": "Fable", "result": "unavailable"},
+            {"tier": "Opus", "result": "unavailable"},
             {"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN},
         ],
         selected_tier=ADVISOR_MODEL_TIER,
@@ -281,9 +281,9 @@ def test_astra_rung_follows_fable_on_third_party_cli_floor_when_enabled() -> Non
 def test_astra_codex_result_requires_astra_candidate() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable"],
-        attempts=[{"tier": "Fable", "result": CODEX_BIND_SUCCESS_TOKEN}],
-        selected_tier="Fable",
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": CODEX_BIND_SUCCESS_TOKEN}],
+        selected_tier="Opus",
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
@@ -292,9 +292,9 @@ def test_astra_codex_result_requires_astra_candidate() -> None:
 def test_astra_spawned_result_does_not_count_as_codex_success() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
+        candidate_tiers=["Opus", ADVISOR_MODEL_TIER],
         attempts=[
-            {"tier": "Fable", "result": "unavailable"},
+            {"tier": "Opus", "result": "unavailable"},
             {"tier": ADVISOR_MODEL_TIER, "result": "spawned"},
         ],
         selected_tier=ADVISOR_MODEL_TIER,
@@ -304,13 +304,13 @@ def test_astra_spawned_result_does_not_count_as_codex_success() -> None:
         validate_model_tier_run(run)
 
 
-def test_exhausted_fable_walk_fails_closed() -> None:
+def test_exhausted_opus_walk_fails_closed() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable"],
-        attempts=[{"tier": "Fable", "result": "unavailable"}],
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": "unavailable"}],
         selected_tier=None,
-        fallback_reason="Fable did not bind; no advisor",
+        fallback_reason="Opus did not bind; no advisor",
     )
     assert validate_model_tier_run(run) is None
 
@@ -318,8 +318,8 @@ def test_exhausted_fable_walk_fails_closed() -> None:
 def test_fully_exhausted_walk_with_fallback_reason_passes() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable"],
-        attempts=[{"tier": "Fable", "result": "unavailable"}],
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": "unavailable"}],
         selected_tier=None,
         fallback_reason="every candidate tier failed",
     )
@@ -329,9 +329,9 @@ def test_fully_exhausted_walk_with_fallback_reason_passes() -> None:
 def test_opus_candidate_on_advisor_walk_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
-        attempts=[{"tier": "Fable", "result": "spawned"}],
-        selected_tier="Fable",
+        candidate_tiers=["Opus", "Opus"],
+        attempts=[{"tier": "Opus", "result": "spawned"}],
+        selected_tier="Opus",
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
@@ -340,7 +340,7 @@ def test_opus_candidate_on_advisor_walk_raises() -> None:
 def test_attempt_tier_outside_candidate_slice_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable"],
+        candidate_tiers=["Opus"],
         attempts=[{"tier": "Haiku", "result": "spawned"}],
         selected_tier="Haiku",
     )
@@ -351,10 +351,10 @@ 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", ADVISOR_MODEL_TIER],
+        candidate_tiers=["Opus", ADVISOR_MODEL_TIER],
         attempts=[
             {"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN},
-            {"tier": "Fable", "result": "unavailable"},
+            {"tier": "Opus", "result": "unavailable"},
         ],
         selected_tier=ADVISOR_MODEL_TIER,
         is_astra_enabled=True,
@@ -366,12 +366,12 @@ 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", ADVISOR_MODEL_TIER],
+        candidate_tiers=["Opus", ADVISOR_MODEL_TIER],
         attempts=[
-            {"tier": "Fable", "result": "unavailable"},
+            {"tier": "Opus", "result": "unavailable"},
             {"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN},
         ],
-        selected_tier="Fable",
+        selected_tier="Opus",
         is_astra_enabled=True,
     )
     with pytest.raises(
@@ -387,9 +387,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"],
-        attempts=[{"tier": "Fable", "result": "unavailable"}],
-        selected_tier="Fable",
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": "unavailable"}],
+        selected_tier="Opus",
         fallback_reason="every candidate tier failed",
     )
     with pytest.raises(ModelTierRunError):
@@ -399,8 +399,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"],
-        attempts=[{"tier": "Fable", "result": "unavailable"}],
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": "unavailable"}],
         selected_tier=None,
     )
     with pytest.raises(ModelTierRunError):
@@ -421,7 +421,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"],
+        candidate_tiers=["Opus"],
         attempts=[],
         selected_tier=None,
         fallback_reason="skipped straight to CLI fallback",
@@ -433,10 +433,10 @@ def test_empty_attempts_with_null_selected_tier_raises() -> None:
 def test_incomplete_fallback_walk_before_astra_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
-        attempts=[{"tier": "Fable", "result": "unavailable"}],
+        candidate_tiers=["Opus", ADVISOR_MODEL_TIER],
+        attempts=[{"tier": "Opus", "result": "unavailable"}],
         selected_tier=None,
-        fallback_reason="stopped after Fable without trying Astra",
+        fallback_reason="stopped after Opus without trying Astra",
         is_astra_enabled=True,
     )
     with pytest.raises(ModelTierRunError):
@@ -446,9 +446,9 @@ def test_incomplete_fallback_walk_before_astra_raises() -> None:
 def test_lowercase_own_tier_and_candidates_pass() -> None:
     run = ModelTierRun(
         own_tier="opus",
-        candidate_tiers=["fable"],
-        attempts=[{"tier": "fable", "result": "spawned"}],
-        selected_tier="fable",
+        candidate_tiers=["opus"],
+        attempts=[{"tier": "opus", "result": "spawned"}],
+        selected_tier="opus",
     )
     assert validate_model_tier_run(run) is None
 
@@ -459,16 +459,16 @@ def test_cli_validates_json_log_file(tmp_path: Path) -> None:
         json.dumps(
             {
                 "own_tier": "Opus",
-                "candidate_tiers": ["Fable"],
-                "attempts": [{"tier": "Fable", "result": "spawned"}],
-                "selected_tier": "Fable",
+                "candidate_tiers": ["Opus"],
+                "attempts": [{"tier": "Opus", "result": "spawned"}],
+                "selected_tier": "Opus",
             }
         ),
         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.selected_tier == "Fable"
+    assert loaded_run.selected_tier == "Opus"
     assert loaded_run.host_profile == "Claude"
 
 
@@ -478,9 +478,9 @@ def test_cli_rejects_non_string_host_profile(tmp_path: Path) -> None:
         json.dumps(
             {
                 "own_tier": "Opus",
-                "candidate_tiers": ["Fable"],
-                "attempts": [{"tier": "Fable", "result": "spawned"}],
-                "selected_tier": "Fable",
+                "candidate_tiers": ["Opus"],
+                "attempts": [{"tier": "Opus", "result": "spawned"}],
+                "selected_tier": "Opus",
                 "host_profile": 1,
             }
         ),
@@ -495,9 +495,9 @@ def test_cli_rejects_non_boolean_astra_enabled(tmp_path: Path) -> None:
         json.dumps(
             {
                 "own_tier": "Opus",
-                "candidate_tiers": ["Fable"],
-                "attempts": [{"tier": "Fable", "result": "spawned"}],
-                "selected_tier": "Fable",
+                "candidate_tiers": ["Opus"],
+                "attempts": [{"tier": "Opus", "result": "spawned"}],
+                "selected_tier": "Opus",
                 "astra_enabled": "false",
             }
         ),
@@ -512,8 +512,8 @@ def test_cli_rejects_incomplete_fallback_log(tmp_path: Path) -> None:
         json.dumps(
             {
                 "own_tier": "Opus",
-                "candidate_tiers": ["Fable", "Astra"],
-                "attempts": [{"tier": "Fable", "result": "unavailable"}],
+                "candidate_tiers": ["Opus", "Astra"],
+                "attempts": [{"tier": "Opus", "result": "unavailable"}],
                 "selected_tier": None,
                 "fallback_reason": "incomplete",
                 "astra_enabled": True,
@@ -531,9 +531,9 @@ def test_cli_loads_astra_enabled_fallback_walk(tmp_path: Path) -> None:
             {
                 "own_tier": "ThirdParty",
                 "host_profile": "ThirdParty",
-                "candidate_tiers": ["Fable", "Astra"],
+                "candidate_tiers": ["Opus", "Astra"],
                 "attempts": [
-                    {"tier": "Fable", "result": "unavailable"},
+                    {"tier": "Opus", "result": "unavailable"},
                     {"tier": "Astra", "result": "codex"},
                 ],
                 "selected_tier": "Astra",
@@ -552,12 +552,12 @@ def test_cli_missing_path_returns_usage_exit_code() -> None:
     assert main([]) == 2
 
 
-def test_cli_bind_at_fable_passes() -> None:
+def test_cli_bind_at_opus_passes() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable"],
-        attempts=[{"tier": "Fable", "result": "cli"}],
-        selected_tier="Fable",
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": "cli"}],
+        selected_tier="Opus",
     )
     assert validate_model_tier_run(run) is None
 
@@ -565,9 +565,9 @@ def test_cli_bind_at_fable_passes() -> None:
 def test_cli_bind_fallthrough_to_opus_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", "Opus"],
+        candidate_tiers=["Opus", "Opus"],
         attempts=[
-            {"tier": "Fable", "result": "unavailable"},
+            {"tier": "Opus", "result": "unavailable"},
             {"tier": "Opus", "result": "cli"},
         ],
         selected_tier="Opus",
@@ -576,12 +576,12 @@ def test_cli_bind_fallthrough_to_opus_raises() -> None:
         validate_model_tier_run(run)
 
 
-def test_third_party_own_tier_maps_to_fable_cli_bind_passes() -> None:
+def test_third_party_own_tier_maps_to_opus_cli_bind_passes() -> None:
     run = ModelTierRun(
         own_tier="ThirdParty",
-        candidate_tiers=["Fable"],
-        attempts=[{"tier": "Fable", "result": "cli"}],
-        selected_tier="Fable",
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": "cli"}],
+        selected_tier="Opus",
     )
     assert validate_model_tier_run(run) is None
 
@@ -589,9 +589,9 @@ def test_third_party_own_tier_maps_to_fable_cli_bind_passes() -> None:
 def test_third_party_own_tier_lowercase_cli_bind_passes() -> None:
     run = ModelTierRun(
         own_tier="thirdparty",
-        candidate_tiers=["fable"],
-        attempts=[{"tier": "fable", "result": "cli"}],
-        selected_tier="fable",
+        candidate_tiers=["opus"],
+        attempts=[{"tier": "opus", "result": "cli"}],
+        selected_tier="opus",
     )
     assert validate_model_tier_run(run) is None
 
@@ -599,9 +599,9 @@ 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"],
-        attempts=[{"tier": "Fable", "result": "self"}],
-        selected_tier="Fable",
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": "self"}],
+        selected_tier="Opus",
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
@@ -610,9 +610,9 @@ 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"],
-        attempts=[{"tier": "Fable", "result": "self"}],
-        selected_tier="Fable",
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": "self"}],
+        selected_tier="Opus",
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
@@ -632,8 +632,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"],
-        attempts=[{"tier": "Fable", "result": "unavailable"}],
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": "unavailable"}],
         selected_tier=None,
         fallback_reason=(
             "third-party host CLI Claude-chain exhausted; fail closed"
@@ -645,8 +645,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"],
-        attempts=[{"tier": "Fable", "result": "unavailable"}],
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": "unavailable"}],
         selected_tier=None,
     )
     with pytest.raises(ModelTierRunError):
@@ -656,9 +656,9 @@ 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"],
-        attempts=[{"tier": "Fable", "result": "cli"}],
-        selected_tier="Opus",
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": "cli"}],
+        selected_tier="Sonnet",
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
@@ -667,9 +667,9 @@ 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"],
-        attempts=[{"tier": "Fable", "result": "self"}],
-        selected_tier="Fable",
+        candidate_tiers=["Opus"],
+        attempts=[{"tier": "Opus", "result": "self"}],
+        selected_tier="Opus",
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
@@ -699,10 +699,10 @@ def test_codex_host_astra_codex_token_counts_as_success() -> None:
     assert validate_model_tier_run(run) is None
 
 
-def test_codex_host_fable_then_astra_walk_raises() -> None:
+def test_codex_host_opus_then_astra_walk_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
-        candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
+        candidate_tiers=["Opus", ADVISOR_MODEL_TIER],
         attempts=[{"tier": ADVISOR_MODEL_TIER, "result": "spawned"}],
         selected_tier=ADVISOR_MODEL_TIER,
         is_astra_enabled=True,

package/_shared/pr-loop/scripts/check_convergence.py

@@ -29,9 +29,10 @@ The frozen process env is only a fallback when that disk read fails (logged once
 A probe error does not waive the gate; the live GitHub checks still run.
 
 The Codex gate is conditional-required: it demands
-``codex_clean_at == current_head`` only when the weekly usage probe reports
-more than the probe's threshold percent left. At or below that threshold, null
-usage, the codex token, or ``codex_down`` never blocks ready.
+``codex_clean_at == current_head`` only when the Codex account picker
+(``scripts/codex_account_choice.py choose``) answers the ``normal`` tier, so
+one signed-in account has room for a review. A ``luna`` or ``wait`` answer, an
+unreadable picker, the codex token, or ``codex_down`` never blocks ready.
 """
 
 from __future__ import annotations
@@ -62,13 +63,12 @@ from check_convergence_thread_gates import (
     _check_no_pending_reviews,
     _count_unresolved_bot_threads,
 )
-from codex_review_scripts_constants.codex_usage_probe_constants import (
-    USAGE_REPORT_KEY_PERCENT_LEFT,
-)
-from codex_usage_probe import is_codex_review_required, probe_weekly_usage_via_subprocess
 from pr_converge_scripts_constants.convergence_gate_constants import (
+    ALL_CODEX_ACCOUNT_PICKER_RELATIVE_PARTS,
     BUGBOT_DOWN_BYPASS_NOTE,
     CLAUDE_JOB_DIR_ENV_VAR_NAME,
+    CODEX_ACCOUNT_PICK_TIMEOUT_SECONDS,
+    CODEX_ACCOUNT_PICKER_CHOOSE_COMMAND,
     CODEX_BYPASS_DETAIL,
     CODEX_CLEAN_AT_STATE_KEY,
     CODEX_CLEAN_DETAIL_TEMPLATE,
@@ -76,11 +76,13 @@ from pr_converge_scripts_constants.convergence_gate_constants import (
     CODEX_GATE_LABEL,
     CODEX_MISSING_CLEAN_DETAIL_TEMPLATE,
     CODEX_SKIPPED_USAGE_DETAIL,
+    CODEX_TIER_KEY,
+    CODEX_TIER_NORMAL,
     COPILOT_DOWN_BYPASS_NOTE,
     FIXTURE_DEFAULT_PENDING_DETAIL,
     FIXTURE_DEFAULT_THREADS_DETAIL,
     FIXTURE_KEY_CODEX_CLEAN_AT,
-    FIXTURE_KEY_CODEX_PERCENT_LEFT,
+    FIXTURE_KEY_CODEX_TIER,
     FIXTURE_KEY_HEAD_SHA,
     FIXTURE_KEY_PENDING_REVIEWS_DETAIL,
     FIXTURE_KEY_PENDING_REVIEWS_PASSED,
@@ -90,6 +92,7 @@ from pr_converge_scripts_constants.convergence_gate_constants import (
     FIXTURE_KEY_UNRESOLVED_BOT_THREADS_PASSED,
     MINIMUM_ABBREVIATED_SHA_LENGTH,
     PR_CONVERGE_STATE_FILENAME,
+    SHARED_PACKAGE_ROOT_PARENT_INDEX,
 )
 from pr_converge_skill_constants.constants import (
     ALL_COPILOT_CLEAN_REVIEW_STATES,
@@ -128,7 +131,7 @@ class ConvergenceFixture(NamedTuple):
     unresolved_bot_threads_detail: str
     is_no_pending_reviews: bool
     pending_reviews_detail: str
-    codex_percent_left: float | None
+    codex_tier: str | None
     codex_clean_at: str | None
 
 
@@ -333,24 +336,24 @@ def _sha_matches_head(stamp_sha: str, head_sha: str) -> bool:
 
 def _evaluate_codex_clean(
     *,
-    read_percent_left: Callable[[], float | None],
+    read_codex_tier: Callable[[], str | None],
     codex_clean_at: str | None,
     head_sha: str,
 ) -> tuple[bool, str]:
-    """Return whether the conditional Codex gate passes for the given stamp and usage.
+    """Return whether the conditional Codex gate passes for the given stamp and account tier.
 
     ::
 
-        clean stamp on head                -> pass  (usage never read)
-        no stamp, percent None or <= limit -> skip  (never blocks)
-        no stamp, percent > limit          -> fail
+        clean stamp on head                  -> pass  (picker never runs)
+        no stamp, tier luna, wait, or None   -> skip  (never blocks)
+        no stamp, tier normal                -> fail
 
-    A stamp on the current HEAD settles the gate on its own, so the usage read
-    stays behind it: the weekly probe spawns a Codex subprocess, and the common
-    already-clean tick has no reason to pay for one.
+    A stamp on the current HEAD settles the gate on its own, so the picker
+    stays behind it: the picker starts one Codex app server per account, and
+    the common already-clean tick has no reason to pay for them.
 
     Args:
-        read_percent_left: Reads weekly Codex percent remaining, or None when unknown.
+        read_codex_tier: Returns the picker's tier, or None when the picker cannot say.
         codex_clean_at: HEAD SHA where Codex last reported clean, or None.
         head_sha: Current PR HEAD commit SHA.
 
@@ -359,32 +362,38 @@ def _evaluate_codex_clean(
     """
     if codex_clean_at is not None and _sha_matches_head(codex_clean_at, head_sha):
         return True, CODEX_CLEAN_DETAIL_TEMPLATE % _short_sha(head_sha)
-    if not is_codex_review_required(read_percent_left()):
+    if read_codex_tier() != CODEX_TIER_NORMAL:
         return True, CODEX_SKIPPED_USAGE_DETAIL
     return False, CODEX_MISSING_CLEAN_DETAIL_TEMPLATE % _short_sha(head_sha)
 
 
-def _probe_codex_percent_left() -> float | None:
-    """Probe weekly Codex usage and return percent remaining, or None when unknown."""
+def _codex_account_picker_path() -> Path:
+    """Return the installed Codex account picker beside this shared tree."""
+    shared_root = Path(__file__).resolve().parents[SHARED_PACKAGE_ROOT_PARENT_INDEX]
+    return shared_root.joinpath(*ALL_CODEX_ACCOUNT_PICKER_RELATIVE_PARTS)
+
+
+def _read_codex_tier() -> str | None:
+    """Ask the Codex account picker which tier a review runs on, or None when it cannot say."""
     try:
-        usage_report = probe_weekly_usage_via_subprocess()
-    except (
-        FileNotFoundError,
-        OSError,
-        subprocess.TimeoutExpired,
-        subprocess.SubprocessError,
-        json.JSONDecodeError,
-        ValueError,
-        TypeError,
-        KeyError,
-    ):
+        completed = subprocess.run(
+            [
+                sys.executable,
+                str(_codex_account_picker_path()),
+                CODEX_ACCOUNT_PICKER_CHOOSE_COMMAND,
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=CODEX_ACCOUNT_PICK_TIMEOUT_SECONDS,
+        )
+        answer = json.loads(completed.stdout)
+    except (OSError, subprocess.SubprocessError, json.JSONDecodeError):
         return None
-    raw_percent = usage_report.get(USAGE_REPORT_KEY_PERCENT_LEFT)
-    if isinstance(raw_percent, bool):
+    if completed.returncode != 0 or not isinstance(answer, dict):
         return None
-    if isinstance(raw_percent, (int, float)):
-        return float(raw_percent)
-    return None
+    tier = answer.get(CODEX_TIER_KEY)
+    return tier if isinstance(tier, str) else None
 
 
 def _read_job_state() -> dict[str, object]:
@@ -468,11 +477,11 @@ def _codex_condition(context: GateContext) -> GateCondition:
     if context.is_codex_down:
         return (CODEX_GATE_LABEL, (True, CODEX_BYPASS_DETAIL))
     if context.fixture is not None:
-        fixture_percent_left = context.fixture.codex_percent_left
+        fixture_codex_tier = context.fixture.codex_tier
         return (
             CODEX_GATE_LABEL,
             _evaluate_codex_clean(
-                read_percent_left=lambda: fixture_percent_left,
+                read_codex_tier=lambda: fixture_codex_tier,
                 codex_clean_at=context.fixture.codex_clean_at,
                 head_sha=context.head_sha,
             ),
@@ -480,7 +489,7 @@ def _codex_condition(context: GateContext) -> GateCondition:
     return (
         CODEX_GATE_LABEL,
         _evaluate_codex_clean(
-            read_percent_left=_probe_codex_percent_left,
+            read_codex_tier=_read_codex_tier,
             codex_clean_at=context.live_codex_clean_at,
             head_sha=context.head_sha,
         ),
@@ -623,17 +632,13 @@ def _load_convergence_fixture(from_path: Path) -> ConvergenceFixture:
         raise ValueError("fixture pending_reviews_passed must be a bool")
     if not isinstance(pending_detail, str):
         raise ValueError("fixture pending_reviews_detail must be a string")
-    codex_percent_left = payload.get(FIXTURE_KEY_CODEX_PERCENT_LEFT)
+    codex_tier = payload.get(FIXTURE_KEY_CODEX_TIER)
     codex_clean_at = payload.get(FIXTURE_KEY_CODEX_CLEAN_AT)
-    if isinstance(codex_percent_left, bool):
-        raise ValueError("fixture codex_percent_left must be a number or null")
-    if codex_percent_left is not None and not isinstance(codex_percent_left, (int, float)):
-        raise ValueError("fixture codex_percent_left must be a number or null")
+    if codex_tier is not None and not isinstance(codex_tier, str):
+        raise ValueError("fixture codex_tier must be a string or null")
     if codex_clean_at is not None and not isinstance(codex_clean_at, str):
         raise ValueError("fixture codex_clean_at must be a string or null")
-    typed_percent_left: float | None = (
-        float(codex_percent_left) if isinstance(codex_percent_left, (int, float)) else None
-    )
+    typed_codex_tier: str | None = codex_tier if isinstance(codex_tier, str) else None
     typed_codex_clean_at: str | None = codex_clean_at if isinstance(codex_clean_at, str) else None
     return ConvergenceFixture(
         head_sha=head_sha,
@@ -643,7 +648,7 @@ def _load_convergence_fixture(from_path: Path) -> ConvergenceFixture:
         unresolved_bot_threads_detail=threads_detail,
         is_no_pending_reviews=is_pending_ok,
         pending_reviews_detail=pending_detail,
-        codex_percent_left=typed_percent_left,
+        codex_tier=typed_codex_tier,
         codex_clean_at=typed_codex_clean_at,
     )
 

package/_shared/pr-loop/scripts/codex_review_scripts_constants/run_constants.py

@@ -3,6 +3,10 @@
 from __future__ import annotations
 
 CODEX_BINARY_NAME = "codex"
+WINDOWS_OS_NAME = "nt"
+WINDOWS_COMMAND_SHELL = "cmd"
+WINDOWS_COMMAND_SHELL_RUN_FLAG = "/c"
+ALL_WINDOWS_SCRIPT_SUFFIXES = (".cmd", ".bat")
 EXEC_SUBCOMMAND = "exec"
 REVIEW_SUBCOMMAND = "review"
 HELP_FLAG = "--help"