claude-dev-env 2.7.1 → 2.8.0

package/scripts/spawn_grok_batch.py

@@ -26,6 +26,7 @@ from pathlib import Path
 
 from dev_env_scripts_constants.grok_worker_constants import (
     ALL_KNOWN_TOOL_PROFILES,
+    ALL_KNOWN_WORKER_SPEC_KEYS,
     BATCH_LAUNCH_ERROR_STDERR_PREFIX,
     BATCH_SPEC_ROLE_KEY,
     BATCH_SPEC_SHOULD_PING_KEY,
@@ -70,11 +71,13 @@ from dev_env_scripts_constants.grok_worker_constants import (
     SUMMARY_WORKERS_KEY,
     TOOL_PROFILE_BUILD,
     TOOL_PROFILE_READONLY,
+    UNKNOWN_WORKER_KEY_ERROR_TEMPLATE,
     UTF8_ENCODING,
     WORKER_EXCEPTION_RETURN_CODE,
     WORKER_SPEC_AGENT_NAME_KEY,
     WORKER_SPEC_CWD_KEY,
     WORKER_SPEC_IS_REPO_ONLY_KEY,
+    WORKER_SPEC_KEY_JOIN_SEPARATOR,
     WORKER_SPEC_PROMPT_PARTS_KEY,
     WORKER_SPEC_ROLE_NAME_KEY,
     WORKER_SPEC_TIMEOUT_KEY,
@@ -89,6 +92,38 @@ batch_headless_runner = run_headless_worker
 batch_preflight = run_preflight
 
 
+def _require_known_worker_keys(all_worker_fields: dict[str, object]) -> None:
+    """Reject a worker entry carrying a key the launcher does not accept.
+
+    ::
+
+        {"role_name": "lens", ..., "timeout_second": <seconds>}
+        flag: unknown worker key(s): timeout_second; accepted keys: agent_name, ...
+
+    A dropped key reads as a setting that took effect. Naming it here makes
+    that a startup error rather than a silent gap.
+
+    Args:
+        all_worker_fields: One raw worker entry straight from the JSON spec.
+
+    Raises:
+        ValueError: When the entry carries any key outside the accepted set.
+    """
+    all_unknown_keys = set(all_worker_fields) - ALL_KNOWN_WORKER_SPEC_KEYS
+    if not all_unknown_keys:
+        return
+    joined_unknown = WORKER_SPEC_KEY_JOIN_SEPARATOR.join(sorted(all_unknown_keys))
+    joined_accepted = WORKER_SPEC_KEY_JOIN_SEPARATOR.join(
+        sorted(ALL_KNOWN_WORKER_SPEC_KEYS)
+    )
+    raise ValueError(
+        UNKNOWN_WORKER_KEY_ERROR_TEMPLATE.format(
+            unknown_keys=joined_unknown,
+            accepted_keys=joined_accepted,
+        )
+    )
+
+
 @dataclass(frozen=True)
 class WorkerSpec:
     """One worker entry from a batch specification."""
@@ -290,6 +325,7 @@ def _require_timeout_within_bounds(raw_field: object) -> int:
 
 
 def _parse_worker_entry(all_worker_fields: dict[str, object]) -> WorkerSpec:
+    _require_known_worker_keys(all_worker_fields)
     role_name = _require_string(
         _require_worker_field(all_worker_fields, WORKER_SPEC_ROLE_NAME_KEY),
         WORKER_SPEC_ROLE_NAME_KEY,
@@ -348,7 +384,8 @@ def load_batch_spec(specification_path: Path) -> BatchSpec:
         The validated batch specification.
 
     Raises:
-        ValueError: When the JSON shape is invalid or a required field is wrong.
+        ValueError: When the JSON shape is invalid, a required field is wrong,
+            or a worker entry carries a key outside the accepted set.
         OSError: When the specification file cannot be read.
         json.JSONDecodeError: When the file is not valid JSON.
     """

package/scripts/test_claude_chain_runner.py

@@ -24,11 +24,13 @@ from dev_env_scripts_constants.claude_chain_constants import (  # noqa: E402
     ATTEMPT_STATUS_USAGE_LIMITED,
     ATTEMPT_SUMMARY_ENTRY_TEMPLATE,
     ATTEMPT_SUMMARY_JOIN_SEPARATOR,
+    CHAIN_ADVISOR_BLOCKED_EXIT_CODE,
     CHAIN_CONFIG_ERROR_EXIT_CODE,
     CHAIN_EXHAUSTED_EXIT_CODE,
     CHAIN_EXHAUSTED_MESSAGE_TEMPLATE,
     CLAUDE_HOME_SUBDIRECTORY,
     CLI_ARGUMENTS_SEPARATOR,
+    CLI_ROUTING_MODE_FLAG,
     CLI_TIMEOUT_FLAG,
     CODEC_ERROR_STRATEGY,
     CONFIG_CHAIN_EMPTY_REASON,
@@ -48,6 +50,11 @@ from dev_env_scripts_constants.claude_chain_constants import (  # noqa: E402
     DEFAULT_TIMEOUT_SECONDS,
     EXAMPLE_CONFIG_FILENAME,
     NO_COMPLETED_PROCESS_RETURN_CODE,
+    ROUTING_MODE_ORDERED_ACCOUNT,
+    SESSION_ID_JSON_KEY,
+    TERMINAL_STATUS_ADVISOR_BLOCKED,
+    TERMINAL_STATUS_SERVED,
+    TERMINAL_STATUS_TIMEOUT,
     UTF8_ENCODING,
 )
 
@@ -65,6 +72,15 @@ _EQUAL_WEEKLY_REMAINING_PERCENT = 50.0
 _HIGH_WEEKLY_REMAINING_PERCENT = 90.0
 _MID_WEEKLY_REMAINING_PERCENT = 50.0
 _LOW_WEEKLY_REMAINING_PERCENT = 10.0
+_PRIMARY_LAUNCHER = "primary-launcher"
+_SECONDARY_LAUNCHER = "secondary-launcher"
+_BOUND_SESSION_ID = "session-bound-abc-123"
+_AUTHENTICATION_ERROR_STDERR = "authentication_error: invalid API key"
+_GENERIC_PROCESS_ERROR_STDERR = "unknown flag: --not-a-real-flag"
+_JSON_BIND_STDOUT_WITH_SESSION = (
+    f'{{"type":"result","{SESSION_ID_JSON_KEY}":"{_BOUND_SESSION_ID}",'
+    f'"result":"ENDORSE"}}\n'
+)
 
 
 def _completed(command, returncode, stdout="", stderr=""):
@@ -567,6 +583,7 @@ def test_timeout_on_primary_does_not_fall_over(
     chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
     assert chain_result.served_command is None
     assert chain_result.returncode == NO_COMPLETED_PROCESS_RETURN_CODE
+    assert chain_result.terminal_status == TERMINAL_STATUS_TIMEOUT
     assert len(chain_result.attempts) == 1
     assert chain_result.attempts[0].status == ATTEMPT_STATUS_TIMEOUT
 
@@ -1119,3 +1136,344 @@ def test_cli_emits_utf8_when_console_encoding_is_legacy(tmp_path: Path) -> None:
     assert completed.returncode == 0
     assert b"Traceback" not in completed.stderr
     assert "report ✅" in completed.stdout.decode(UTF8_ENCODING)
+
+
+def test_usage_limit_classifier_keys_on_exact_signature_constants() -> None:
+    assert ALL_USAGE_LIMIT_SIGNATURES == (
+        "hit your session limit",
+        "usage limit reached",
+        "out of usage",
+        "usage quota exceeded",
+    )
+    assert _A_SIGNATURE in ALL_USAGE_LIMIT_SIGNATURES
+    assert runner._is_usage_limit_failure(
+        _completed("primary-launcher", 1, stderr=_A_SIGNATURE)
+    )
+    assert not runner._is_usage_limit_failure(
+        _completed("primary-launcher", 1, stderr=_GENERIC_PROCESS_ERROR_STDERR)
+    )
+
+
+def test_extract_session_id_from_stdout_reads_json_object_and_ndjson() -> None:
+    single_object = (
+        f'{{"type":"result","{SESSION_ID_JSON_KEY}":"{_BOUND_SESSION_ID}",'
+        f'"result":"ENDORSE"}}'
+    )
+    assert runner.extract_session_id_from_stdout(single_object) == _BOUND_SESSION_ID
+    ndjson_stream = (
+        f'{{"type":"system","{SESSION_ID_JSON_KEY}":"{_BOUND_SESSION_ID}"}}\n'
+        f'{{"type":"result","{SESSION_ID_JSON_KEY}":"{_BOUND_SESSION_ID}",'
+        f'"result":"ok"}}\n'
+    )
+    assert runner.extract_session_id_from_stdout(ndjson_stream) == _BOUND_SESSION_ID
+    assert runner.extract_session_id_from_stdout("not json at all") is None
+    assert runner.extract_session_id_from_stdout("") is None
+
+
+def test_ordered_account_mode_tries_primary_launcher_first(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    config_file = _write_chain_config(
+        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
+    )
+    usage_reporter = _usage_reporter_from_remaining(
+        {
+            _PRIMARY_LAUNCHER: _LOW_WEEKLY_REMAINING_PERCENT,
+            _SECONDARY_LAUNCHER: _HIGH_WEEKLY_REMAINING_PERCENT,
+        }
+    )
+    recorder = _install(
+        monkeypatch,
+        config_file,
+        {
+            _PRIMARY_LAUNCHER: _completed(
+                _PRIMARY_LAUNCHER, 0, stdout=_JSON_BIND_STDOUT_WITH_SESSION
+            ),
+            _SECONDARY_LAUNCHER: _completed(
+                _SECONDARY_LAUNCHER, 0, stdout="should-not-run"
+            ),
+        },
+        weekly_usage_reporter=usage_reporter,
+    )
+    chain_result = runner.run_claude(
+        _PROMPT_ARGUMENTS,
+        timeout_seconds=5,
+        routing_mode=ROUTING_MODE_ORDERED_ACCOUNT,
+    )
+    assert chain_result.served_command == _PRIMARY_LAUNCHER
+    assert chain_result.terminal_status == TERMINAL_STATUS_SERVED
+    assert recorder.invocations[0][0] == _PRIMARY_LAUNCHER
+    assert usage_reporter.call_count["count"] == 0
+    assert [each_attempt.command for each_attempt in chain_result.attempts] == [
+        _PRIMARY_LAUNCHER
+    ]
+
+
+def test_ordered_account_mode_usage_limit_falls_over_to_secondary(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    config_file = _write_chain_config(
+        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
+    )
+    _install(
+        monkeypatch,
+        config_file,
+        {
+            _PRIMARY_LAUNCHER: _completed(
+                _PRIMARY_LAUNCHER, 1, stderr=_A_SIGNATURE
+            ),
+            _SECONDARY_LAUNCHER: _completed(
+                _SECONDARY_LAUNCHER, 0, stdout=_JSON_BIND_STDOUT_WITH_SESSION
+            ),
+        },
+    )
+    chain_result = runner.run_claude(
+        _PROMPT_ARGUMENTS,
+        timeout_seconds=5,
+        routing_mode=ROUTING_MODE_ORDERED_ACCOUNT,
+    )
+    assert chain_result.served_command == _SECONDARY_LAUNCHER
+    assert chain_result.returncode == 0
+    assert chain_result.terminal_status == TERMINAL_STATUS_SERVED
+    assert [each_attempt.command for each_attempt in chain_result.attempts] == [
+        _PRIMARY_LAUNCHER,
+        _SECONDARY_LAUNCHER,
+    ]
+    assert chain_result.attempts[0].status == ATTEMPT_STATUS_USAGE_LIMITED
+    assert chain_result.attempts[1].status == ATTEMPT_STATUS_SERVED
+
+
+def test_ordered_account_mode_authentication_error_is_advisor_blocked(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    config_file = _write_chain_config(
+        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
+    )
+    recorder = _install(
+        monkeypatch,
+        config_file,
+        {
+            _PRIMARY_LAUNCHER: _completed(
+                _PRIMARY_LAUNCHER, 1, stderr=_AUTHENTICATION_ERROR_STDERR
+            ),
+            _SECONDARY_LAUNCHER: _completed(
+                _SECONDARY_LAUNCHER, 0, stdout="should-not-run"
+            ),
+        },
+    )
+    chain_result = runner.run_claude(
+        _PROMPT_ARGUMENTS,
+        timeout_seconds=5,
+        routing_mode=ROUTING_MODE_ORDERED_ACCOUNT,
+    )
+    assert chain_result.terminal_status == TERMINAL_STATUS_ADVISOR_BLOCKED
+    assert chain_result.served_command is None
+    assert chain_result.returncode == 1
+    assert _AUTHENTICATION_ERROR_STDERR in chain_result.stderr
+    assert len(recorder.invocations) == 1
+    assert chain_result.attempts[0].status == ATTEMPT_STATUS_NONZERO_EXIT
+
+
+def test_ordered_account_mode_timeout_is_advisor_blocked(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    config_file = _write_chain_config(
+        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
+    )
+    recorder = _install(
+        monkeypatch,
+        config_file,
+        {
+            _PRIMARY_LAUNCHER: subprocess.TimeoutExpired(
+                cmd=[_PRIMARY_LAUNCHER], timeout=5
+            ),
+            _SECONDARY_LAUNCHER: _completed(_SECONDARY_LAUNCHER, 0),
+        },
+    )
+    chain_result = runner.run_claude(
+        _PROMPT_ARGUMENTS,
+        timeout_seconds=5,
+        routing_mode=ROUTING_MODE_ORDERED_ACCOUNT,
+    )
+    assert chain_result.terminal_status == TERMINAL_STATUS_ADVISOR_BLOCKED
+    assert chain_result.served_command is None
+    assert chain_result.returncode == NO_COMPLETED_PROCESS_RETURN_CODE
+    assert len(recorder.invocations) == 1
+    assert chain_result.attempts[0].status == ATTEMPT_STATUS_TIMEOUT
+
+
+def test_ordered_account_mode_generic_process_error_is_advisor_blocked(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    config_file = _write_chain_config(
+        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
+    )
+    recorder = _install(
+        monkeypatch,
+        config_file,
+        {
+            _PRIMARY_LAUNCHER: _completed(
+                _PRIMARY_LAUNCHER, 2, stderr=_GENERIC_PROCESS_ERROR_STDERR
+            ),
+            _SECONDARY_LAUNCHER: _completed(
+                _SECONDARY_LAUNCHER, 0, stdout="should-not-run"
+            ),
+        },
+    )
+    chain_result = runner.run_claude(
+        _PROMPT_ARGUMENTS,
+        timeout_seconds=5,
+        routing_mode=ROUTING_MODE_ORDERED_ACCOUNT,
+    )
+    assert chain_result.terminal_status == TERMINAL_STATUS_ADVISOR_BLOCKED
+    assert chain_result.served_command is None
+    assert chain_result.returncode == 2
+    assert len(recorder.invocations) == 1
+    assert chain_result.attempts[0].status == ATTEMPT_STATUS_NONZERO_EXIT
+
+
+def test_ordered_account_mode_configuration_error_does_not_fall_over(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    missing_config = tmp_path / CONFIG_FILENAME
+    monkeypatch.setattr(runner, "chain_config_path", lambda: missing_config)
+    _install_tty_stdin(monkeypatch)
+    exit_code = runner.main(
+        [
+            CLI_ROUTING_MODE_FLAG,
+            ROUTING_MODE_ORDERED_ACCOUNT,
+            CLI_ARGUMENTS_SEPARATOR,
+            "-p",
+            "hi",
+        ]
+    )
+    captured = capsys.readouterr()
+    assert exit_code == CHAIN_CONFIG_ERROR_EXIT_CODE
+    assert EXAMPLE_CONFIG_FILENAME in captured.err
+
+
+def test_ordered_account_mode_preserves_session_id_on_success(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    config_file = _write_chain_config(
+        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
+    )
+    _install(
+        monkeypatch,
+        config_file,
+        {
+            _PRIMARY_LAUNCHER: _completed(
+                _PRIMARY_LAUNCHER, 0, stdout=_JSON_BIND_STDOUT_WITH_SESSION
+            ),
+            _SECONDARY_LAUNCHER: _completed(_SECONDARY_LAUNCHER, 0),
+        },
+    )
+    chain_result = runner.run_claude(
+        _PROMPT_ARGUMENTS,
+        timeout_seconds=5,
+        routing_mode=ROUTING_MODE_ORDERED_ACCOUNT,
+    )
+    assert chain_result.terminal_status == TERMINAL_STATUS_SERVED
+    assert chain_result.session_id == _BOUND_SESSION_ID
+    assert chain_result.served_command == _PRIMARY_LAUNCHER
+
+
+def test_default_routing_mode_remains_usage_ranked(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    config_file = _write_chain_config(
+        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
+    )
+    usage_reporter = _usage_reporter_from_remaining(
+        {
+            _PRIMARY_LAUNCHER: _LOW_WEEKLY_REMAINING_PERCENT,
+            _SECONDARY_LAUNCHER: _HIGH_WEEKLY_REMAINING_PERCENT,
+        }
+    )
+    recorder = _install(
+        monkeypatch,
+        config_file,
+        {
+            _PRIMARY_LAUNCHER: _completed(
+                _PRIMARY_LAUNCHER, 0, stdout="from-primary"
+            ),
+            _SECONDARY_LAUNCHER: _completed(
+                _SECONDARY_LAUNCHER, 0, stdout="from-secondary"
+            ),
+        },
+        weekly_usage_reporter=usage_reporter,
+    )
+    chain_result = runner.run_claude(_PROMPT_ARGUMENTS, timeout_seconds=5)
+    assert chain_result.served_command == _SECONDARY_LAUNCHER
+    assert chain_result.terminal_status == TERMINAL_STATUS_SERVED
+    assert recorder.invocations[0][0] == _SECONDARY_LAUNCHER
+    assert usage_reporter.call_count["count"] == 1
+
+
+def test_cli_ordered_account_routing_mode_flag(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    config_file = _write_chain_config(
+        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
+    )
+    usage_reporter = _usage_reporter_from_remaining(
+        {
+            _PRIMARY_LAUNCHER: _LOW_WEEKLY_REMAINING_PERCENT,
+            _SECONDARY_LAUNCHER: _HIGH_WEEKLY_REMAINING_PERCENT,
+        }
+    )
+    recorder = _install(
+        monkeypatch,
+        config_file,
+        {
+            _PRIMARY_LAUNCHER: _completed(
+                _PRIMARY_LAUNCHER, 0, stdout=_JSON_BIND_STDOUT_WITH_SESSION
+            ),
+            _SECONDARY_LAUNCHER: _completed(
+                _SECONDARY_LAUNCHER, 0, stdout="should-not-run"
+            ),
+        },
+        weekly_usage_reporter=usage_reporter,
+    )
+    exit_code = runner.main(
+        [
+            CLI_ROUTING_MODE_FLAG,
+            ROUTING_MODE_ORDERED_ACCOUNT,
+            CLI_ARGUMENTS_SEPARATOR,
+            "-p",
+            "hi",
+        ]
+    )
+    assert exit_code == 0
+    assert recorder.invocations[0][0] == _PRIMARY_LAUNCHER
+    assert usage_reporter.call_count["count"] == 0
+
+
+def test_cli_ordered_account_advisor_blocked_exit_code(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    config_file = _write_chain_config(
+        tmp_path, [_entry(_PRIMARY_LAUNCHER), _entry(_SECONDARY_LAUNCHER)]
+    )
+    _install(
+        monkeypatch,
+        config_file,
+        {
+            _PRIMARY_LAUNCHER: _completed(
+                _PRIMARY_LAUNCHER, 2, stderr=_GENERIC_PROCESS_ERROR_STDERR
+            ),
+            _SECONDARY_LAUNCHER: _completed(_SECONDARY_LAUNCHER, 0),
+        },
+    )
+    exit_code = runner.main(
+        [
+            CLI_ROUTING_MODE_FLAG,
+            ROUTING_MODE_ORDERED_ACCOUNT,
+            CLI_ARGUMENTS_SEPARATOR,
+            "-p",
+            "hi",
+        ]
+    )
+    assert exit_code == CHAIN_ADVISOR_BLOCKED_EXIT_CODE
+
+

package/scripts/test_grok_headless_runner.py

@@ -7,7 +7,6 @@ include the signature substrings the constants module lists.
 
 from __future__ import annotations
 
-import os
 import subprocess
 import sys
 import time
@@ -20,6 +19,7 @@ if str(_SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(_SCRIPTS_DIR))
 
 import grok_headless_runner as runner  # noqa: E402
+import process_tree_kill  # noqa: E402
 from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
     AGENT_FLAG,
     ALWAYS_APPROVE_FLAG,
@@ -46,16 +46,10 @@ from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
     OUTPUT_FORMAT_FLAG,
     OUTPUT_FORMAT_JSON,
     PROCESS_TREE_KILL_ATTEMPT_LIMIT,
-    PROCESS_TREE_KILL_TIMEOUT_SECONDS,
     PROMPT_FILE_FLAG,
     TIMEOUT_RETURN_CODE,
     UTF8_DECODE_ERRORS,
     UTF8_ENCODING,
-    WINDOWS_OS_NAME,
-    WINDOWS_TASKKILL_COMMAND,
-    WINDOWS_TASKKILL_FORCE_FLAG,
-    WINDOWS_TASKKILL_PID_FLAG,
-    WINDOWS_TASKKILL_TREE_FLAG,
 )
 
 FIXTURE_GROK_BINARY_VERSION = "0.2.99 (b1b49ccb71) [stable]"
@@ -297,7 +291,9 @@ def _run_once(
     recorder = _PopenRecorder([fake_process])
     monkeypatch.setattr(runner, "runner_popen", recorder)
     if should_install_tree_kill_recorder:
-        monkeypatch.setattr(runner, "runner_subprocess_run", _TreeKillRecorder())
+        monkeypatch.setattr(
+            process_tree_kill, "process_tree_subprocess_run", _TreeKillRecorder()
+        )
     outcome = runner.run_headless_worker(
         prompt_file=prompt_file,
         working_directory=working_directory,
@@ -407,7 +403,7 @@ def test_timeout_kills_process(monkeypatch: pytest.MonkeyPatch, tmp_path: Path)
     assert recorder.all_keyword_arguments[0].get("encoding") == UTF8_ENCODING
     assert recorder.all_keyword_arguments[0].get("errors") == UTF8_DECODE_ERRORS
     assert recorder.all_keyword_arguments[0].get("start_new_session") is (
-        os.name != WINDOWS_OS_NAME
+        process_tree_kill.should_start_new_session()
     )
 
 
@@ -825,59 +821,16 @@ def test_turn_capped_worker_cancels_and_uncapped_worker_completes(
     assert MAX_TURNS_FLAG not in launcher.all_invocations[1]
 
 
-def test_windows_timeout_kill_issues_the_taskkill_tree_argv(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    tree_kill_recorder = _TreeKillRecorder()
-    monkeypatch.setattr(runner, "runner_subprocess_run", tree_kill_recorder)
-
-    runner._kill_windows_process_tree(FAKE_PROCESS_IDENTIFIER)
-
-    assert tree_kill_recorder.all_invocations == [
-        [
-            WINDOWS_TASKKILL_COMMAND,
-            WINDOWS_TASKKILL_TREE_FLAG,
-            WINDOWS_TASKKILL_FORCE_FLAG,
-            WINDOWS_TASKKILL_PID_FLAG,
-            str(FAKE_PROCESS_IDENTIFIER),
-        ]
-    ]
-    assert (
-        tree_kill_recorder.all_keyword_arguments[0].get("timeout")
-        == PROCESS_TREE_KILL_TIMEOUT_SECONDS
-    )
-
-
-@pytest.mark.parametrize(
-    "raised_error",
-    [
-        subprocess.TimeoutExpired(
-            cmd=[WINDOWS_TASKKILL_COMMAND], timeout=PROCESS_TREE_KILL_TIMEOUT_SECONDS
-        ),
-        OSError("taskkill is not on PATH"),
-    ],
-    ids=["taskkill_times_out", "taskkill_cannot_launch"],
-)
-def test_windows_tree_kill_absorbs_a_failing_taskkill(
-    monkeypatch: pytest.MonkeyPatch, raised_error: Exception
-) -> None:
-    """A taskkill that never completes leaves the caller free to fall back."""
-
-    def raise_on_tree_kill(
-        invocation: list[str], **keyword_arguments: object
-    ) -> subprocess.CompletedProcess[str]:
-        del invocation, keyword_arguments
-        raise raised_error
-
-    monkeypatch.setattr(runner, "runner_subprocess_run", raise_on_tree_kill)
-
-    runner._kill_windows_process_tree(FAKE_PROCESS_IDENTIFIER)
-
-
 def test_tree_kill_falls_back_to_direct_kill_when_taskkill_fails(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
-    """A failed tree kill still ends the direct child, so no caller waits on it."""
+    """A failed tree kill still ends the direct child, so no caller waits on it.
+
+    The platform is pinned to Windows so the taskkill seam is the branch under
+    test on every host. Left unpinned on POSIX, the kill would reach the
+    process group of the fake process id, which names an unrelated process.
+    """
+    monkeypatch.setattr(process_tree_kill.sys, "platform", "win32")
 
     def raise_on_tree_kill(
         invocation: list[str], **keyword_arguments: object
@@ -888,7 +841,9 @@ def test_tree_kill_falls_back_to_direct_kill_when_taskkill_fails(
     fake_process = _FakeProcess(
         returncode=0, stderr="still running", should_timeout=True
     )
-    monkeypatch.setattr(runner, "runner_subprocess_run", raise_on_tree_kill)
+    monkeypatch.setattr(
+        process_tree_kill, "process_tree_subprocess_run", raise_on_tree_kill
+    )
     outcome, _, _, _, _ = _run_once(
         monkeypatch,
         tmp_path,
@@ -1090,7 +1045,7 @@ def _launch_kill_resistant_tree(
     """Wire a real parent-and-grandchild launch whose kills are dropped."""
     all_launched_processes: list[_KillResistantProcess] = []
     tree_kill_recorder = _TreeKillAttemptRecorder(
-        runner._kill_process_tree_by_identifier,
+        process_tree_kill.kill_process_tree_by_identifier,
         should_drop_every_attempt=should_drop_every_kill,
     )
 
@@ -1116,7 +1071,7 @@ def _launch_kill_resistant_tree(
 
     monkeypatch.setattr(runner, "runner_popen", _spawn_kill_resistant_tree)
     monkeypatch.setattr(
-        runner, "_kill_process_tree_by_identifier", tree_kill_recorder
+        process_tree_kill, "kill_process_tree_by_identifier", tree_kill_recorder
     )
     monkeypatch.setattr(
         runner, "KILL_GRACE_TIMEOUT_SECONDS", SHORT_KILL_GRACE_SECONDS
@@ -1182,7 +1137,7 @@ def test_worker_surviving_both_kill_attempts_is_reported_kill_failed(
     run_state_directory.mkdir()
     heartbeat_path = tmp_path / "grandchild-heartbeat.txt"
     heartbeat_path.write_text("", encoding=UTF8_ENCODING)
-    real_tree_kill = runner._kill_process_tree_by_identifier
+    real_tree_kill = process_tree_kill.kill_process_tree_by_identifier
     tree_kill_recorder, all_launched_processes = _launch_kill_resistant_tree(
         monkeypatch, heartbeat_path, should_drop_every_kill=True
     )