claude-dev-env 2.11.0 → 2.13.0

package/_shared/advisor/reference/sol-rung.md

@@ -5,8 +5,11 @@ Open this when `ADVISOR_SOL_XHIGH` is set and a bind is starting.
 
 ## Flag
 
-`ADVISOR_SOL_XHIGH=1` (or `true` / `yes` / `on`) opens the rung, set in the environment or by the consuming skill's invocation.
-Flag off: the walk starts at the host's Claude ladder, Fable first.
+`ADVISOR_SOL_XHIGH=1` (or `true` / `yes` / `on`) opens the rung. Two channels exist: set the variable in the helper's process environment, or pass `--enable-sol` on the helper invocation — the CLI flag opens the rung for that run without touching the environment.
+Flag off both ways: the walk starts at the host's Claude ladder, Fable first.
+A Windows `setx` write only updates the persisted user environment; only a process started after that write inherits the new value, so an already-running session either sets the flag in its own invoking process environment or passes `--enable-sol`.
+
+Every fallback reply carries a `fallback_kind` field: `declined` when policy closed the rung (flag off, usage meter at or below the gate) and `broken` when the Sol path itself failed (missing executable, spawn error, timeout, malformed reply). A `broken` fallback is a defect to report, not a routing outcome.
 
 ## Preflight
 

package/_shared/advisor/reference/warm-up.md

@@ -25,6 +25,7 @@ State plainly:
 - Reply via SendMessage to whoever sent the consult, by name — each reply goes back to its own sender, and many different consumers may reach this one agent.
 - Treat each consult on its own terms, keyed to the sender's stated assignment. Different consumers' consults will interleave in this one transcript — keep each consumer's context separate, and blend only when a consult explicitly asks for that.
 - If a consult re-raises a question already answered, with nothing new attached, reply by restating the prior answer and naming it as a restatement.
+- Every reply, including this first bind turn, opens its first line with exactly one of the four uppercase signal words — `ENDORSE`, `CORRECTION`, `PLAN`, `STOP` — and nothing else on that line. Standing by after the bind is itself an `ENDORSE` of the charter, stated as that first line.
 
 The agent finishes its first turn standing by. `SendMessage` alone resumes it; between consults it waits quietly.
 

package/_shared/advisor/scripts/codex_sol_advisor.py

@@ -7,6 +7,7 @@ import importlib
 import json
 import math
 import os
+import shutil
 import subprocess
 import sys
 from collections.abc import Callable, Mapping, Sequence
