claude-dev-env 2.16.0 → 2.18.0

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
@@ -16,19 +21,19 @@ Every fallback reply carries a `fallback_kind` field: `declined` when policy clo
 Flag on: run the Codex preflight first —
 
 ```
-python ~/.claude/skills/codex-review/scripts/codex_usage_probe.py
+python ~/.claude/_shared/pr-loop/scripts/codex_usage_probe.py
 ```
 
-Repo home: `packages/claude-dev-env/.agents/skills/codex-review/scripts/`.
+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.
-   Opus routing follows [`rules/opus5-communication-contract.md`](../../../rules/opus5-communication-contract.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.
+   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).
    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.

package/_shared/advisor/scripts/codex_sol_advisor.py

@@ -1,4 +1,4 @@
-"""Bind and consult a read-only Codex CLI session at Sol xhigh."""
+"""Bind and consult a read-only Codex CLI session at Sol low effort."""
 
 from __future__ import annotations
 
@@ -22,6 +22,8 @@ if _config_directory_text not in sys.path:
 
 from advisor_scripts_constants.sol_advisor_constants import (  # noqa: E402
     ADVISOR_CODEX_EXECUTABLE_ENV_VAR,
+    ALL_SOL_TRUTHY_VALUES,
+    CLAUDE_CONFIG_DIRECTORY_NAME,
     CODEX_CONFIG_FLAG,
     CODEX_EXECUTABLE,
     CODEX_EXEC_SUBCOMMAND,
@@ -29,15 +31,15 @@ from advisor_scripts_constants.sol_advisor_constants import (  # noqa: E402
     CODEX_MODEL_FLAG,
     CODEX_PROMPT_FROM_STDIN,
     CODEX_READ_ONLY_SANDBOX,
-    CODEX_REASONING_CONFIG,
+    CODEX_REASONING_CONFIG_TEMPLATE,
     CODEX_RESUME_SUBCOMMAND,
     CODEX_SANDBOX_FLAG,
-    CLAUDE_CONFIG_DIRECTORY_NAME,
     SOL_BIND_FAILURE_REASON,
     SOL_CODEX_TIMEOUT_REASON,
     SOL_CODEX_TIMEOUT_SECONDS,
-    SOL_ENV_VAR,
+    SOL_EFFORT_FLAG,
     SOL_ENABLE_FLAG,
+    SOL_ENV_VAR,
     SOL_EXECUTABLE_NOT_FOUND_REASON,
     SOL_FALLBACK_KIND_BROKEN,
     SOL_FALLBACK_KIND_DECLINED,
@@ -48,14 +50,16 @@ from advisor_scripts_constants.sol_advisor_constants import (  # noqa: E402
     SOL_PROBE_TIMEOUT_REASON,
     SOL_REPLY_FAILURE_REASON,
     SOL_SESSION_ID_METAVAR,
-    ALL_SOL_TRUTHY_VALUES,
     SOL_USAGE_PROBE_TIMEOUT_SECONDS,
 )
 from advisor_scripts_constants.advisor_route_constants import (  # noqa: E402
     ADVISOR_CODEX_MODEL_ID,
+    ADVISOR_EFFORT_DEFAULT,
+    ADVISOR_EFFORT_ENV_VAR,
     ADVISOR_FALLBACK_RESULT,
     ADVISOR_FALLBACK_TIER,
     ADVISOR_MODEL_TIER,
+    ALL_ADVISOR_EFFORT_LEVELS,
     ALL_ADVISOR_GUIDANCE_SIGNALS,
     CODEX_BIND_SUCCESS_TOKEN,
     SPAWN_OUTCOME_KEY,
@@ -143,7 +147,7 @@ def _resolved_setting_by_name(
 def is_sol_advisor_enabled(
     setting_by_name: Mapping[str, str] | None,
 ) -> bool:
-    """Return whether the optional Sol xhigh rung is enabled.
+    """Return whether the optional Sol rung is enabled.
 
     Args:
         setting_by_name: Optional environment-like settings mapping.
@@ -158,6 +162,42 @@ def is_sol_advisor_enabled(
     )
 
 
+def resolve_advisor_effort(
+    setting_by_name: Mapping[str, str] | None,
+) -> str:
+    """Return the shared advisor effort from settings, or the default.
+
+    ::
+
+        resolve_advisor_effort({"ADVISOR_EFFORT": "medium"})
+        # ok: "medium"
+        resolve_advisor_effort({"ADVISOR_EFFORT": "MAX"})
+        # ok: "max"
+        resolve_advisor_effort({})
+        # ok: default low
+        resolve_advisor_effort({"ADVISOR_EFFORT": "nope"})
+        # ok: default low
+        resolve_advisor_effort({"ADVISOR_SOL_EFFORT": "high"})
+        # ok: default low
+
+    Fable and Sol both read this value. Unset and unrecognized values use
+    low. The Sol-only name does not set effort.
+
+    Args:
+        setting_by_name: Optional environment-like settings mapping.
+
+    Returns:
+        One of low, medium, high, xhigh, or max.
+    """
+    resolved_setting_by_name = _resolved_setting_by_name(setting_by_name)
+    requested_effort = (
+        resolved_setting_by_name.get(ADVISOR_EFFORT_ENV_VAR, "").strip().lower()
+    )
+    if requested_effort in ALL_ADVISOR_EFFORT_LEVELS:
+        return requested_effort
+    return ADVISOR_EFFORT_DEFAULT
+
+
 def resolve_usage_probe_path(home_directory: Path) -> Path:
     """Return the installed Codex weekly usage probe path.
 
@@ -290,12 +330,14 @@ def resolve_codex_executable(
 def build_codex_arguments(
     codex_executable: str,
     session_id: str | None = None,
+    reasoning_effort: str = ADVISOR_EFFORT_DEFAULT,
 ) -> list[str]:
     """Build the installed CLI's shell-free bind or resume argv.
 
     Args:
         codex_executable: Resolved executable name or path to invoke.
         session_id: Optional existing session to resume.
+        reasoning_effort: Codex model_reasoning_effort token.
 
     Returns:
         The shell-free Codex command argument vector.
@@ -306,7 +348,7 @@ def build_codex_arguments(
         CODEX_MODEL_FLAG,
         ADVISOR_CODEX_MODEL_ID,
         CODEX_CONFIG_FLAG,
-        CODEX_REASONING_CONFIG,
+        CODEX_REASONING_CONFIG_TEMPLATE.format(effort=reasoning_effort),
         CODEX_SANDBOX_FLAG,
         CODEX_READ_ONLY_SANDBOX,
         CODEX_JSON_FLAG,
@@ -435,7 +477,11 @@ def run_codex_sol_advisor(
         )
     try:
         completed_process = process_runner(
-            build_codex_arguments(codex_executable, session_id=session_id),
+            build_codex_arguments(
+                codex_executable,
+                session_id=session_id,
+                reasoning_effort=resolve_advisor_effort(setting_by_name),
+            ),
             cwd=str(working_directory),
             input=prompt,
             capture_output=True,
@@ -467,7 +513,7 @@ def build_argument_parser() -> argparse.ArgumentParser:
         The parser for the helper's bind and resume modes.
     """
     argument_parser = argparse.ArgumentParser(
-        description="Bind or consult a read-only Codex Sol xhigh advisor."
+        description="Bind or consult a read-only Codex Sol advisor."
     )
     mode_group = argument_parser.add_mutually_exclusive_group(required=True)
     mode_group.add_argument("--bind", action="store_true")
@@ -479,6 +525,13 @@ def build_argument_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Open the Sol rung for this invocation without an environment flag.",
     )
+    argument_parser.add_argument(
+        SOL_EFFORT_FLAG,
+        dest="sol_effort",
+        choices=ALL_ADVISOR_EFFORT_LEVELS,
+        default=None,
+        help="Shared advisor effort for this invocation.",
+    )
     return argument_parser
 
 
@@ -492,9 +545,11 @@ def main(all_cli_arguments: Sequence[str]) -> int:
         Zero for a successful Sol response, or one for an explicit fallback.
     """
     parsed_arguments = build_argument_parser().parse_args(list(all_cli_arguments))
-    setting_by_name: Mapping[str, str] = os.environ
+    setting_by_name: dict[str, str] = dict(os.environ)
     if parsed_arguments.is_sol_requested:
-        setting_by_name = {**os.environ, SOL_ENV_VAR: "1"}
+        setting_by_name[SOL_ENV_VAR] = "1"
+    if parsed_arguments.sol_effort is not None:
+        setting_by_name[ADVISOR_EFFORT_ENV_VAR] = parsed_arguments.sol_effort
     advisor_reply = run_codex_sol_advisor(
         prompt=sys.stdin.read(),
         working_directory=parsed_arguments.cwd,

package/_shared/advisor/scripts/config/advisor_scripts_constants/advisor_route_constants.py

@@ -6,6 +6,15 @@ ADVISOR_MODEL_TIER: str = "Sol"
 ADVISOR_CODEX_MODEL_ID: str = "gpt-5.6-sol"
 ADVISOR_FALLBACK_TIER: str = "Fable"
 ADVISOR_FALLBACK_RESULT: str = "fable"
+ADVISOR_EFFORT_ENV_VAR: str = "ADVISOR_EFFORT"
+ADVISOR_EFFORT_DEFAULT: str = "low"
+ALL_ADVISOR_EFFORT_LEVELS: tuple[str, ...] = (
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+)
 ALL_ADVISOR_GUIDANCE_SIGNALS: frozenset[str] = frozenset(
     {"ENDORSE", "CORRECTION", "PLAN", "STOP"}
 )

package/_shared/advisor/scripts/config/advisor_scripts_constants/model_tier_run_validator_constants.py

@@ -1,7 +1,7 @@
 """Constants for the model-tier-run validator and CLI / Agent alias map.
 
 They name the parts of a spawn-walk log: the tier ladder (strongest
-first), the two host profiles, and the validation messages. Shared log
+first), the three host profiles, and the validation messages. Shared log
 keys and bind-result tokens live in ``advisor_route_constants``.
 
 ::
@@ -11,9 +11,15 @@ The alias map turns each tier into its short CLI / Agent name (``opus``,
 
 Host-profile detection (see ``detect_host_profile``):
 
-- ``ADVISOR_HOST_PROFILE=ThirdParty`` or ``=Claude`` — explicit override
+- ``ADVISOR_HOST_PROFILE=ThirdParty``, ``=Claude``, or ``=Codex`` — explicit override
 - ``THIRD_PARTY=1`` (or ``true`` / ``yes``) — a third-party (non-Claude) harness
 - default when neither is set: Claude
+
+Session identity (see ``resolve_session_identity``):
+
+- a ``codex`` token maps to Codex
+- a ``claude`` token maps to Claude
+- any other identity maps to ThirdParty
 """
 
 from __future__ import annotations
@@ -24,11 +30,17 @@ from advisor_scripts_constants.advisor_route_constants import (
 )
 
 HOST_PROFILE_CLAUDE: str = "Claude"
+HOST_PROFILE_CODEX: str = "Codex"
 HOST_PROFILE_THIRD_PARTY: str = "ThirdParty"
 ALL_HOST_PROFILES: tuple[str, ...] = (
     HOST_PROFILE_CLAUDE,
+    HOST_PROFILE_CODEX,
     HOST_PROFILE_THIRD_PARTY,
 )
+SESSION_IDENTITY_CLAUDE_TOKEN: str = "claude"
+SESSION_IDENTITY_CODEX_TOKEN: str = "codex"
+SESSION_IDENTITY_WORD_PATTERN: str = r"[a-z0-9]+"
+HOST_PROFILE_JSON_KEY: str = "host_profile"
 
 ALL_MODEL_TIERS: tuple[str, ...] = (
     ADVISOR_FALLBACK_TIER,
@@ -42,7 +54,6 @@ ALL_KNOWN_TIER_NAMES: tuple[str, ...] = (
     *ALL_MODEL_TIERS,
     THIRD_PARTY_MODEL_TIER,
 )
-THIRD_PARTY_CLI_ADVISOR_FLOOR_TIER: str = "Opus"
 
 ADVISOR_SENDMESSAGE_REPLY_WAIT_SECONDS: int = 120
 
@@ -62,8 +73,9 @@ ALL_THIRD_PARTY_TRUTHY_VALUES: frozenset[str] = frozenset(
 UNKNOWN_OWN_TIER_MESSAGE: str = "own_tier is not a known model tier"
 UNKNOWN_LADDER_NAME_ERROR: str = "ladder name is not a known model tier: {!r}"
 UNKNOWN_HOST_PROFILE_ERROR: str = "host profile is not a known profile: {!r}"
+HOST_PROFILE_MUST_BE_STRING_MESSAGE: str = "host_profile must be a string"
 CANDIDATE_TIERS_MISMATCH_MESSAGE: str = (
-    "candidate_tiers does not match the ladder slice down to own_tier"
+    "candidate_tiers does not match the advisor walk for this host"
 )
 ATTEMPT_TIER_OUT_OF_SLICE_MESSAGE: str = (
     "a spawn try names a tier outside the candidate slice"

package/_shared/advisor/scripts/config/advisor_scripts_constants/sol_advisor_constants.py

@@ -1,4 +1,4 @@
-"""Constants for the optional Codex Sol xhigh advisor bind."""
+"""Constants for the optional Codex Sol advisor bind."""
 
 from __future__ import annotations
 
@@ -8,7 +8,7 @@ CODEX_READ_ONLY_SANDBOX: str = "read-only"
 CODEX_JSON_FLAG: str = "--json"
 CODEX_MODEL_FLAG: str = "--model"
 CODEX_CONFIG_FLAG: str = "--config"
-CODEX_REASONING_CONFIG: str = 'model_reasoning_effort="xhigh"'
+CODEX_REASONING_CONFIG_TEMPLATE: str = 'model_reasoning_effort="{effort}"'
 CODEX_PROMPT_FROM_STDIN: str = "-"
 CODEX_EXEC_SUBCOMMAND: str = "exec"
 CODEX_RESUME_SUBCOMMAND: str = "resume"
@@ -17,17 +17,18 @@ CLAUDE_CONFIG_DIRECTORY_NAME: str = ".claude"
 SOL_SESSION_ID_METAVAR: str = "SESSION_ID"
 SOL_CODEX_TIMEOUT_SECONDS: float = 120.0
 SOL_USAGE_PROBE_TIMEOUT_SECONDS: float = 30.0
-SOL_ENV_VAR: str = "ADVISOR_SOL_XHIGH"
+SOL_ENV_VAR: str = "ADVISOR_SOL"
 ALL_SOL_TRUTHY_VALUES: frozenset[str] = frozenset({"1", "true", "yes", "on"})
 SOL_PREFLIGHT_FAILURE_REASON: str = "sol preflight did not establish an eligible Codex meter"
-SOL_BIND_FAILURE_REASON: str = "Codex Sol xhigh bind failed"
-SOL_REPLY_FAILURE_REASON: str = "Codex Sol xhigh returned no advisor guidance"
+SOL_BIND_FAILURE_REASON: str = "Codex Sol bind failed"
+SOL_REPLY_FAILURE_REASON: str = "Codex Sol returned no advisor guidance"
 SOL_PROBE_TIMEOUT_REASON: str = "Codex Sol meter check timed out"
-SOL_CODEX_TIMEOUT_REASON: str = "Codex Sol xhigh request timed out"
-SOL_MALFORMED_JSONL_REASON: str = "Codex Sol xhigh returned malformed JSONL"
-SOL_MISSING_SESSION_REASON: str = "Codex Sol xhigh returned no session id"
-SOL_INVALID_SIGNAL_REASON: str = "Codex Sol xhigh returned an invalid guidance signal"
-SOL_EXECUTABLE_NOT_FOUND_REASON: str = "Codex Sol xhigh could not find the codex executable on PATH"
+SOL_CODEX_TIMEOUT_REASON: str = "Codex Sol request timed out"
+SOL_MALFORMED_JSONL_REASON: str = "Codex Sol returned malformed JSONL"
+SOL_MISSING_SESSION_REASON: str = "Codex Sol returned no session id"
+SOL_INVALID_SIGNAL_REASON: str = "Codex Sol returned an invalid guidance signal"
+SOL_EXECUTABLE_NOT_FOUND_REASON: str = "Codex Sol could not find the codex executable on PATH"
 SOL_FALLBACK_KIND_DECLINED: str = "declined"
 SOL_FALLBACK_KIND_BROKEN: str = "broken"
 SOL_ENABLE_FLAG: str = "--enable-sol"
+SOL_EFFORT_FLAG: str = "--effort"