claude-dev-env 8.13.0 → 8.14.0

package/.agents/skills/team-advisor/SKILL.md

@@ -24,7 +24,7 @@ One warm advisor at the strongest tier this session can reach. This session is t
 ## Bind
 
 1. Name the session identity first (protocol **Host profiles**), then walk the model floor.
-2. Claude: when `advisor` is in this session's tool list, the built-in advisor tool is the advisor. Spawn nothing and call `advisor()` at each consult point. Otherwise spawn or resume `pstack:poteto-agent` at `ADVISOR_EFFORT` (default low) with the advisor response contract in the prompt. When the bound model is out of usage, use the configured fallback at the same effort. Codex: use the native advisor path. Third-party: use the headless advisor path. When the host's walk fails, fail closed.
+2. Claude: when `advisor` is in this session's tool list, the built-in advisor tool is the advisor. Spawn nothing and call `advisor()` at each consult point. Otherwise spawn or resume `pstack:poteto-agent` at `ADVISOR_EFFORT` (default xhigh) with the advisor response contract in the prompt. When the bound model is out of usage, use the configured fallback at the same effort. Codex: use the native advisor path. Third-party: use the headless advisor path. When the host's walk fails, fail closed.
 3. Name the warm instance `team-advisor-agent` and keep its advisor response contract in every first prompt. When a native Codex subagent spawn is the advisor path and the spawn tool has a `flags` field, pass `flags: ["--advisor"]` with Astra and record `advisor_flag: passed`. A spawn that skips an offered flag is a failed bind. When the spawn tool has no `flags` field, as in `codex exec`, spawn `gpt-6-astra` plainly, record `advisor_flag: unavailable`, and treat it as bound.
 4. Skip the multi-consumer "who you are" opener. This session is the sole consumer.
 5. When the bind or reply path fails, fail closed and report to the user. On a third-party host, only the bound advisor issues ENDORSE / CORRECTION / PLAN / STOP.

package/_shared/advisor/advisor-protocol.md

@@ -18,10 +18,10 @@ The sections below hold the standing rules. Open a reference file at the moment
 | Moment | Open |
 |---|---|
 | Naming the session identity | [`reference/identity.md`](reference/identity.md): Claude, Codex, or neither |
-| Binding on a Claude host | [`reference/warm-up.md`](reference/warm-up.md): spawn fields, Fable token, charter |
+| Binding on a Claude host | [`reference/warm-up.md`](reference/warm-up.md): spawn fields, Opus token, charter |
 | Binding on a Codex host | [`reference/identity.md`](reference/identity.md): in-session Astra spawn |
 | Binding from a third-party host | [`reference/third-party-bind.md`](reference/third-party-bind.md): CLI bind steps, fail-closed rule |
-| Fable is out of usage | [`reference/astra-rung.md`](reference/astra-rung.md): Astra fallback at shared effort |
+| Opus is out of usage | [`reference/astra-rung.md`](reference/astra-rung.md): Astra fallback at shared effort |
 | Composing a consult | [`reference/consult-format.md`](reference/consult-format.md): packet, new-evidence and report-back rules |
 | Assembling an executor spawn prompt | [`reference/advisor-block.md`](reference/advisor-block.md): the paste parts |
 | Advisor drifts, dies, or the task pivots | [`reference/lifecycle.md`](reference/lifecycle.md): re-spawn and re-bind steps |
@@ -47,25 +47,25 @@ Mechanical override for scripts:
 
 ### Shared effort, any host
 
-Fable and Astra both read `ADVISOR_EFFORT` (`low`, `medium`, `high`, `xhigh`, `max`). Fable keeps its low default. Astra uses the policy default, Medium.
+Opus and Astra both read `ADVISOR_EFFORT` (`low`, `medium`, `high`, `xhigh`, `max`). Opus keeps its xhigh default. Astra uses the policy default, Medium.
 Pass `--effort <level>` on the Astra helper to set effort for that Astra run.
