claude-dev-env 1.92.1 → 1.93.0

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

@@ -0,0 +1,302 @@
+"""Behavioral tests for the model-tier spawn-walk log validator."""
+
+import importlib.util
+import json
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+
+def _load_validator_module() -> ModuleType:
+    scripts_root = Path(__file__).parent.parent
+    constants_root = scripts_root / "config"
+    sys.path.insert(0, str(constants_root))
+    module_path = scripts_root / "model_tier_run_validator.py"
+    specification = importlib.util.spec_from_file_location(
+        "model_tier_run_validator", module_path
+    )
+    assert specification is not None
+    assert specification.loader is not None
+    module = importlib.util.module_from_spec(specification)
+    sys.modules[specification.name] = module
+    specification.loader.exec_module(module)
+    return module
+
+
+model_tier_run_validator = _load_validator_module()
+ModelTierRun = model_tier_run_validator.ModelTierRun
+ModelTierRunError = model_tier_run_validator.ModelTierRunError
+validate_model_tier_run = model_tier_run_validator.validate_model_tier_run
+main = model_tier_run_validator.main
+load_model_tier_run_from_json_path = (
+    model_tier_run_validator.load_model_tier_run_from_json_path
+)
+
+
+def test_clean_single_spawn_at_top_of_slice_passes() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[{"tier": "Fable", "result": "spawned"}],
+        selected_tier="Fable",
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_fallthrough_to_floor_tier_passes() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[
+            {"tier": "Fable", "result": "unavailable"},
+            {"tier": "Opus", "result": "spawned"},
+        ],
+        selected_tier="Opus",
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_fully_exhausted_walk_with_fallback_reason_passes() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[
+            {"tier": "Fable", "result": "unavailable"},
+            {"tier": "Opus", "result": "unavailable"},
+        ],
+        selected_tier=None,
+        fallback_reason="every candidate tier failed; CLI fallback took over",
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_candidate_tiers_shorter_than_ladder_slice_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable"],
+        attempts=[{"tier": "Fable", "result": "spawned"}],
+        selected_tier="Fable",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_attempt_tier_outside_candidate_slice_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[{"tier": "Haiku", "result": "spawned"}],
+        selected_tier="Haiku",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_attempts_out_of_ladder_order_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[
+            {"tier": "Opus", "result": "unavailable"},
+            {"tier": "Fable", "result": "spawned"},
+        ],
+        selected_tier="Fable",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_selected_tier_not_first_spawned_attempt_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[
+            {"tier": "Fable", "result": "unavailable"},
+            {"tier": "Opus", "result": "spawned"},
+        ],
+        selected_tier="Fable",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_exhausted_walk_with_non_null_selected_tier_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[
+            {"tier": "Fable", "result": "unavailable"},
+            {"tier": "Opus", "result": "unavailable"},
+        ],
+        selected_tier="Opus",
+        fallback_reason="every candidate tier failed",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_exhausted_walk_missing_fallback_reason_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        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_unknown_own_tier_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Titan",
+        candidate_tiers=["Titan"],
+        attempts=[{"tier": "Titan", "result": "spawned"}],
+        selected_tier="Titan",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_empty_attempts_with_null_selected_tier_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[],
+        selected_tier=None,
+        fallback_reason="skipped straight to CLI fallback",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_incomplete_fallback_walk_before_floor_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Opus",
+        candidate_tiers=["Fable", "Opus"],
+        attempts=[{"tier": "Fable", "result": "unavailable"}],
+        selected_tier=None,
+        fallback_reason="stopped after Fable without trying Opus",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_lowercase_own_tier_and_candidates_pass() -> None:
+    run = ModelTierRun(
+        own_tier="opus",
+        candidate_tiers=["fable", "opus"],
+        attempts=[
+            {"tier": "fable", "result": "unavailable"},
+            {"tier": "opus", "result": "spawned"},
+        ],
+        selected_tier="opus",
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_cli_validates_json_log_file(tmp_path: Path) -> None:
+    log_path = tmp_path / "model-tier-run.json"
+    log_path.write_text(
+        json.dumps(
+            {
+                "own_tier": "Opus",
+                "candidate_tiers": ["Fable", "Opus"],
+                "attempts": [{"tier": "Fable", "result": "spawned"}],
+                "selected_tier": "Fable",
+            }
+        ),
+        encoding="utf-8",
+    )
+    assert main([str(log_path)]) == 0
+    loaded_run = load_model_tier_run_from_json_path(from_path=log_path)
+    assert loaded_run.selected_tier == "Fable"
+
+
+def test_cli_rejects_incomplete_fallback_log(tmp_path: Path) -> None:
+    log_path = tmp_path / "incomplete-walk.json"
+    log_path.write_text(
+        json.dumps(
+            {
+                "own_tier": "Opus",
+                "candidate_tiers": ["Fable", "Opus"],
+                "attempts": [{"tier": "Fable", "result": "unavailable"}],
+                "selected_tier": None,
+                "fallback_reason": "incomplete",
+            }
+        ),
+        encoding="utf-8",
+    )
+    assert main([str(log_path)]) == 1
+
+
+def test_cli_missing_path_returns_usage_exit_code() -> None:
+    assert main([]) == 2
+
+
+def test_grok_host_single_tier_self_bind_passes() -> None:
+    run = ModelTierRun(
+        own_tier="Grok",
+        candidate_tiers=["Grok"],
+        attempts=[{"tier": "Grok", "result": "self"}],
+        selected_tier="Grok",
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_grok_host_lowercase_self_bind_passes() -> None:
+    run = ModelTierRun(
+        own_tier="grok",
+        candidate_tiers=["grok"],
+        attempts=[{"tier": "grok", "result": "self"}],
+        selected_tier="grok",
+    )
+    assert validate_model_tier_run(run) is None
+
+
+def test_grok_host_multi_tier_candidate_list_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Grok",
+        candidate_tiers=["Fable", "Opus", "Grok"],
+        attempts=[{"tier": "Grok", "result": "self"}],
+        selected_tier="Grok",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_grok_host_spawned_token_is_not_self_bind_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Grok",
+        candidate_tiers=["Grok"],
+        attempts=[{"tier": "Grok", "result": "spawned"}],
+        selected_tier="Grok",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_grok_host_selected_tier_mismatch_raises() -> None:
+    run = ModelTierRun(
+        own_tier="Grok",
+        candidate_tiers=["Grok"],
+        attempts=[{"tier": "Grok", "result": "self"}],
+        selected_tier="Opus",
+    )
+    with pytest.raises(ModelTierRunError):
+        validate_model_tier_run(run)
+
+
+def test_claude_host_self_token_is_not_spawn_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)

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

@@ -0,0 +1,180 @@
+"""Behavioral tests for ladder-tier to CLI model-alias resolution."""
+
+import importlib.util
+import os
+import subprocess
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+
+def _load_tier_model_ids_module() -> ModuleType:
+    scripts_root = Path(__file__).parent.parent
+    module_path = scripts_root / "tier_model_ids.py"
+    specification = importlib.util.spec_from_file_location(
+        "tier_model_ids", module_path
+    )
+    assert specification is not None
+    assert specification.loader is not None
+    module = importlib.util.module_from_spec(specification)
+    sys.modules[specification.name] = module
+    specification.loader.exec_module(module)
+    return module
+
+
+tier_model_ids = _load_tier_model_ids_module()
+resolve_cli_model_id = tier_model_ids.resolve_cli_model_id
+canonical_tier_name = tier_model_ids.canonical_tier_name
+detect_host_profile = tier_model_ids.detect_host_profile
+constants_root = Path(__file__).parent.parent / "config"
+if str(constants_root) not in sys.path:
+    sys.path.insert(0, str(constants_root))
+
+from advisor_scripts_constants.model_tier_run_validator_constants import (  # noqa: E402
+    ADVISOR_SENDMESSAGE_REPLY_WAIT_SECONDS,
+    ALL_CLI_MODEL_ID_BY_TIER,
+    ALL_KNOWN_TIER_NAMES,
+    ALL_MODEL_TIERS,
+    GROK_MODEL_TIER,
+    HOST_PROFILE_CLAUDE,
+    HOST_PROFILE_GROK,
+)
+
+SCRIPTS_ROOT = Path(__file__).parent.parent
+DOCUMENTED_RESOLVE_ONE_LINER = (
+    "from tier_model_ids import resolve_cli_model_id; "
+    "print(resolve_cli_model_id('Opus'))"
+)
+
+
+@pytest.mark.parametrize(
+    ("tier_name", "expected_model_alias"),
+    [
+        ("Fable", "fable"),
+        ("Opus", "opus"),
+        ("Sonnet", "sonnet"),
+        ("Haiku", "haiku"),
+        ("Grok", "grok"),
+        ("fable", "fable"),
+        ("OPUS", "opus"),
+        ("sonnet", "sonnet"),
+        ("hAiKu", "haiku"),
+        ("grok", "grok"),
+        (" GROK ", "grok"),
+        (" Opus ", "opus"),
+        ("\thaiku\n", "haiku"),
+    ],
+)
+def test_resolve_cli_model_id_maps_known_tiers(
+    tier_name: str,
+    expected_model_alias: str,
+) -> None:
+    assert resolve_cli_model_id(tier_name) == expected_model_alias
+
+
+def test_resolve_cli_model_id_rejects_unknown_tier() -> None:
+    with pytest.raises(ValueError, match="not a known model tier"):
+        resolve_cli_model_id("Titan")
+
+
+def test_resolve_cli_model_id_rejects_empty_string() -> None:
+    with pytest.raises(ValueError, match="not a known model tier"):
+        resolve_cli_model_id("")
+
+
+def test_resolve_cli_model_id_rejects_whitespace_only() -> None:
+    with pytest.raises(ValueError, match="not a known model tier"):
+        resolve_cli_model_id("   ")
+
+
+def test_sendmessage_reply_wait_is_positive_bound() -> None:
+    assert ADVISOR_SENDMESSAGE_REPLY_WAIT_SECONDS > 0
+    assert ADVISOR_SENDMESSAGE_REPLY_WAIT_SECONDS == 120
+
+
+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 all(
+        ALL_CLI_MODEL_ID_BY_TIER[each_tier] for each_tier in ALL_KNOWN_TIER_NAMES
+    )
+
+
+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("") is None
+    assert canonical_tier_name("Titan") is None
+
+
+def test_detect_host_profile_defaults_to_claude() -> None:
+    assert detect_host_profile(setting_by_name={}) == HOST_PROFILE_CLAUDE
+
+
+@pytest.mark.parametrize(
+    "truthy_value",
+    ["1", "true", "TRUE", "yes", "YES", "on", "On"],
+)
+def test_detect_host_profile_reads_grok_build_truthy_values(
+    truthy_value: str,
+) -> None:
+    assert (
+        detect_host_profile(setting_by_name={"GROK_BUILD": truthy_value})
+        == HOST_PROFILE_GROK
+    )
+
+
+def test_detect_host_profile_reads_grok_build_flag() -> None:
+    assert (
+        detect_host_profile(setting_by_name={"GROK_BUILD": "0"})
+        == HOST_PROFILE_CLAUDE
+    )
+    assert (
+        detect_host_profile(setting_by_name={"GROK_BUILD": "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
+    )
+    assert (
+        detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "claude"})
+        == HOST_PROFILE_CLAUDE
+    )
+    assert (
+        detect_host_profile(
+            setting_by_name={"ADVISOR_HOST_PROFILE": "Claude", "GROK_BUILD": "1"}
+        )
+        == HOST_PROFILE_CLAUDE
+    )
+
+
+def test_detect_host_profile_rejects_unknown_explicit_value() -> None:
+    with pytest.raises(ValueError, match="not a known profile"):
+        detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "Titan"})
+
+
+def test_documented_resolve_one_liner_runs_without_prior_path_pollution() -> None:
+    clean_environment = {
+        each_key: each_value
+        for each_key, each_value in os.environ.items()
+        if each_key.upper() != "PYTHONPATH"
+    }
+    clean_environment["PYTHONPATH"] = ""
+    completed_process = subprocess.run(
+        [sys.executable, "-c", DOCUMENTED_RESOLVE_ONE_LINER],
+        cwd=str(SCRIPTS_ROOT),
+        capture_output=True,
+        text=True,
+        env=clean_environment,
+        check=False,
+    )
+    assert completed_process.returncode == 0, completed_process.stderr
+    assert completed_process.stdout.strip() == "opus"

