claude-dev-env 1.95.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 (CLI chain as fallback), Grok 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 (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, model floor, warm-up / CLI bind procedure and charter, consult format and cadence, lifecycle ownership (Agent spawn on Claude / CLI re-bind on Grok), host-matched Advisor blocks for executor spawns, and the shared CLI Claude-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,28 +2,28 @@
 
 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 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 Grok session as the advisor.
+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 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 Grok host.
+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:
 
    ```
@@ -32,10 +32,10 @@ Grok Build / xAI cannot spawn a Claude `session-advisor` through the Agent tool.
 
    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 Grok session. Do **not** self-endorse.
-6. Paste the **Grok 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.
+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 Grok session's own model field with `resolve_cli_model_id("Grok")` → `grok` when a host model alias is required. The **advisor** bind uses Fable/Opus aliases only.
+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.
 
 ## Model floor
 
@@ -43,9 +43,9 @@ Resolve a Grok session's own model field with `resolve_cli_model_id("Grok")` →
 - `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.
 
-**Grok host:** the CLI advisor floor is fixed at **Opus** (walk Fable → Opus only). The Grok session's own tier is not the advisor floor — see **Host profiles → Grok host**.
+**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**.
 
-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 Grok host each walk attempt uses the CLI chain with that alias and the effort flags in **Host profiles → Grok 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 Grok host the CLI chain **is** the primary path, so floor failure is fail-closed (report unreachable).
+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:
 
@@ -55,11 +55,11 @@ 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). Host policy on top: a Grok host with `selected_tier=null` after an exhausted Fable→Opus walk must fail closed (report unreachable; never self-endorse).
+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**, follow **Host profiles → Grok 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 **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:
 - `subagent_type: session-advisor` (see [`agents/session-advisor.md`](../../agents/session-advisor.md) for the full signal contract).
@@ -92,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 Agent or Grok CLI re-bind). A Grok host that cannot re-bind fails closed and reports to the user — it does not answer the four signals as itself.
+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
 
@@ -102,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 (Claude CLI advisor; report to orchestrating session)
+### Third-party host (Claude CLI advisor; report to orchestrating session)
 
-> 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 Grok orchestrator's own judgment as an advisor signal.
+> 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
 
@@ -114,7 +114,7 @@ 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.
 
@@ -124,7 +124,7 @@ The orchestrating session owns the Claude CLI advisor bind for the whole run —
 
 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.
 
-**Grok host:** this runner is the **primary** advisor bind and consult path (see **Host profiles → Grok host**). Map each walk attempt to `--model <alias>` and the effort flags there. When the walk exhausts, fail closed.
+**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.
 
 **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.
@@ -139,7 +139,7 @@ Map `selected_tier` when one exists (the warm agent already bound above the floo
 | Opus | `opus` |
 | Sonnet | `sonnet` |
 | Haiku | `haiku` |
-| Grok (Grok session model field only; not an advisor walk tier) | `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`). 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.
 

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

@@ -13,25 +13,28 @@ that mark a bind.
     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)
-GROK_CLI_ADVISOR_FLOOR_TIER: str = "Opus"
+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
 
@@ -40,12 +43,12 @@ 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"}
 )
 
@@ -67,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

@@ -23,7 +23,7 @@ from data, not inferred from a transcript.
         attempts=[{"tier": "Fable", "result": "cli"}],
         selected_tier="Fable",
     )
-    validate_model_tier_run(cli_bind)  # ok: Grok-host CLI Claude-chain 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.
@@ -58,14 +58,14 @@ from advisor_scripts_constants.model_tier_run_validator_constants import (  # no
     CLI_SUCCESS_EXIT_CODE,
     CLI_USAGE_MESSAGE,
     CLI_VALIDATION_FAILURE_EXIT_CODE,
-    GROK_CLI_ADVISOR_FLOOR_TIER,
-    GROK_MODEL_TIER,
     INCOMPLETE_FALLBACK_WALK_MESSAGE,
     MISSING_FALLBACK_REASON_MESSAGE,
     SELECTED_TIER_MISMATCH_MESSAGE,
     SELECTED_TIER_NOT_NULL_MESSAGE,
     SPAWN_OUTCOME_KEY,
     SPAWN_SUCCESS_TOKEN,
+    THIRD_PARTY_CLI_ADVISOR_FLOOR_TIER,
+    THIRD_PARTY_MODEL_TIER,
     TIER_KEY,
     UNKNOWN_OWN_TIER_MESSAGE,
 )