-Pass `--effort <level>` on the Claude CLI bind for Fable. An unset or unrecognized Fable value uses `low`.
+Pass `--effort <level>` on the Claude CLI bind for Opus. An unset or unrecognized Opus value uses `xhigh`.
 
 ### Astra rung
 
-On Claude and ThirdParty: when Fable is out of usage, bind Astra through the Codex helper.
+On Claude and ThirdParty: when Opus is out of usage, bind Astra through the Codex helper.
 Open that attempt with `ADVISOR_ASTRA=1` (or `true` / `yes` / `on`) in the environment, or pass `--enable-astra` on the helper invocation.
-Flag off both ways: fail closed when Fable did not bind.
-Flag on: run the Codex preflight and bind per [`reference/astra-rung.md`](reference/astra-rung.md); a failed preflight fails closed when Fable did not bind.
+Flag off both ways: fail closed when Opus did not bind.
+Flag on: run the Codex preflight and bind per [`reference/astra-rung.md`](reference/astra-rung.md); a failed preflight fails closed when Opus did not bind.
 
 On Codex: Astra is the in-session default. The `ADVISOR_ASTRA` flag is not required. Fail closed when that spawn does not bind.
 
 ### Claude host
 
-When `advisor` is in the session's tool list, the built-in advisor tool is the advisor. The user turns it on with `/advisor`, the `advisorModel` setting, or `--advisor`. Spawn nothing and call `advisor()` at each consult point. The tool forwards the whole transcript, so a consult needs no packet. Its reply is free text, so the four signal words do not apply; weigh it per `docs/references/advisor-tool.md` **How to treat advice**. It is a server tool, so hooks and the spawn-walk log do not see it. A Fable or Opus 5 advisor returns an encrypted result that a log cannot read. When a readable record matters, use the warm agent below.
+When `advisor` is in the session's tool list, the built-in advisor tool is the advisor. The user turns it on with `/advisor`, the `advisorModel` setting, or `--advisor`. Spawn nothing and call `advisor()` at each consult point. The tool forwards the whole transcript, so a consult needs no packet. Its reply is free text, so the four signal words do not apply; weigh it per `docs/references/advisor-tool.md` **How to treat advice**. It is a server tool, so hooks and the spawn-walk log do not see it. An Opus advisor returns an encrypted result that a log cannot read. When a readable record matters, use the warm agent below.
 
-When `advisor` is not in the tool list, use the **Model floor** ladder below (Fable first, then Astra when Fable is out of usage).
-Warm-up spawns `subagent_type: session-advisor` via the Agent tool for Fable; consults go through `SendMessage` to that warm agent. Astra uses the Codex helper.
+When `advisor` is not in the tool list, use the **Model floor** ladder below (Opus first, then Astra when Opus is out of usage).
+Warm-up spawns `subagent_type: session-advisor` via the Agent tool for Opus; consults go through `SendMessage` to that warm agent. Astra uses the Codex helper.
 Assemble and paste each executor's Advisor block per the **Advisor block** section.
 
 ### Codex host
@@ -73,14 +73,14 @@ Assemble and paste each executor's Advisor block per the **Advisor block** secti
 Spawn a native in-session Astra subagent at `resolve_codex_model_id("Astra")`.
 Walk `candidate_tiers = ["Astra"]`. Record `{tier: "Astra", result: "spawned"}` on success.
 **Fail closed:** when Astra does not bind, set `selected_tier = null` and a `fallback_reason`, report that the advisor is unreachable, and **stop**.
-Do not walk Fable on a Codex host. Consults stay in-session with that Astra subagent.
+Do not walk Opus on a Codex host. Consults stay in-session with that Astra subagent.
 Assemble and paste each executor's Advisor block per the **Advisor block** section.
 
 ### Third-party host
 
-On a third-party (non-Claude, non-Codex) harness, the shared CLI Claude-chain is the one path to a Claude advisor: bind Fable through it, per [`reference/third-party-bind.md`](reference/third-party-bind.md).
+On a third-party (non-Claude, non-Codex) harness, the shared CLI Claude-chain is the one path to a Claude advisor: bind Opus through it, per [`reference/third-party-bind.md`](reference/third-party-bind.md).
 The bound Claude session is the advisor; this third-party session stays the executor.
