claude-dev-env 8.11.1 → 8.13.0

package/_shared/advisor/scripts/codex_astra_advisor.py

@@ -30,6 +30,7 @@ from advisor_scripts_constants.advisor_route_constants import (
 )
 from advisor_scripts_constants.astra_advisor_constants import (
     ADVISOR_CODEX_EXECUTABLE_ENV_VAR,
+    ALL_ACCOUNT_PICKER_RELATIVE_PARTS,
     ALL_ASTRA_TRUTHY_VALUES,
     ASTRA_BIND_FAILURE_REASON,
     ASTRA_CODEX_TIMEOUT_REASON,
@@ -41,10 +42,10 @@ from advisor_scripts_constants.astra_advisor_constants import (
     ASTRA_FALLBACK_KIND_BROKEN,
     ASTRA_FALLBACK_KIND_DECLINED,
     ASTRA_SESSION_ID_METAVAR,
-    CLAUDE_CONFIG_DIRECTORY_NAME,
     CODEX_CONFIG_FLAG,
     CODEX_EXEC_SUBCOMMAND,
     CODEX_EXECUTABLE,
+    CODEX_HOME_ENV_VAR,
     CODEX_JSON_FLAG,
     CODEX_MODEL_FLAG,
     CODEX_PROMPT_FROM_STDIN,
@@ -52,10 +53,7 @@ from advisor_scripts_constants.astra_advisor_constants import (
     CODEX_REASONING_CONFIG_TEMPLATE,
     CODEX_RESUME_SUBCOMMAND,
     CODEX_SANDBOX_FLAG,
-    USAGE_PROBE_FILENAME,
-    USAGE_PROBE_PACKAGE_DIRECTORY_NAME,
-    USAGE_PROBE_SCRIPTS_DIRECTORY_NAME,
-    USAGE_PROBE_SHARED_DIRECTORY_NAME,
+    SHARED_PACKAGE_ROOT_PARENT_INDEX,
 )
 from codex_astra_preflight import AstraPreflight, run_astra_preflight
 from codex_astra_reply import (
@@ -176,23 +174,18 @@ def resolve_advisor_effort(all_settings: Mapping[str, str] | None) -> str:
     return resolve_advisor_pair(all_settings, None)[1]
 
 
-def resolve_usage_probe_path(home_directory: Path) -> Path:
-    """Return the Codex usage-probe path under home_directory.
+def resolve_account_picker_path() -> Path:
+    """Return the Codex account picker in the scripts directory beside this shared tree.
 
-    Args:
-        home_directory: Home directory that holds the installed probe.
+    ::
+
+        ~/.claude/_shared/advisor/scripts  ->  ~/.claude/scripts/codex_account_choice.py
 
     Returns:
-        Path to the usage probe under that home.
+        Path to ``codex_account_choice.py``.
     """
-    return (
-        home_directory
-        / CLAUDE_CONFIG_DIRECTORY_NAME
-        / USAGE_PROBE_SHARED_DIRECTORY_NAME
-        / USAGE_PROBE_PACKAGE_DIRECTORY_NAME
-        / USAGE_PROBE_SCRIPTS_DIRECTORY_NAME
-        / USAGE_PROBE_FILENAME
-    )
+    shared_root = _scripts_directory.parents[SHARED_PACKAGE_ROOT_PARENT_INDEX]
+    return shared_root.joinpath(*ALL_ACCOUNT_PICKER_RELATIVE_PARTS)
 
 
 def resolve_codex_executable(all_settings: Mapping[str, str] | None) -> str | None:
@@ -244,21 +237,28 @@ def build_codex_arguments(
 
 def _resolve_preflight(
     preflight: AstraPreflight | None,
-    probe_path: Path | None,
+    picker_path: Path | None,
     process_runner: Callable[..., subprocess.CompletedProcess[str]],
 ) -> AstraPreflight:
     if preflight is not None:
         return preflight
-    resolved_path = resolve_usage_probe_path(Path.home()) if probe_path is None else probe_path
+    resolved_path = resolve_account_picker_path() if picker_path is None else picker_path
     return run_astra_preflight(resolved_path, process_runner)
 
 
+def _codex_environment(codex_home: Path | None) -> dict[str, str] | None:
+    if codex_home is None:
+        return None
+    return {**os.environ, CODEX_HOME_ENV_VAR: str(codex_home)}
+
+
 def _run_codex(
     prompt: str,
     working_directory: Path,
     session_id: str | None,
     all_settings: Mapping[str, str] | None,
     executable: str,
+    codex_home: Path | None,
     process_runner: Callable[..., subprocess.CompletedProcess[str]],
 ) -> subprocess.CompletedProcess[str]:
     model_id, effort = resolve_advisor_pair(all_settings, None)
@@ -270,6 +270,7 @@ def _run_codex(
             model_id=model_id,
         ),
         cwd=str(working_directory),
+        env=_codex_environment(codex_home),
         input=prompt,
         capture_output=True,
         text=True,
@@ -292,7 +293,13 @@ def _run_enabled_advisor(
         return build_fallback_reply(resolved_preflight.reason, True, resolved_preflight.fallback_kind)
     try:
         completed = _run_codex(
-            prompt, working_directory, session_id, setting_by_name, executable, process_runner
+            prompt,
+            working_directory,
+            session_id,
+            setting_by_name,
+            executable,
+            resolved_preflight.codex_home,
+            process_runner,
         )
     except subprocess.TimeoutExpired as error:
         return build_fallback_reply(
@@ -324,7 +331,7 @@ def run_codex_astra_advisor(
     prompt: str,
     working_directory: Path,
     preflight: AstraPreflight | None,
-    probe_path: Path | None,
+    picker_path: Path | None,
     setting_by_name: Mapping[str, str] | None,
     session_id: str | None,
     process_runner: Callable[..., subprocess.CompletedProcess[str]],
@@ -334,11 +341,11 @@ def run_codex_astra_advisor(
     Args:
         prompt: Advisor prompt text.
         working_directory: Working directory for Codex.
-        preflight: Usage probe result, or None to run the probe.
-        probe_path: Usage-probe path, or None for the installed path.
+        preflight: Account picker result, or None to run the picker.
+        picker_path: Account picker path, or None for the one beside this shared tree.
         setting_by_name: Environment mapping, or None to read os.environ.
         session_id: Session to resume, or None for a new bind.
-        process_runner: Callable that runs the probe and Codex.
+        process_runner: Callable that runs the picker and Codex.
 
     Returns:
         Advisor reply, or a fallback.
@@ -348,7 +355,7 @@ def run_codex_astra_advisor(
     executable = resolve_codex_executable(setting_by_name)
     if executable is None:
         return build_fallback_reply(ASTRA_EXECUTABLE_NOT_FOUND_REASON, True)
-    resolved_preflight = _resolve_preflight(preflight, probe_path, process_runner)
+    resolved_preflight = _resolve_preflight(preflight, picker_path, process_runner)
     return _run_enabled_advisor(prompt, working_directory, setting_by_name, session_id, executable, resolved_preflight, process_runner)
 
 

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/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/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"