@@ -99,8 +99,8 @@ 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:
-        floor_index = ALL_MODEL_TIERS.index(GROK_CLI_ADVISOR_FLOOR_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])
@@ -110,7 +110,7 @@ def _is_successful_attempt_outcome(
     canonical_tier: str,
     outcome_token: str,
 ) -> bool:
-    if canonical_tier == GROK_MODEL_TIER:
+    if canonical_tier == THIRD_PARTY_MODEL_TIER:
         return False
     if outcome_token == SPAWN_SUCCESS_TOKEN:
         return True
@@ -128,11 +128,12 @@ def validate_model_tier_run(run: ModelTierRun) -> None:
         validate_model_tier_run(cli_bind)     # ok: CLI Claude-chain bind
         validate_model_tier_run(broken_log)   # flag: ModelTierRunError
 
-    Candidate tiers must match the floor slice. ``own_tier=Grok`` maps to the
-    Grok-host CLI advisor floor (Fable → Opus). Tries walk that slice in order;
+    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 Grok when the chain
-    cannot serve).
+    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)
 
 
@@ -261,9 +267,9 @@ def test_cli_bind_fallthrough_to_opus_passes() -> None:
     assert validate_model_tier_run(run) is None
 
 
-def test_grok_own_tier_maps_to_fable_opus_cli_bind_passes() -> None:
+def test_third_party_own_tier_maps_to_fable_opus_cli_bind_passes() -> None:
     run = ModelTierRun(
-        own_tier="Grok",
+        own_tier="ThirdParty",
         candidate_tiers=["Fable", "Opus"],
         attempts=[{"tier": "Fable", "result": "cli"}],
         selected_tier="Fable",
@@ -271,9 +277,9 @@ def test_grok_own_tier_maps_to_fable_opus_cli_bind_passes() -> None:
     assert validate_model_tier_run(run) is None
 
 
-def test_grok_own_tier_lowercase_cli_bind_passes() -> None:
+def test_third_party_own_tier_lowercase_cli_bind_passes() -> None:
     run = ModelTierRun(
-        own_tier="grok",
+        own_tier="thirdparty",
         candidate_tiers=["fable", "opus"],
         attempts=[{"tier": "fable", "result": "cli"}],
         selected_tier="fable",
@@ -292,9 +298,9 @@ def test_self_token_is_not_bind_success_raises() -> None:
         validate_model_tier_run(run)
 
 
-def test_grok_self_token_is_not_bind_success_raises() -> None:
+def test_third_party_self_token_is_not_bind_success_raises() -> None:
     run = ModelTierRun(
-        own_tier="Grok",
+        own_tier="ThirdParty",
         candidate_tiers=["Fable", "Opus"],
         attempts=[{"tier": "Fable", "result": "self"}],
         selected_tier="Fable",
@@ -303,20 +309,20 @@ def test_grok_self_token_is_not_bind_success_raises() -> None:
         validate_model_tier_run(run)
 
 
-def test_grok_host_legacy_single_tier_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": "self"}],
-        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_cli_exhausted_fail_closed_passes() -> None:
+def test_third_party_cli_exhausted_fail_closed_passes() -> None:
     run = ModelTierRun(
-        own_tier="Grok",
+        own_tier="ThirdParty",
         candidate_tiers=["Fable", "Opus"],
         attempts=[
             {"tier": "Fable", "result": "unavailable"},
@@ -324,15 +330,15 @@ def test_grok_cli_exhausted_fail_closed_passes() -> None:
         ],
         selected_tier=None,
         fallback_reason=(
-            "Grok host CLI Claude-chain exhausted; fail closed"
+            "third-party host CLI Claude-chain exhausted; fail closed"
         ),
     )
     assert validate_model_tier_run(run) is None
 
 
-def test_grok_cli_exhausted_without_fallback_reason_raises() -> None:
+def test_third_party_cli_exhausted_without_fallback_reason_raises() -> None:
     run = ModelTierRun(
-        own_tier="Grok",
+        own_tier="ThirdParty",
         candidate_tiers=["Fable", "Opus"],
         attempts=[
             {"tier": "Fable", "result": "unavailable"},
@@ -344,9 +350,9 @@ def test_grok_cli_exhausted_without_fallback_reason_raises() -> None:
         validate_model_tier_run(run)
 
 
-def test_grok_cli_selected_tier_mismatch_raises() -> None:
+def test_third_party_cli_selected_tier_mismatch_raises() -> None:
     run = ModelTierRun(
-        own_tier="Grok",
+        own_tier="ThirdParty",
         candidate_tiers=["Fable", "Opus"],
         attempts=[{"tier": "Fable", "result": "cli"}],
         selected_tier="Opus",

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
     )

package/_shared/advisor/scripts/tier_model_ids.py

@@ -4,16 +4,16 @@
 
     resolve_cli_model_id("Opus")   # ok: "opus"
     resolve_cli_model_id("fable")  # ok: "fable" (any letter case)
-    resolve_cli_model_id("Grok")   # ok: "grok" (Grok host single tier)
+    resolve_cli_model_id("ThirdParty")  # ok: "third-party" (third-party host tier)
     resolve_cli_model_id(" Opus ") # ok: "opus" (leading/trailing whitespace)
     resolve_cli_model_id("Titan")  # flag: ValueError
 
-    detect_host_profile(setting_by_name={"GROK_BUILD": "1"})  # ok: "Grok"
+    detect_host_profile(setting_by_name={"THIRD_PARTY": "1"})  # ok: "ThirdParty"
     detect_host_profile(
         setting_by_name={"ADVISOR_HOST_PROFILE": "Claude"}
     )  # ok: "Claude"
 
-Values are stable short aliases (``opus``, ``sonnet``, ``grok``), not dated
+Values are stable short aliases (``opus``, ``sonnet``, ``third-party``), not dated
 full model IDs such as ``claude-opus-4-…``. The map lives in
 ``advisor_scripts_constants`` so protocol text, skills, and tests share one
 source of truth for the aliases the Agent tool ``model:`` field and CLI
@@ -35,13 +35,13 @@ if _config_directory not in sys.path:
 
 from advisor_scripts_constants.model_tier_run_validator_constants import (  # noqa: E402
     ALL_CLI_MODEL_ID_BY_TIER,
-    ALL_GROK_BUILD_TRUTHY_VALUES,
     ALL_HOST_PROFILES,
     ALL_KNOWN_TIER_NAMES,
-    GROK_BUILD_ENV_VAR,
+    ALL_THIRD_PARTY_TRUTHY_VALUES,
     HOST_PROFILE_CLAUDE,
     HOST_PROFILE_ENV_VAR,
-    HOST_PROFILE_GROK,
+    HOST_PROFILE_THIRD_PARTY,
+    THIRD_PARTY_ENV_VAR,
     UNKNOWN_HOST_PROFILE_ERROR,
     UNKNOWN_LADDER_NAME_ERROR,
 )
@@ -53,13 +53,13 @@ def canonical_tier_name(tier_name: str) -> str | None:
     ::
 
         canonical_tier_name("opus")   # ok: "Opus"
-        canonical_tier_name("grok")   # ok: "Grok"
+        canonical_tier_name("thirdparty")  # ok: "ThirdParty"
         canonical_tier_name(" Opus ") # ok: "Opus"
         canonical_tier_name("")       # ok: None
         canonical_tier_name("Titan")  # ok: None
 
     Strips leading and trailing whitespace, then matches any letter case
-    against ``ALL_KNOWN_TIER_NAMES`` (Claude ladder plus the Grok host tier).
+    against ``ALL_KNOWN_TIER_NAMES`` (Claude ladder plus the third-party host tier).
 
     Args:
         tier_name: Raw tier text from a spawn log, protocol walk, or caller.
@@ -83,7 +83,7 @@ def resolve_cli_model_id(tier: str) -> str:
 
         resolve_cli_model_id("Sonnet")  # ok: "sonnet"
         resolve_cli_model_id("HAIKU")   # ok: "haiku"
-        resolve_cli_model_id("Grok")    # ok: "grok"
+        resolve_cli_model_id("ThirdParty")  # ok: "third-party"
         resolve_cli_model_id(" Opus ")  # ok: "opus"
         resolve_cli_model_id("Titan")   # flag: ValueError
 
@@ -93,7 +93,7 @@ def resolve_cli_model_id(tier: str) -> str:
 
     Args:
         tier: Ladder tier name (``Fable``, ``Opus``, ``Sonnet``, ``Haiku``,
-            or ``Grok``).
+            or ``ThirdParty``).
 
     Returns:
         The short model alias for that tier (for example ``"opus"``).
@@ -118,9 +118,9 @@ def detect_host_profile(
 
     ::
 
-        detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "Grok"})
-        # ok: "Grok"
-        detect_host_profile(setting_by_name={"GROK_BUILD": "1"})  # ok: "Grok"
+        detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "ThirdParty"})
+        # ok: "ThirdParty"
+        detect_host_profile(setting_by_name={"THIRD_PARTY": "1"})  # ok: "ThirdParty"
         detect_host_profile(setting_by_name={})                   # ok: "Claude"
         detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "X"})
         # flag: ValueError
