claude-dev-env 1.94.0 → 2.0.0

package/_shared/advisor/CLAUDE.md

@@ -2,13 +2,13 @@
 
 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 Grok) is detected first; Claude walks the multi-tier Agent spawn ladder, Grok self-binds as the advisor with a separate executor paste block.
+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.
 
 ## Key documents
 
 | File | Purpose |
 |---|---|
-| `advisor-protocol.md` | Host profiles first, Claude-only model floor, warm-up spawn procedure and charter, consult format and cadence, lifecycle ownership (spawn on Claude / re-charter on Grok), host-matched Advisor blocks for executor spawns, and the Claude CLI fallback chain |
+| `advisor-protocol.md` | Host profiles first, model floor, warm-up / CLI bind procedure and charter, consult format and cadence, lifecycle ownership (Agent spawn on Claude / CLI re-bind on a third-party host), host-matched Advisor blocks for executor spawns, and the shared CLI Claude-chain |
 
 ## Subdirectory
 

package/_shared/advisor/advisor-protocol.md

@@ -2,46 +2,52 @@
 
 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 host-matched Advisor block below.
 
-**First step of every bind:** detect the host profile (next section). Do not walk the model-floor ladder, spawn `session-advisor`, or open the CLI fallback until the host is known. On Grok, skip straight to **Host profiles → Grok host**. On Claude, continue with **Model floor** and the rest of this document.
+**First step of every bind:** detect the host profile (next section). Do not walk the model-floor ladder, spawn `session-advisor`, or open the CLI fallback until the host is known. 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.
 
 ## Host profiles
 