-Walk `candidate_tiers = ["Fable"]`. When Fable is out of usage, the Astra rung binds after Fable (`candidate_tiers = ["Fable", "Astra"]`).
+Walk `candidate_tiers = ["Opus"]`. When Opus is out of usage, the Astra rung binds after Opus (`candidate_tiers = ["Opus", "Astra"]`).
 **Cursor Astra first shot:** when the walk reaches Astra (or the user asks for Astra), bind through `codex_astra_advisor.py --bind --enable-astra` on the first tool call (see the GOTCHA in [`reference/third-party-bind.md`](reference/third-party-bind.md)). Do not use the Agent tool, and do not hunt a probe path.
 **Fail closed:** when every candidate fails, set `selected_tier = null` and a `fallback_reason`, report that the advisor is unreachable, and **stop**. ENDORSE / CORRECTION / PLAN / STOP come only from a bound advisor.
 Executors report to the orchestrating session; that session consults the bound advisor and relays the four-signal reply.
@@ -88,26 +88,26 @@ Executors report to the orchestrating session; that session consults the bound a
 ## Model floor
 
 The built-in advisor tool sits outside this ladder. Claude Code and the API accept it only when the advisor is at least as capable as the main model, and that check is its floor.
-On Claude and ThirdParty the advisor ladder is `Fable` first, then Astra (flag-gated, Codex CLI) when Fable is out of usage.
+On Claude and ThirdParty the advisor ladder is `Opus` first, then Astra (flag-gated, Codex CLI) when Opus is out of usage.
 On Codex the walk is Astra only, in-session.
 Opus is not an advisor candidate. `Sonnet` and `Haiku` are executor tiers only.
 Consumer `own_tier` is recorded on the spawn-walk log; it does not add Opus to the advisor walk.
 Tier names are canonical Title Case; the validator accepts any letter case and normalizes to Title Case.
-Try binds top-down. Fable resolves to the short model alias in [`reference/cli-chain.md`](reference/cli-chain.md); Astra resolves through `resolve_codex_model_id("Astra")` to `gpt-6-astra`.
+Try binds top-down. Opus resolves to the short model alias in [`reference/cli-chain.md`](reference/cli-chain.md); Astra resolves through `resolve_codex_model_id("Astra")` to `gpt-6-astra`.
 The advisor is created at `selected_tier`, the first ladder tier that binds.
-When Fable fails on a Claude host, try Astra if the flag is on, else fail closed. The CLI chain is the Fable bind path on a third-party host and the Claude-host fallback for Fable; it does not bind Opus as advisor.
+When Opus fails on a Claude host, try Astra if the flag is on, else fail closed. The CLI chain is the Opus bind path on a third-party host and the Claude-host fallback for Opus.
 On a Codex host a failed Astra spawn fails closed per **Host profiles → Codex host**.
-On a third-party host the CLI chain is already the primary path, so a failed Fable (and Astra, when enabled) walk fails closed per **Host profiles → Third-party host**.
+On a third-party host the CLI chain is already the primary path, so a failed Opus (and Astra, when enabled) walk fails closed per **Host profiles → Third-party host**.
 
 Emit a structured spawn-walk log so the walk can be checked mechanically: [`reference/spawn-walk-log.md`](reference/spawn-walk-log.md).
 The validator checks ladder shape only; host policy sits on top.
 
-**Equal-tier pairings.** Bind Fable for an independent second pass on irreversible or security-sensitive work. The advisor is Fable or Astra.
+**Equal-tier pairings.** Bind Opus for an independent second pass on irreversible or security-sensitive work. The advisor is Opus or Astra.
 
 ## Warm-up (once per session)
 
 On a **Claude host** with `advisor` in the tool list, skip the warm-up; the built-in tool needs none.