@@ -20,6 +21,7 @@ if _config_directory_text not in sys.path:
     sys.path.insert(0, _config_directory_text)
 
 from advisor_scripts_constants.sol_advisor_constants import (  # noqa: E402
+    ADVISOR_CODEX_EXECUTABLE_ENV_VAR,
     CODEX_CONFIG_FLAG,
     CODEX_EXECUTABLE,
     CODEX_EXEC_SUBCOMMAND,
@@ -35,6 +37,10 @@ from advisor_scripts_constants.sol_advisor_constants import (  # noqa: E402
     SOL_CODEX_TIMEOUT_REASON,
     SOL_CODEX_TIMEOUT_SECONDS,
     SOL_ENV_VAR,
+    SOL_ENABLE_FLAG,
+    SOL_EXECUTABLE_NOT_FOUND_REASON,
+    SOL_FALLBACK_KIND_BROKEN,
+    SOL_FALLBACK_KIND_DECLINED,
     SOL_INVALID_SIGNAL_REASON,
     SOL_MALFORMED_JSONL_REASON,
     SOL_MISSING_SESSION_REASON,
@@ -63,6 +69,7 @@ class SolPreflight:
     eligible: bool
     percent_left: float | None
     reason: str
+    fallback_kind: str | None = None
 
 
 @dataclass(frozen=True)
@@ -78,17 +85,21 @@ class CodexSolAdvisorReply:
     sol_enabled: bool
     selected_tier: str
     outcome: str
+    fallback_kind: str | None
 
 
 def _preflight_fallback(
-    reason: str, percent_left: float | None
+    reason: str,
+    percent_left: float | None,
+    fallback_kind: str = SOL_FALLBACK_KIND_BROKEN,
 ) -> SolPreflight:
-    return SolPreflight(False, percent_left, reason)
+    return SolPreflight(False, percent_left, reason, fallback_kind)
 
 
 def _reply_fallback(
     reason: str,
     is_sol_enabled: bool,
+    fallback_kind: str | None = SOL_FALLBACK_KIND_BROKEN,
 ) -> CodexSolAdvisorReply:
     return CodexSolAdvisorReply(
         session_id=None,
@@ -100,6 +111,7 @@ def _reply_fallback(
         sol_enabled=is_sol_enabled,
         selected_tier=ADVISOR_FALLBACK_TIER,
         outcome=ADVISOR_FALLBACK_RESULT,
+        fallback_kind=fallback_kind,
     )
 
 
@@ -118,9 +130,16 @@ def _reply_success(
         sol_enabled=True,
         selected_tier=ADVISOR_MODEL_TIER,
         outcome=CODEX_BIND_SUCCESS_TOKEN,
+        fallback_kind=None,
     )
 
 
+def _resolved_setting_by_name(
+    setting_by_name: Mapping[str, str] | None,
+) -> Mapping[str, str]:
+    return os.environ if setting_by_name is None else setting_by_name
+
+
 def is_sol_advisor_enabled(
     setting_by_name: Mapping[str, str] | None,
 ) -> bool:
@@ -132,7 +151,7 @@ def is_sol_advisor_enabled(
     Returns:
         Whether the Sol feature flag contains a recognized truthy value.
     """
-    resolved_setting_by_name = os.environ if setting_by_name is None else setting_by_name
+    resolved_setting_by_name = _resolved_setting_by_name(setting_by_name)
     return (
         resolved_setting_by_name.get(SOL_ENV_VAR, "").strip().lower()
         in ALL_SOL_TRUTHY_VALUES
@@ -223,11 +242,11 @@ def run_sol_preflight(
             return _preflight_fallback(
                 f"{SOL_PREFLIGHT_FAILURE_REASON}: usage meter is unknown", None
             )
-        usage_gate = _load_usage_gate(probe_path)
         if not usage_gate(percent_left):
             return _preflight_fallback(
                 f"{SOL_PREFLIGHT_FAILURE_REASON}: usage meter is at or below the gate",
                 percent_left,
+                fallback_kind=SOL_FALLBACK_KIND_DECLINED,
             )
     except subprocess.TimeoutExpired as probe_error:
         return _preflight_fallback(f"{SOL_PROBE_TIMEOUT_REASON}: {probe_error}", None)
@@ -245,17 +264,44 @@ def run_sol_preflight(
     return SolPreflight(True, percent_left, "usage meter is above the Sol gate")
 
 
-def build_codex_arguments(session_id: str | None = None) -> list[str]:
+def resolve_codex_executable(
+    setting_by_name: Mapping[str, str] | None,
+) -> str | None:
+    """Resolve the Codex CLI executable to an invocable name or path.
+
+    A bare "codex" name fails Windows `CreateProcess`, since the npm shim
+    directory holds only `codex` (a sh script), `codex.cmd`, and `codex.ps1`.
+    `shutil.which` finds `codex.cmd` via `PATHEXT`. An explicit override
+    always wins and is trusted without a `which` check.
+
+    Args:
+        setting_by_name: Optional environment-like settings mapping.
+
+    Returns:
+        An invocable executable name or path, or None when unresolved.
+    """
+    resolved_setting_by_name = _resolved_setting_by_name(setting_by_name)
+    executable_override = resolved_setting_by_name.get(ADVISOR_CODEX_EXECUTABLE_ENV_VAR, "").strip()
+    if executable_override:
+        return executable_override
+    return shutil.which(CODEX_EXECUTABLE)
+
+
+def build_codex_arguments(
+    codex_executable: str,
+    session_id: str | None = None,
+) -> list[str]:
     """Build the installed CLI's shell-free bind or resume argv.
 
     Args:
+        codex_executable: Resolved executable name or path to invoke.
         session_id: Optional existing session to resume.
 
     Returns:
         The shell-free Codex command argument vector.
     """
     command_arguments = [
-        CODEX_EXECUTABLE,
+        codex_executable,
         CODEX_EXEC_SUBCOMMAND,
         CODEX_MODEL_FLAG,
         ADVISOR_CODEX_MODEL_ID,
@@ -333,6 +379,21 @@ def parse_codex_jsonl_reply(
     return _reply_success(discovered_session_id, final_guidance, guidance_signal)
 
 
+def _resolve_sol_preflight(
+    preflight: SolPreflight | None,
+    probe_path: Path | None,
+    process_runner: Callable[..., subprocess.CompletedProcess[str]],
+) -> SolPreflight:
+    if preflight is not None:
+        return preflight
+    resolved_probe_path = (
+        resolve_usage_probe_path(Path.home()) if probe_path is None else probe_path
+    )
+    return run_sol_preflight(
+        probe_path=resolved_probe_path, process_runner=process_runner
+    )
+
+
 def run_codex_sol_advisor(
     prompt: str,
     working_directory: Path,
@@ -356,26 +417,25 @@ def run_codex_sol_advisor(
     Returns:
         The parsed Sol guidance or an explicit Fable fallback reply.
     """
-    is_sol_enabled = is_sol_advisor_enabled(setting_by_name)
-    if not is_sol_enabled:
-        return _reply_fallback("Sol advisor flag is disabled", False)
-    resolved_preflight = (
-        run_sol_preflight(
-            probe_path=(
-                resolve_usage_probe_path(Path.home())
-                if probe_path is None
-                else probe_path
-            ),
-            process_runner=process_runner,
+    if not is_sol_advisor_enabled(setting_by_name):
+        return _reply_fallback(
+            "Sol advisor flag is disabled",
+            False,
+            fallback_kind=SOL_FALLBACK_KIND_DECLINED,
         )
-        if preflight is None
-        else preflight
-    )
+    codex_executable = resolve_codex_executable(setting_by_name)
+    if codex_executable is None:
+        return _reply_fallback(SOL_EXECUTABLE_NOT_FOUND_REASON, True)
+    resolved_preflight = _resolve_sol_preflight(preflight, probe_path, process_runner)
     if not resolved_preflight.eligible:
-        return _reply_fallback(resolved_preflight.reason, is_sol_enabled)
+        return _reply_fallback(
+            resolved_preflight.reason,
+            True,
+            fallback_kind=resolved_preflight.fallback_kind,
+        )
     try:
         completed_process = process_runner(
-            build_codex_arguments(session_id=session_id),
+            build_codex_arguments(codex_executable, session_id=session_id),
             cwd=str(working_directory),
             input=prompt,
             capture_output=True,
@@ -385,22 +445,18 @@ def run_codex_sol_advisor(
             timeout=SOL_CODEX_TIMEOUT_SECONDS,
         )
     except subprocess.TimeoutExpired as bind_error:
-        return _reply_fallback(
-            f"{SOL_CODEX_TIMEOUT_REASON}: {bind_error}", is_sol_enabled
-        )
+        return _reply_fallback(f"{SOL_CODEX_TIMEOUT_REASON}: {bind_error}", True)
     except (OSError, subprocess.SubprocessError) as bind_error:
-        return _reply_fallback(
-            f"{SOL_BIND_FAILURE_REASON}: {bind_error}", is_sol_enabled
-        )
+        return _reply_fallback(f"{SOL_BIND_FAILURE_REASON}: {bind_error}", True)
     if completed_process.returncode != 0:
         return _reply_fallback(
             f"{SOL_BIND_FAILURE_REASON}: process exit {completed_process.returncode}",
-            is_sol_enabled,
+            True,
         )
     return parse_codex_jsonl_reply(
         completed_process.stdout,
         existing_session_id=session_id,
-        is_sol_enabled=is_sol_enabled,
+        is_sol_enabled=True,
     )
 
 
@@ -417,6 +473,12 @@ def build_argument_parser() -> argparse.ArgumentParser:
     mode_group.add_argument("--bind", action="store_true")
     mode_group.add_argument("--resume", metavar=SOL_SESSION_ID_METAVAR)
     argument_parser.add_argument("--cwd", required=True, type=Path)
+    argument_parser.add_argument(
+        SOL_ENABLE_FLAG,
+        dest="is_sol_requested",
+        action="store_true",
+        help="Open the Sol rung for this invocation without an environment flag.",
+    )
     return argument_parser
 
 
@@ -430,12 +492,15 @@ def main(all_cli_arguments: Sequence[str]) -> int:
         Zero for a successful Sol response, or one for an explicit fallback.
     """
     parsed_arguments = build_argument_parser().parse_args(list(all_cli_arguments))
+    setting_by_name: Mapping[str, str] = os.environ
+    if parsed_arguments.is_sol_requested:
+        setting_by_name = {**os.environ, SOL_ENV_VAR: "1"}
     advisor_reply = run_codex_sol_advisor(
         prompt=sys.stdin.read(),
         working_directory=parsed_arguments.cwd,
         preflight=None,
         probe_path=None,
-        setting_by_name=os.environ,
+        setting_by_name=setting_by_name,
         session_id=parsed_arguments.resume if not parsed_arguments.bind else None,
         process_runner=subprocess.run,
     )

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

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 CODEX_EXECUTABLE: str = "codex"
+ADVISOR_CODEX_EXECUTABLE_ENV_VAR: str = "ADVISOR_CODEX_EXECUTABLE"
 CODEX_READ_ONLY_SANDBOX: str = "read-only"
 CODEX_JSON_FLAG: str = "--json"
 CODEX_MODEL_FLAG: str = "--model"
@@ -26,3 +27,7 @@ SOL_CODEX_TIMEOUT_REASON: str = "Codex Sol xhigh request timed out"
 SOL_MALFORMED_JSONL_REASON: str = "Codex Sol xhigh returned malformed JSONL"
 SOL_MISSING_SESSION_REASON: str = "Codex Sol xhigh returned no session id"
 SOL_INVALID_SIGNAL_REASON: str = "Codex Sol xhigh returned an invalid guidance signal"
+SOL_EXECUTABLE_NOT_FOUND_REASON: str = "Codex Sol xhigh could not find the codex executable on PATH"
+SOL_FALLBACK_KIND_DECLINED: str = "declined"
+SOL_FALLBACK_KIND_BROKEN: str = "broken"
+SOL_ENABLE_FLAG: str = "--enable-sol"

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

@@ -37,6 +37,17 @@ USAGE_PROBE_PATH = (
     / "scripts"
     / "codex_usage_probe.py"
 )
+WINDOWS_SHIM_PATH = r"C:\Users\me\AppData\Roaming\npm\codex.cmd"
+ENABLED_SETTING_BY_NAME = {sol_advisor.SOL_ENV_VAR: "1"}
+
+
+@pytest.fixture(autouse=True)
+def _codex_on_search_path(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        sol_advisor.shutil,
+        "which",
+        lambda name: "codex" if name == sol_advisor.CODEX_EXECUTABLE else None,
+    )
 
 
 def _probe_process(
@@ -130,6 +141,7 @@ def test_main_serializes_stable_result_field(monkeypatch: pytest.MonkeyPatch, ca
             sol_enabled=True,
         selected_tier=sol_advisor.ADVISOR_MODEL_TIER,
         outcome=sol_advisor.CODEX_BIND_SUCCESS_TOKEN,
+        fallback_kind=None,
         ),
     )
     monkeypatch.setattr(sys, "stdin", io.StringIO("first consult"))
@@ -155,18 +167,165 @@ def test_bind_and_resume_arguments_match_installed_codex_interface() -> None:
         "read-only",
         "--json",
     ]
-    assert sol_advisor.build_codex_arguments() == [
+    assert sol_advisor.build_codex_arguments("codex") == [
         *expected_common_arguments,
         "-",
     ]
-    assert sol_advisor.build_codex_arguments("thread-1") == [
-        *expected_common_arguments,
+    assert sol_advisor.build_codex_arguments(
+        WINDOWS_SHIM_PATH, session_id="thread-1"
+    ) == [
+        WINDOWS_SHIM_PATH,
+        *expected_common_arguments[1:],
         "resume",
         "thread-1",
         "-",
     ]
 
 
+def test_resolve_codex_executable_prefers_the_env_var_override(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(sol_advisor.shutil, "which", lambda name: None)
+
+    resolved_executable = sol_advisor.resolve_codex_executable(
+        {sol_advisor.ADVISOR_CODEX_EXECUTABLE_ENV_VAR: WINDOWS_SHIM_PATH}
+    )
+
+    assert resolved_executable == WINDOWS_SHIM_PATH
+
+
+def test_resolve_codex_executable_falls_back_to_which_search(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        sol_advisor.shutil,
+        "which",
+        lambda name: (
+            WINDOWS_SHIM_PATH if name == sol_advisor.CODEX_EXECUTABLE else None
+        ),
+    )
+
+    resolved_executable = sol_advisor.resolve_codex_executable({})
+
+    assert resolved_executable == WINDOWS_SHIM_PATH
+
+
+def test_resolve_codex_executable_returns_none_when_unresolved(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(sol_advisor.shutil, "which", lambda name: None)
+
+    resolved_executable = sol_advisor.resolve_codex_executable({})
+
+    assert resolved_executable is None
+
+
+def test_bind_falls_back_with_a_clear_reason_when_executable_is_missing(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(sol_advisor.shutil, "which", lambda name: None)
+    calls: list[list[str]] = []
+
+    def process_runner(
+        arguments: list[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[str]:
+        calls.append(arguments)
+        return _probe_process({"percent_left": 90})
+
+    reply = sol_advisor.run_codex_sol_advisor(
+        prompt="first consult",
+        working_directory=Path("."),
+        preflight=None,
+        probe_path=USAGE_PROBE_PATH,
+        session_id=None,
+        process_runner=process_runner,
+        setting_by_name={sol_advisor.SOL_ENV_VAR: "1"},
+    )
+
+    assert not reply.successful
+    assert reply.is_fallback
+    assert reply.reason is not None
+    assert "codex" in reply.reason
+    assert reply.fallback_kind == sol_advisor.SOL_FALLBACK_KIND_BROKEN
+    assert calls == []
+
+
+def test_policy_fallbacks_are_marked_declined() -> None:
+    def gate_closed_runner(
+        arguments: list[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[str]:
+        return _probe_process({"percent_left": 5})
+
+    disabled_reply = sol_advisor.run_codex_sol_advisor(
+        prompt="first consult",
+        working_directory=Path("."),
+        preflight=None,
+        probe_path=USAGE_PROBE_PATH,
+        session_id=None,
+        process_runner=gate_closed_runner,
+        setting_by_name={},
+    )
+    gate_closed_reply = sol_advisor.run_codex_sol_advisor(
+        prompt="first consult",
+        working_directory=Path("."),
+        preflight=None,
+        probe_path=USAGE_PROBE_PATH,
+        session_id=None,
+        process_runner=gate_closed_runner,
+        setting_by_name=ENABLED_SETTING_BY_NAME,
+    )
+
+    assert disabled_reply.fallback_kind == sol_advisor.SOL_FALLBACK_KIND_DECLINED
+    assert gate_closed_reply.fallback_kind == sol_advisor.SOL_FALLBACK_KIND_DECLINED
+
+
+def test_probe_failure_fallback_is_marked_broken() -> None:
+    def failing_probe_runner(
+        arguments: list[str], **kwargs: object
+    ) -> subprocess.CompletedProcess[str]:
+        return _probe_process({}, returncode=3)
+
+    reply = sol_advisor.run_codex_sol_advisor(
+        prompt="first consult",
+        working_directory=Path("."),
+        preflight=None,
+        probe_path=USAGE_PROBE_PATH,
+        session_id=None,
+        process_runner=failing_probe_runner,
+        setting_by_name=ENABLED_SETTING_BY_NAME,
+    )
+
+    assert reply.is_fallback
+    assert reply.fallback_kind == sol_advisor.SOL_FALLBACK_KIND_BROKEN
+
+
+def test_enable_sol_flag_opens_the_rung_without_an_environment_flag(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    captured_settings: dict[str, str] = {}
+
+    def fake_advisor(**kwargs: object) -> object:
+        captured_settings.update(dict(kwargs["setting_by_name"]))  # type: ignore[arg-type]
+        return sol_advisor._reply_fallback(
+            "probe declined",
+            True,
+            fallback_kind=sol_advisor.SOL_FALLBACK_KIND_DECLINED,
+        )
+
+    monkeypatch.setattr(sol_advisor, "run_codex_sol_advisor", fake_advisor)
+    monkeypatch.delenv(sol_advisor.SOL_ENV_VAR, raising=False)
+    monkeypatch.setattr(sys, "stdin", io.StringIO("first consult"))
+
+    exit_code = sol_advisor.main(
+        ["--bind", "--cwd", ".", sol_advisor.SOL_ENABLE_FLAG]
+    )
+    payload = json.loads(capsys.readouterr().out)
+
+    assert exit_code == 1
+    assert captured_settings[sol_advisor.SOL_ENV_VAR] == "1"
+    assert payload["fallback_kind"] == sol_advisor.SOL_FALLBACK_KIND_DECLINED
+
+
 def test_successful_probe_requires_finite_meter_above_configured_gate() -> None:
     def probe_runner(arguments: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:
         return _probe_process({"percent_left": 90})
@@ -304,12 +463,12 @@ def test_bind_runs_probe_then_codex_with_read_only_xhigh_settings() -> None:
         probe_path=USAGE_PROBE_PATH,
         session_id=None,
         process_runner=process_runner,
-        setting_by_name={"ADVISOR_SOL_XHIGH": "1"},
+        setting_by_name=ENABLED_SETTING_BY_NAME,
     )
 
     assert reply.successful
     assert len(calls) == 2
-    assert calls[1][0] == sol_advisor.build_codex_arguments()
+    assert calls[1][0] == sol_advisor.build_codex_arguments("codex")
     assert calls[1][1]["cwd"] == "."
     assert calls[1][1]["shell"] is False
     assert calls[1][1]["timeout"]
@@ -331,7 +490,7 @@ def test_team_advisor_path_preserves_sol_routing_fields() -> None:
         probe_path=USAGE_PROBE_PATH,
         session_id=None,
         process_runner=_two_step_process_runner(calls, guidance="PLAN\ninspect"),
-        setting_by_name={"ADVISOR_SOL_XHIGH": "1"},
+        setting_by_name=ENABLED_SETTING_BY_NAME,
     )
 
     assert reply.successful
@@ -358,7 +517,7 @@ def test_team_advisor_path_uses_fable_result_when_sol_gate_is_closed() -> None:
         probe_path=USAGE_PROBE_PATH,
         session_id=None,
         process_runner=process_runner,
-        setting_by_name={"ADVISOR_SOL_XHIGH": "1"},
+        setting_by_name=ENABLED_SETTING_BY_NAME,
     )
 
     assert not reply.successful
@@ -369,7 +528,10 @@ def test_team_advisor_path_uses_fable_result_when_sol_gate_is_closed() -> None:
     assert len(calls) == 1
 
 
-def test_disabled_flag_uses_default_optional_routing_inputs() -> None:
+def test_disabled_flag_uses_default_optional_routing_inputs(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv(sol_advisor.SOL_ENV_VAR, raising=False)
     reply = sol_advisor.run_codex_sol_advisor(
         prompt="first consult",
         working_directory=Path("."),
@@ -398,13 +560,13 @@ def test_resume_runs_the_usage_gate_before_codex() -> None:
         session_id="thread-1",
         probe_path=USAGE_PROBE_PATH,
         process_runner=_two_step_process_runner(calls, guidance="ENDORSE\nready"),
-        setting_by_name={"ADVISOR_SOL_XHIGH": "1"},
+        setting_by_name=ENABLED_SETTING_BY_NAME,
     )
 
     assert reply.successful
     assert calls == [
         [sys.executable, str(USAGE_PROBE_PATH)],
-        sol_advisor.build_codex_arguments("thread-1"),
+        sol_advisor.build_codex_arguments("codex", session_id="thread-1"),
     ]
 
 
@@ -465,7 +627,7 @@ def test_codex_failure_modes_always_return_fallback(
         probe_path=USAGE_PROBE_PATH,
         session_id=None,
         process_runner=process_runner,
-        setting_by_name={"ADVISOR_SOL_XHIGH": "1"},
+        setting_by_name=ENABLED_SETTING_BY_NAME,
     )
 
     assert not reply.successful

package/_shared/pr-loop/scripts/code_rules_gate.py

@@ -116,9 +116,8 @@ def _report_partitioned_violations(
 ) -> int:
     """Print the violation sections and return the gate exit code.
 
-    Importers outside this directory (the code-verifier spawn-preflight hook)
-    call this surface with the partition spread across positional arguments,
-    so this wrapper keeps that calling shape and folds the pieces into the
+    External callers pass the partition across positional arguments, so this
+    wrapper keeps that calling shape and folds the pieces into the
     ``PartitionedViolations`` tuple the gate-running module consumes.
 
     Args:

package/_shared/pr-loop/scripts/test_code_rules_gate.py

@@ -250,29 +250,3 @@ def _gate_import_names_in_source(module_source: str) -> set[str]:
         for each_line in import_block.splitlines()
         if each_line.strip() and not each_line.strip().startswith("#")
     }
-
-
-def test_entry_exposes_every_symbol_the_preflight_hook_imports() -> None:
-    """The gate entry re-exports the whole surface the spawn-preflight hook uses.
-
-    The code-verifier spawn-preflight hook imports gate helpers by name at
-    runtime; a name the entry drops breaks that hook's import and silently
-    turns its deny paths into allows.
-    """
-    hook_path = (
-        Path(__file__).resolve().parents[3]
-        / "hooks"
-        / "blocking"
-        / "code_verifier_spawn_preflight_gate.py"
-    )
-    hook_imported_names = _gate_import_names_in_source(
-        hook_path.read_text(encoding="utf-8")
-    )
-
-    assert hook_imported_names, "hook no longer imports from code_rules_gate"
-    missing_names = sorted(
-        each_name
-        for each_name in hook_imported_names
-        if not hasattr(gate_module, each_name)
-    )
-    assert not missing_names, f"gate entry drops hook imports: {missing_names}"

package/agents/CLAUDE.md

@@ -11,13 +11,12 @@ Agent definition files installed into `~/.claude/agents/` by `bin/install.mjs`.
 | `clean-coder.md` | Clean Coder | Primary code-writing agent; links AGENTS.md / CODE_RULES / enforcer; task-local discovery and gate-clean first writes |
 | `code-advisor.md` | Code Advisor | Single-executor mid-run advisor (PLAN/CORRECTION/STOP as final text); distinct from session-advisor |
 | `code-quality-agent.md` | Code Quality Agent | Multi-file code quality review across an entire diff or set of files |
-| `code-verifier.md` | Code Verifier | Post-hoc verification, run only when the task owner asks for a pass; never edits files in the verified tree, with one exception, a deliberate break at an off-tree break site outside it, defined in the agent body; fresh context, puts the draft verdict through one strongest-tier validation subagent, ends with a fenced verdict; `all_pass` true needs a complete shown-red table as well as clean layers |
 | `deep-research.md` | Deep Research | Citation-grounded research with web search |
 | `docs-agent.md` | Docs Agent | Documentation authoring and maintenance |
 | `git-commit-crafter.md` | Git Commit Crafter | Stages changes, writes conventional commit messages, creates commits |
 | `issue-tracker.md` | Issue Tracker | Primary handler for one GitHub issue action per spawn; loads the issue-tracker skill (plain-brief); returns issue numbers and URLs |
 | `plan-packet-validator.md` | Plan Packet Validator | Fresh-context validator for workflow-generated plan packets under `docs/plans/` |
-| `pr-description-writer.md` | PR Description Writer | Authors PR descriptions in Anthropic-style shapes that pass the `pr_description_enforcer` hook's body audit |
+| `pr-description-writer.md` | PR Description Writer | Drafts PR descriptions and comments from the current diff using the canonical description and comment guides |
 | `session-advisor.md` | Session Advisor | Standing multi-consumer reviewer; SendMessage only; returns endorse/correction/plan/stop |
 | `skill-writer-agent.md` | Skill Writer Agent | Authors SKILL.md and companion files to skill-builder conventions; caller-agnostic authoring specialist |