claude-dev-env 8.12.0 → 8.13.0

package/.agents/skills/pull-request/scripts/test_pull_request.py

@@ -22,7 +22,7 @@ import pull_request
 REPOSITORY = "jl-cmd/claude-dev-env"
 PR_NUMBER = "2518"
 PR_TITLE = "feat(skills): add guarded pull request publication"
-ACCOUNT_A = "JonEcho"
+ACCOUNT_A = "octocat"
 ACCOUNT_B = "ReviewBot"
 BODY_FILENAME = "pull-request-body.md"
 LINTER_PATH = _SCRIPTS_DIRECTORY.parents[3] / "scripts/durable_post_lint.py"

package/.agents/skills-archived/pr-converge/scripts/test_check_convergence.py

@@ -135,7 +135,7 @@ def should_pass_when_clean_bugteam_review_present_on_current_head(
         check_convergence, "_gh_api_paginated", _make_stub_gh_paginated(reviews_payload)
     )
     passed, detail = check_convergence._check_bugteam_clean(
-        owner="JonEcho", repo="tests", number=42, head_sha=CURRENT_HEAD_SHA
+        owner="octocat", repo="tests", number=42, head_sha=CURRENT_HEAD_SHA
     )
     assert passed is True
     assert "clean bugteam audit" in detail
@@ -157,7 +157,7 @@ def should_fail_when_dirty_bugteam_review_present_on_current_head(
         check_convergence, "_gh_api_paginated", _make_stub_gh_paginated(reviews_payload)
     )
     passed, detail = check_convergence._check_bugteam_clean(
-        owner="JonEcho", repo="tests", number=42, head_sha=CURRENT_HEAD_SHA
+        owner="octocat", repo="tests", number=42, head_sha=CURRENT_HEAD_SHA
     )
     assert passed is False
     assert "dirty bugteam audit" in detail
@@ -185,7 +185,7 @@ def should_fail_when_no_bugteam_review_present_on_current_head(
         check_convergence, "_gh_api_paginated", _make_stub_gh_paginated(reviews_payload)
     )
     passed, detail = check_convergence._check_bugteam_clean(
-        owner="JonEcho", repo="tests", number=42, head_sha=CURRENT_HEAD_SHA
+        owner="octocat", repo="tests", number=42, head_sha=CURRENT_HEAD_SHA
     )
     assert passed is False
     assert "no bugteam review found" in detail
@@ -204,7 +204,7 @@ def should_fail_with_shape_detail_when_gh_returns_non_list_payload(
         check_convergence, "_gh_api_paginated", stub_gh_api_paginated_returning_object
     )
     passed, detail = check_convergence._check_bugteam_clean(
-        owner="JonEcho", repo="tests", number=42, head_sha=CURRENT_HEAD_SHA
+        owner="octocat", repo="tests", number=42, head_sha=CURRENT_HEAD_SHA
     )
     assert passed is False
     assert "unexpected gh api response shape" in detail

package/_shared/advisor/reference/astra-rung.md

@@ -14,26 +14,26 @@ A Windows `setx` write only updates the persisted user environment; only a proce
 
 `ADVISOR_EFFORT` selects Codex `model_reasoning_effort` for Astra: `low`, `medium`, `high`, `xhigh`, or `max`. The policy default is `medium`, which sends `model_reasoning_effort="medium"`. Astra Xhigh and Max requests route to Medium. Pass `--effort <level>` on the helper to set effort for that Astra run without changing the environment. An unset value uses the policy default. An unknown value blocks advisor routing.
 
-Every fallback reply carries a `fallback_kind` field. `declined` means policy closed the rung (flag off, usage meter at or below the gate). `broken` means the Astra path itself failed (missing executable, spawn error, timeout, malformed reply). A `broken` fallback is a defect to report.
+Every fallback reply carries a `fallback_kind` field. `declined` means policy closed the rung (flag off, or the account picker named no Codex account on the `normal` tier). `broken` means the Astra path itself failed (missing executable, spawn error, timeout, malformed reply). A `broken` fallback is a defect to report.
 
 ## Preflight
 
-Flag on: run the Codex preflight first.
+Flag on: the helper asks the Codex account picker for an account first.
 
 ```
-python ~/.claude/_shared/pr-loop/scripts/codex_usage_probe.py
+python ~/.claude/scripts/codex_account_choice.py choose
 ```
 