@@ -128,14 +128,14 @@ def detect_host_profile(
     Order:
 
     1. ``ADVISOR_HOST_PROFILE`` when set (must be a known profile name).
-    2. ``GROK_BUILD`` when truthy (``1``, ``true``, ``yes``, ``on``).
+    2. ``THIRD_PARTY`` when truthy (``1``, ``true``, ``yes``, ``on``).
     3. Default ``Claude``.
 
     Args:
         setting_by_name: Env name → setting text (defaults to ``os.environ``).
 
     Returns:
-        ``HOST_PROFILE_GROK`` or ``HOST_PROFILE_CLAUDE``.
+        ``HOST_PROFILE_THIRD_PARTY`` or ``HOST_PROFILE_CLAUDE``.
 
     Raises:
         ValueError: When ``ADVISOR_HOST_PROFILE`` is set to an unknown name.
@@ -157,8 +157,8 @@ def detect_host_profile(
             raise ValueError(UNKNOWN_HOST_PROFILE_ERROR.format(explicit_host_profile))
         return maybe_canonical_host
     raw_harness_marker = resolved_setting_by_name.get(
-        GROK_BUILD_ENV_VAR, ""
+        THIRD_PARTY_ENV_VAR, ""
     ).strip().lower()
-    if raw_harness_marker in ALL_GROK_BUILD_TRUTHY_VALUES:
-        return HOST_PROFILE_GROK
+    if raw_harness_marker in ALL_THIRD_PARTY_TRUTHY_VALUES:
+        return HOST_PROFILE_THIRD_PARTY
     return HOST_PROFILE_CLAUDE

package/_shared/pr-loop/CLAUDE.md

@@ -14,6 +14,7 @@ Runtime documents and scripts shared by every PR-loop skill. Changes here affect
 | `state-schema.md` | Fields each PR-loop workflow tracks across iterations; documents common fields and per-skill extensions |
 | `code-rules-gate.md` | Reference for the CODE_RULES pre-commit gate check; describes what the gate blocks and when it runs |
 | `precatch-rubric.md` | Shared pre-catch lane checklist — deterministic sweep, doc-vs-code parity, test-assertion completeness, PR-description parity, adversarial audit — that autoconverge's lenses and pr-converge's CODE_REVIEW step read on demand |
+| `worker-spawn.md` | Worker-spawn tier protocol and Claude-only slash-step host routing: three tiers, CLI/API inputs, JSON result shape, host detection, code-review modes via `detect_host_profile` + `invoke_code_review`, leader-socket rule, cloud setup; documents `scripts/resolve_worker_spawn.py` |
 
 ## Subdirectory
 

package/_shared/pr-loop/scripts/CLAUDE.md

@@ -13,7 +13,7 @@ Python scripts invoked at runtime by the PR-loop skills. Each script is a standa
 | `revoke_project_claude_permissions.py` | Removes the allow-rules and entries that `grant_project_claude_permissions.py` wrote; safe to run when no prior grant exists |
 | `code_rules_gate.py` | Pre-commit gate that runs `code_rules_enforcer` checks on staged Python files before a fix commit lands, and the terminology sweep over the staged diff |
 | `terminology_sweep.py` | Flags a prose term that near-misses an identifier introduced on added code lines of a unified diff (shared leading word, divergent tail) |
-| `reviews_disabled.py` | Shared helper for the reviewer opt-out and opt-in gates; parses `CLAUDE_REVIEWS_DISABLED` and `CLAUDE_REVIEWS_ENABLED` tokens to decide which reviewers run (bugbot is off by default and runs only when `CLAUDE_REVIEWS_ENABLED` lists it) |
+| `reviews_disabled.py` | Shared helper for the reviewer opt-out and opt-in gates; parses `CLAUDE_REVIEWS_DISABLED` tokens `bugteam`, `bugbot`, `copilot`, and `codex`, plus `CLAUDE_REVIEWS_ENABLED` for bugbot opt-in (bugbot is off by default and runs only when `CLAUDE_REVIEWS_ENABLED` lists it) |
 | `copilot_quota.py` | Copilot premium-request quota pre-check: resolves a configured GitHub account, reads its remaining `premium_interactions` quota via `gh api copilot_internal/user`, and exits 0 (run Copilot) or non-zero (skip: out of quota, API down, or no account configured) |
 | `reviewer_availability.py` | Unified reviewer-availability entry point for Copilot and Bugbot: reuses `copilot_quota.py` and `reviews_disabled.py` and exits 0 when the named `--reviewer` may be spawned, non-zero when it is opted out or (for Copilot) out of quota |
 | `fix_hookspath.py` | Repairs a malformed `core.hooksPath` global git config entry |
@@ -23,6 +23,7 @@ Python scripts invoked at runtime by the PR-loop skills. Each script is a standa
 
 | Entry | Description |
 |---|---|
+| `code_rules_gate_parts/` | The decomposed modules `code_rules_gate.py` wires together: enforcer loading, git file sets, blob readers, added-line maps, violation scoping, wrapper plumb-through, gate running, staged-test running, and argument parsing |
 | `pr_loop_shared_constants/` | Named constants used by the scripts above |
 | `tests/` | pytest suite for all scripts in this directory |
 

package/_shared/pr-loop/scripts/README.md

@@ -8,6 +8,7 @@ Runnable helpers used by **bugteam**, **qbug**, **pr-converge**, and related ski
 | --- | --- |
 | `preflight.py` | Local checks before a PR-loop run (pytest discovery, optional pre-commit, hooksPath sanity). |
 | `reviewer_availability.py` | Unified availability check for Copilot and Bugbot; reuses `copilot_quota.py` and `reviews_disabled.py` and exits 0 when the named `--reviewer` may be spawned. |
+| `reviews_disabled.py` | Opt-out and opt-in gate for reviewer tokens `bugteam`, `bugbot`, `copilot`, and `codex` via `CLAUDE_REVIEWS_DISABLED` / `CLAUDE_REVIEWS_ENABLED`. |
 | `code_rules_gate.py` | CODE_RULES gate over PR-scoped diffs (`--base`, staged-only, path filters). |
 | `fix_hookspath.py` | Repair `core.hooksPath` when it does not point at the packaged git-hooks tree. Single home for unexpected non-empty git stderr (hard-fail `RuntimeError`); skill wrappers may call it later. |
 | `grant_project_claude_permissions.py` / `revoke_project_claude_permissions.py` | Claude Code permission JSON helpers used during publish-style flows. |