claude-dev-env 2.35.0 → 4.0.0

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

@@ -0,0 +1,271 @@
+"""Behavioral tests for the executable Codex Astra advisor path."""
+import io
+import importlib.util
+import json
+import subprocess
+import sys
+from collections.abc import Callable
+from pathlib import Path
+from types import ModuleType
+import pytest
+
+_ProcessRunner = Callable[..., subprocess.CompletedProcess[str]]
+
+
+def _load_astra_module() -> ModuleType:
+    scripts_root = Path(__file__).parent.parent
+    config_root = str(scripts_root / "config")
+    if config_root not in sys.path:
+        sys.path.insert(0, config_root)
+    specification = importlib.util.spec_from_file_location(
+        "codex_astra_advisor", scripts_root / "codex_astra_advisor.py"
+    )
+    assert specification is not None and specification.loader is not None
+    module = importlib.util.module_from_spec(specification)
+    sys.modules[specification.name] = module
+    specification.loader.exec_module(module)
+    return module
+
+
+astra_advisor = _load_astra_module()
+SCRIPTS_ROOT = Path(__file__).parent.parent
+USAGE_PROBE_PATH = (
+    SCRIPTS_ROOT.parents[1] / "pr-loop" / "scripts" / "codex_usage_probe.py"
+)
+ENABLED_SETTINGS = {astra_advisor.ASTRA_ENV_VAR: "1"}
+
+
+@pytest.fixture(autouse=True)
+def _codex_on_search_path(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(astra_advisor.shutil, "which", lambda name: "codex")
+
+
+def _probe(payload: object, returncode: int = 0) -> subprocess.CompletedProcess[str]:
+    return subprocess.CompletedProcess(
+        [sys.executable, str(USAGE_PROBE_PATH)],
+        returncode,
+        json.dumps(payload),
+        "",
+    )
+
+
+def _events(session_id: str = "thread-1", guidance: str = "PLAN\ninspect") -> str:
+    return "\n".join(
+        (
+            json.dumps({"type": "thread.started", "thread_id": session_id}),
+            json.dumps(
+                {
+                    "type": "item.completed",
+                    "item": {"type": "agent_message", "text": guidance},
+                }
+            ),
+        )
+    )
+
+
+def _two_step_runner(
+    all_calls: list[list[str]], guidance: str = "PLAN\ninspect"
+) -> _ProcessRunner:
+    def runner(
+        arguments: list[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[str]:
+        all_calls.append(arguments)
+        if len(all_calls) == 1:
+            return _probe({"percent_left": 90})
+        return subprocess.CompletedProcess(arguments, 0, _events(guidance=guidance), "")
+    return runner
+
+
+@pytest.mark.parametrize("truthy", ["1", "true", "TRUE", "yes", "on", " On "])
+def test_astra_flag_accepts_documented_truthy_values(truthy: str) -> None:
+    assert astra_advisor.is_astra_advisor_enabled({"ADVISOR_ASTRA": truthy})
+
+
+def test_astra_flag_rejects_legacy_sol_setting() -> None:
+    assert not astra_advisor.is_astra_advisor_enabled({"ADVISOR_SOL": "1"})
+
+
+def test_resolve_advisor_effort_uses_shared_setting_and_default() -> None:
+    assert astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "HIGH"}) == "high"
+    assert astra_advisor.resolve_advisor_effort({"ADVISOR_EFFORT": "unknown"}) == "low"
+
+
+def test_resolve_codex_executable_prefers_override_and_falls_back_to_path(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    assert astra_advisor.resolve_codex_executable(
+        {astra_advisor.ADVISOR_CODEX_EXECUTABLE_ENV_VAR: "/tmp/codex-custom"}
+    ) == "/tmp/codex-custom"
+    monkeypatch.setattr(astra_advisor.shutil, "which", lambda name: "/usr/bin/codex")
+    assert astra_advisor.resolve_codex_executable({}) == "/usr/bin/codex"
+
+
+@pytest.mark.parametrize("effort", ["low", "medium", "high", "xhigh", "max"])
+def test_codex_arguments_apply_selected_effort(effort: str) -> None:
+    arguments = astra_advisor.build_codex_arguments("codex", reasoning_effort=effort)
+    config_index = arguments.index("--config")
+    assert arguments[config_index + 1] == f'model_reasoning_effort="{effort}"'
+
+
+def test_codex_arguments_use_astra_and_read_only_sandbox() -> None:
+    arguments = astra_advisor.build_codex_arguments("codex", session_id="thread-1")
+    assert arguments[:4] == ["codex", "exec", "--model", "gpt-6-astra"]
+    assert ["--sandbox", "read-only"] == arguments[6:8]
+    assert arguments[-3:] == ["resume", "thread-1", "-"]
+
+
+def test_argument_parser_accepts_astra_and_rejects_sol() -> None:
+    parser = astra_advisor.build_argument_parser()
+    parsed = parser.parse_args(["--bind", "--cwd", ".", "--enable-astra"])
+    assert parsed.is_astra_requested
+    with pytest.raises(SystemExit):
+        parser.parse_args(["--bind", "--cwd", ".", "--enable-sol"])
+
+
+def test_usage_probe_path_uses_supplied_home(tmp_path: Path) -> None:
+    path = astra_advisor.resolve_usage_probe_path(tmp_path)
+    assert path == tmp_path / ".claude" / "_shared" / "pr-loop" / "scripts" / "codex_usage_probe.py"
+
+
+def test_preflight_accepts_meter_above_gate() -> None:
+    preflight = astra_advisor.run_astra_preflight(
+        USAGE_PROBE_PATH, lambda arguments, **kwargs: _probe({"percent_left": 90})
+    )
+    assert preflight.eligible
+    assert preflight.percent_left == 90
+
+
+def test_preflight_declines_meter_at_gate() -> None:
+    preflight = astra_advisor.run_astra_preflight(
+        USAGE_PROBE_PATH, lambda arguments, **kwargs: _probe({"percent_left": 10})
+    )
+    assert not preflight.eligible
+    assert preflight.fallback_kind == astra_advisor.ASTRA_FALLBACK_KIND_DECLINED
+
+
+@pytest.mark.parametrize("payload", [{"percent_left": None}, {"percent_left": "90"}, ["bad"]])
+def test_preflight_rejects_malformed_meter(payload: object) -> None:
+    preflight = astra_advisor.run_astra_preflight(
+        USAGE_PROBE_PATH, lambda arguments, **kwargs: _probe(payload)
+    )
+    assert not preflight.eligible
+    assert preflight.fallback_kind == astra_advisor.ASTRA_FALLBACK_KIND_BROKEN
+
+
+@pytest.mark.parametrize("signal", ["ENDORSE", "CORRECTION", "PLAN", "STOP"])
+def test_jsonl_parser_accepts_guidance_signals(signal: str) -> None:
+    reply = astra_advisor.parse_codex_jsonl_reply(
+        _events(guidance=f"{signal}\nmore"), None, True
+    )
+    assert reply.successful
+    assert reply.signal == signal
+
+
+@pytest.mark.parametrize(
+    "jsonl_text",
+    [
+        "{broken",
+        json.dumps({"type": "thread.started", "thread_id": "thread-1"}),
+        _events(guidance="PLAN: inspect"),
+    ],
+)
+def test_jsonl_parser_falls_back_for_invalid_reply(jsonl_text: str) -> None:
+    reply = astra_advisor.parse_codex_jsonl_reply(jsonl_text, None, True)
+    assert reply.is_fallback
+    assert not reply.successful
+
+
+def test_bind_runs_probe_then_codex() -> None:
+    calls: list[list[str]] = []
+    reply = astra_advisor.run_codex_astra_advisor(
+        "consult",
+        Path("."),
+        None,
+        USAGE_PROBE_PATH,
+        ENABLED_SETTINGS,
+        None,
+        _two_step_runner(calls),
+    )
+    assert reply.successful
+    assert calls[1] == astra_advisor.build_codex_arguments("codex")
+
+
+def test_disabled_flag_returns_declined_fallback() -> None:
+    reply = astra_advisor.run_codex_astra_advisor(
+        "consult",
+        Path("."),
+        astra_advisor.AstraPreflight(True, 90, "ok"),
+        None,
+        {},
+        None,
+        subprocess.run,
+    )
+    assert reply.is_fallback
+    assert reply.fallback_kind == astra_advisor.ASTRA_FALLBACK_KIND_DECLINED
+
+
+def test_missing_codex_returns_broken_fallback(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(astra_advisor.shutil, "which", lambda name: None)
+    reply = astra_advisor.run_codex_astra_advisor(
+        "consult", Path("."), None, USAGE_PROBE_PATH, ENABLED_SETTINGS, None, subprocess.run
+    )
+    assert reply.is_fallback
+    assert reply.fallback_kind == astra_advisor.ASTRA_FALLBACK_KIND_BROKEN
+
+
+def test_resume_uses_existing_session() -> None:
+    calls: list[list[str]] = []
+    reply = astra_advisor.run_codex_astra_advisor(
+        "resume",
+        Path("."),
+        None,
+        USAGE_PROBE_PATH,
+        ENABLED_SETTINGS,
+        "thread-1",
+        _two_step_runner(calls, "ENDORSE\nready"),
+    )
+    assert reply.successful
+    assert calls[1][-3:] == ["resume", "thread-1", "-"]
+
+
+def test_main_serializes_result_and_astra_fields(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setattr(
+        astra_advisor,
+        "run_codex_astra_advisor",
+        lambda *args, **kwargs: astra_advisor.CodexAstraAdvisorReply(
+            "thread-1", "PLAN\ninspect", True, None, False, "PLAN", True, "Astra", "codex", None
+        ),
+    )
+    monkeypatch.setattr(sys, "stdin", io.StringIO("consult"))
+    assert astra_advisor.main(["--bind", "--cwd", "."]) == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["result"] == "codex"
+    assert payload["astra_enabled"] is True
+    assert "sol_enabled" not in payload
+
+
+def test_active_docs_use_astra_names() -> None:
+    package_root = SCRIPTS_ROOT.parents[2]
+    advisor_root = SCRIPTS_ROOT.parent
+    all_paths = [
+        advisor_root / "advisor-protocol.md",
+        *sorted((advisor_root / "reference").glob("*.md")),
+        package_root / ".agents" / "skills" / "team-advisor" / "SKILL.md",
+        package_root / "docs" / "references" / "team-advisor-skill.md",
+    ]
+    legacy_names = ("ADVISOR_SOL", "--enable-sol", "codex_sol_advisor", "sol-rung.md")
+    for each_path in all_paths:
+        content = each_path.read_text(encoding="utf-8")
+        assert all(name not in content for name in legacy_names)
+
+
+def test_astra_docs_name_shared_effort_and_helper() -> None:
+    advisor_root = SCRIPTS_ROOT.parent
+    rung = (advisor_root / "reference" / "astra-rung.md").read_text(encoding="utf-8")
+    protocol = (advisor_root / "advisor-protocol.md").read_text(encoding="utf-8")
+    assert "ADVISOR_EFFORT" in rung
+    assert "ADVISOR_ASTRA=1" in protocol
+    assert "codex_astra_advisor.py" in rung
+    assert "--resume <session_id>" in rung

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

@@ -0,0 +1,24 @@
+"""Tests for Codex Astra usage preflight."""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+SCRIPTS_ROOT = Path(__file__).parent.parent
+sys.path.insert(0, str(SCRIPTS_ROOT / "config"))
+sys.path.insert(0, str(SCRIPTS_ROOT))
+
+from codex_astra_preflight import run_astra_preflight
+
+
+def test_run_astra_preflight_rejects_probe_failure(tmp_path: Path) -> None:
+    probe_path = tmp_path / "codex_usage_probe.py"
+
+    def process_runner(*args: object, **kwargs: object) -> subprocess.CompletedProcess[str]:
+        return subprocess.CompletedProcess([], 1, json.dumps({}), "")
+
+    preflight = run_astra_preflight(probe_path, process_runner)
+
+    assert not preflight.eligible
+    assert preflight.fallback_kind == "broken"

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

@@ -0,0 +1,42 @@
+"""Tests for typed Codex Astra replies."""
+
+import json
+import sys
+from pathlib import Path
+
+SCRIPTS_ROOT = Path(__file__).parent.parent
+sys.path.insert(0, str(SCRIPTS_ROOT / "config"))
+sys.path.insert(0, str(SCRIPTS_ROOT))
+
+from codex_astra_reply import (
+    build_fallback_reply,
+    build_success_reply,
+    parse_codex_jsonl_reply,
+)
+
+
+def test_build_fallback_reply_preserves_fallback_kind() -> None:
+    reply = build_fallback_reply("declined", True, "declined")
+
+    assert reply.is_fallback
+    assert reply.fallback_kind == "declined"
+
+
+def test_build_success_reply_preserves_guidance_fields() -> None:
+    reply = build_success_reply("thread-1", "PLAN\ninspect", "PLAN")
+
+    assert reply.successful
+    assert reply.session_id == "thread-1"
+    assert reply.signal == "PLAN"
+
+
+def test_parse_codex_jsonl_reply_preserves_fallback_kind() -> None:
+    reply = parse_codex_jsonl_reply(
+        json.dumps({"type": "thread.started", "thread_id": "thread-1"}),
+        None,
+        True,
+        "broken",
+    )
+
+    assert reply.is_fallback
+    assert reply.fallback_kind == "broken"

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

@@ -47,7 +47,7 @@ def test_clean_single_spawn_at_top_of_slice_passes() -> None:
     assert validate_model_tier_run(run) is None
 
 
-def test_sol_codex_bind_succeeds_after_fable_when_enabled() -> None:
+def test_astra_codex_bind_succeeds_after_fable_when_enabled() -> None:
     run = ModelTierRun(
         own_tier="Opus",
         candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
@@ -56,35 +56,35 @@ def test_sol_codex_bind_succeeds_after_fable_when_enabled() -> None:
             {"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN},
         ],
         selected_tier=ADVISOR_MODEL_TIER,
-        is_sol_enabled=True,
+        is_astra_enabled=True,
     )
     assert validate_model_tier_run(run) is None
 
 
-def test_fable_success_with_sol_enabled_stops_before_sol() -> None:
+def test_fable_success_with_astra_enabled_stops_before_astra() -> None:
     run = ModelTierRun(
         own_tier="Opus",
         candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
         attempts=[{"tier": "Fable", "result": "spawned"}],
         selected_tier="Fable",
-        is_sol_enabled=True,
+        is_astra_enabled=True,
     )
     assert validate_model_tier_run(run) is None
 
 
-def test_sol_first_walk_raises_when_sol_is_enabled() -> None:
+def test_astra_first_walk_raises_when_astra_is_enabled() -> None:
     run = ModelTierRun(
         own_tier="Opus",
         candidate_tiers=[ADVISOR_MODEL_TIER, "Fable"],
         attempts=[{"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN}],
         selected_tier=ADVISOR_MODEL_TIER,
-        is_sol_enabled=True,
+        is_astra_enabled=True,
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
 
 
-def test_sol_rung_follows_fable_on_third_party_cli_floor_when_enabled() -> None:
+def test_astra_rung_follows_fable_on_third_party_cli_floor_when_enabled() -> None:
     run = ModelTierRun(
         own_tier="ThirdParty",
         candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
@@ -93,13 +93,14 @@ def test_sol_rung_follows_fable_on_third_party_cli_floor_when_enabled() -> None:
             {"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN},
         ],
         selected_tier=ADVISOR_MODEL_TIER,
-        is_sol_enabled=True,
+        is_astra_enabled=True,
+        host_profile="ThirdParty",
     )
 
     assert validate_model_tier_run(run) is None
 
 
-def test_sol_codex_result_requires_sol_candidate() -> None:
+def test_astra_codex_result_requires_astra_candidate() -> None:
     run = ModelTierRun(
         own_tier="Opus",
         candidate_tiers=["Fable"],
@@ -110,7 +111,7 @@ def test_sol_codex_result_requires_sol_candidate() -> None:
         validate_model_tier_run(run)
 
 
-def test_sol_spawned_result_does_not_count_as_codex_success() -> None:
+def test_astra_spawned_result_does_not_count_as_codex_success() -> None:
     run = ModelTierRun(
         own_tier="Opus",
         candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
@@ -119,7 +120,7 @@ def test_sol_spawned_result_does_not_count_as_codex_success() -> None:
             {"tier": ADVISOR_MODEL_TIER, "result": "spawned"},
         ],
         selected_tier=ADVISOR_MODEL_TIER,
-        is_sol_enabled=True,
+        is_astra_enabled=True,
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
@@ -178,7 +179,7 @@ def test_attempts_out_of_ladder_order_raises() -> None:
             {"tier": "Fable", "result": "unavailable"},
         ],
         selected_tier=ADVISOR_MODEL_TIER,
-        is_sol_enabled=True,
+        is_astra_enabled=True,
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
@@ -193,7 +194,7 @@ def test_selected_tier_not_first_spawned_attempt_raises() -> None:
             {"tier": ADVISOR_MODEL_TIER, "result": CODEX_BIND_SUCCESS_TOKEN},
         ],
         selected_tier="Fable",
-        is_sol_enabled=True,
+        is_astra_enabled=True,
     )
     with pytest.raises(
         ModelTierRunError,
@@ -251,14 +252,14 @@ def test_empty_attempts_with_null_selected_tier_raises() -> None:
         validate_model_tier_run(run)
 
 
-def test_incomplete_fallback_walk_before_sol_raises() -> None:
+def test_incomplete_fallback_walk_before_astra_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
         candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
         attempts=[{"tier": "Fable", "result": "unavailable"}],
         selected_tier=None,
-        fallback_reason="stopped after Fable without trying Sol",
-        is_sol_enabled=True,
+        fallback_reason="stopped after Fable without trying Astra",
+        is_astra_enabled=True,
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
@@ -310,8 +311,8 @@ def test_cli_rejects_non_string_host_profile(tmp_path: Path) -> None:
     assert main([str(log_path)]) == 2
 
 
-def test_cli_rejects_non_boolean_sol_enabled(tmp_path: Path) -> None:
-    log_path = tmp_path / "invalid-sol-enabled.json"
+def test_cli_rejects_non_boolean_astra_enabled(tmp_path: Path) -> None:
+    log_path = tmp_path / "invalid-astra-enabled.json"
     log_path.write_text(
         json.dumps(
             {
@@ -319,7 +320,7 @@ def test_cli_rejects_non_boolean_sol_enabled(tmp_path: Path) -> None:
                 "candidate_tiers": ["Fable"],
                 "attempts": [{"tier": "Fable", "result": "spawned"}],
                 "selected_tier": "Fable",
-                "sol_enabled": "false",
+                "astra_enabled": "false",
             }
         ),
         encoding="utf-8",
@@ -333,11 +334,11 @@ def test_cli_rejects_incomplete_fallback_log(tmp_path: Path) -> None:
         json.dumps(
             {
                 "own_tier": "Opus",
-                "candidate_tiers": ["Fable", "Sol"],
+                "candidate_tiers": ["Fable", "Astra"],
                 "attempts": [{"tier": "Fable", "result": "unavailable"}],
                 "selected_tier": None,
                 "fallback_reason": "incomplete",
-                "sol_enabled": True,
+                "astra_enabled": True,
             }
         ),
         encoding="utf-8",
@@ -345,6 +346,30 @@ def test_cli_rejects_incomplete_fallback_log(tmp_path: Path) -> None:
     assert main([str(log_path)]) == 1
 
 
+def test_cli_loads_astra_enabled_fallback_walk(tmp_path: Path) -> None:
+    log_path = tmp_path / "astra-enabled-walk.json"
+    log_path.write_text(
+        json.dumps(
+            {
+                "own_tier": "ThirdParty",
+                "host_profile": "ThirdParty",
+                "candidate_tiers": ["Fable", "Astra"],
+                "attempts": [
+                    {"tier": "Fable", "result": "unavailable"},
+                    {"tier": "Astra", "result": "codex"},
+                ],
+                "selected_tier": "Astra",
+                "astra_enabled": True,
+            }
+        ),
+        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.is_astra_enabled
+    assert loaded_run.selected_tier == "Astra"
+
+
 def test_cli_missing_path_returns_usage_exit_code() -> None:
     assert main([]) == 2
 
@@ -472,7 +497,7 @@ def test_claude_host_self_token_is_not_spawn_success_raises() -> None:
         validate_model_tier_run(run)
 
 
-def test_codex_host_sol_in_session_spawn_passes() -> None:
+def test_codex_host_astra_in_session_spawn_passes() -> None:
     run = ModelTierRun(
         own_tier="Opus",
         candidate_tiers=[ADVISOR_MODEL_TIER],
@@ -483,7 +508,7 @@ def test_codex_host_sol_in_session_spawn_passes() -> None:
     assert validate_model_tier_run(run) is None
 
 
-def test_codex_host_sol_codex_token_counts_as_success() -> None:
+def test_codex_host_astra_codex_token_counts_as_success() -> None:
     run = ModelTierRun(
         own_tier="Opus",
         candidate_tiers=[ADVISOR_MODEL_TIER],
@@ -496,26 +521,26 @@ def test_codex_host_sol_codex_token_counts_as_success() -> None:
     assert validate_model_tier_run(run) is None
 
 
-def test_codex_host_fable_then_sol_walk_raises() -> None:
+def test_codex_host_fable_then_astra_walk_raises() -> None:
     run = ModelTierRun(
         own_tier="Opus",
         candidate_tiers=["Fable", ADVISOR_MODEL_TIER],
         attempts=[{"tier": ADVISOR_MODEL_TIER, "result": "spawned"}],
         selected_tier=ADVISOR_MODEL_TIER,
-        is_sol_enabled=True,
+        is_astra_enabled=True,
         host_profile="Codex",
     )
     with pytest.raises(ModelTierRunError):
         validate_model_tier_run(run)
 
 
-def test_codex_host_exhausted_sol_fails_closed() -> None:
+def test_codex_host_exhausted_astra_fails_closed() -> None:
     run = ModelTierRun(
         own_tier="Opus",
         candidate_tiers=[ADVISOR_MODEL_TIER],
         attempts=[{"tier": ADVISOR_MODEL_TIER, "result": "unavailable"}],
         selected_tier=None,
-        fallback_reason="Codex in-session Sol spawn did not bind",
+        fallback_reason="Codex in-session Astra spawn did not bind",
         host_profile="Codex",
     )
     assert validate_model_tier_run(run) is None
@@ -527,9 +552,9 @@ def test_cli_loads_codex_host_profile(tmp_path: Path) -> None:
         json.dumps(
             {
                 "own_tier": "Opus",
-                "candidate_tiers": ["Sol"],
-                "attempts": [{"tier": "Sol", "result": "spawned"}],
-                "selected_tier": "Sol",
+                "candidate_tiers": ["Astra"],
+                "attempts": [{"tier": "Astra", "result": "spawned"}],
+                "selected_tier": "Astra",
                 "host_profile": "Codex",
             }
         ),

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

@@ -105,10 +105,19 @@ def test_sendmessage_reply_wait_is_positive_bound() -> None:
     assert ADVISOR_SENDMESSAGE_REPLY_WAIT_SECONDS == 120
 
 
-def test_resolve_codex_model_id_maps_sol() -> None:
-    assert resolve_codex_model_id(f" {ADVISOR_MODEL_TIER.lower()} ") == (
-        ADVISOR_CODEX_MODEL_ID
-    )
+@pytest.mark.parametrize("tier_name", ["Astra", "astra", "ASTRA", " Astra "])
+def test_resolve_codex_model_id_maps_astra(tier_name: str) -> None:
+    assert resolve_codex_model_id(tier_name) == "gpt-6-astra"
+
+
+def test_resolve_codex_model_id_rejects_old_sol_tier() -> None:
+    with pytest.raises(ValueError, match="not a known model tier"):
+        resolve_codex_model_id("Sol")
+
+
+def test_resolve_cli_model_id_rejects_astra_as_a_claude_alias() -> None:
+    with pytest.raises(ValueError, match="not a known model tier"):
+        resolve_cli_model_id("Astra")
 
 
 def test_resolve_codex_model_id_rejects_claude_tier() -> None:
@@ -132,6 +141,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("thirdparty") == "ThirdParty"
+    assert canonical_tier_name(" astra ") == "Astra"
     assert canonical_tier_name("") is None
     assert canonical_tier_name("Titan") is None
 

package/_shared/pr-loop/scripts/pr_loop_shared_constants/terminology_sweep_constants.py

@@ -109,6 +109,20 @@ ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND: tuple[str, ...] = (
 
 GIT_DIFF_SUBPROCESS_TIMEOUT_SECONDS: int = 30
 
+GIT_NO_MATCH_EXIT_CODE: int = 1
+
+GIT_OPERATION_FAILURE_TEMPLATE: str = "{operation} failed: {details}"
+
+GIT_DIFF_OPERATION: str = "git diff --cached"
+
+GIT_GREP_OPERATION_TEMPLATE: str = "git grep for {identifier}"
+
+GIT_FAILURE_WITHOUT_DETAILS: str = "no diagnostic text"
+
+GIT_TEXT_ENCODING: str = "utf-8"
+
+GIT_DECODE_ERRORS: str = "replace"
+
 TERMINOLOGY_SWEEP_GATE_HEADER: str = (
     "terminology_sweep: {finding_count} cross-surface terminology near-miss(es) "
     "on staged prose:"