-On a **Claude host** without it, spawn `session-advisor` at the Fable alias with the charter as its prompt. When Fable is out of usage and the Astra rung is open, bind Astra through the Codex helper instead.
+On a **Claude host** without it, spawn `session-advisor` at the Opus alias with the charter as its prompt. When Opus is out of usage and the Astra rung is open, bind Astra through the Codex helper instead.
 Full spawn fields and the charter template: [`reference/warm-up.md`](reference/warm-up.md).
 
 On a **Codex host**, spawn a native in-session Astra subagent with the same charter. Bind fields: [`reference/identity.md`](reference/identity.md) and [`reference/warm-up.md`](reference/warm-up.md).

package/_shared/advisor/reference/advisor-block.md

@@ -26,7 +26,7 @@ Subagents inherit the session's advisor tool, so the executor calls it directly.
 ## Transport preamble for a third-party host
 
 > The orchestrating session owns a standing advisor for this run.
-> The advisor chain: Claude Fable, then Astra through the Codex CLI when Fable is out of usage and the Astra flag and its preflight open that rung. Fable uses its low default. Astra uses the policy default, Medium. When neither binds, there is no advisor.
+> The advisor chain: Claude Opus, then Astra through the Codex CLI when Opus is out of usage and the Astra flag and its preflight open that rung. Opus uses its xhigh default. Astra uses the policy default, Medium. When neither binds, there is no advisor.
 > The orchestrating session is your one path to it: send each consult as a report to the session that assigned you, and it relays the advisor's reply.
 
 ## Shared core for every host

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

@@ -1,13 +1,13 @@
 # Astra rung
 
 Detail behind the **Host profiles → Astra rung** section of [`advisor-protocol.md`](../advisor-protocol.md).
-Open this when Fable is out of usage on a Claude or ThirdParty host and an Astra fallback bind is starting.
+Open this when Opus is out of usage on a Claude or ThirdParty host and an Astra fallback bind is starting.
 On a Codex host, Astra is the in-session default. See [`identity.md`](identity.md).
 
 ## Flag
 
-`ADVISOR_ASTRA=1` (or `true` / `yes` / `on`) opens the Astra fallback after Fable is out of usage. Set the variable in the helper's process environment, or pass `--enable-astra` on the helper invocation. The CLI flag opens the rung for that run without touching the environment.
-Flag off both ways: fail closed when Fable did not bind.
+`ADVISOR_ASTRA=1` (or `true` / `yes` / `on`) opens the Astra fallback after Opus is out of usage. Set the variable in the helper's process environment, or pass `--enable-astra` on the helper invocation. The CLI flag opens the rung for that run without touching the environment.
+Flag off both ways: fail closed when Opus did not bind.
 A Windows `setx` write only updates the persisted user environment; only a process started after that write inherits the new value, so an already-running session either sets the flag in its own invoking process environment or passes `--enable-astra`.
 
 ## Effort
@@ -28,12 +28,12 @@ python ~/.claude/scripts/codex_account_choice.py choose
 
 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 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.
+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 Opus 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.** A picker failure, non-zero exit, timeout, malformed answer, or a `luna` or `wait` tier 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 Opus 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.
+The helper owns the Astra attempt and returns an explicit fallback result. The consuming advisor path owns the Opus bind. Apply the same gate to every Astra attempt, including resume.

package/_shared/advisor/reference/identity.md

