claude-dev-env 2.7.1 → 2.9.0

package/scripts/test_spawn_grok_batch.py

@@ -874,6 +874,107 @@ def test_load_batch_spec_missing_worker_keys_raise_value_error(
     ).lower() or "must be" in str(raised_error.value).lower()
 
 
+def test_load_batch_spec_rejects_an_unknown_worker_key(
+    tmp_path: Path,
+) -> None:
+    header_part, body_part = _write_prompt_parts(tmp_path)
+    working_directory = tmp_path / "project"
+    working_directory.mkdir()
+    worker_payload = _worker_payload(
+        role_name="stray-key-worker",
+        all_prompt_parts=[str(header_part), str(body_part)],
+        working_directory=working_directory,
+        tool_profile=TOOL_PROFILE_BUILD,
+    )
+    worker_payload["timeout_second"] = 30
+    specification_path = _write_batch_spec(
+        tmp_path, all_worker_payloads=[worker_payload]
+    )
+
+    with pytest.raises(ValueError) as raised_error:
+        batch.load_batch_spec(specification_path)
+
+    error_text = str(raised_error.value)
+    assert "timeout_second" in error_text
+    assert WORKER_SPEC_TIMEOUT_KEY in error_text
+
+
+def test_load_batch_spec_names_every_unknown_worker_key(
+    tmp_path: Path,
+) -> None:
+    header_part, body_part = _write_prompt_parts(tmp_path)
+    working_directory = tmp_path / "project"
+    working_directory.mkdir()
+    worker_payload = _worker_payload(
+        role_name="two-stray-keys",
+        all_prompt_parts=[str(header_part), str(body_part)],
+        working_directory=working_directory,
+        tool_profile=TOOL_PROFILE_BUILD,
+    )
+    worker_payload["stray_cap"] = 5
+    worker_payload["notes"] = "operator scratch"
+    specification_path = _write_batch_spec(
+        tmp_path, all_worker_payloads=[worker_payload]
+    )
+
+    with pytest.raises(ValueError) as raised_error:
+        batch.load_batch_spec(specification_path)
+
+    error_text = str(raised_error.value)
+    assert "stray_cap" in error_text
+    assert "notes" in error_text
+
+
+def test_load_batch_spec_rejects_the_retired_turn_cap_key(
+    tmp_path: Path,
+) -> None:
+    header_part, body_part = _write_prompt_parts(tmp_path)
+    working_directory = tmp_path / "project"
+    working_directory.mkdir()
+    worker_payload = _worker_payload(
+        role_name="retired-cap-worker",
+        all_prompt_parts=[str(header_part), str(body_part)],
+        working_directory=working_directory,
+        tool_profile=TOOL_PROFILE_BUILD,
+    )
+    worker_payload[RETIRED_MAX_TURNS_KEYWORD] = 5
+    specification_path = _write_batch_spec(
+        tmp_path, all_worker_payloads=[worker_payload]
+    )
+
+    with pytest.raises(ValueError) as raised_error:
+        batch.load_batch_spec(specification_path)
+
+    error_text = str(raised_error.value)
+    assert RETIRED_MAX_TURNS_KEYWORD in error_text
+    assert WORKER_SPEC_TIMEOUT_KEY in error_text
+
+
+def test_load_batch_spec_accepts_every_documented_worker_key(
+    tmp_path: Path,
+) -> None:
+    header_part, body_part = _write_prompt_parts(tmp_path)
+    working_directory = tmp_path / "project"
+    working_directory.mkdir()
+    worker_payload: dict[str, object] = {
+        "role_name": "every-key-worker",
+        "prompt_parts": [str(header_part), str(body_part)],
+        "cwd": str(working_directory),
+        "tool_profile": TOOL_PROFILE_READONLY,
+        "timeout_seconds": 30,
+        "is_repo_only": True,
+        "agent_name": None,
+    }
+    specification_path = _write_batch_spec(
+        tmp_path, all_worker_payloads=[worker_payload]
+    )
+
+    batch_spec = batch.load_batch_spec(specification_path)
+
+    assert batch_spec.all_workers[0].role_name == "every-key-worker"
+    assert batch_spec.all_workers[0].is_repo_only is True
+
+
 def test_load_batch_spec_rejects_non_positive_timeout(
     tmp_path: Path,
 ) -> None:
@@ -1218,3 +1319,298 @@ def test_load_batch_spec_rejects_empty_agent_name(tmp_path: Path) -> None:
 
     with pytest.raises(ValueError, match=WORKER_SPEC_AGENT_NAME_KEY):
         batch.load_batch_spec(specification_path)
+
+# --- O-02 worker advisor contract ---
+
+
+def test_extract_advisor_signal_accepts_four_tokens_only() -> None:
+    assert batch.extract_advisor_signal("ENDORSE\nok") == "ENDORSE"
+    assert batch.extract_advisor_signal("CORRECTION fix path") == "CORRECTION"
+    assert batch.extract_advisor_signal("PLAN later") == "PLAN"
+    assert batch.extract_advisor_signal("STOP") == "STOP"
+    assert batch.extract_advisor_signal("hello ENDORSE") is None
+    assert batch.extract_advisor_signal("") is None
+
+
+def test_load_batch_spec_parses_advisor_block(tmp_path: Path) -> None:
+    header_part, body_part = _write_prompt_parts(tmp_path)
+    payload = _worker_payload(
+        role_name="lens",
+        all_prompt_parts=[str(header_part), str(body_part)],
+        working_directory=tmp_path,
+        tool_profile=TOOL_PROFILE_READONLY,
+    )
+    specification_path = tmp_path / "batch-spec.json"
+    specification_path.write_text(
+        json.dumps(
+            {
+                "role": DEFAULT_ROLE,
+                "should_ping": False,
+                "workers": [payload],
+                "advisor": {
+                    "launcher": "fixture-advisor-launcher",
+                    "model": "opus",
+                    "effort": "high",
+                },
+            }
+        ),
+        encoding=UTF8_ENCODING,
+    )
+    loaded = batch.load_batch_spec(specification_path)
+    assert loaded.advisor is not None
+    assert loaded.advisor.launcher == "fixture-advisor-launcher"
+    assert loaded.advisor.model == "opus"
+    assert loaded.advisor.effort == "high"
+
+
+def test_unique_advisor_sessions_and_completion_verdict(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    header_a, body_a = _write_prompt_parts(tmp_path, role_marker="alpha")
+    header_b, body_b = _write_prompt_parts(tmp_path, role_marker="beta")
+    workers = [
+        _worker_payload(
+            role_name="alpha",
+            all_prompt_parts=[str(header_a), str(body_a)],
+            working_directory=tmp_path,
+            tool_profile=TOOL_PROFILE_BUILD,
+        ),
+        _worker_payload(
+            role_name="beta",
+            all_prompt_parts=[str(header_b), str(body_b)],
+            working_directory=tmp_path,
+            tool_profile=TOOL_PROFILE_BUILD,
+        ),
+    ]
+    specification_path = tmp_path / "batch-spec.json"
+    specification_path.write_text(
+        json.dumps(
+            {
+                "role": DEFAULT_ROLE,
+                "should_ping": False,
+                "workers": workers,
+                "advisor": {
+                    "launcher": "fixture-advisor-launcher",
+                    "model": "opus",
+                    "effort": "high",
+                },
+            }
+        ),
+        encoding=UTF8_ENCODING,
+    )
+    bind_count = {"n": 0}
+    sessions_issued: list[str] = []
+
+    def fake_advisor(
+        *,
+        launcher: str,
+        model: str,
+        effort: str,
+        prompt_text: str,
+        session_id: str | None = None,
+    ) -> tuple[str | None, str, int]:
+        assert launcher == "fixture-advisor-launcher"
+        assert model == "opus"
+        assert effort == "high"
+        if session_id is None:
+            bind_count["n"] += 1
+            session = f"session-{bind_count['n']}"
+            sessions_issued.append(session)
+            return session, "ENDORSE\npre-dispatch ok", 0
+        return session_id, "ENDORSE\npost-report ok", 0
+
+    monkeypatch.setattr(batch, "batch_invoke_advisor", fake_advisor)
+    monkeypatch.setattr(
+        batch,
+        "batch_preflight",
+        lambda **kwargs: PreflightOutcome(is_usable=True, reason=None),
+    )
+    monkeypatch.setattr(batch, "batch_sleep", lambda seconds: None)
+    recorder = _RunnerRecorder(
+        {
+            "alpha": _ok_outcome(),
+            "beta": _ok_outcome(),
+        }
+    )
+    monkeypatch.setattr(batch, "batch_headless_runner", recorder)
+    loaded = batch.load_batch_spec(specification_path)
+    summary = batch.run_grok_batch(
+        batch_spec=loaded, run_state_directory=tmp_path / "run"
+    )
+    assert summary.is_preflight_usable
+    assert len(summary.all_worker_reports) == 2
+    all_session_ids = {
+        each.advisor_session_id for each in summary.all_worker_reports
+    }
+    assert all_session_ids == {"session-1", "session-2"}
+    assert all(
+        each.advisor_completion_signal == "ENDORSE"
+        for each in summary.all_worker_reports
+    )
+    assert all(
+        each.classification != "advisor_blocked"
+        for each in summary.all_worker_reports
+    )
+    for each_report in summary.all_worker_reports:
+        prompt_text = Path(each_report.prompt_path).read_text(encoding=UTF8_ENCODING)
+        assert each_report.advisor_session_id in prompt_text
+
+
+def test_advisor_failure_classifies_advisor_blocked(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    header_part, body_part = _write_prompt_parts(tmp_path, role_marker="solo")
+    payload = _worker_payload(
+        role_name="solo",
+        all_prompt_parts=[str(header_part), str(body_part)],
+        working_directory=tmp_path,
+        tool_profile=TOOL_PROFILE_BUILD,
+    )
+    specification_path = tmp_path / "batch-spec.json"
+    specification_path.write_text(
+        json.dumps(
+            {
+                "role": DEFAULT_ROLE,
+                "should_ping": False,
+                "workers": [payload],
+                "advisor": {"launcher": "fixture-advisor-launcher"},
+            }
+        ),
+        encoding=UTF8_ENCODING,
+    )
+
+    def failing_advisor(**kwargs: object) -> tuple[str | None, str, int]:
+        return None, "", 1
+
+    monkeypatch.setattr(batch, "batch_invoke_advisor", failing_advisor)
+    monkeypatch.setattr(
+        batch,
+        "batch_preflight",
+        lambda **kwargs: PreflightOutcome(is_usable=True, reason=None),
+    )
+    monkeypatch.setattr(batch, "batch_sleep", lambda seconds: None)
+    monkeypatch.setattr(
+        batch,
+        "batch_headless_runner",
+        _RunnerRecorder({"solo": _ok_outcome()}),
+    )
+    loaded = batch.load_batch_spec(specification_path)
+    summary = batch.run_grok_batch(
+        batch_spec=loaded, run_state_directory=tmp_path / "run"
+    )
+    assert len(summary.all_worker_reports) == 1
+    report = summary.all_worker_reports[0]
+    assert report.classification == "advisor_blocked"
+    assert report.is_ok is False
+
+def test_bind_unique_worker_advisor_rejects_placeholder(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def boom(**kwargs: object) -> tuple[str | None, str, int]:
+        raise AssertionError("should not call launcher for placeholder")
+
+    monkeypatch.setattr(batch, "batch_invoke_advisor", boom)
+    with pytest.raises(ValueError, match="placeholder"):
+        batch.bind_unique_worker_advisor(
+            advisor_spec=batch.AdvisorSpec(launcher=batch.DEFAULT_ADVISOR_LAUNCHER_PLACEHOLDER),
+            role_name="lens",
+            all_used_session_ids=set(),
+        )
+
+
+def test_bind_unique_worker_advisor_returns_session(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def fake(**kwargs: object) -> tuple[str | None, str, int]:
+        return "sess-unique-1", "ENDORSE\nok", 0
+
+    monkeypatch.setattr(batch, "batch_invoke_advisor", fake)
+    session_id, signal = batch.bind_unique_worker_advisor(
+        advisor_spec=batch.AdvisorSpec(launcher="fixture-advisor-launcher"),
+        role_name="lens",
+        all_used_session_ids=set(),
+    )
+    assert session_id == "sess-unique-1"
+    assert signal == "ENDORSE"
+
+
+def test_obtain_advisor_completion_verdict_endorses(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def fake(**kwargs: object) -> tuple[str | None, str, int]:
+        return kwargs.get("session_id"), "ENDORSE\nok", 0
+
+    monkeypatch.setattr(batch, "batch_invoke_advisor", fake)
+    signal = batch.obtain_advisor_completion_verdict(
+        advisor_spec=batch.AdvisorSpec(launcher="fixture-advisor-launcher"),
+        role_name="lens",
+        session_id="sess-1",
+        report_text="done",
+    )
+    assert signal == "ENDORSE"
+
+
+def test_invoke_advisor_launcher_builds_command(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured: dict[str, object] = {}
+
+    class _Completed:
+        returncode = 0
+        stdout = '{"session_id":"s1","result":"ENDORSE\\nok"}'
+        stderr = ""
+
+    def fake_run(args, **kwargs):  # type: ignore[no-untyped-def]  # subprocess.run stub for argv capture
+        captured["args"] = list(args)
+        captured["input"] = kwargs.get("input")
+        return _Completed()
+
+    monkeypatch.setattr(batch.subprocess, "run", fake_run)
+    session_id, body, code = batch.invoke_advisor_launcher(
+        launcher="fixture-advisor-launcher",
+        model="opus",
+        effort="high",
+        prompt_text="hello",
+    )
+    assert code == 0
+    assert session_id == "s1"
+    assert "ENDORSE" in body
+    assert captured["args"][0] == "fixture-advisor-launcher"
+    assert "--model" in captured["args"]
+
+
+def test_invoke_advisor_launcher_missing_binary_raises_advisor_failure() -> None:
+    try:
+        batch.invoke_advisor_launcher(
+            launcher="__no_such_advisor_launcher_xyz__",
+            model="opus",
+            effort="high",
+            prompt_text="ping",
+        )
+        raise AssertionError("expected AdvisorFailureError")
+    except batch.AdvisorFailureError as raised:
+        assert "not found" in str(raised).lower() or "launcher" in str(raised).lower()
+
+
+def test_invoke_advisor_launcher_passes_timeout(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured: dict[str, object] = {}
+
+    class _Completed:
+        returncode = 0
+        stdout = '{"session_id":"s-timeout","result":"ENDORSE\\nok"}'
+        stderr = ""
+
+    def fake_run(args, **kwargs):  # type: ignore[no-untyped-def]  # subprocess.run stub
+        captured["timeout"] = kwargs.get("timeout")
+        return _Completed()
+
+    monkeypatch.setattr(batch.subprocess, "run", fake_run)
+    batch.invoke_advisor_launcher(
+        launcher="fixture-advisor-launcher",
+        model="opus",
+        effort="high",
+        prompt_text="hello",
+    )
+    assert captured["timeout"] == batch.MAXIMUM_ADVISOR_TIMEOUT_SECONDS

package/scripts/tests/CLAUDE.md

@@ -10,6 +10,7 @@ pytest suite for the Python scripts and Pester suite for the PowerShell scripts
 | `test_setup_project_paths_config.py` | Configuration constants used by `setup_project_paths.py` |
 | `test_sweep_empty_dirs.py` | `sweep_empty_dirs.py` — age check, one-shot mode, and continuous-watch behavior |
 | `test_sync_to_cursor.py` | `sync_to_cursor/` package — mapping, hashing, manifest, and path resolution |
+| `test_grok_worker_constants.py` | `grok_worker_constants.py` — the accepted batch worker-key set stays in step with the worker key constants, and the unknown-key message names both its placeholders |
 
 ## PowerShell test files
 

package/scripts/tests/test_grok_worker_constants.py

@@ -0,0 +1,59 @@
+"""Specifications for the accepted-key set on a batch worker entry.
+
+The batch launcher rejects a worker entry carrying any key outside
+``ALL_KNOWN_WORKER_SPEC_KEYS``. That makes the set a gate on the published
+JSON contract: a worker key the module defines but the set omits is rejected
+from every spec that uses it, and a member the module declares nowhere keeps
+accepting a key the launcher drops. Both drifts are silent, so they are
+pinned here.
+"""
+
+from __future__ import annotations
+
+from dev_env_scripts_constants import grok_worker_constants
+
+WORKER_SPEC_KEY_NAME_PREFIX: str = "WORKER_SPEC_"
+WORKER_SPEC_KEY_NAME_SUFFIX: str = "_KEY"
+
+
+def _all_declared_worker_key_values() -> set[str]:
+    """Read every ``WORKER_SPEC_*_KEY`` value the constants module declares."""
+    return {
+        getattr(grok_worker_constants, each_name)
+        for each_name in dir(grok_worker_constants)
+        if each_name.startswith(WORKER_SPEC_KEY_NAME_PREFIX)
+        and each_name.endswith(WORKER_SPEC_KEY_NAME_SUFFIX)
+    }
+
+
+def test_should_accept_every_declared_worker_spec_key() -> None:
+    all_declared_key_values = _all_declared_worker_key_values()
+    all_missing_key_values = (
+        all_declared_key_values - grok_worker_constants.ALL_KNOWN_WORKER_SPEC_KEYS
+    )
+
+    assert not all_missing_key_values, (
+        "worker key constants missing from the accepted set: "
+        f"{sorted(all_missing_key_values)}"
+    )
+
+
+def test_should_accept_only_keys_the_module_declares() -> None:
+    all_declared_key_values = _all_declared_worker_key_values()
+    all_stale_key_values = (
+        grok_worker_constants.ALL_KNOWN_WORKER_SPEC_KEYS - all_declared_key_values
+    )
+
+    assert not all_stale_key_values, (
+        f"accepted keys with no worker key constant: {sorted(all_stale_key_values)}"
+    )
+
+
+def test_should_name_both_placeholders_in_the_unknown_key_message() -> None:
+    formatted_message = grok_worker_constants.UNKNOWN_WORKER_KEY_ERROR_TEMPLATE.format(
+        unknown_keys="timeout_second",
+        accepted_keys="timeout_seconds",
+    )
+
+    assert "timeout_second;" in formatted_message
+    assert formatted_message.endswith("timeout_seconds")

package/skills/CLAUDE.md

@@ -17,7 +17,9 @@ Skills install to `~/.claude/skills/<skill-name>/` via `packages/claude-dev-env/
 
 ## Shared support code
 
-`_shared/` — support code used by more than one skill. It holds `pr-loop/`, which provides prompt templates and Python helper scripts shared across the PR-loop skills, and `advisor/`, which provides the shared warm-advisor protocol used by `team-advisor`, `orchestrator`, and `orchestrator-refresh`.
+**`skills/_shared/`** — skill-local PR-loop helpers plus `@` stubs that name
+canonical homes under **`@~/.claude/_shared/`** (advisor protocol, PR-loop
+contracts, runtime scripts). Map: `skills/_shared/CLAUDE.md`. End-of-run gotchas: `skills/_shared/end-of-run-gotcha-recommendations.md`.
 
 ## Skill groups
 
@@ -25,7 +27,7 @@ Skills install to `~/.claude/skills/<skill-name>/` via `packages/claude-dev-env/
 - `anthropic-plan` — creates a source-grounded plan packet before any code changes
 - `orchestrator` — turns the session into the orchestrator: it spawns executor subagents to do the code edits and test runs; hard decisions go to a shared advisor (Claude warm `session-advisor` via SendMessage; a third-party host: max-tier Claude via CLI Claude-chain)
 - `orchestrator-refresh` — sub-skill fired by the `/orchestrator` loop to re-assert the host-matched shared-advisor discipline mid-run (Claude SendMessage; a third-party host's Claude CLI chain, no Agent-tool advisor spawn)
-- `team-advisor` — binds one advisor at the strongest reachable tier (Claude warm agent; a third-party host: max-tier Claude via CLI Claude-chain, fail closed when unreachable) and consults it for a second opinion before a big decision, at completion, when stuck, or when reconsidering the approach
+- `team-advisor` — binds one advisor at the strongest reachable tier (Claude warm agent; a third-party host: max-tier Claude via CLI Claude-chain, fail closed when unreachable); consult cadence and weight live in `docs/references/advisor-tool.md`
 - `grokify` — builds a paste-ready Grok Build handoff with a Claude advisor charter
 - `grok-spawn` — orchestrator playbook for fleets of headless grok CLI workers (preflight, batch spec, `spawn_grok_batch.py`)
 

package/skills/_shared/CLAUDE.md

@@ -1,11 +1,44 @@
-# _shared
+# skills/_shared
 
-Support code shared across multiple skills. Each subdirectory targets a specific cross-skill concern.
+**Map** for skill-install shared assets. Open a stub, then load the `@` target.
+
+## Two homes
+
+| Home | Path | Holds |
+|---|---|---|
+| **Skills shared** | `~/.claude/skills/_shared/` | Converge helpers, end-of-run gotcha ref, and `@` stubs |
+| **Top-level shared** | `~/.claude/_shared/` | Advisor protocol, PR-loop contracts, runtime scripts |
+
+
+## Reference docs (this tree)
+
+| File | Role |
+|---|---|
+| **`end-of-run-gotcha-recommendations.md`** | End-of-run pasteable gotcha protocol for every skill |
 
 ## Subdirectories
 
 | Directory | Role |
 |---|---|
-| `pr-loop/` | Prompt templates and Python helper scripts used by both `bugteam` and `pr-converge` for their audit-fix loop. |
+| **`advisor/`** | Stubs → `@~/.claude/_shared/advisor/` |
+| **`pr-loop/`** | Local converge helpers + stubs → `@~/.claude/_shared/pr-loop/` |
+
+## Canonical-path stubs
+
+| Stub here | Load |
+|---|---|
+| `advisor/advisor-protocol.md` | `@~/.claude/_shared/advisor/advisor-protocol.md` |
+| `advisor/CLAUDE.md` | `@~/.claude/_shared/advisor/CLAUDE.md` |
+| `advisor/scripts/README.md` | `@~/.claude/_shared/advisor/scripts/` |
+| `pr-loop/audit-contract.md` | `@~/.claude/_shared/pr-loop/audit-contract.md` |
+| `pr-loop/audit-reply-template.md` | `@~/.claude/_shared/pr-loop/audit-reply-template.md` |
+| `pr-loop/code-rules-gate.md` | `@~/.claude/_shared/pr-loop/code-rules-gate.md` |
+| `pr-loop/fix-protocol.md` | `@~/.claude/_shared/pr-loop/fix-protocol.md` |
+| `pr-loop/gh-payloads.md` | `@~/.claude/_shared/pr-loop/gh-payloads.md` |
+| `pr-loop/post-audit-thread-contract.md` | `@~/.claude/_shared/pr-loop/post-audit-thread-contract.md` |
+| `pr-loop/precatch-rubric.md` | `@~/.claude/_shared/pr-loop/precatch-rubric.md` |
+| `pr-loop/state-schema.md` | `@~/.claude/_shared/pr-loop/state-schema.md` |
+| `pr-loop/worker-spawn.md` | `@~/.claude/_shared/pr-loop/worker-spawn.md` |
+| `pr-loop/scripts/RUNTIME_SCRIPTS.md` | `@~/.claude/_shared/pr-loop/scripts/` |
 
-Files here are not skills themselves and have no `SKILL.md`. They install alongside each consuming skill via the install pipeline in `packages/claude-dev-env/bin/install.mjs`.
+Install via `packages/claude-dev-env/bin/install.mjs`.

package/skills/_shared/advisor/CLAUDE.md

@@ -0,0 +1,9 @@
+# Advisor
+
+**Canonical home:**
+
+@~/.claude/_shared/advisor/CLAUDE.md
+
+@~/.claude/_shared/advisor/advisor-protocol.md
+
+Scripts: `~/.claude/_shared/advisor/scripts/` (`model_tier_run_validator.py`, `tier_model_ids.py`, constants under `scripts/config/`).

package/skills/_shared/advisor/advisor-protocol.md

@@ -0,0 +1,5 @@
+# Advisor protocol
+
+**Canonical home:**
+
+@~/.claude/_shared/advisor/advisor-protocol.md

package/skills/_shared/advisor/scripts/README.md

@@ -0,0 +1,9 @@
+# Advisor scripts
+
+**Canonical home:**
+
+@~/.claude/_shared/advisor/scripts/model_tier_run_validator.py
+
+@~/.claude/_shared/advisor/scripts/tier_model_ids.py
+
+Full tree: `~/.claude/_shared/advisor/scripts/`.