-Detect the host profile **before** any model-floor walk. Source of truth for names and detection: `HOST_PROFILE_CLAUDE`, `HOST_PROFILE_GROK`, `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`.
+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`.
 
 Detection order:
 
-1. `ADVISOR_HOST_PROFILE=Grok` or `=Claude` (explicit override; any letter case).
-2. `GROK_BUILD=1` (or `true` / `yes` / `on`) — Grok Build / xAI harness.
+1. `ADVISOR_HOST_PROFILE=ThirdParty` or `=Claude` (explicit override; any letter case).
+2. `THIRD_PARTY=1` (or `true` / `yes` / `on`) — a third-party (non-Claude) harness.
 3. Default: Claude.
 
 ### Claude host
 
 Use the **Model floor** ladder below (Fable → Opus → Sonnet → Haiku). Warm-up spawns `subagent_type: session-advisor` via the Agent tool; consults go through `SendMessage` to that warm agent. When every candidate down to the floor fails, take the CLI Claude-chain fallback. Paste the **Claude host** Advisor block into every executor spawn prompt.
 
-### Grok host
+### Third-party host
 
-Grok Build / xAI has exactly one model tier. Do **not** walk the Claude ladder and do **not** require a `claude` binary.
+A third-party (non-Claude) harness cannot spawn a Claude `session-advisor` through the Agent tool. Bind a **max-tier Claude advisor** through the shared CLI Claude-chain (account usage failover). Do **not** treat this third-party session as the advisor.
 
 1. Detect host profile first (this section).
-2. Set `own_tier = Grok`, `candidate_tiers = ["Grok"]`, one attempt only, `selected_tier = Grok`.
-3. **Self-as-advisor:** skip the Agent-tool spawn of `session-advisor`. The orchestrating Grok session *is* the advisor — the same process answers ENDORSE / CORRECTION / PLAN / STOP. Executors (when any) report blockers to the orchestrating session; that session answers with the four signals inline (or via its own same-session consult loop). There is no SendMessage-to-another-Claude-agent path on a pure Grok host.
-4. Record the single attempt as `{tier: "Grok", result: "self"}` — the `self` token marks a self-bind so logs stay honest (not a separate spawn).
-5. CLI Claude-chain fallback does **not** apply on a pure Grok host.
-6. Paste the **Grok host** Advisor block into every executor spawn prompt — never the Claude SendMessage block.
+2. Set the advisor floor to **Opus** so the walk is `candidate_tiers = ["Fable", "Opus"]` with `own_tier = Opus`. The walk never drops to Sonnet or Haiku on a third-party host.
+3. **CLI bind (primary path):** for each candidate top-down, pipe a charter file into:
 
-Resolve the Grok alias with `resolve_cli_model_id("Grok")` → `grok` when a model field is required.
+   ```
+   python "$HOME/.claude/scripts/claude_chain_runner.py" -- -p --model <alias> --effort <effort> --output-format json
+   ```
 
-## Model floor
+   Use `--model fable --effort high` on Fable; use `--model opus --effort max` on Opus. The chain runner walks `~/.claude/claude-chain.json` (binaries such as `claude`, `claude-ev`, `claude-editor`, `claude-mel`) and fails over only on a usage-limit signature.
+4. Stop at the first successful bind. Record `{tier, result: "cli"}` and set `selected_tier` to that tier. Persist `session_id` from the JSON events (any event carries it; 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 or model unavailable), set `selected_tier = null` and a `fallback_reason`, report that the advisor is unreachable, and **stop**. Do **not** answer ENDORSE / CORRECTION / PLAN / STOP as this third-party session. Do **not** self-endorse.
+6. Paste the **Third-party host** Advisor block into every executor spawn prompt — never the Claude SendMessage block. Executors report to the orchestrating session; that session consults the bound Claude CLI advisor and relays the four-signal reply.
+
+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.
 
-**Claude host only.** On a Grok host, skip this section entirely — follow **Host profiles → Grok host**.
+## Model floor
 
-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:
+**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 just 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 max of those.
 
-Ladder, strongest first (canonical Title Case names: `Fable`, `Opus`, `Sonnet`, `Haiku`; the validator accepts any letter case and normalizes to Title Case): Fable, Opus, Sonnet, Haiku. Read the floor tier — the lower bound only — then try the warm-agent spawn top-down from Fable, stopping at the floor tier — never spawn below it. Each walk attempt sets the Agent tool `model:` field to the short alias for that attempt's candidate tier (`resolve_cli_model_id(candidate_tier)` — for example `opus`, not Title Case `Opus`). The warm agent is created at `selected_tier` (the first ladder tier that actually spawned), which may sit above the floor. If even the floor tier's spawn fails, move to the CLI fallback below rather than spawning below the floor.
+**Third-party host:** the CLI advisor floor is fixed at **Opus** (walk Fable → Opus only). The third-party session's own tier is not the advisor floor — see **Host profiles → Third-party host**.
 
-Emit a structured spawn-walk log so it can be checked mechanically rather than inferred from a transcript. Record: `own_tier` (the floor tier read at the top of this section), `candidate_tiers` (the ladder slice down to that floor), `attempts` (one `{tier, result}` entry appended as each spawn try happens, `result` one of `spawned` for a Claude Agent spawn, `self` for a Grok host self-bind, or a failure reason such as `unavailable`), and `selected_tier` (the tier of the first successful bind — first `spawned` or `self` entry — or `null` paired with a `fallback_reason` string when none bound and the CLI fallback took over). Write the log as JSON with those field names to a path the session controls — typically `<job-temp-dir>/model-tier-run.json` (or the OS temp directory when no job directory exists). Check it with:
+Ladder, strongest first (canonical Title Case names: `Fable`, `Opus`, `Sonnet`, `Haiku`; the validator accepts any letter case and normalizes to Title Case): Fable, Opus, Sonnet, Haiku. Read the floor tier — the lower bound only — then try binds top-down from Fable, stopping at the floor tier — never bind below it. On a Claude host each walk attempt sets the Agent tool `model:` field to the short alias for that attempt's candidate tier (`resolve_cli_model_id(candidate_tier)` — for example `opus`, not Title Case `Opus`). On a third-party host each walk attempt uses the CLI chain with that alias and the effort flags in **Host profiles → Third-party host**. The advisor is created at `selected_tier` (the first ladder tier that actually bound), which may sit above the floor. If even the floor tier fails on a Claude host, move to the CLI fallback below; on a third-party host the CLI chain **is** the primary path, so floor failure is fail-closed (report unreachable).
+
+Emit a structured spawn-walk log so it can be checked mechanically rather than inferred from a transcript. Record: `own_tier` (the floor tier), `candidate_tiers` (the ladder slice down to that floor), `attempts` (one `{tier, result}` entry appended as each bind try happens, `result` one of `spawned` for a Claude Agent spawn, `cli` for a CLI Claude-chain bind, or a failure reason such as `unavailable`), and `selected_tier` (the tier of the first successful bind — first `spawned` or `cli` entry — or `null` paired with a `fallback_reason` string when none bound). Write the log as JSON with those field names to a path the session controls — typically `<job-temp-dir>/model-tier-run.json` (or the OS temp directory when no job directory exists). Check it with:
 
 ```
 python "$HOME/.claude/_shared/advisor/scripts/model_tier_run_validator.py" <path-to-model-tier-run.json>