package/_shared/advisor/scripts/tier_model_ids.py

@@ -0,0 +1,164 @@
+"""Map ladder tier names to Claude Code CLI / Agent short model aliases.
+
+::
+
+    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(" 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={"ADVISOR_HOST_PROFILE": "Claude"}
+    )  # ok: "Claude"
+
+Values are stable short aliases (``opus``, ``sonnet``, ``grok``), 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
+``--model`` flag already accept.
+
+Args and returns for the public helpers are documented on each function.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from collections.abc import Mapping
+from pathlib import Path
+
+_config_directory = str(Path(__file__).resolve().parent / "config")
+if _config_directory not in sys.path:
+    sys.path.insert(0, _config_directory)
+
+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,
+    HOST_PROFILE_CLAUDE,
+    HOST_PROFILE_ENV_VAR,
+    HOST_PROFILE_GROK,
+    UNKNOWN_HOST_PROFILE_ERROR,
+    UNKNOWN_LADDER_NAME_ERROR,
+)
+
+
+def canonical_tier_name(tier_name: str) -> str | None:
+    """Return the Title Case ladder name for ``tier_name``, or ``None``.
+
+    ::
+
+        canonical_tier_name("opus")   # ok: "Opus"
+        canonical_tier_name("grok")   # ok: "Grok"
+        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).
+
+    Args:
+        tier_name: Raw tier text from a spawn log, protocol walk, or caller.
+
+    Returns:
+        The canonical Title Case ladder name, or ``None`` when unknown.
+    """
+    stripped_tier_name = tier_name.strip()
+    if not stripped_tier_name:
+        return None
+    tier_by_lower_name = {
+        each_tier.lower(): each_tier for each_tier in ALL_KNOWN_TIER_NAMES
+    }
+    return tier_by_lower_name.get(stripped_tier_name.lower())
+
+
+def resolve_cli_model_id(tier: str) -> str:
+    """Return the CLI / Agent short model alias for a ladder tier name.
+
+    ::
+
+        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(" Opus ")  # ok: "opus"
+        resolve_cli_model_id("Titan")   # flag: ValueError
+
+    Accepts any letter case and surrounding whitespace. The returned string is
+    the short alias used by the Agent tool ``model:`` field and the CLI
+    ``--model`` flag — not a dated full model ID.
+
+    Args:
+        tier: Ladder tier name (``Fable``, ``Opus``, ``Sonnet``, ``Haiku``,
+            or ``Grok``).
+
+    Returns:
+        The short model alias for that tier (for example ``"opus"``).
+
+    Raises:
+        ValueError: When ``tier`` is not a known ladder tier, or the alias map
+            is missing that ladder name.
+    """
+    maybe_canonical_tier = canonical_tier_name(tier)
+    if maybe_canonical_tier is None:
+        raise ValueError(UNKNOWN_LADDER_NAME_ERROR.format(tier))
+    maybe_model_alias = ALL_CLI_MODEL_ID_BY_TIER.get(maybe_canonical_tier)
+    if maybe_model_alias is None:
+        raise ValueError(UNKNOWN_LADDER_NAME_ERROR.format(tier))
+    return maybe_model_alias
+
+
+def detect_host_profile(
+    setting_by_name: Mapping[str, str] | None = None,
+) -> str:
+    """Return the advisor host profile from environment detection hints.
+
+    ::
+
+        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={})                   # ok: "Claude"
+        detect_host_profile(setting_by_name={"ADVISOR_HOST_PROFILE": "X"})
+        # flag: ValueError
+
+    Order:
+
+    1. ``ADVISOR_HOST_PROFILE`` when set (must be a known profile name).
+    2. ``GROK_BUILD`` 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``.
+
+    Raises:
+        ValueError: When ``ADVISOR_HOST_PROFILE`` is set to an unknown name.
+    """
+    resolved_setting_by_name: Mapping[str, str] = (
+        os.environ if setting_by_name is None else setting_by_name
+    )
+    explicit_host_profile = resolved_setting_by_name.get(
+        HOST_PROFILE_ENV_VAR, ""
+    ).strip()
+    if explicit_host_profile:
+        host_profile_by_lower_name = {
+            each_profile.lower(): each_profile for each_profile in ALL_HOST_PROFILES
+        }
+        maybe_canonical_host = host_profile_by_lower_name.get(
+            explicit_host_profile.lower()
+        )
+        if maybe_canonical_host is None:
+            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, ""
+    ).strip().lower()
+    if raw_harness_marker in ALL_GROK_BUILD_TRUTHY_VALUES:
+        return HOST_PROFILE_GROK
+    return HOST_PROFILE_CLAUDE

package/_shared/pr-loop/CLAUDE.md

@@ -12,6 +12,7 @@ Runtime documents and scripts shared by every PR-loop skill. Changes here affect
 | `gh-payloads.md` | How to build GitHub review and reply payloads via MCP tools; describes the one-review-per-loop pattern |
 | `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 |
 
 ## Subdirectory