@@ -10,18 +10,18 @@ Call `resolve_session_identity` from `$HOME/.claude/_shared/advisor/scripts/tier
 | Identity text | Host profile | Bind path |
 |---|---|---|
 | a `codex` token | Codex | In-session Astra spawn |
-| a `claude` token | Claude | In-session Fable spawn of `session-advisor` |
+| a `claude` token | Claude | In-session Opus spawn of `session-advisor` |
 | any other identity | ThirdParty | Headless CLI chain |
 
 When both `codex` and `claude` tokens appear, Codex wins. Empty text is ThirdParty.
 
 ## Bind path
 
-**Claude.** Spawn `subagent_type: session-advisor` at Fable through the Agent tool. When Fable is out of usage, bind Astra through the Codex helper if `ADVISOR_ASTRA` is on. Fail closed when neither binds.
+**Claude.** Spawn `subagent_type: session-advisor` at Opus through the Agent tool. When Opus is out of usage, bind Astra through the Codex helper if `ADVISOR_ASTRA` is on. Fail closed when neither binds.
 
-**Codex.** Spawn a native in-session Astra subagent at `resolve_codex_model_id("Astra")` (`gpt-6-astra`). Walk `candidate_tiers = ["Astra"]`. When the spawn tool has a `flags` field, pass `flags: ["--advisor"]` and record `fallback.advisor_flag: "passed"`. When it has none, as in `codex exec`, spawn `gpt-6-astra` plainly and record `fallback.advisor_flag: "unavailable"`. Both count as a bind. Record `{tier: "Astra", result: "spawned"}` on success. The `ADVISOR_ASTRA` flag is not required. Fail closed when Astra does not bind, or when the spawn skips a flag the host offers. Do not walk Fable on a Codex host.
+**Codex.** Spawn a native in-session Astra subagent at `resolve_codex_model_id("Astra")` (`gpt-6-astra`). Walk `candidate_tiers = ["Astra"]`. When the spawn tool has a `flags` field, pass `flags: ["--advisor"]` and record `fallback.advisor_flag: "passed"`. When it has none, as in `codex exec`, spawn `gpt-6-astra` plainly and record `fallback.advisor_flag: "unavailable"`. Both count as a bind. Record `{tier: "Astra", result: "spawned"}` on success. The `ADVISOR_ASTRA` flag is not required. Fail closed when Astra does not bind, or when the spawn skips a flag the host offers. Do not walk Opus on a Codex host.
 
-**ThirdParty.** Bind Fable through the CLI Claude-chain. When Fable is out of usage, bind Astra through the Codex helper if `ADVISOR_ASTRA` is on. Fail closed when neither binds.
+**ThirdParty.** Bind Opus through the CLI Claude-chain. When Opus is out of usage, bind Astra through the Codex helper if `ADVISOR_ASTRA` is on. Fail closed when neither binds.
 
 ## Mechanical override
 

package/_shared/advisor/reference/lifecycle.md

@@ -22,6 +22,6 @@ Every other consumer reaches it by message alone; spawn, respawn, and shutdown b
 
 The orchestrating session owns the CLI advisor bind for the whole run: first bind, re-bind on drift or lost `session_id`, and fail-closed report when the bound path cannot serve.
 
-**Re-bind on drift.** If a reply shows a stale picture, the task pivots, or `--resume` fails after a usage-limit failover (session stores are per binary/account), re-bind Fable through `claude_chain_runner.py` with the charter plus a compact recap of consults so far.
-Capture the new `session_id`, and log a fresh Fable walk with `result: "cli"` on success, then Astra when that rung is open. An Astra re-bind uses `codex_astra_advisor.py --bind --enable-astra` with the same charter and recap, and records `result: "codex"` on success.
+**Re-bind on drift.** If a reply shows a stale picture, the task pivots, or `--resume` fails after a usage-limit failover (session stores are per binary/account), re-bind Opus through `claude_chain_runner.py` with the charter plus a compact recap of consults so far.
+Capture the new `session_id`, and log a fresh Opus walk with `result: "cli"` on success, then Astra when that rung is open. An Astra re-bind uses `codex_astra_advisor.py --bind --enable-astra` with the same charter and recap, and records `result: "codex"` on success.
 Executors keep reporting to the orchestrating session; advisor binding stays with that session alone.

package/_shared/advisor/reference/spawn-walk-log.md

@@ -6,10 +6,10 @@ Detail behind the **Model floor** section of [`advisor-protocol.md`](../advisor-
 
 Write the log as JSON with these field names:
 
-- `own_tier`: the consuming session's tier (recorded; it does not add Opus to the advisor walk).
+- `own_tier`: the consuming session's tier.
 - `host_profile`: `Claude`, `Codex`, or `ThirdParty`. Omit to default to `Claude`.
-- `candidate_tiers`: on Claude and ThirdParty, Fable, plus Astra when `astra_enabled` is true. On Codex, Astra only.
-- `astra_enabled`: a boolean recorded before candidate selection. On Claude and ThirdParty, `true` adds Astra after Fable and `false` walks Fable alone. On Codex this flag does not change the walk.
+- `candidate_tiers`: on Claude and ThirdParty, Opus, plus Astra when `astra_enabled` is true. On Codex, Astra only.
+- `astra_enabled`: a boolean recorded before candidate selection. On Claude and ThirdParty, `true` adds Astra after Opus and `false` walks Opus alone. On Codex this flag does not change the walk.
 - `attempts`: one `{tier, result}` entry appended as each bind try happens. `result` is `codex` for an Astra helper bind, `spawned` for an in-session spawn (Claude Agent or Codex native Astra), `cli` for a CLI Claude-chain bind, or a failure reason such as `unavailable`.
 - `selected_tier`: the tier of the first successful bind (first `codex`, `spawned`, or `cli` entry), or `null` paired with a `fallback_reason` string when none bound.
 - `evidence`: the versioned reference, fallback, and consult record described in `docs/references/advisor-tool.md`. A reference status records optional path repair separately from bind status.
@@ -29,5 +29,5 @@ Exit code `1` means a ladder invariant failed.
 Exit code `2` means the path or JSON was unusable.
 The same checks are available in-process via `validate_model_tier_run(run)`.
 
-The validator checks ladder shape and validates `evidence` when it is present. On Claude and ThirdParty, Astra is attempted after Fable when `astra_enabled` is enabled, and `selected_tier: "Astra"` requires `result: "codex"`. On Codex, the walk is Astra only, and `result: "spawned"` or `result: "codex"` counts as success. A Codex success record uses `reply_path: "native"` and `advisor_flag: "passed"` or `advisor_flag: "unavailable"`. A missing `advisor_flag` or `advisor_flag: "omitted"` fails validation.
+The validator checks ladder shape and validates `evidence` when it is present. On Claude and ThirdParty, Astra is attempted after Opus when `astra_enabled` is enabled, and `selected_tier: "Astra"` requires `result: "codex"`. On Codex, the walk is Astra only, and `result: "spawned"` or `result: "codex"` counts as success. A Codex success record uses `reply_path: "native"` and `advisor_flag: "passed"` or `advisor_flag: "unavailable"`. A missing `advisor_flag` or `advisor_flag: "omitted"` fails validation.
 Host policy sits on top of it. See the Model floor section of the protocol.

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

@@ -5,7 +5,7 @@ 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 the Codex account picker.
+Cursor is a third-party host. When the walk reaches Astra (`ADVISOR_ASTRA=1` / `--enable-astra` after Opus 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>
@@ -18,18 +18,18 @@ When the Astra flag is off, follow the Claude-chain steps below.
 ## Bind steps
 
 1. Name the session identity first (protocol **Host profiles**). This path is for a ThirdParty profile.
-2. Walk `candidate_tiers = ["Fable"]`. When Fable is out of usage, the Astra rung ([`astra-rung.md`](astra-rung.md)) binds Astra after Fable (`candidate_tiers = ["Fable", "Astra"]`).
-3. **CLI bind (primary path):** for Fable, pipe a charter file into:
+2. Walk `candidate_tiers = ["Opus"]`. When Opus is out of usage, the Astra rung ([`astra-rung.md`](astra-rung.md)) binds Astra after Opus (`candidate_tiers = ["Opus", "Astra"]`).
+3. **CLI bind (primary path):** for Opus, pipe a charter file into:
 
    ```
    python "$HOME/.claude/scripts/claude_chain_runner.py" --routing-mode ordered_account -- -p --model <alias> --effort <effort> --output-format json
    ```
 
-   Use `--model fable --effort` with the value of `ADVISOR_EFFORT` (default `low`) on Fable.
+   Use `--model opus --effort` with the value of `ADVISOR_EFFORT` (default `xhigh`) on Opus.
    User-facing wording follows [`rules/asd-ste100-language.md`](../../../rules/asd-ste100-language.md).
    A root advisor bind uses `--routing-mode ordered_account`. Walk order, failover, and the `advisor_blocked` terminal status are in [`cli-chain.md`](cli-chain.md).
 4. Stop at the first successful bind.
-   Record `{tier, result: "cli"}` for Fable or `{tier: "Astra", result: "codex"}` for the Astra helper, and set `selected_tier` to that tier.
+   Record `{tier, result: "cli"}` for Opus or `{tier: "Astra", result: "codex"}` for the Astra helper, and set `selected_tier` to that tier.
    Persist `session_id` from the JSON events (any event carries it; the runner also surfaces it on `ChainInvocationOutcome.session_id`; reply text is the `type == "result"` event's `.result` field).
    Run every bind and every later consult with cwd set to the repo root the work is for. Claude sessions are project-scoped by working directory.
 5. **Fail closed:** when every candidate fails (chain exhausted, `advisor_blocked`, or model unavailable), set `selected_tier = null` and a `fallback_reason`, report that the advisor is unreachable, and **stop**. ENDORSE / CORRECTION / PLAN / STOP come only from a bound advisor.
@@ -38,4 +38,4 @@ When the Astra flag is off, follow the Claude-chain steps below.
 ## Session model field
 
 Resolve a third-party session's own model field with `resolve_cli_model_id("ThirdParty")` → `third-party` when a host model alias is required.
-The **advisor** bind uses the Fable alias. Astra binds through the Codex helper.
+The **advisor** bind uses the Opus alias. Astra binds through the Codex helper.

package/_shared/advisor/reference/warm-up.md

@@ -5,10 +5,10 @@ Open this when binding the warm advisor on a Claude host or a Codex host, and fo
 
 ## Spawn fields for a Claude host
 
-The consuming skill's session tries Fable first. Spawn with:
+The consuming skill's session tries Opus first. Spawn with:
 
 - `subagent_type: session-advisor` (see [`agents/session-advisor.md`](../../../agents/session-advisor.md) for the full signal contract).
-- `model`: the short alias via `resolve_cli_model_id("Fable")` (alias table: [`cli-chain.md`](cli-chain.md)): `fable`. When Fable is out of usage and the Astra rung is open, continue with the Codex helper in [`astra-rung.md`](astra-rung.md) as the Astra fallback.
+- `model`: the short alias via `resolve_cli_model_id("Opus")` (alias table: [`cli-chain.md`](cli-chain.md)): `opus`. When Opus is out of usage and the Astra rung is open, continue with the Codex helper in [`astra-rung.md`](astra-rung.md) as the Astra fallback.
 - `name`: a name the session and every consumer will use to reach it (e.g. `team-advisor-agent`).
 - `run_in_background: true`.
 - `prompt`: the charter below.
@@ -34,7 +34,7 @@ Spawn a native in-session Astra subagent at `resolve_codex_model_id("Astra")` (`
 When the spawn tool has a `flags` field, pass `flags: ["--advisor"]` and record `fallback.advisor_flag: "passed"`.
 When the spawn tool has no `flags` field, as in `codex exec`, spawn `gpt-6-astra` plainly, record `fallback.advisor_flag: "unavailable"`, and treat the advisor as bound.
 Record `{tier: "Astra", result: "spawned"}` on success. Fail closed when that spawn does not bind, or when it skips a flag the host offers.
-The `ADVISOR_ASTRA` flag is not required. Do not walk Fable. Consults stay in-session with that Astra subagent.
+The `ADVISOR_ASTRA` flag is not required. Do not walk Opus. Consults stay in-session with that Astra subagent.
 Identity routing: [`identity.md`](identity.md).
 
 ## Third-party host

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/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_model_tier_run_validator.py

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.13.0",
+    "version": "8.14.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {