claude-dev-env 8.11.1 → 8.13.0

package/.agents/skills/e-code-review/reference/medium.md

@@ -1,198 +1,14 @@
-`medium effort → 3+5 angles → 1-vote verify`
+`minimal prompt → single careful diff pass → ≤15 findings`
 
-You are reviewing for **precision** at medium effort: assign severity carefully
-so a later consumer can select maintainer-action findings. **Collection
-reports every finding** (including `low` and `nit`); do not drop by
-severity during collection. Severity filtering is a separate consumer stage
-after the collection record is complete.
-
-## Phase 0 — Gather the diff
-
-Run `git diff @{upstream}...HEAD` (or `git diff main...HEAD` / `git diff HEAD~1`
+You are reviewing a pull request for bugs. Run `git diff @{upstream}...HEAD` (or `git diff main...HEAD` / `git diff HEAD~1`
 if there's no upstream) to get the unified diff under review. If there are
 uncommitted changes, or the range diff is empty, also run `git diff HEAD` and
 include the working-tree changes in scope — the review often runs before the
-commit. If a target was passed as an argument, review that target instead. A
-target names one or more items, each a PR number, a branch name, a file path, or
-`default-range` — the diff this phase gathers when no target is passed — and it
-may mix those forms. A loop round widens a target by adding a path to whatever
-it started as, and it names `default-range` as an item whenever the round it
-widened was given no target argument, so the original scope stays under review.
-When a target names more than one item, gather each item's diff and take their
-union — a shared hunk counted once, an empty one adding nothing — as the
-target's diff. Treat this diff as the review scope.
-
-## Phase 1 — Find candidates (3 correctness angles + 3 cleanup angles + 1 altitude angle + 1 conventions angle)
-
-Run **8 independent finder angles** via the Agent tool. Each surfaces
-candidate findings with `file`, `line`, a one-line `summary`, and a concrete
-`failure_scenario`. If the Agent tool is not available in your current tool
-set, do not error — perform each angle (and each verification) yourself,
-sequentially, in this context.
-
-### Angle A — line-by-line diff scan
-
-Read every hunk in the diff, line by line. Then Read the enclosing function for
-each hunk — bugs in unchanged lines of a touched function are in scope (the PR
-re-exposes or fails to fix them). For every line ask: what input, state, timing,
-or platform makes this line wrong? Look for inverted/wrong conditions,
-off-by-one, null/undefined deref, missing `await`, falsy-zero checks,
-wrong-variable copy-paste, error swallowed in catch, unescaped regex metachars.
-
-### Angle B — removed-behavior auditor
-
-For every line the diff DELETES or replaces, name the invariant or behavior it
-enforced, then search the new code for where that invariant is re-established.
-If you can't find it, that's a candidate: a removed guard, a dropped error
-path, a narrowed validation, a deleted test that was covering a case.
-
-### Angle C — cross-file tracer
-
-For each function the diff changes, find its callers (Grep for the symbol) and
-check whether the change breaks any call site: a new precondition, a changed
-return shape, a new exception, a timing/ordering dependency. Also check callees:
-does a parallel change in the same PR make a call unsafe?
-
-### Reuse
-
-The angles above hunt for bugs; this one and the next two hunt for cleanup in
-the changed code. Flag new code that re-implements something the codebase
-already has — Grep shared/utility modules and files adjacent to the change,
-and name the existing helper to call instead.
-
-### Simplification
-
-Flag unnecessary complexity the diff adds: redundant or derivable state,
-copy-paste with slight variation, deep nesting, dead code left behind. Name
-the simpler form that does the same job.
-
-### Efficiency
-
-Flag wasted work the diff introduces: redundant computation or repeated I/O,
-independent operations run sequentially, blocking work added to startup or
-hot paths. Also flag long-lived objects built from closures or captured
-environments — they keep the entire enclosing scope alive for the object's
-lifetime (a memory leak when that scope holds large values); prefer a
-class/struct that copies only the fields it needs. Name the cheaper
-alternative.
-
-### Altitude
-
-Check that each change is implemented at the right depth, not as a fragile
-bandaid. Special cases layered on shared infrastructure are a sign the fix
-isn't deep enough — prefer generalizing the underlying mechanism over adding
-special cases.
-
-### Conventions (CLAUDE.md)
-
-Find the CLAUDE.md files that govern the changed code: the user-level
-~/.claude/CLAUDE.md, the repo-root CLAUDE.md, plus any CLAUDE.md or
-CLAUDE.local.md in a directory that is an ancestor of a changed file (a
-directory's CLAUDE.md only applies to files at or below it). Read each one
-that exists, then check the diff for clear violations of the rules they state.
-
-Only flag a violation when you can quote the exact rule and the exact line
-that breaks it — no style preferences, no vague "spirit of the doc"
-inferences. In the finding, name the CLAUDE.md path and quote the rule so the
-report can cite it. If no CLAUDE.md applies, return nothing for this angle.
-
-Cleanup, altitude, and conventions candidates use the same
-`file`/`line`/`summary` shape; in `failure_scenario`, state the concrete
-cost (what is duplicated, wasted, harder to maintain, or which CLAUDE.md rule
-is broken) instead of a crash. Correctness bugs always outrank cleanup,
-altitude, and conventions findings.
-
-Pass every candidate with a nameable failure scenario through — finders that
-silently drop half-believed candidates bypass the verify step and are the
-dominant cause of misses.
-
-## Phase 2 — Verify (1-vote, 3-state)
-
-Dedup candidates that point at the same line/mechanism, keeping the one with
-the most concrete failure scenario. For each remaining candidate, run **one
-verifier** via the Agent tool: give it the diff, the relevant
-file(s), and the candidate, and have it return exactly one of:
-
-- **CONFIRMED** — can name the inputs/state that trigger it and the wrong
-  output or crash. Quote the line.
-- **PLAUSIBLE** — mechanism is present in the code, trigger is uncertain (timing, env,
-  config). State what would confirm it.
-- **REFUTED** — factually wrong (code doesn't say that) or guarded elsewhere.
-  Quote the line that proves it.
-
-Keep candidates where the vote is CONFIRMED or PLAUSIBLE.
-
-## Output
-
-**Collection stage first.** Keep every CONFIRMED or PLAUSIBLE finding in the
-collection record, including `low` and `nit`. Drop only REFUTED candidates.
-Do not drop a finding because its severity is low.
-
-Report this review's results — `{level, findings}` — through the structured
-findings-report call: the mechanism that renders a review's results as a typed
-list in the host UI, ranked most-severe first. Each **retained** entry carries
-every field below. Do not emit a finding that lacks `severity` or `verdict`.
-
-**Severity filter stage (later consumer).** After the collection record is
-complete, a separate consumer may filter by minimum severity for action or
-display. That filter must not rewrite or discard fields on the collection
-record itself.
-
-| Field | Required | Value |
-|---|---|---|
-| `file` | yes | path under review |
-| `line` | yes | 1-based line number |
-| `summary` | yes | full claim |
-| `short_summary` | yes | claim compressed to ≤60 characters, no rationale or consequence clause |
-| `failure_scenario` | yes | concrete trigger and wrong outcome, or concrete cost for cleanup |
-| `category` | yes | short kebab-case slug for the angle (`correctness`, `simplification`, `efficiency`, `reuse`, `altitude`, `conventions`, or a tighter slug like `test-coverage`) |
-| `severity` | yes | one of `blocker`, `high`, `medium`, `low`, `nit` |
-| `verdict` | yes | `CONFIRMED` or `PLAUSIBLE` from Phase 2 |
-
-**Severity rules.** Assign exactly one token from the frozen set above. Use
-`nit` only when all five hold: the change is localized clarity, formatting, or
-a typo; correctness, security, data, and API behavior stay identical; test
-coverage and operability stay identical; dependencies and rollout stay
-identical; the fix is mechanical and bounded. Any other retained finding is
-`low` or higher. Correctness bugs outrank cleanup, altitude, and conventions.
-
-If nothing survives verification, make that call with an empty array. Do not
-also print the findings as text, and do not create or publish an artifact of
-the review — the structured call is the report.
-
-## Applying fixes (--fix)
-
-The `--fix` flag was passed. Follow `reference\fix.md` (relative
-to this skill's folder) for the exact fix, code-rules-gate, and skip-handling
-behavior — it governs which agent applies each fix, how the code-rules gate
-runs, how a skip is logged, and how outcomes get reported. Do not repeat the
-findings as text; follow that document's reporting rules once fixes land.
-
-When `loop` is also set, skip this section.
-
-## If findings are fixed later
-
-Whenever a reported finding is fixed later in this session — the user asks you
-to fix it, or later work fixes it incidentally — follow `reference\fix.md`'s
-reporting rules again: report the same findings through the structured
-findings-report call, each carrying an `outcome`. Do not repeat the findings
-as text. Make that call immediately after the fixes land, before any prose
-summary; the host UI's per-finding status updates only from that call.
-
-## Looping (`loop`)
+commit. If a PR number, branch name, or file path was passed as an argument,
+review that target instead. Treat this diff as the review scope.
 
-The `loop` arg was passed. Follow `reference\loop.md` (relative to this
-skill's folder) for how to re-run Phases 0–2 and Output repeatedly — including
-its exit condition and re-invocation rules. Schedule no fix pass of your own
-here: when `--fix` is also present, `reference\loop.md`'s gate sequence owns the
-round's fixing and loads `reference\fix.md` for the mechanics. Do not treat a
-single pass through this document as complete while `loop` is active; hand
-control to that document, and do not stop at Output.
+Review the diff as a careful senior engineer would: read every hunk, open the surrounding files for context as needed (Read, Grep, git log/blame/show), and hunt for correctness issues — wrong or inverted conditions, off-by-one, null/undefined dereference, missing `await`, dropped error handling, removed guards or validations, broken callers of changed functions, races. Report failure modes and leave style out; every finding needs a concrete scenario in which the code misbehaves.
 
-That hand-off applies when this document is entered directly. When a loop round
-is already running and has handed this document its target, the round owns the
-loop: end at Output with the findings report and return those findings to
-`reference\loop.md`'s gate sequence, rather than handing control to that
-document again from here.
+When you are done, submit at most 15 findings via the ReportFindings tool, filling its fields as defined — for each: the file path and start line, a severity, and a comment that states the issue and the concrete scenario in which the code misbehaves. Quality over quantity: include every issue you believe is a bug, and nothing you don't.
 
-When `loop` was not passed, skip this section.
+After the tool call, also restate the findings in your final reply — one line each, `file:line — summary` — so they stay visible in sessions that do not render tool output.

package/.agents/skills/e-code-review/reference/xhigh.md

@@ -1,7 +1,7 @@
-`xhigh effort → 5+5 angles → 1-vote verify → sweep`
+`xhigh effort → 10 inline angles → dedup (no verify) → sweep → ≤15 findings`
 
 You are reviewing for **recall** at extra-high effort: catch every bug. At
-this level, catching bugs matters more than avoiding false positives — a
+this level, surface a finding even when it may be a false positive. A
 missed bug ships. Err on the side of surfacing.
 
 ## Phase 0 — Gather the diff
@@ -10,23 +10,15 @@ Run `git diff @{upstream}...HEAD` (or `git diff main...HEAD` / `git diff HEAD~1`
 if there's no upstream) to get the unified diff under review. If there are
 uncommitted changes, or the range diff is empty, also run `git diff HEAD` and
 include the working-tree changes in scope — the review often runs before the
-commit. If a target was passed as an argument, review that target instead. A
-target names one or more items, each a PR number, a branch name, a file path, or
-`default-range` — the diff this phase gathers when no target is passed — and it
-may mix those forms. A loop round widens a target by adding a path to whatever
-it started as, and it names `default-range` as an item whenever the round it
-widened was given no target argument, so the original scope stays under review.
-When a target names more than one item, gather each item's diff and take their
-union — a shared hunk counted once, an empty one adding nothing — as the
-target's diff. Treat this diff as the review scope.
-
-## Phase 1 — Find candidates (5 correctness angles + 3 cleanup angles + 1 altitude angle + 1 conventions angle)
-
-Run **10 independent finder angles** via the Agent tool. Each surfaces
-candidate findings. Do NOT let one angle's conclusions suppress another's — if
-two angles flag the same line for different reasons, record both. If the Agent
-tool is not available in your current tool set, do not error — perform each
-angle (and each verification) yourself, sequentially, in this context.
+commit. If a PR number, branch name, or file path was passed as an argument,
+review that target instead. Treat this diff as the review scope.
+
+## Phase 1 — Find candidates (5 correctness angles + 3 cleanup angles + 1 altitude angle + 1 conventions angle, up to 8 each)
+
+Run **10 independent finder angles** in sequence yourself, in THIS context — do NOT spawn subagents for them. Each
+surfaces **up to 8 candidate findings**. Do NOT let one angle's conclusions
+suppress another's — if two angles flag the same line for different reasons,
+record both.
 
 ### Angle A — line-by-line diff scan
 
@@ -39,10 +31,10 @@ wrong-variable copy-paste, error swallowed in catch, unescaped regex metachars.
 
 ### Angle B — removed-behavior auditor
 
-For every line the diff DELETES or replaces, name the invariant or behavior it
+For every line the diff DELETES or rewrites, name the invariant or behavior it
 enforced, then search the new code for where that invariant is re-established.
 If you can't find it, that's a candidate: a removed guard, a dropped error
-path, a narrowed validation, a deleted test that was covering a case.
+path, a narrowed validation, a deleted test that was covering a live case.
 
 ### Angle C — cross-file tracer
 
@@ -63,7 +55,7 @@ timezone/DST drift; float equality. Flag any instance the diff introduces.
 When the PR adds or modifies a type that wraps another (cache, proxy, decorator,
 adapter): check that every method routes to the wrapped instance and not back
 through a registry/session/global — e.g. a caching provider holding a
-`delegate` field that resolves IDs via `session.get(...)` instead of
+`delegate` field that resolves IDs via `session.get(...)` where it should call
 `delegate.get(...)` will re-enter the cache or recurse. Also check that the
 wrapper forwards all the methods the callers use.
 
@@ -92,10 +84,11 @@ alternative.
 
 ### Altitude
 
-Check that each change is implemented at the right depth, not as a fragile
-bandaid. Special cases layered on shared infrastructure are a sign the fix
-isn't deep enough — prefer generalizing the underlying mechanism over adding
-special cases.
+Check that each change fixes the root cause at the right depth. A fix that
+patches a symptom with a fragile bandaid is a finding. Special cases layered on shared
+infrastructure are a sign the fix isn't deep enough — prefer the simpler, more
+general change to the underlying mechanism over adding special cases, and name
+that change.
 
 ### Conventions (CLAUDE.md)
 
@@ -113,31 +106,16 @@ report can cite it. If no CLAUDE.md applies, return nothing for this angle.
 Cleanup, altitude, and conventions candidates use the same
 `file`/`line`/`summary` shape; in `failure_scenario`, state the concrete
 cost (what is duplicated, wasted, harder to maintain, or which CLAUDE.md rule
-is broken) instead of a crash. Correctness bugs always outrank cleanup,
-altitude, and conventions findings.
-
-## Phase 2 — Verify (1-vote, 3-state)
+is broken) in the place a crash would go. Correctness bugs always outrank cleanup,
+altitude, and conventions findings when the output cap forces a cut.
 
-Dedup candidates that point at the same line/mechanism, keeping the one with
-the most concrete failure scenario. For each remaining candidate, run **one
-verifier** via the Agent tool: give it the diff, the relevant
-file(s), and the candidate, and have it return exactly one of:
+## Phase 2 — Dedup only (no verify)
 
-- **CONFIRMED** — can name the inputs/state that trigger it and the wrong
-  output or crash. Quote the line.
-- **PLAUSIBLE** — mechanism is present in the code, trigger is uncertain (timing, env,
-  config). State what would confirm it.
-- **REFUTED** — factually wrong (code doesn't say that) or guarded elsewhere.
-  Quote the line that proves it.
-
-Keep candidates where the vote is CONFIRMED or PLAUSIBLE.
-
-This is recall mode — a single non-REFUTED vote carries the finding. Do NOT
-drop on uncertainty.
+Pool all candidates. Dedup near-duplicates only (same defect, same location, same reason → keep one). Do NOT run verifiers; do NOT re-judge. Sort by severity. Do NOT drop on uncertainty.
 
 ## Phase 3 — Sweep for gaps
 
-Run **one more finder** as a fresh reviewer who has the verified list. Re-read
+Take one more pass (same context — no subagent) as a fresh reviewer who has the deduplicated list. Re-read
 the diff and enclosing functions looking ONLY for defects not already listed.
 Do not re-derive or re-confirm anything already there — the job is gaps. Focus
 on what the first pass tends to miss: moved/extracted code that dropped a guard
@@ -145,56 +123,34 @@ or anchor; second-tier footguns (dataclass default evaluated once, `hash()`
 non-determinism, lock-scope shrink, predicate methods with side effects);
 setup/teardown asymmetry in tests; config defaults flipped.
 
-Surface additional candidates, each naming a defect not already on the list.
-If nothing new, return an empty sweep — do not pad.
+Surface **up to 8 additional candidates**, each naming a defect not already on
+the list. If nothing new, return nothing from this phase — do not pad.
 
 ## Output
 
-Report this review's results — `{level, findings}` — through the structured
-findings-report call: the mechanism that renders a review's results as a typed
-list in the host UI, ranked most-severe first. Each entry has `file`, `line`,
-`summary`, `short_summary` — the claim compressed to ≤60 characters, no
-rationale or consequence clause — `failure_scenario`, and `category` — a short
-kebab-case slug for the angle that produced it (`correctness`,
-`simplification`, `efficiency`, `reuse`, `altitude`, `conventions`, or a more
-specific slug like `test-coverage` when one fits better) — plus `verdict` when
-a verify pass produced one. If nothing survives verification, make that call
-with an empty array. Do not also print the findings as text, and do not create
-or publish an artifact of the review — the structured call is the report.
-
-## Applying fixes (--fix)
+Target **at least 7 findings**. If fewer findings exist, emit what you have — do not invent to hit the floor.
 
-The `--fix` flag was passed. Follow `reference\fix.md` (relative
-to this skill's folder) for the exact fix, code-rules-gate, and skip-handling
-behavior — it governs which agent applies each fix, how the code-rules gate
-runs, how a skip is logged, and how outcomes get reported. Do not repeat the
-findings as text; follow that document's reporting rules once fixes land.
+Call the ReportFindings tool once to report this review's results
+with `{level, findings}`. `findings` is at most 15 entries ranked
+most-severe first; each entry has `file`, `line`, `summary`,
+`short_summary` — the claim compressed to ≤60 characters, no rationale
+or consequence clause — `failure_scenario`, and `category` — a short kebab-case slug for the angle
+that produced it (`correctness`, `simplification`, `efficiency`,
+`reuse`, `altitude`, `conventions`, or a more specific slug like
+`test-coverage` when one fits better) — plus `verdict` when a verify pass
+produced one. If more than 15 survive, keep the 15 most severe. If
+nothing survives, call it with an empty array. Do not also print
+the findings as text, and do not create or publish an artifact of the review -
+the tool call is the report.
 
-When `loop` is also set, skip this section.
 
 ## If findings are fixed later
 
-Whenever a reported finding is fixed later in this session — the user asks you
-to fix it, or later work fixes it incidentally — follow `reference\fix.md`'s
-reporting rules again: report the same findings through the structured
-findings-report call, each carrying an `outcome`. Do not repeat the findings
-as text. Make that call immediately after the fixes land, before any prose
-summary; the host UI's per-finding status updates only from that call.
-
-## Looping (`loop`)
-
-The `loop` arg was passed. Follow `reference\loop.md` (relative to this
-skill's folder) for how to re-run Phases 0–3 and Output repeatedly — including
-its exit condition and re-invocation rules. Schedule no fix pass of your own
-here: when `--fix` is also present, `reference\loop.md`'s gate sequence owns the
-round's fixing and loads `reference\fix.md` for the mechanics. Do not treat a
-single pass through this document as complete while `loop` is active; hand
-control to that document, and do not stop at Output.
-
-That hand-off applies when this document is entered directly. When a loop round
-is already running and has handed this document its target, the round owns the
-loop: end at Output with the findings report and return those findings to
-`reference\loop.md`'s gate sequence, rather than handing control to that
-document again from here.
-
-When `loop` was not passed, skip this section.
+Whenever reported findings get fixed later in this session - the user asks you
+to fix them, or later work fixes them incidentally - you MUST call ReportFindings again with the same findings, each
+carrying an `outcome`: `fixed`, `no_change_needed` (the finding was wrong or
+already handled), or `skipped` (valid but not applied). Do not repeat the
+findings as text.
+Make that call immediately after the fixes land, before any prose summary; the
+host UI's per-finding status updates only from it, and without it the findings
+stay marked unresolved.

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.