-**GOTCHA. Probe path.** That installed path is the only one. `codex_astra_advisor.resolve_usage_probe_path` builds `~/.claude/_shared/pr-loop/scripts/codex_usage_probe.py` and stops. Do not hunt `skills/codex-review/`, Codex worktrees under `C:\dev\.codex\worktrees\`, or other copies. Repo home: `packages/claude-dev-env/_shared/pr-loop/scripts/`.
+**GOTCHA. Picker path.** `codex_astra_advisor.resolve_account_picker_path` builds the picker path from the helper's own location: two directories above `_shared/advisor/scripts`, then `scripts/codex_account_choice.py`. Installed, that is `~/.claude/scripts/codex_account_choice.py`. Do not hunt other copies. Repo home: `packages/claude-dev-env/scripts/`. The accounts, their order, and sign-in steps are in [`codex-accounts.md`](../../../docs/codex-accounts.md).
 
-The shared entry point is `~/.claude/_shared/advisor/scripts/codex_astra_advisor.py`. It calls the installed probe and owns Astra bind or resume parsing. Bind with `python ~/.claude/_shared/advisor/scripts/codex_astra_advisor.py --bind --enable-astra --cwd <repo-root>` and pipe the charter on stdin. Resume with `--resume <session_id>` and pipe the delta consult on stdin.
+The shared entry point is `~/.claude/_shared/advisor/scripts/codex_astra_advisor.py`. It runs the picker and owns Astra bind or resume parsing. Bind with `python ~/.claude/_shared/advisor/scripts/codex_astra_advisor.py --bind --enable-astra --cwd <repo-root>` and pipe the charter on stdin. Resume with `--resume <session_id>` and pipe the delta consult on stdin.
 
-The gate passes only when the probe exits 0, `percent_left` is finite numeric data, and `percent_left` is strictly greater than `WEEKLY_USAGE_GATE_THRESHOLD_PERCENT` from the existing probe. The exact-threshold case fails closed when Fable did not bind.
+The gate passes only when the picker exits 0 and answers `tier: normal` with a `codex_home` and a finite `percent_left`. The helper then runs Codex with `CODEX_HOME` set to that `codex_home`. A `luna` or `wait` answer fails closed when Fable did not bind.
 
 ## Branches
 
 **Preflight pass.** Bind one Codex CLI session at `gpt-6-astra` with `model_reasoning_effort` set from the policy-selected `ADVISOR_EFFORT` value, `--sandbox read-only`, and JSON output. The helper receives the standing-reviewer charter on stdin and returns only parsed ENDORSE / CORRECTION / PLAN / STOP guidance with a session ID.
 
-**Preflight fail.** Probe failure, non-zero exit, timeout, missing or malformed usage, `null`, non-finite usage, or usage at or below the threshold fails closed when Fable did not bind.
+**Preflight fail.** A picker failure, non-zero exit, timeout, malformed answer, or a `luna` or `wait` tier fails closed when Fable did not bind.
 
 The helper owns the Astra attempt and returns an explicit fallback result. The consuming advisor path owns the Fable bind. Apply the same gate to every Astra attempt, including resume.

package/_shared/advisor/reference/third-party-bind.md

@@ -5,13 +5,13 @@ Open this when binding or re-binding the advisor from a third-party (non-Claude,
 
 ## GOTCHA: Cursor Astra first shot
 
-Cursor is a third-party host. When the walk reaches Astra (`ADVISOR_ASTRA=1` / `--enable-astra` after Fable is out of usage, or the user asks for Astra), bind Astra on the **first** tool call through the headless Codex helper. Do not use the Agent or Task tool, do not spawn Grok as a substitute, and do not search the filesystem for `codex_usage_probe.py`.
+Cursor is a third-party host. When the walk reaches Astra (`ADVISOR_ASTRA=1` / `--enable-astra` after Fable is out of usage, or the user asks for Astra), bind Astra on the **first** tool call through the headless Codex helper. Do not use the Agent or Task tool, do not spawn Grok as a substitute, and do not search the filesystem for the Codex account picker.
 
 ```
 python "$HOME/.claude/_shared/advisor/scripts/codex_astra_advisor.py" --bind --enable-astra --cwd <repo-root>
 ```
 
-Pipe the standing-reviewer charter on stdin. Persist `session_id` from the JSON reply. Later consults: `--resume <session_id>` with the delta on stdin. Capture helper / `codex` stdout as UTF-8 on Windows (`encoding="utf-8"`, `errors="replace"`). Probe path and preflight: [`astra-rung.md`](astra-rung.md).
+Pipe the standing-reviewer charter on stdin. Persist `session_id` from the JSON reply. Later consults: `--resume <session_id>` with the delta on stdin. Capture helper / `codex` stdout as UTF-8 on Windows (`encoding="utf-8"`, `errors="replace"`). Picker path and preflight: [`astra-rung.md`](astra-rung.md).
 
 When the Astra flag is off, follow the Claude-chain steps below.
 

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"