@@ -49,15 +55,15 @@ python "$HOME/.claude/_shared/advisor/scripts/model_tier_run_validator.py" <path
 
 Exit code `0` means every invariant holds; `1` means a ladder invariant failed; `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 (candidate slice, attempt order, success-token rules per tier). On a pure Grok host the protocol forbids CLI fallback after a failed self-bind; a log with `own_tier=Grok`, exhausted attempts, and `selected_tier=null` may still pass the structural validator — treat that as a host-policy violation outside the ladder checker.
+The validator checks ladder shape only (candidate slice, attempt order, success-token rules per tier). Host policy on top: a third-party host with `selected_tier=null` after an exhausted Fable→Opus walk must fail closed (report unreachable; never self-endorse).
 
 ## Warm-up (once per session)
 
-On a Grok host, skip this section — follow **Host profiles → Grok host** (self-as-advisor; no Agent spawn walk).
+On a **third-party host**, follow **Host profiles → Third-party host** (CLI Claude-chain bind at Fable then Opus; no Agent-tool `session-advisor` spawn). Charter the CLI session as a standing reviewer that only answers with ENDORSE / CORRECTION / PLAN / STOP — same consult contract as the Agent path, without SendMessage.
 
-On a Claude host, the consuming skill's session walks the candidate tiers top-down. For each attempt, spawn with:
+On a **Claude host**, the consuming skill's session walks the candidate tiers top-down. For each attempt, 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 attempt's candidate tier via `resolve_cli_model_id` (or the alias table under Fallback) — for example `opus`, not Title Case `Opus`. The floor is only the lower bound of the walk; the walk still tries stronger tiers first.
+- `model`: the short alias for that attempt's candidate tier via `resolve_cli_model_id` (or the alias table under CLI chain) — for example `opus`, not Title Case `Opus`. The floor is only the lower bound of the walk; the walk still tries stronger tiers first.
 - `name`: a name the session and every consumer will use to reach it (e.g. `team-advisor-agent`).
 - `run_in_background: true`.
 
@@ -86,7 +92,7 @@ Each consult carries, in order: who you are and your assignment (only needed on
 
 **Report-back rule.** After a CORRECTION or PLAN, your next consult on that topic opens with what happened when you followed it.
 
-Treat the reply as a serious second opinion: a CORRECTION — whether it names a wrong step or a risk worth closing — is something to address before treating the plan or the work as done. A STOP, or a consult that finds the advisor unreachable, is reported up rather than retried — 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 (see below); that session alone decides whether to respawn (Claude) or re-charter itself (Grok).
+Treat the reply as a serious second opinion: a CORRECTION — whether it names a wrong step or a risk worth closing — is something to address before treating the plan or the work as done. A STOP, or a consult that finds the advisor unreachable, is reported up rather than retried — 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 (see below); that session alone decides whether to respawn (Claude Agent or third-party CLI re-bind). A third-party host that cannot re-bind fails closed and reports to the user — it does not answer the four signals as itself.
 
 ## Advisor block — paste the host-matched block into every executor spawn prompt
 
@@ -96,9 +102,9 @@ Each paragraph is self-contained — the executor receives only this text, not t
 
 > A shared session advisor named `<name>` is reachable via SendMessage. Consult it before locking in a nontrivial approach, once you believe your assignment is done, before any hard-to-reverse action, when the same failure repeats or progress has stalled, and when the chosen approach is being reconsidered. Open each consult with who you are and your assignment, then: what you tried, the exact decision or blocker, and relevant paths or excerpts. Re-raise something it already answered only when you have new evidence to attach — the result of trying its advice, fresh output, or a changed constraint; otherwise act on its standing answer. After a CORRECTION or PLAN, your next consult on that topic opens with what happened when you followed it. Its replies open with one of ENDORSE, CORRECTION, PLAN, or STOP — treat CORRECTION and PLAN as actions to take. On STOP, or if the advisor is unreachable, report that back to whoever assigned you and leave lifecycle decisions to the session that owns the advisor.
 
-### Grok host (self-as-advisor; report to orchestrating session)
+### Third-party host (Claude CLI advisor; report to orchestrating session)
 
-> The orchestrating session is the shared advisor for this run — there is no separate `session-advisor` agent and no SendMessage path to one. Report blockers and hard decisions to the **orchestrating session** (the session that assigned you) before locking in a nontrivial approach, once you believe your assignment is done, before any hard-to-reverse action, when the same failure repeats or progress has stalled, and when the chosen approach is being reconsidered. Open each report with who you are and your assignment, then: what you tried, the exact decision or blocker, and relevant paths or excerpts. Re-raise something already answered only when you have new evidence to attach — the result of trying prior advice, fresh output, or a changed constraint; otherwise act on the standing answer. After a CORRECTION or PLAN, your next report on that topic opens with what happened when you followed it. The orchestrating session answers with one of ENDORSE, CORRECTION, PLAN, or STOP — treat CORRECTION and PLAN as actions to take. On STOP, or if the orchestrating session is unreachable, stop work and surface that upward; do not spawn a `session-advisor` agent yourself.
+> The orchestrating session owns a standing **Claude** advisor bound through the CLI Claude-chain (max tier: Fable high, then Opus max). There is no Agent-tool `session-advisor` and no SendMessage path to one. Report blockers and hard decisions to the **orchestrating session** (the session that assigned you) before locking in a nontrivial approach, once you believe your assignment is done, before any hard-to-reverse action, when the same failure repeats or progress has stalled, and when the chosen approach is being reconsidered. Open each report with who you are and your assignment, then: what you tried, the exact decision or blocker, and relevant paths or excerpts. Re-raise something already answered only when you have new evidence to attach — the result of trying prior advice, fresh output, or a changed constraint; otherwise act on the standing answer. After a CORRECTION or PLAN, your next report on that topic opens with what happened when you followed it. The orchestrating session consults the Claude CLI advisor and relays one of ENDORSE, CORRECTION, PLAN, or STOP — treat CORRECTION and PLAN as actions to take. On STOP, or if the orchestrating session reports the advisor unreachable, stop work and surface that upward; do not spawn a `session-advisor` agent yourself, and do not treat the third-party orchestrator's own judgment as an advisor signal.
 
 ## Lifecycle ownership
 
@@ -108,17 +114,19 @@ The session that spawns the shared advisor owns its whole lifecycle — spawn, d
 
 **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, rather than forcing the old context to stretch across two different jobs.
 
-### Grok host
+### 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.
 
-The orchestrating session owns the self-as-advisor role for the whole run. There is no Agent spawn to end or respawn.
+**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. Executors keep reporting to the orchestrating session; they never bind a replacement advisor themselves.
 
-**Re-charter on drift.** If the session's own answers show a stale picture, or the task pivots, re-state the self-as-advisor charter in-session (goal, four-signal contract, executor report path) and log another `{tier: "Grok", result: "self"}` bind only when a fresh structural log is needed. Executors keep reporting to the orchestrating session; they never spawn a replacement advisor.
+## CLI chain
 
-## Fallback: the CLI chain
+The shared runner is `python "$HOME/.claude/scripts/claude_chain_runner.py" -- <claude args...>`. It walks `~/.claude/claude-chain.json` and fails over to the next binary only on a usage-limit signature, so a usage-limited primary account still gets served.
 
-This section applies on a **Claude host** only. On a pure Grok host, skip it — there is no Claude binary chain and the session is already the advisor (see **Host profiles**).
+**Third-party host:** this runner is the **primary** advisor bind and consult path (see **Host profiles → Third-party host**). Map each walk attempt to `--model <alias>` and the effort flags there. When the walk exhausts, fail closed.
 
-Fall back to the CLI when any of these holds, rather than on judgment call:
+**Claude host:** fall back to this runner when any of these holds, rather than on judgment call:
 - The Agent-tool spawn errors at every candidate tier down to the floor — the tool itself, not just the top tier, 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.
 - The running session is itself a subagent barred from spawning further agents.
@@ -131,11 +139,11 @@ Map `selected_tier` when one exists (the warm agent already bound above the floo
 | Opus | `opus` |
 | Sonnet | `sonnet` |
 | Haiku | `haiku` |
-| Grok (Grok host only; not part of the Claude walk) | `grok` |
+| ThirdParty (third-party session model field only; not an advisor walk tier) | `third-party` |
 
-Resolve in code with `python -c "from tier_model_ids import resolve_cli_model_id; print(resolve_cli_model_id('Opus'))"` from `$HOME/.claude/_shared/advisor/scripts/` (any letter case accepted; unknown tiers raise `ValueError`). Use `python "$HOME/.claude/scripts/claude_chain_runner.py" -- -p --model <model alias> --output-format json` in place of the Agent-tool spawn. The chain runner walks the fallback chain configured at `~/.claude/claude-chain.json` (typically `claude` then `claude-ev`), so a usage-limited primary account still gets served. Write the charter or the consult brief to a temporary file under the job's own temporary directory (or the OS temp directory when no job directory exists) and pipe it in, rather than passing either as an inline argument, and drop that file once the consult completes.
+Resolve in code with `python -c "from tier_model_ids import resolve_cli_model_id; print(resolve_cli_model_id('Opus'))"` from `$HOME/.claude/_shared/advisor/scripts/` (any letter case accepted; unknown tiers raise `ValueError`). Write the charter or the consult brief to a temporary file under the job's own temporary directory (or the OS temp directory when no job directory exists) and pipe it in, rather than passing either as an inline argument, and drop that file once the consult completes.
 
-Read the `session_id` out of the first call's JSON response and pass it to `-p --resume <session_id> --output-format json` on every later consult — `-p` stays on the resume call too, since it is still a non-interactive invocation. A usage-limit failover to the next binary in the chain does not carry the `session_id` forward: a session store belongs to the binary and account that minted it, so a `--resume` against the new binary can fail. Treat that failure as starting over, not as an error to retry — resend the charter plus a compact recap of the consults since the last one, capture the new `session_id` the fresh call returns, and continue the fallback path from there.
+Read the `session_id` out of the first call's JSON events and pass it to `-p --resume <session_id> --output-format json` on every later consult — `-p` stays on the resume call too, since it is still a non-interactive invocation. A usage-limit failover to the next binary in the chain does not carry the `session_id` forward: a session store belongs to the binary and account that minted it, so a `--resume` against the new binary can fail. Treat that failure as starting over, not as an error to retry — resend the charter plus a compact recap of the consults since the last one, capture the new `session_id` the fresh call returns, and continue from there.
 
 ## Mechanism, not a measured saving
 

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

@@ -9,28 +9,32 @@ that mark a bind.
     attempt = {"tier": "Opus", "result": "spawned"}
                        ^^^^^^           ^^^^^^^^^
                        a ladder tier    SPAWN_SUCCESS_TOKEN
-    ok:   "self" marks a Grok host self-bind (SELF_BIND_SUCCESS_TOKEN)
+    ok:   "cli" marks a CLI Claude-chain bind (CLI_BIND_SUCCESS_TOKEN)
     flag: any other result token counts as no bind
 
 The alias map turns each tier into its short CLI / Agent name (``opus``,
-``grok``), never a dated full model ID.
+``third-party``), never a dated full model ID.
 
 Host-profile detection (see ``detect_host_profile``):
 
-- ``ADVISOR_HOST_PROFILE=Grok`` or ``=Claude`` — explicit override
-- ``GROK_BUILD=1`` (or ``true`` / ``yes``) — Grok Build / xAI harness
+- ``ADVISOR_HOST_PROFILE=ThirdParty`` or ``=Claude`` — explicit override
+- ``THIRD_PARTY=1`` (or ``true`` / ``yes``) — a third-party (non-Claude) harness
 - default when neither is set: Claude
 """
 
 from __future__ import annotations
 
 HOST_PROFILE_CLAUDE: str = "Claude"
-HOST_PROFILE_GROK: str = "Grok"
-ALL_HOST_PROFILES: tuple[str, ...] = (HOST_PROFILE_CLAUDE, HOST_PROFILE_GROK)
+HOST_PROFILE_THIRD_PARTY: str = "ThirdParty"
+ALL_HOST_PROFILES: tuple[str, ...] = (
+    HOST_PROFILE_CLAUDE,
+    HOST_PROFILE_THIRD_PARTY,
+)
 
 ALL_MODEL_TIERS: tuple[str, ...] = ("Fable", "Opus", "Sonnet", "Haiku")
-GROK_MODEL_TIER: str = "Grok"
-ALL_KNOWN_TIER_NAMES: tuple[str, ...] = (*ALL_MODEL_TIERS, GROK_MODEL_TIER)
+THIRD_PARTY_MODEL_TIER: str = "ThirdParty"
+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
 
@@ -39,19 +43,19 @@ ALL_CLI_MODEL_ID_BY_TIER: dict[str, str] = {
     "Opus": "opus",
     "Sonnet": "sonnet",
     "Haiku": "haiku",
-    GROK_MODEL_TIER: "grok",
+    THIRD_PARTY_MODEL_TIER: "third-party",
 }
 
 HOST_PROFILE_ENV_VAR: str = "ADVISOR_HOST_PROFILE"
-GROK_BUILD_ENV_VAR: str = "GROK_BUILD"
-ALL_GROK_BUILD_TRUTHY_VALUES: frozenset[str] = frozenset(
+THIRD_PARTY_ENV_VAR: str = "THIRD_PARTY"
+ALL_THIRD_PARTY_TRUTHY_VALUES: frozenset[str] = frozenset(
     {"1", "true", "yes", "on"}
 )
 
 TIER_KEY: str = "tier"
 SPAWN_OUTCOME_KEY: str = "result"
 SPAWN_SUCCESS_TOKEN: str = "spawned"
-SELF_BIND_SUCCESS_TOKEN: str = "self"
+CLI_BIND_SUCCESS_TOKEN: str = "cli"
 
 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}"
@@ -66,7 +70,7 @@ ATTEMPT_ORDER_MISMATCH_MESSAGE: str = (
     "spawn tries do not walk the candidate tiers in ladder order"
 )
 SELECTED_TIER_MISMATCH_MESSAGE: str = (
-    "selected_tier does not match the first successful bind (spawned or self)"
+    "selected_tier does not match the first successful bind (spawned or cli)"
 )
 SELECTED_TIER_NOT_NULL_MESSAGE: str = (
     "selected_tier must be null when no spawn try succeeded"

package/_shared/advisor/scripts/model_tier_run_validator.py

@@ -17,13 +17,13 @@ from data, not inferred from a transcript.
     )
     validate_model_tier_run(ladder_walk)  # ok: returns None, raises nothing
 
-    self_bind = ModelTierRun(
-        own_tier="Grok",
-        candidate_tiers=["Grok"],
-        attempts=[{"tier": "Grok", "result": "self"}],
-        selected_tier="Grok",
+    cli_bind = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[{"tier": "Fable", "result": "cli"}],
+        selected_tier="Fable",
     )
-    validate_model_tier_run(self_bind)  # ok: host self-as-advisor bind
+    validate_model_tier_run(cli_bind)  # ok: third-party-host CLI Claude-chain bind
 
 A run whose selected_tier is not the first successful bind fails.
 On any broken invariant, validate_model_tier_run raises ModelTierRunError.
@@ -52,19 +52,20 @@ from advisor_scripts_constants.model_tier_run_validator_constants import (  # no
     ATTEMPT_ORDER_MISMATCH_MESSAGE,
     ATTEMPT_TIER_OUT_OF_SLICE_MESSAGE,
     CANDIDATE_TIERS_MISMATCH_MESSAGE,
+    CLI_BIND_SUCCESS_TOKEN,
     CLI_INVALID_JSON_EXIT_CODE,
     CLI_MISSING_PATH_EXIT_CODE,
     CLI_SUCCESS_EXIT_CODE,
     CLI_USAGE_MESSAGE,
     CLI_VALIDATION_FAILURE_EXIT_CODE,
-    GROK_MODEL_TIER,
     INCOMPLETE_FALLBACK_WALK_MESSAGE,
     MISSING_FALLBACK_REASON_MESSAGE,
     SELECTED_TIER_MISMATCH_MESSAGE,
     SELECTED_TIER_NOT_NULL_MESSAGE,
-    SELF_BIND_SUCCESS_TOKEN,
     SPAWN_OUTCOME_KEY,
     SPAWN_SUCCESS_TOKEN,
+    THIRD_PARTY_CLI_ADVISOR_FLOOR_TIER,
+    THIRD_PARTY_MODEL_TIER,
     TIER_KEY,
     UNKNOWN_OWN_TIER_MESSAGE,
 )
@@ -98,8 +99,9 @@ def _expected_candidate_tiers(own_tier: str) -> list[str]:
     maybe_canonical_own_tier = canonical_tier_name(own_tier)
     if maybe_canonical_own_tier is None:
         raise ModelTierRunError(f"{UNKNOWN_OWN_TIER_MESSAGE}: {own_tier!r}")
-    if maybe_canonical_own_tier == GROK_MODEL_TIER:
-        return [GROK_MODEL_TIER]
+    if maybe_canonical_own_tier == THIRD_PARTY_MODEL_TIER:
+        floor_index = ALL_MODEL_TIERS.index(THIRD_PARTY_CLI_ADVISOR_FLOOR_TIER)
+        return list(ALL_MODEL_TIERS[: floor_index + 1])
     floor_index = ALL_MODEL_TIERS.index(maybe_canonical_own_tier)
     return list(ALL_MODEL_TIERS[: floor_index + 1])
 
@@ -108,9 +110,13 @@ def _is_successful_attempt_outcome(
     canonical_tier: str,
     outcome_token: str,
 ) -> bool:
-    if canonical_tier == GROK_MODEL_TIER:
-        return outcome_token == SELF_BIND_SUCCESS_TOKEN
-    return outcome_token == SPAWN_SUCCESS_TOKEN
+    if canonical_tier == THIRD_PARTY_MODEL_TIER:
+        return False
+    if outcome_token == SPAWN_SUCCESS_TOKEN:
+        return True
+    if outcome_token == CLI_BIND_SUCCESS_TOKEN:
+        return True
+    return False
 
 
 def validate_model_tier_run(run: ModelTierRun) -> None:
@@ -118,13 +124,16 @@ def validate_model_tier_run(run: ModelTierRun) -> None:
 
     ::
 
-        validate_model_tier_run(ladder_walk)  # ok: multi-tier ladder walk
-        validate_model_tier_run(self_bind)    # ok: single-tier self-bind
+        validate_model_tier_run(ladder_walk)  # ok: multi-tier Agent walk
+        validate_model_tier_run(cli_bind)     # ok: CLI Claude-chain bind
         validate_model_tier_run(broken_log)   # flag: ModelTierRunError
 
-    Candidate tiers must match the floor slice (or ``["Grok"]`` alone). Tries
-    walk that slice in order; early stop only after ``spawned`` or ``self``.
-    A null selected_tier requires a full walk plus fallback_reason.
+    Candidate tiers must match the floor slice. ``own_tier=ThirdParty`` maps to
+    the third-party-host CLI advisor floor (Fable → Opus). Tries walk that
+    slice in order;
+    early stop only after ``spawned`` or ``cli``. A null selected_tier requires
+    a full walk plus fallback_reason (fail-closed on a third-party host when
+    the chain cannot serve).
 
     Args:
         run: The structured spawn-walk log to check.

package/_shared/advisor/scripts/tests/test_model_tier_run_validator.py

@@ -118,7 +118,13 @@ def test_selected_tier_not_first_spawned_attempt_raises() -> None:
         ],
         selected_tier="Fable",
     )
-    with pytest.raises(ModelTierRunError):
+    with pytest.raises(
+        ModelTierRunError,
+        match=(
+            "selected_tier does not match the first successful bind "
+            r"\(spawned or cli\)"
+        ),
+    ):
         validate_model_tier_run(run)
 
 
@@ -238,53 +244,117 @@ def test_cli_missing_path_returns_usage_exit_code() -> None:
     assert main([]) == 2
 
 
-def test_grok_host_single_tier_self_bind_passes() -> None:
+def test_cli_bind_at_fable_passes() -> None:
     run = ModelTierRun(
-        own_tier="Grok",
-        candidate_tiers=["Grok"],
-        attempts=[{"tier": "Grok", "result": "self"}],
-        selected_tier="Grok",
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[{"tier": "Fable", "result": "cli"}],
+        selected_tier="Fable",
     )
     assert validate_model_tier_run(run) is None
 
 
-def test_grok_host_lowercase_self_bind_passes() -> None:
+def test_cli_bind_fallthrough_to_opus_passes() -> None:
     run = ModelTierRun(
-        own_tier="grok",
-        candidate_tiers=["grok"],
-        attempts=[{"tier": "grok", "result": "self"}],
-        selected_tier="grok",
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[
+            {"tier": "Fable", "result": "unavailable"},
+            {"tier": "Opus", "result": "cli"},
+        ],
+        selected_tier="Opus",
     )
     assert validate_model_tier_run(run) is None
 
 
-def test_grok_host_multi_tier_candidate_list_raises() -> None:
+def test_third_party_own_tier_maps_to_fable_opus_cli_bind_passes() -> None:
+    run = ModelTierRun(
+        own_tier="ThirdParty",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[{"tier": "Fable", "result": "cli"}],
+        selected_tier="Fable",
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_third_party_own_tier_lowercase_cli_bind_passes() -> None:
+    run = ModelTierRun(
+        own_tier="thirdparty",
+        candidate_tiers=["fable", "opus"],
+        attempts=[{"tier": "fable", "result": "cli"}],
+        selected_tier="fable",
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_self_token_is_not_bind_success_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[{"tier": "Fable", "result": "self"}],
+        selected_tier="Fable",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_third_party_self_token_is_not_bind_success_raises() -> None:
     run = ModelTierRun(
-        own_tier="Grok",
-        candidate_tiers=["Fable", "Opus", "Grok"],
-        attempts=[{"tier": "Grok", "result": "self"}],
-        selected_tier="Grok",
+        own_tier="ThirdParty",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[{"tier": "Fable", "result": "self"}],
+        selected_tier="Fable",
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
 
 
-def test_grok_host_spawned_token_is_not_self_bind_raises() -> None:
+def test_third_party_host_legacy_single_tier_self_bind_raises() -> None:
     run = ModelTierRun(
-        own_tier="Grok",
-        candidate_tiers=["Grok"],
-        attempts=[{"tier": "Grok", "result": "spawned"}],
-        selected_tier="Grok",
+        own_tier="ThirdParty",
+        candidate_tiers=["ThirdParty"],
+        attempts=[{"tier": "ThirdParty", "result": "self"}],
+        selected_tier="ThirdParty",
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
 
 
-def test_grok_host_selected_tier_mismatch_raises() -> None:
+def test_third_party_cli_exhausted_fail_closed_passes() -> None:
     run = ModelTierRun(
-        own_tier="Grok",
-        candidate_tiers=["Grok"],
-        attempts=[{"tier": "Grok", "result": "self"}],
+        own_tier="ThirdParty",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[
+            {"tier": "Fable", "result": "unavailable"},
+            {"tier": "Opus", "result": "unavailable"},
+        ],
+        selected_tier=None,
+        fallback_reason=(
+            "third-party host CLI Claude-chain exhausted; fail closed"
+        ),
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_third_party_cli_exhausted_without_fallback_reason_raises() -> None:
+    run = ModelTierRun(
+        own_tier="ThirdParty",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[
+            {"tier": "Fable", "result": "unavailable"},
+            {"tier": "Opus", "result": "unavailable"},
+        ],
+        selected_tier=None,
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_third_party_cli_selected_tier_mismatch_raises() -> None:
+    run = ModelTierRun(
+        own_tier="ThirdParty",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[{"tier": "Fable", "result": "cli"}],
         selected_tier="Opus",
     )
     with pytest.raises(ModelTierRunError):

package/_shared/advisor/scripts/tests/test_tier_model_ids.py

@@ -37,9 +37,9 @@ from advisor_scripts_constants.model_tier_run_validator_constants import (  # no
     ALL_CLI_MODEL_ID_BY_TIER,
     ALL_KNOWN_TIER_NAMES,
     ALL_MODEL_TIERS,
-    GROK_MODEL_TIER,
     HOST_PROFILE_CLAUDE,
-    HOST_PROFILE_GROK,
+    HOST_PROFILE_THIRD_PARTY,
+    THIRD_PARTY_MODEL_TIER,
 )
 
 SCRIPTS_ROOT = Path(__file__).parent.parent
@@ -56,13 +56,13 @@ DOCUMENTED_RESOLVE_ONE_LINER = (
         ("Opus", "opus"),
         ("Sonnet", "sonnet"),
         ("Haiku", "haiku"),
-        ("Grok", "grok"),
+        ("ThirdParty", "third-party"),
         ("fable", "fable"),
         ("OPUS", "opus"),
         ("sonnet", "sonnet"),
         ("hAiKu", "haiku"),
-        ("grok", "grok"),
-        (" GROK ", "grok"),
+        ("thirdparty", "third-party"),
+        (" THIRDPARTY ", "third-party"),
         (" Opus ", "opus"),
         ("\thaiku\n", "haiku"),
     ],
@@ -97,8 +97,8 @@ def test_sendmessage_reply_wait_is_positive_bound() -> None:
 def test_cli_model_alias_map_keys_match_known_tiers() -> None:
     assert set(ALL_CLI_MODEL_ID_BY_TIER) == set(ALL_KNOWN_TIER_NAMES)
     assert set(ALL_MODEL_TIERS).issubset(set(ALL_KNOWN_TIER_NAMES))
-    assert GROK_MODEL_TIER in ALL_KNOWN_TIER_NAMES
-    assert GROK_MODEL_TIER not in ALL_MODEL_TIERS
+    assert THIRD_PARTY_MODEL_TIER in ALL_KNOWN_TIER_NAMES
+    assert THIRD_PARTY_MODEL_TIER not in ALL_MODEL_TIERS
     assert all(
         ALL_CLI_MODEL_ID_BY_TIER[each_tier] for each_tier in ALL_KNOWN_TIER_NAMES
     )
@@ -106,7 +106,7 @@ def test_cli_model_alias_map_keys_match_known_tiers() -> None:
 
 def test_canonical_tier_name_strips_and_normalizes() -> None:
     assert canonical_tier_name(" opus ") == "Opus"
-    assert canonical_tier_name("grok") == "Grok"
+    assert canonical_tier_name("thirdparty") == "ThirdParty"
     assert canonical_tier_name("") is None
     assert canonical_tier_name("Titan") is None
 
@@ -119,30 +119,30 @@ def test_detect_host_profile_defaults_to_claude() -> None:
     "truthy_value",
     ["1", "true", "TRUE", "yes", "YES", "on", "On"],
 )
-def test_detect_host_profile_reads_grok_build_truthy_values(
+def test_detect_host_profile_reads_third_party_truthy_values(
     truthy_value: str,
 ) -> None:
     assert (
-        detect_host_profile(setting_by_name={"GROK_BUILD": truthy_value})
-        == HOST_PROFILE_GROK
+        detect_host_profile(setting_by_name={"THIRD_PARTY": truthy_value})
+        == HOST_PROFILE_THIRD_PARTY
     )
 
 
-def test_detect_host_profile_reads_grok_build_flag() -> None:
+def test_detect_host_profile_reads_third_party_flag() -> None:
     assert (
-        detect_host_profile(setting_by_name={"GROK_BUILD": "0"})
+        detect_host_profile(setting_by_name={"THIRD_PARTY": "0"})
         == HOST_PROFILE_CLAUDE
     )
     assert (
-        detect_host_profile(setting_by_name={"GROK_BUILD": "false"})
+        detect_host_profile(setting_by_name={"THIRD_PARTY": "false"})
         == HOST_PROFILE_CLAUDE
     )
 
 
 def test_detect_host_profile_reads_explicit_override() -> None:
     assert (
-        detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "Grok"})
-        == HOST_PROFILE_GROK
+        detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "ThirdParty"})
+        == HOST_PROFILE_THIRD_PARTY
     )
     assert (
         detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "claude"})
@@ -150,7 +150,7 @@ def test_detect_host_profile_reads_explicit_override() -> None:
     )
     assert (
         detect_host_profile(
-            setting_by_name={"ADVISOR_HOST_PROFILE": "Claude", "GROK_BUILD": "1"}
+            setting_by_name={"ADVISOR_HOST_PROFILE": "Claude", "THIRD_PARTY": "1"}
         )
         == HOST_PROFILE_CLAUDE
     )