claude-dev-env 2.17.0 → 2.18.0

package/.agents/skills/orchestrator/SKILL.md

@@ -122,9 +122,11 @@ pending, or when the tool is `CronCreate`.
    `rearm_pending` when already active, but still do not re-arm.)
 2. **Bind the shared advisor before any executor.** Follow
    [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md)
-   end to end: detect the host profile, compute the floor from the
+   end to end: name the session identity, compute the floor from the
    orchestrator consumer set — this session plus every tier in the
-   routing table (its Model floor section) — walk the ladder top-down,
+   routing table (its Model floor section) — walk the ladder for that
+   host (Claude: Fable first, then Sol when Fable is out of usage;
+   Codex: Sol in-session; ThirdParty: headless Fable then Sol),
    and fail closed when nothing binds. This session owns the advisor's
    whole lifecycle (its Lifecycle ownership section); executors only ever
    message the warm agent or report here, and an executor that finds the
@@ -261,8 +263,8 @@ Routing rules:
   way — the coding spawn stops and the orchestrator reports it.
 - Host detection follows
   [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md)
-  (Host profiles section, `detect_host_profile`) — the sole detection
-  system, with no second one.
+  (Host profiles section, `resolve_session_identity` then
+  `detect_host_profile`) — the sole detection system, with no second one.
 - Resume a warm workflow agent before creating a new workflow run when
   the warm agent holds the relevant context.
 - Review and verification workflows apply the [review guide](../reviews/SKILL.md#review-workflow).

package/.agents/skills/orchestrator-refresh/SKILL.md

@@ -10,10 +10,10 @@ description: >-
 
 # Orchestrator Refresh
 
-Detect the host profile first (see Host profiles in
+Name the session identity first (see Host profiles in
 [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md)).
 Re-assert the discipline for that host only — do not invent an Agent-tool
-Claude `session-advisor` spawn on a third-party host.
+Claude `session-advisor` spawn on a Codex or third-party host.
 
 ## 0. status_gate first (deterministic)
 
@@ -94,9 +94,13 @@ once, and reports the unreachable advisor.
      the protocol's warm-up rule states;
      `hooks/blocking/fable_spawn_gate.py` denies a fable spawn whose
      prompt lacks it.
-   - **Third-party host:** advisor is a max-tier Claude CLI bind owned
-     by this session (`claude_chain_runner.py`, Fable high then Opus
-     max). Do **not** spawn `session-advisor` via Agent. Executors
+   - **Codex host:** advisor is a native in-session Sol subagent owned
+     by this session. Do **not** spawn Claude `session-advisor` via
+     Agent. Executors consult that Sol subagent in-session. If Sol does
+     not bind, fail closed.
+   - **Third-party host:** advisor is a Claude CLI bind owned
+     by this session (`claude_chain_runner.py`, Fable then Sol when Fable
+     is out of usage, both at `ADVISOR_EFFORT`). Do **not** spawn `session-advisor` via Agent. Executors
      report blockers here; consult the CLI advisor and relay signals.
      If the CLI bind is unreachable, fail closed — do not answer the
      four signals as this third-party session.

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

@@ -16,15 +16,15 @@ One warm advisor at the strongest tier this session can reach. This session is t
 | Doc | Holds |
 |---|---|
 | [`docs/references/advisor-tool.md`](../../docs/references/advisor-tool.md) | **Consult cadence and weight** — when to call, hard rule before first write, how to treat advice. Read this for every consult. |
-| [`~/.claude/_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md) | **Bind and lifecycle** — host detect, model floor, warm-up, CLI fallback; its read map routes each moment to a `reference/` detail file. |
+| [`~/.claude/_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md) | **Bind and lifecycle** — session identity, host detect, model floor, warm-up, CLI fallback; its read map routes each moment to a `reference/` detail file. |
 | [`agents/session-advisor.md`](../../agents/session-advisor.md) | **Reply contract** — ENDORSE / CORRECTION / PLAN / STOP; SendMessage only. |
 | [`reference/advisor-docs-review.md`](reference/advisor-docs-review.md) | Anthropic advisor-tool source facts: measured effects, Sonnet steering, cost levers, failure modes. Background — read it when tuning the bind, not on every consult. |
 
 ## Bind
 
-1. Detect the host profile first (protocol **Host profiles**), then walk the model floor.
-2. Floor: the stronger of Opus and this session's own tier on Claude; Opus floor with Fable first on a third-party host.
-3. Name: `team-advisor-agent` on Claude (Agent spawn of `session-advisor`); one CLI `session_id` on a third-party host via the protocol Claude-chain.
+1. Name the session identity first (protocol **Host profiles**), then walk the model floor.
+2. Claude: Fable first in-session at `ADVISOR_EFFORT` (default low). When Fable is out of usage, bind Sol at the same effort. Codex: Sol in-session. Third-party: headless Fable then Sol. When the host's walk fails, fail closed.
+3. Name: `team-advisor-agent` on Claude (Agent spawn of `session-advisor`); a native Sol subagent on Codex; one CLI `session_id` on a third-party host via the protocol Claude-chain.
 4. A Fable-tier spawn or re-spawn carries the exact token `FABLE-SPAWN-AUTHORIZED` in its prompt (protocol warm-up; `fable_spawn_gate` requires it).
 5. Skip the multi-consumer "who you are" opener — sole consumer.
 6. When the bind or reply path fails, fail closed and report to the user. On a third-party host, only the bound Claude advisor issues ENDORSE / CORRECTION / PLAN / STOP.
@@ -41,6 +41,6 @@ Aim for two consults on a normal task: one after orientation and one after write
 
 ## Constraints
 
-- One bind per session; this session owns spawn or CLI bind, drift re-bind, and shutdown.
+- One bind per session; this session owns spawn, in-session Sol spawn, or CLI bind, drift re-bind, and shutdown.
 - Bind at or above the protocol floor for this host.
 - The advisor only answers (messaging); the session runs tools and posts.

package/_shared/advisor/AGENTS.md

@@ -2,21 +2,21 @@
 
 Warm-advisor bind-and-consult protocol shared by `team-advisor`, `orchestrator`, `orchestrator-refresh`, and every executor subagent `orchestrator` routes work to. Changes here affect all of these simultaneously — treat this as a breaking-change surface.
 
-Host profile (Claude vs third-party) is detected first; Claude walks the multi-tier Agent spawn ladder (CLI chain as fallback), a third-party host binds a max-tier Claude advisor through the CLI Claude-chain (fail closed when the chain cannot serve) with a separate executor paste block.
+Host profile is resolved from session identity first (Claude, Codex, or neither). Claude walks Fable then Sol in-session (CLI chain as the Fable fallback). Codex walks Sol in-session. A third-party host binds Fable through the CLI Claude-chain (fail closed when Fable and Sol cannot serve) with a separate executor paste block.
 
 ## Key documents
 
 | File | Purpose |
 |---|---|
-| `advisor-protocol.md` | Router with a moment-keyed read map: host profiles first, model floor, warm-up and consult standing rules, lifecycle ownership, Advisor-block assembly rule, and the shared CLI Claude-chain — each with a stub pointing at its `reference/` detail file |
+| `advisor-protocol.md` | Router with a moment-keyed read map: session identity and host profiles first, model floor, warm-up and consult standing rules, lifecycle ownership, Advisor-block assembly rule, and the shared CLI Claude-chain — each with a stub pointing at its `reference/` detail file |
 
 ## Subdirectory
 
 | Entry | Description |
 |---|---|
-| `scripts/` | `model_tier_run_validator.py` (spawn-walk log checks, including optional Sol), `codex_sol_advisor.py` (read-only Sol xhigh bind and resume), `tier_model_ids.py` (Claude aliases, Codex model ids, and host detection), and `advisor_scripts_constants` under `scripts/config/` (ladder, bind tokens, aliases, host profiles, and SendMessage wait bound) |
-| `reference/` | Progressive-disclosure detail behind protocol stub sections: `warm-up.md`, `third-party-bind.md`, `sol-rung.md`, `consult-format.md`, `advisor-block.md`, `lifecycle.md`, `cli-chain.md`, and `spawn-walk-log.md` |
+| `scripts/` | `model_tier_run_validator.py` (spawn-walk log checks, including Codex Sol-first and optional Sol), `codex_sol_advisor.py` (read-only Sol bind and resume at shared `ADVISOR_EFFORT`), `tier_model_ids.py` (Claude aliases, Codex model ids, session identity, and host detection), and `advisor_scripts_constants` under `scripts/config/` (ladder, bind tokens, aliases, host profiles, identity tokens, shared effort, and SendMessage wait bound) |
+| `reference/` | Progressive-disclosure detail behind protocol stub sections: `identity.md`, `warm-up.md`, `third-party-bind.md`, `sol-rung.md`, `consult-format.md`, `advisor-block.md`, `lifecycle.md`, `cli-chain.md`, and `spawn-walk-log.md` |
 
 ## Breaking-change rule
 
-A change to host detection, the model-floor rule, the charter template, either host's Advisor block, or lifecycle ownership in `advisor-protocol.md` requires updating every consuming skill (`team-advisor`, `orchestrator`, `orchestrator-refresh`) in the same commit.
+A change to session identity, host detection, the model-floor rule, the charter template, any host's Advisor block, or lifecycle ownership in `advisor-protocol.md` requires updating every consuming skill (`team-advisor`, `orchestrator`, `orchestrator-refresh`) in the same commit.

package/_shared/advisor/advisor-protocol.md

@@ -2,8 +2,9 @@
 
 Shared spawn-once, consult-by-message protocol for a warm advisor. Two skills depend on this: `team-advisor` (binds the advisor for its own consulting session) and `orchestrator` (binds the same advisor and lets its own routed executor subagents consult it too). Executor spawn prompts are a third consumer, via the assembled Advisor block.
 
-**First step of every bind:** detect the host profile (next section).
-Walk the model-floor ladder, spawn `session-advisor`, or open the CLI fallback only after the host is known.
+**First step of every bind:** name the session identity and resolve the host profile (next section).
+Walk the model-floor ladder, spawn the in-session advisor, or open the CLI fallback only after the host is known.
+On a Codex host, skip straight to **Host profiles → Codex host**.
 On a third-party host, skip straight to **Host profiles → Third-party host**.
 On Claude, continue with **Model floor** and the rest of this document.
 
@@ -13,9 +14,11 @@ 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 Codex host | [`reference/identity.md`](reference/identity.md) — in-session Sol spawn |
 | Binding from a third-party host | [`reference/third-party-bind.md`](reference/third-party-bind.md) — CLI bind steps, fail-closed rule |
-| `ADVISOR_SOL_XHIGH` is set | [`reference/sol-rung.md`](reference/sol-rung.md) — preflight, bind, fallback |
+| Fable is out of usage | [`reference/sol-rung.md`](reference/sol-rung.md) — Sol 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 |
@@ -24,59 +27,75 @@ The sections below hold the standing rules; open a reference file at the moment
 
 ## Host profiles
 
-Detect the host profile **before** any model-floor walk. Source of truth for names and detection: `HOST_PROFILE_CLAUDE`, `HOST_PROFILE_THIRD_PARTY`, `ALL_HOST_PROFILES`, and `detect_host_profile(...)` in `$HOME/.claude/_shared/advisor/scripts/config/advisor_scripts_constants/model_tier_run_validator_constants.py` and `tier_model_ids.py`.
+Name the session identity **before** any model-floor walk. Source of truth for names and detection: `HOST_PROFILE_CLAUDE`, `HOST_PROFILE_CODEX`, `HOST_PROFILE_THIRD_PARTY`, `ALL_HOST_PROFILES`, `resolve_session_identity(...)`, and `detect_host_profile(...)` in `$HOME/.claude/_shared/advisor/scripts/config/advisor_scripts_constants/model_tier_run_validator_constants.py` and `tier_model_ids.py`.
+Identity tokens and bind paths: [`reference/identity.md`](reference/identity.md).
 
-Detection order:
+Session identity:
 
-1. `ADVISOR_HOST_PROFILE=ThirdParty` or `=Claude` (explicit override; any letter case).
+1. Call `resolve_session_identity` with the session's named identity.
+2. A `codex` token selects Codex. A `claude` token selects Claude. Any other identity selects ThirdParty.
+3. When both tokens appear, Codex wins.
+
+Mechanical override for scripts:
+
+1. `ADVISOR_HOST_PROFILE=ThirdParty` or `=Claude` or `=Codex` (explicit override; any letter case).
 2. `THIRD_PARTY=1` (or `true` / `yes` / `on`) — a third-party (non-Claude) harness.
 3. Default: Claude.
 
-### Sol rung — any host
+### Shared effort — any host
+
+Fable and Sol both read `ADVISOR_EFFORT` (`low`, `medium`, `high`, `xhigh`, `max`). The default is `low`.
+Pass `--effort <level>` on the Sol helper to set effort for that Sol run.
+Pass `--effort <level>` on the Claude CLI bind for Fable. An unset or unrecognized value uses `low`.
+
+### Sol rung
 
-An optional **sol xhigh** rung sits above the Claude ladder on every host, switched by the flag `ADVISOR_SOL_XHIGH=1` (or `true` / `yes` / `on`), set in the environment or by the consuming skill's invocation.
-Flag off: the walk starts at the host's Claude ladder, Fable first.
-Flag on: run the Codex preflight and bind per [`reference/sol-rung.md`](reference/sol-rung.md); a failed preflight falls back to the Claude ladder.
+On Claude and ThirdParty: when Fable is out of usage, bind Sol through the Codex helper.
+Open that attempt with `ADVISOR_SOL=1` (or `true` / `yes` / `on`) in the environment, or pass `--enable-sol` 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/sol-rung.md`](reference/sol-rung.md); a failed preflight fails closed when Fable did not bind.
+
+On Codex: Sol is the in-session default. The `ADVISOR_SOL` flag is not required. Fail closed when that spawn does not bind.
 
 ### Claude host
 
-Use the **Model floor** ladder below (sol when flagged, then Fable → Opus).
+Use the **Model floor** ladder below (Fable first, then Sol when Fable is out of usage).
 Warm-up spawns `subagent_type: session-advisor` via the Agent tool; consults go through `SendMessage` to that warm agent.
 Assemble and paste each executor's Advisor block per the **Advisor block** section.
 
+### Codex host
+
+Spawn a native in-session Sol subagent at `resolve_codex_model_id("Sol")`.
+Walk `candidate_tiers = ["Sol"]`. Record `{tier: "Sol", result: "spawned"}` on success.
+**Fail closed:** when Sol 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 Sol subagent.
+Assemble and paste each executor's Advisor block per the **Advisor block** section.
+
 ### Third-party host
 
-On a third-party (non-Claude) harness, the shared CLI Claude-chain is the one path to a Claude advisor: bind a **max-tier Claude advisor** 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 Fable 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.
-Floor **Opus**; walk `candidate_tiers = ["Fable", "Opus"]` with `own_tier = Opus`; the sol rung binds ahead of the chain when open.
+Walk `candidate_tiers = ["Fable"]`. When Fable is out of usage, the sol rung binds after Fable (`candidate_tiers = ["Fable", "Sol"]`).
 **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.
 
 ## Model floor
 
-**Claude host:** the advisor's model tier must be at or above the highest tier of any consumer that will reach it. Each consuming skill supplies its own consumer set when computing the floor:
-- `team-advisor`: the sole consumer is the calling session itself, so the floor is the stronger of Opus and that session's own tier.
-- `orchestrator`: the consumer set is the orchestrating session plus every tier named in its routing table, so the floor is the stronger of Opus and the max of those.
-
-Whatever the consumer set, the floor sits at Opus or above — use the stronger of Opus and the strongest consumer tier.
-
-**Third-party host:** the CLI advisor floor is fixed at **Opus** (walk Fable → Opus only), whatever the session's own tier.
-
-Ladder, strongest first: sol (flag-gated, Codex CLI) → `Fable` → `Opus`.
-Advisors bind at Opus or above; `Sonnet` and `Haiku` are executor tiers only.
+On Claude and ThirdParty the advisor ladder is `Fable` first, then sol (flag-gated, Codex CLI) when Fable is out of usage.
+On Codex the walk is Sol 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.
-Read the floor tier — the lower bound only — then try binds top-down, stopping at the floor tier.
-Each try resolves its candidate tier to the short model alias via the tier-to-alias map in [`reference/cli-chain.md`](reference/cli-chain.md).
-The advisor is created at `selected_tier` — the first ladder tier that binds — which may sit above the floor.
-When even the floor tier fails on a Claude host, move to the **CLI chain** fallback below.
-On a third-party host the CLI chain is already the primary path, so floor failure fails closed per **Host profiles → Third-party host**.
+Try binds top-down. Each try resolves its candidate tier to the short model alias via the tier-to-alias map in [`reference/cli-chain.md`](reference/cli-chain.md).
+The advisor is created at `selected_tier` — the first ladder tier that binds.
+When Fable fails on a Claude host, try Sol 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.
+On a Codex host a failed Sol 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 Sol, 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 a same-tier advisor when the goal is an independent second pass.
-For irreversible or security-sensitive work, pair a top-tier executor with a top-tier advisor for independent frontier review.
-The floor rule holds — the advisor sits at or above the strongest consumer's tier — and an equal-tier bind sits inside that bound.
+**Equal-tier pairings.** Bind Fable for an independent second pass on irreversible or security-sensitive work. The advisor is Fable or Sol.
 
 ## Warm-up (once per session)
 
@@ -84,6 +103,8 @@ On a **Claude host**, walk the candidate tiers top-down, spawning `session-advis
 A **Fable**-tier try carries the exact token `FABLE-SPAWN-AUTHORIZED` in its prompt — `hooks/blocking/fable_spawn_gate.py` denies a Fable-tier spawn without it.
 Full spawn fields and the charter template: [`reference/warm-up.md`](reference/warm-up.md).
 
+On a **Codex host**, spawn a native in-session Sol subagent with the same charter. Bind fields: [`reference/identity.md`](reference/identity.md) and [`reference/warm-up.md`](reference/warm-up.md).
+
 On a **third-party host**, bind per [`reference/third-party-bind.md`](reference/third-party-bind.md) and charter the CLI session with the same charter — the reply contract is the same, and consults travel through the CLI runner.
 
 ## Consulting the warm agent
@@ -115,6 +136,8 @@ Modes and failover, the tier-to-alias table, brief piping, and `--resume` sessio
 
 **Third-party host:** the primary bind and consult path; the walk order and fail-closed rule live in [`reference/third-party-bind.md`](reference/third-party-bind.md).
 
+**Codex host:** do not use this runner as the primary path. Sol binds in-session.
+
 **Claude host:** fall back to this runner exactly when one of these holds:
 - The Agent-tool spawn errors at every candidate tier down to the floor — the tool itself is unavailable.
 - `SendMessage` to the shared advisor errors, or draws no reply within the bound in `ADVISOR_SENDMESSAGE_REPLY_WAIT_SECONDS` (120) in `$HOME/.claude/_shared/advisor/scripts/config/advisor_scripts_constants/model_tier_run_validator_constants.py`, and a re-spawn also fails.

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

@@ -12,10 +12,14 @@ The consult rules it restates are owned by [`consult-format.md`](consult-format.
 
 > A shared session advisor named `<name>` is reachable via SendMessage; send each consult to it directly by that name.
 
+## Transport preamble — Codex host
+
+> A shared session advisor named `<name>` is reachable as a native Codex Sol subagent; send each consult to it in-session by that name.
+
 ## Transport preamble — third-party host
 
 > The orchestrating session owns a standing advisor for this run.
-> The advisor chain, strongest first: sol xhigh through the Codex CLI when the sol flag and its preflight open that rung, then Claude Fable at effort high, then Claude Opus at effort xhigh through the CLI Claude-chain.
+> The advisor chain: Claude Fable, then Sol through the Codex CLI when Fable is out of usage and the sol flag and its preflight open that rung. Both rungs use `ADVISOR_EFFORT` (default low). 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 — every host

package/_shared/advisor/reference/consult-format.md

@@ -37,5 +37,5 @@ After a CORRECTION or PLAN, your next consult on that topic opens with what happ
 
 Address a CORRECTION before treating the plan or the work as done, whether it names a wrong step or a risk worth closing.
 Report a STOP, or a consult that finds the advisor unreachable, upward: team-advisor's sole consumer is the session itself, so it reports to the user; orchestrator's executors report to the orchestrating session, which decides.
-When the advisor becomes unreachable, report that to the session that owns its lifecycle ([`lifecycle.md`](lifecycle.md)); that session alone decides whether to respawn (Claude Agent or third-party CLI re-bind).
+When the advisor becomes unreachable, report that to the session that owns its lifecycle ([`lifecycle.md`](lifecycle.md)); that session alone decides whether to respawn (Claude Agent, Codex native Sol, or third-party CLI re-bind).
 A third-party host that cannot re-bind follows the fail-closed rule in [`third-party-bind.md`](third-party-bind.md).

package/_shared/advisor/reference/identity.md

@@ -0,0 +1,28 @@
+# Session identity
+
+Detail behind the **Host profiles** section of [`advisor-protocol.md`](../advisor-protocol.md).
+Open this when binding the advisor and the session must name its identity.
+
+## Resolve the profile
+
+Call `resolve_session_identity` from `$HOME/.claude/_shared/advisor/scripts/tier_model_ids.py` with the session's named identity.
+
+| Identity text | Host profile | Bind path |
+|---|---|---|
+| a `codex` token | Codex | In-session Sol spawn |
+| a `claude` token | Claude | In-session Fable 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 Sol through the Codex helper if `ADVISOR_SOL` is on. Fail closed when neither binds.
+
+**Codex.** Spawn a native in-session Sol subagent at `resolve_codex_model_id("Sol")` (`gpt-5.6-sol`). Walk `candidate_tiers = ["Sol"]`. Record `{tier: "Sol", result: "spawned"}` on success. The `ADVISOR_SOL` flag is not required. Fail closed when Sol does not bind. Do not walk Fable on a Codex host.
+
+**ThirdParty.** Bind Fable through the CLI Claude-chain. When Fable is out of usage, bind Sol through the Codex helper if `ADVISOR_SOL` is on. Fail closed when neither binds.
+
+## Mechanical override
+
+Scripts that cannot self-identify read `detect_host_profile`. `ADVISOR_HOST_PROFILE` accepts `Claude`, `Codex`, or `ThirdParty`. `THIRD_PARTY=1` selects ThirdParty. The default is Claude.

package/_shared/advisor/reference/lifecycle.md

@@ -12,10 +12,17 @@ One shared advisor exists per orchestrated session, owned by the session that sp
 **Re-spawn on drift.** If a reply shows the agent working from a stale picture, or the session pivots to an unrelated task, the owning session ends that agent and spawns a fresh one with a new charter.
 A **Fable**-tier re-spawn carries the exact token `FABLE-SPAWN-AUTHORIZED` in that fresh prompt, as a Fable-tier warm-up try does.
 
+## Codex host
+
+The session that spawns the shared Sol subagent owns its whole lifecycle — spawn, drift-respawn, and shutdown.
+Every other consumer reaches it by message alone; spawn, respawn, and shutdown belong to the owning session.
+
+**Re-spawn on drift.** If a reply shows the agent working from a stale picture, or the session pivots to an unrelated task, the owning session ends that agent and spawns a fresh native Sol subagent with a new charter.
+
 ## Third-party host
 
 The orchestrating session owns the Claude CLI advisor bind for the whole run — first bind, re-bind on drift or lost `session_id`, and fail-closed report when the chain 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 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→Opus walk with `result: "cli"` on success.
+Capture the new `session_id`, and log a fresh Fable walk with `result: "cli"` on success, then Sol when that rung is open.
 Executors keep reporting to the orchestrating session; advisor binding stays with that session alone.

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

@@ -1,14 +1,19 @@
 # Sol rung
 
-Detail behind the **Host profiles → Sol rung — any host** section of [`advisor-protocol.md`](../advisor-protocol.md).
-Open this when `ADVISOR_SOL_XHIGH` is set and a bind is starting.
+Detail behind the **Host profiles → Sol rung** section of [`advisor-protocol.md`](../advisor-protocol.md).
+Open this when Fable is out of usage on a Claude or ThirdParty host and a Sol fallback bind is starting.
+On a Codex host, Sol is the in-session default; see [`identity.md`](identity.md).
 
 ## Flag
 
-`ADVISOR_SOL_XHIGH=1` (or `true` / `yes` / `on`) opens the rung. Two channels exist: set the variable in the helper's process environment, or pass `--enable-sol` on the helper invocation — the CLI flag opens the rung for that run without touching the environment.
-Flag off both ways: the walk starts at the host's Claude ladder, Fable first.
+`ADVISOR_SOL=1` (or `true` / `yes` / `on`) opens the Sol fallback after Fable is out of usage. Two channels exist: set the variable in the helper's process environment, or pass `--enable-sol` 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.
 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-sol`.
 
+## Effort
+
+`ADVISOR_EFFORT` selects Codex `model_reasoning_effort` for Sol and `--effort` for Fable: `low`, `medium`, `high`, `xhigh`, or `max`. The default is `low`, which sends `model_reasoning_effort="low"`. Pass `--effort <level>` on the helper to set effort for that Sol run without changing the environment. An unset or unrecognized value uses `low`.
+
 Every fallback reply carries a `fallback_kind` field: `declined` when policy closed the rung (flag off, usage meter at or below the gate) and `broken` when the Sol path itself failed (missing executable, spawn error, timeout, malformed reply). A `broken` fallback is a defect to report, not a routing outcome.
 
 ## Preflight
@@ -23,12 +28,12 @@ Repo home: `packages/claude-dev-env/_shared/pr-loop/scripts/`.
 
 The shared entry point is `~/.claude/_shared/advisor/scripts/codex_sol_advisor.py`; it calls the installed probe and owns Sol bind or resume parsing. Bind with `python ~/.claude/_shared/advisor/scripts/codex_sol_advisor.py --bind --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 selects Fable.
+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.
 
 ## Branches
 
-**Preflight pass** — bind one Codex CLI session at `gpt-5.6-sol` with `model_reasoning_effort="xhigh"`, `--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 pass** — bind one Codex CLI session at `gpt-5.6-sol` with `model_reasoning_effort` set from `ADVISOR_EFFORT` (default `low`), `--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 selects Fable and continues the normal walk.
+**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.
 
 The helper owns the Sol attempt and returns an explicit fallback result. The consuming advisor path owns the Fable bind. Apply the same gate to every Sol attempt, including resume.

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

@@ -6,10 +6,11 @@ Detail behind the **Model floor** section of [`advisor-protocol.md`](../advisor-
 
 Write the log as JSON with these field names:
 
-- `own_tier` — the floor tier.
-- `candidate_tiers` — the ladder slice down to that floor.
-- `sol_enabled` — a boolean recorded before candidate selection; `true` adds Sol ahead of the Claude ladder and `false` walks the Claude ladder alone.
-- `attempts` — one `{tier, result}` entry appended as each bind try happens; `result` is `codex` only for Sol, `spawned` for a Claude Agent spawn, `cli` for a CLI Claude-chain bind, or a failure reason such as `unavailable`.
+- `own_tier` — the consuming session's tier (recorded; it does not add Opus to the advisor walk).
+- `host_profile` — `Claude`, `Codex`, or `ThirdParty`. Omit to default to `Claude`.
+- `candidate_tiers` — on Claude and ThirdParty, Fable, plus Sol when `sol_enabled` is true. On Codex, Sol only.
+- `sol_enabled` — a boolean recorded before candidate selection; on Claude and ThirdParty, `true` adds Sol after Fable and `false` walks Fable 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 a Sol helper bind, `spawned` for an in-session spawn (Claude Agent or Codex native Sol), `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.
 
 ## Log path
@@ -27,5 +28,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 only: the candidate slice, the order of bind tries, and the success-token rules per tier. Sol is attempted before Fable when `sol_enabled` is true. `selected_tier: "Sol"` requires `result: "codex"`; `result: "codex"` requires Sol.
+The validator checks ladder shape only: the candidate slice, the order of bind tries, and the success-token rules per tier and host. On Claude and ThirdParty, Sol is attempted after Fable when `sol_enabled` is true, and `selected_tier: "Sol"` requires `result: "codex"`. On Codex, the walk is Sol only, and `result: "spawned"` or `result: "codex"` counts as success.
 Host policy sits on top of it — see the Model floor section of the protocol.

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

@@ -1,21 +1,20 @@
 # Third-party bind
 
 Detail behind the **Host profiles → Third-party host** section of [`advisor-protocol.md`](../advisor-protocol.md).
-Open this when binding or re-binding the advisor from a third-party (non-Claude) harness.
+Open this when binding or re-binding the advisor from a third-party (non-Claude, non-Codex) harness.
 
 ## Bind steps
 
-1. Detect the host profile first (protocol **Host profiles**).
-2. Set the advisor floor to **Opus** so the walk is `candidate_tiers = ["Fable", "Opus"]` with `own_tier = Opus`. The sol rung ([`sol-rung.md`](sol-rung.md)) governs whether sol xhigh binds ahead of the chain.
+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 sol rung ([`sol-rung.md`](sol-rung.md)) binds Sol after Fable (`candidate_tiers = ["Fable", "Sol"]`).
 3. **CLI bind (primary path):** for each candidate top-down, 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 high` on Fable; use `--model opus --effort xhigh` on Opus.
+   Use `--model fable --effort` with the value of `ADVISOR_EFFORT` (default `low`) on Fable.
    User-facing wording follows [`rules/asd-ste100-language.md`](../../../rules/asd-ste100-language.md).
-   The caller picks the Fable effort from task scope; when the caller cannot judge scope well enough to pick, it asks the user through AskUserQuestion before binding, and defaults to `high` when no caller choice arrives.
    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"}` and set `selected_tier` to that tier.
@@ -27,4 +26,4 @@ Open this when binding or re-binding the advisor from a third-party (non-Claude)
 ## 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 Fable/Opus aliases only.
+The **advisor** bind uses the Fable alias. Sol binds through the Codex helper.

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

@@ -1,14 +1,14 @@
 # Warm-up spawn fields and charter
 
 Detail behind the **Warm-up** section of [`advisor-protocol.md`](../advisor-protocol.md).
-Open this when binding the warm advisor on a Claude host, and for the charter text on either host.
+Open this when binding the warm advisor on a Claude host or a Codex host, and for the charter text on every host.
 
 ## Spawn fields — Claude host
 
 The consuming skill's session walks the candidate tiers top-down. For each try, spawn with:
 
 - `subagent_type: session-advisor` (see [`agents/session-advisor.md`](../../../agents/session-advisor.md) for the full signal contract).
-- `model`: the short alias for that try's candidate tier via `resolve_cli_model_id` (alias table: [`cli-chain.md`](cli-chain.md)) — for example `opus`. The floor is the lower bound of the walk; the walk tries stronger tiers first.
+- `model`: the short alias for that try's candidate tier via `resolve_cli_model_id` (alias table: [`cli-chain.md`](cli-chain.md)) — for example `fable`. The walk tries Fable first, then Sol when that rung is open.
 - `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. A **Fable**-tier try carries the exact token `FABLE-SPAWN-AUTHORIZED` in that prompt — `hooks/blocking/fable_spawn_gate.py` denies every `Agent` or `Task` spawn at `model: fable` whose prompt lacks that token. A try at any other tier needs no token.
@@ -29,6 +29,13 @@ State plainly:
 
 The agent finishes its first turn standing by. `SendMessage` alone resumes it; between consults it waits quietly.
 
+## Codex host
+
+Spawn a native in-session Sol subagent at `resolve_codex_model_id("Sol")` (`gpt-5.6-sol`) with the charter as its prompt.
+Record `{tier: "Sol", result: "spawned"}` on success. Fail closed when that spawn does not bind.
+The `ADVISOR_SOL` flag is not required. Do not walk Fable. Consults stay in-session with that Sol subagent.
+Identity routing: [`identity.md`](identity.md).
+
 ## Third-party host
 
 Bind per [`third-party-bind.md`](third-party-bind.md) and charter the CLI session with the same charter — the reply contract is the same, and consults travel through the CLI runner.