claude-dev-env 8.12.0 → 8.14.0

package/_shared/advisor/scripts/codex_astra_preflight.py

@@ -1,8 +1,7 @@
-"""Evaluate Codex usage before an Astra advisor request."""
+"""Ask the Codex account picker for an account before an Astra advisor request."""
 
 from __future__ import annotations
 
-import importlib
 import json
 import math
 import subprocess
@@ -12,11 +11,13 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from advisor_scripts_constants.astra_advisor_constants import (
+    ACCOUNT_PICKER_CHOOSE_COMMAND,
+    ASTRA_ACCOUNT_PICK_TIMEOUT_REASON,
+    ASTRA_ACCOUNT_PICK_TIMEOUT_SECONDS,
     ASTRA_FALLBACK_KIND_BROKEN,
     ASTRA_FALLBACK_KIND_DECLINED,
     ASTRA_PREFLIGHT_FAILURE_REASON,
-    ASTRA_PROBE_TIMEOUT_REASON,
-    ASTRA_USAGE_PROBE_TIMEOUT_SECONDS,
+    CODEX_TIER_NORMAL,
 )
 
 
@@ -26,6 +27,7 @@ class AstraPreflight:
     percent_left: float | None
     reason: str
     fallback_kind: str | None = None
+    codex_home: Path | None = None
 
 
 def _preflight_fallback(
@@ -34,82 +36,82 @@ def _preflight_fallback(
     return AstraPreflight(False, percent_left, reason, fallback_kind)
 
 
-def _load_usage_gate(probe_path: Path) -> Callable[[float], bool]:
-    probe_directory = str(probe_path.parent)
-    if probe_directory not in sys.path:
-        sys.path.insert(0, probe_directory)
-    return importlib.import_module("codex_usage_probe").is_codex_review_required
+def _broken(detail: str) -> AstraPreflight:
+    return _preflight_fallback(
+        f"{ASTRA_PREFLIGHT_FAILURE_REASON}: {detail}", None, ASTRA_FALLBACK_KIND_BROKEN
+    )
 
 
-def _parse_probe_percent(stdout_text: str) -> tuple[float | None, str | None]:
-    try:
-        report = json.loads(stdout_text)
-    except (TypeError, json.JSONDecodeError):
-        return None, "usage report is malformed"
-    if not isinstance(report, dict):
-        return None, "usage report is malformed"
-    raw_percent = report.get("percent_left")
+def _finite_percent(raw_percent: object) -> float | None:
     if isinstance(raw_percent, bool) or not isinstance(raw_percent, (int, float)):
-        return None, "usage meter is unknown" if raw_percent is None else "usage meter is malformed"
-    percent_left = float(raw_percent)
-    if not math.isfinite(percent_left):
-        return None, "usage meter is malformed"
-    return percent_left, None
-
-
-def _run_probe(
-    probe_path: Path,
+        return None
+    return float(raw_percent) if math.isfinite(raw_percent) else None
+
+
+def _preflight_from_answer(field_by_name: dict[str, object]) -> AstraPreflight:
+    if not isinstance(field_by_name.get("tier"), str):
+        return _broken("picker answer is malformed")
+    if field_by_name["tier"] != CODEX_TIER_NORMAL:
+        reason = f"{ASTRA_PREFLIGHT_FAILURE_REASON}: no Codex account has room ({field_by_name.get('reason')})"
+        return _preflight_fallback(reason, None, ASTRA_FALLBACK_KIND_DECLINED)
+    codex_home = field_by_name.get("codex_home")
+    percent_left = _finite_percent(field_by_name.get("percent_left"))
+    if not isinstance(codex_home, str) or not codex_home or percent_left is None:
+        return _broken("picker answer names no Codex home with room")
+    reason = f"{field_by_name.get('account')} has {percent_left:.0f}% left"
+    return AstraPreflight(True, percent_left, reason, codex_home=Path(codex_home))
+
+
+def _run_picker(
+    picker_path: Path,
     process_runner: Callable[..., subprocess.CompletedProcess[str]],
 ) -> subprocess.CompletedProcess[str]:
     return process_runner(
-        [sys.executable, str(probe_path)],
+        [sys.executable, str(picker_path), ACCOUNT_PICKER_CHOOSE_COMMAND],
         capture_output=True,
         text=True,
         check=False,
         shell=False,
-        timeout=ASTRA_USAGE_PROBE_TIMEOUT_SECONDS,
+        timeout=ASTRA_ACCOUNT_PICK_TIMEOUT_SECONDS,
     )
 
 
-def _preflight_from_probe(
-    probe_path: Path, completed: subprocess.CompletedProcess[str]
-) -> AstraPreflight:
+def _preflight_from_picker(completed: subprocess.CompletedProcess[str]) -> AstraPreflight:
     if completed.returncode != 0:
-        reason = f"{ASTRA_PREFLIGHT_FAILURE_REASON}: probe exit {completed.returncode}"
-        return _preflight_fallback(reason, None, ASTRA_FALLBACK_KIND_BROKEN)
-    percent_left, parse_reason = _parse_probe_percent(completed.stdout)
-    if parse_reason is not None or percent_left is None:
-        reason = f"{ASTRA_PREFLIGHT_FAILURE_REASON}: {parse_reason or 'usage meter is unknown'}"
-        return _preflight_fallback(reason, None, ASTRA_FALLBACK_KIND_BROKEN)
-    if not _load_usage_gate(probe_path)(percent_left):
-        reason = f"{ASTRA_PREFLIGHT_FAILURE_REASON}: usage meter is at or below the gate"
-        return _preflight_fallback(reason, percent_left, ASTRA_FALLBACK_KIND_DECLINED)
-    return AstraPreflight(True, percent_left, "usage meter is above the Astra gate")
+        return _broken(f"picker exit {completed.returncode}")
+    try:
+        answer = json.loads(completed.stdout)
+    except (TypeError, json.JSONDecodeError):
+        return _broken("picker answer is malformed")
+    if not isinstance(answer, dict):
+        return _broken("picker answer is malformed")
+    return _preflight_from_answer(answer)
 
 
 def run_astra_preflight(
-    probe_path: Path,
+    picker_path: Path,
     process_runner: Callable[..., subprocess.CompletedProcess[str]],
 ) -> AstraPreflight:
-    """Run the usage probe and decide whether Astra may bind.
+    """Run the Codex account picker and decide whether Astra may bind.
+
+    ::
+
+        tier normal, codex-2, 62% left  -> eligible, codex_home of codex-2
+        tier luna or wait               -> declined
+        picker exit 1, bad JSON, timeout -> broken
 
     Args:
-        probe_path: Path to the installed usage probe.
-        process_runner: Callable that runs the probe.
+        picker_path: Path to ``codex_account_choice.py``.
+        process_runner: Callable that runs the picker.
 
     Returns:
-        Eligibility, remaining usage percent, reason, and fallback kind.
+        Eligibility, the chosen account's percent left and Codex home, reason, and fallback kind.
     """
     try:
-        completed = _run_probe(probe_path, process_runner)
-        return _preflight_from_probe(probe_path, completed)
+        return _preflight_from_picker(_run_picker(picker_path, process_runner))
     except subprocess.TimeoutExpired as error:
         return _preflight_fallback(
-            f"{ASTRA_PROBE_TIMEOUT_REASON}: {error}", None, ASTRA_FALLBACK_KIND_BROKEN
-        )
-    except (OSError, subprocess.SubprocessError, ImportError, AttributeError, TypeError, ValueError) as error:
-        return _preflight_fallback(
-            f"{ASTRA_PREFLIGHT_FAILURE_REASON}: {error}",
-            None,
-            ASTRA_FALLBACK_KIND_BROKEN,
+            f"{ASTRA_ACCOUNT_PICK_TIMEOUT_REASON}: {error}", None, ASTRA_FALLBACK_KIND_BROKEN
         )
+    except (OSError, subprocess.SubprocessError, TypeError, ValueError) as error:
+        return _broken(str(error))

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

@@ -6,8 +6,8 @@ import json
 from pathlib import Path
 
 ADVISOR_MODEL_TIER: str = "Astra"
-ADVISOR_FALLBACK_TIER: str = "Fable"
-ADVISOR_FALLBACK_RESULT: str = "fable"
+ADVISOR_FALLBACK_TIER: str = "Opus"
+ADVISOR_FALLBACK_RESULT: str = "opus"
 ADVISOR_EFFORT_ENV_VAR: str = "ADVISOR_EFFORT"
 ADVISOR_ROUTING_TIMEOUT_SECONDS: int = 10
 

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

@@ -13,20 +13,20 @@ CODEX_PROMPT_FROM_STDIN: str = "-"
 CODEX_EXEC_SUBCOMMAND: str = "exec"
 CODEX_RESUME_SUBCOMMAND: str = "resume"
 CODEX_SANDBOX_FLAG: str = "--sandbox"
-CLAUDE_CONFIG_DIRECTORY_NAME: str = ".claude"
-USAGE_PROBE_SHARED_DIRECTORY_NAME: str = "_shared"
-USAGE_PROBE_PACKAGE_DIRECTORY_NAME: str = "pr-loop"
-USAGE_PROBE_SCRIPTS_DIRECTORY_NAME: str = "scripts"
-USAGE_PROBE_FILENAME: str = "codex_usage_probe.py"
+CODEX_HOME_ENV_VAR: str = "CODEX_HOME"
+ALL_ACCOUNT_PICKER_RELATIVE_PARTS: tuple[str, ...] = ("scripts", "codex_account_choice.py")
+SHARED_PACKAGE_ROOT_PARENT_INDEX: int = 2
+ACCOUNT_PICKER_CHOOSE_COMMAND: str = "choose"
+CODEX_TIER_NORMAL: str = "normal"
 ASTRA_SESSION_ID_METAVAR: str = "SESSION_ID"
 ASTRA_CODEX_TIMEOUT_SECONDS: float = 120.0
-ASTRA_USAGE_PROBE_TIMEOUT_SECONDS: float = 30.0
+ASTRA_ACCOUNT_PICK_TIMEOUT_SECONDS: float = 150.0
 ASTRA_ENV_VAR: str = "ADVISOR_ASTRA"
 ALL_ASTRA_TRUTHY_VALUES: frozenset[str] = frozenset({"1", "true", "yes", "on"})
-ASTRA_PREFLIGHT_FAILURE_REASON: str = "astra preflight did not establish an eligible Codex meter"
+ASTRA_PREFLIGHT_FAILURE_REASON: str = "astra preflight found no Codex account to bind"
 ASTRA_BIND_FAILURE_REASON: str = "Codex Astra bind failed"
 ASTRA_REPLY_FAILURE_REASON: str = "Codex Astra returned no advisor guidance"
-ASTRA_PROBE_TIMEOUT_REASON: str = "Codex Astra meter check timed out"
+ASTRA_ACCOUNT_PICK_TIMEOUT_REASON: str = "Codex Astra account pick timed out"
 ASTRA_CODEX_TIMEOUT_REASON: str = "Codex Astra request timed out"
 ASTRA_MALFORMED_JSONL_REASON: str = "Codex Astra returned malformed JSONL"
 ASTRA_MISSING_SESSION_REASON: str = "Codex Astra returned no session id"

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

@@ -43,8 +43,8 @@ SESSION_IDENTITY_WORD_PATTERN: str = r"[a-z0-9]+"
 HOST_PROFILE_JSON_KEY: str = "host_profile"
 
 ALL_MODEL_TIERS: tuple[str, ...] = (
+    "Fable",
     ADVISOR_FALLBACK_TIER,
-    "Opus",
     "Sonnet",
     "Haiku",
 )
@@ -58,8 +58,8 @@ ALL_KNOWN_TIER_NAMES: tuple[str, ...] = (
 ADVISOR_SENDMESSAGE_REPLY_WAIT_SECONDS: int = 120
 
 ALL_CLI_MODEL_ID_BY_TIER: dict[str, str] = {
-    ADVISOR_FALLBACK_TIER: "fable",
-    "Opus": "opus",
+    "Fable": "fable",
+    ADVISOR_FALLBACK_TIER: "opus",
     "Sonnet": "sonnet",
     "Haiku": "haiku",
     THIRD_PARTY_MODEL_TIER: "third-party",

package/_shared/advisor/scripts/model_tier_run_validator.py

@@ -7,17 +7,17 @@ This validator reads that log back and checks its invariants.
 
     ladder_walk = 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",
     )
     validate_model_tier_run(ladder_walk)  # ok: returns None, raises nothing
 
     cli_bind = 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",
     )
     validate_model_tier_run(cli_bind)  # ok: third-party-host CLI Claude-chain bind
 
@@ -330,10 +330,9 @@ 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 are Fable, plus Astra when ``is_astra_enabled`` is true, on
+    Candidate tiers are Opus, plus Astra when ``is_astra_enabled`` is true, on
     Claude and ThirdParty hosts. A Codex host walks Astra 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
+    ``own_tier`` is recorded and must be a known tier. Tries walk that list in order. Early stop only
     after ``spawned``, ``cli``, or Astra ``codex`` (and Astra ``spawned`` on a
     Codex host). A null selected_tier requires a full walk plus
     fallback_reason.

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

@@ -31,9 +31,15 @@ def _load_astra_module() -> ModuleType:
 astra_advisor = _load_astra_module()
 
 SCRIPTS_ROOT = Path(__file__).parent.parent
-USAGE_PROBE_PATH = (
-    SCRIPTS_ROOT.parents[1] / "pr-loop" / "scripts" / "codex_usage_probe.py"
-)
+PICKER_PATH = SCRIPTS_ROOT.parents[2] / "scripts" / "codex_account_choice.py"
+PICKED_CODEX_HOME = Path("codex-profiles") / "codex-2"
+NORMAL_ANSWER = {
+    "tier": "normal",
+    "account": "codex-2",
+    "codex_home": str(PICKED_CODEX_HOME),
+    "percent_left": 90,
+    "reason": "codex-2 has 90% left",
+}
 ENABLED_SETTINGS = {astra_advisor.ASTRA_ENV_VAR: "1"}
 
 
@@ -42,9 +48,9 @@ def _codex_on_search_path(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(astra_advisor.shutil, "which", lambda name: "codex")
 
 
-def _probe(payload: object, returncode: int = 0) -> subprocess.CompletedProcess[str]:
+def _pick(payload: object, returncode: int = 0) -> subprocess.CompletedProcess[str]:
     return subprocess.CompletedProcess(
-        [sys.executable, str(USAGE_PROBE_PATH)],
+        [sys.executable, str(PICKER_PATH), "choose"],
         returncode,
         json.dumps(payload),
         "",
@@ -66,14 +72,18 @@ def _events(session_id: str = "thread-1", guidance: str = "PLAN\ninspect") -> st
 
 
 def _two_step_runner(
-    all_calls: list[list[str]], guidance: str = "PLAN\ninspect"
+    all_calls: list[list[str]],
+    guidance: str = "PLAN\ninspect",
+    all_call_keywords: list[dict[str, object]] | None = None,
 ) -> _ProcessRunner:
     def runner(
         arguments: list[str], **kwargs: object
     ) -> subprocess.CompletedProcess[str]:
         all_calls.append(arguments)
+        if all_call_keywords is not None:
+            all_call_keywords.append(kwargs)
         if len(all_calls) == 1:
-            return _probe({"percent_left": 90})
+            return _pick(NORMAL_ANSWER)
         return subprocess.CompletedProcess(arguments, 0, _events(guidance=guidance), "")
     return runner
 
@@ -155,31 +165,63 @@ def test_argument_parser_accepts_astra_and_rejects_sol() -> None:
         parser.parse_args(["--bind", "--cwd", ".", "--enable-sol"])
 
 
-def test_usage_probe_path_uses_supplied_home(tmp_path: Path) -> None:
-    path = astra_advisor.resolve_usage_probe_path(tmp_path)
-    assert path == tmp_path / ".claude" / "_shared" / "pr-loop" / "scripts" / "codex_usage_probe.py"
+def test_account_picker_path_names_the_packaged_picker() -> None:
+    path = astra_advisor.resolve_account_picker_path()
+    assert path == PICKER_PATH.resolve()
+    assert path.is_file()
+
+
+def test_preflight_runs_the_picker_choose_command() -> None:
+    all_calls: list[list[str]] = []
+
+    def runner(arguments: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:
+        all_calls.append(arguments)
+        return _pick(NORMAL_ANSWER)
 
+    astra_advisor.run_astra_preflight(PICKER_PATH, runner)
+    assert all_calls == [[sys.executable, str(PICKER_PATH), "choose"]]
 
-def test_preflight_accepts_meter_above_gate() -> None:
+
+def test_preflight_accepts_the_normal_tier_and_keeps_its_codex_home() -> None:
     preflight = astra_advisor.run_astra_preflight(
-        USAGE_PROBE_PATH, lambda arguments, **kwargs: _probe({"percent_left": 90})
+        PICKER_PATH, lambda arguments, **kwargs: _pick(NORMAL_ANSWER)
     )
     assert preflight.eligible
     assert preflight.percent_left == 90
+    assert preflight.codex_home == PICKED_CODEX_HOME
 
 
-def test_preflight_declines_meter_at_gate() -> None:
+@pytest.mark.parametrize("tier", ["luna", "wait"])
+def test_preflight_declines_a_tier_without_room(tier: str) -> None:
+    answer = {**NORMAL_ANSWER, "tier": tier, "reason": "every account is low"}
     preflight = astra_advisor.run_astra_preflight(
-        USAGE_PROBE_PATH, lambda arguments, **kwargs: _probe({"percent_left": 10})
+        PICKER_PATH, lambda arguments, **kwargs: _pick(answer)
     )
     assert not preflight.eligible
     assert preflight.fallback_kind == astra_advisor.ASTRA_FALLBACK_KIND_DECLINED
+    assert preflight.codex_home is None
 
 
-@pytest.mark.parametrize("payload", [{"percent_left": None}, {"percent_left": "90"}, ["bad"]])
-def test_preflight_rejects_malformed_meter(payload: object) -> None:
+@pytest.mark.parametrize(
+    "payload",
+    [
+        {"tier": None},
+        {**NORMAL_ANSWER, "codex_home": None},
+        {**NORMAL_ANSWER, "percent_left": "90"},
+        ["bad"],
+    ],
+)
+def test_preflight_rejects_a_malformed_answer(payload: object) -> None:
+    preflight = astra_advisor.run_astra_preflight(
+        PICKER_PATH, lambda arguments, **kwargs: _pick(payload)
+    )
+    assert not preflight.eligible
+    assert preflight.fallback_kind == astra_advisor.ASTRA_FALLBACK_KIND_BROKEN
+
+
+def test_preflight_rejects_a_failed_picker() -> None:
     preflight = astra_advisor.run_astra_preflight(
-        USAGE_PROBE_PATH, lambda arguments, **kwargs: _probe(payload)
+        PICKER_PATH, lambda arguments, **kwargs: _pick(NORMAL_ANSWER, returncode=1)
     )
     assert not preflight.eligible
     assert preflight.fallback_kind == astra_advisor.ASTRA_FALLBACK_KIND_BROKEN
@@ -208,17 +250,21 @@ def test_jsonl_parser_falls_back_for_invalid_reply(jsonl_text: str) -> None:
     assert not reply.successful
 
 
-def test_bind_runs_probe_then_codex() -> None:
+def test_bind_runs_picker_then_codex_under_the_chosen_home() -> None:
     calls: list[list[str]] = []
+    all_call_keywords: list[dict[str, object]] = []
     reply = astra_advisor.run_codex_astra_advisor(
         "consult",
         Path("."),
         None,
-        USAGE_PROBE_PATH,
+        PICKER_PATH,
         ENABLED_SETTINGS,
         None,
-        _two_step_runner(calls),
+        _two_step_runner(calls, all_call_keywords=all_call_keywords),
     )
+    codex_environment = all_call_keywords[1]["env"]
+    assert isinstance(codex_environment, dict)
+    assert codex_environment["CODEX_HOME"] == str(PICKED_CODEX_HOME)
     assert reply.successful
     assert reply.selected_tier == "Astra"
     assert reply.outcome == "codex"
@@ -236,7 +282,7 @@ def test_bind_routes_astra_xhigh_to_the_policy_effort() -> None:
         "consult",
         Path("."),
         None,
-        USAGE_PROBE_PATH,
+        PICKER_PATH,
         settings,
         None,
         _two_step_runner(calls),
@@ -263,7 +309,7 @@ def test_disabled_flag_returns_declined_fallback() -> None:
 def test_missing_codex_returns_broken_fallback(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(astra_advisor.shutil, "which", lambda name: None)
     reply = astra_advisor.run_codex_astra_advisor(
-        "consult", Path("."), None, USAGE_PROBE_PATH, ENABLED_SETTINGS, None, subprocess.run
+        "consult", Path("."), None, PICKER_PATH, ENABLED_SETTINGS, None, subprocess.run
     )
     assert reply.is_fallback
     assert reply.fallback_kind == astra_advisor.ASTRA_FALLBACK_KIND_BROKEN
@@ -275,7 +321,7 @@ def test_resume_uses_existing_session() -> None:
         "resume",
         Path("."),
         None,
-        USAGE_PROBE_PATH,
+        PICKER_PATH,
         ENABLED_SETTINGS,
         "thread-1",
         _two_step_runner(calls, "ENDORSE\nready"),

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

@@ -1,4 +1,4 @@
-"""Tests for Codex Astra usage preflight."""
+"""Tests for the Codex Astra account preflight."""
 
 import json
 import subprocess
@@ -12,13 +12,13 @@ sys.path.insert(0, str(SCRIPTS_ROOT))
 from codex_astra_preflight import run_astra_preflight
 
 
-def test_run_astra_preflight_rejects_probe_failure(tmp_path: Path) -> None:
-    probe_path = tmp_path / "codex_usage_probe.py"
+def test_run_astra_preflight_rejects_picker_failure(tmp_path: Path) -> None:
+    picker_path = tmp_path / "codex_account_choice.py"
 
     def process_runner(*args: object, **kwargs: object) -> subprocess.CompletedProcess[str]:
         return subprocess.CompletedProcess([], 1, json.dumps({}), "")
 
-    preflight = run_astra_preflight(probe_path, process_runner)
+    preflight = run_astra_preflight(picker_path, process_runner)
 
     assert not preflight.eligible
     assert preflight.fallback_kind == "broken"