claude-dev-env 2.7.0 → 2.7.1

package/scripts/test_resolve_worker_spawn.py

@@ -35,17 +35,20 @@ from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
     CLI_TIMEOUT_FLAG,
     CLASSIFICATION_AUTH_FAILURE,
     CLASSIFICATION_OK,
+    CLASSIFICATION_TIMEOUT,
     CLASSIFICATION_USAGE_LIMIT,
     CWD_FLAG,
     DEFAULT_ROLE,
-    DEFAULT_SPAWN_MAX_TURNS,
     DEFAULT_WORKER_TIMEOUT_SECONDS,
+    MAXIMUM_WORKER_TIMEOUT_SECONDS,
+    MIN_WORKER_TIMEOUT_SECONDS,
     OUTPUT_FORMAT_FLAG,
     OUTPUT_FORMAT_JSON,
     PROMPT_FILE_FLAG,
     REASON_CLAUDE_AGENT_REQUIRED,
     REASON_GROK_AUTH_FAILED,
     REASON_PROMPT_FILE_MISSING,
+    REASON_TIMEOUT_OUT_OF_BOUNDS,
     RESULT_KEY_ATTEMPTS,
     RESULT_KEY_OK,
     RESULT_KEY_OUTPUT,
@@ -59,11 +62,16 @@ from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
     TIER_CLAUDE_HEADLESS,
     TIER_GROK,
 )
-from grok_headless_runner import GrokRunnerOutcome  # noqa: E402
+import grok_headless_runner  # noqa: E402
+from grok_headless_runner import (  # noqa: E402
+    GrokRunnerOutcome,
+    run_headless_worker,
+)
 from grok_worker_preflight import PreflightOutcome  # noqa: E402
 
 HOST_PROFILE_CLAUDE = "Claude"
 HOST_PROFILE_THIRD_PARTY = "ThirdParty"
+NON_POSITIVE_TIMEOUT_SECONDS = 0
 
 FIXTURE_GROK_STDOUT = '{"tier":"grok","status":"done"}'
 FIXTURE_CLAUDE_STDOUT = '{"tier":"claude","status":"done"}'
@@ -72,6 +80,7 @@ FIXTURE_GROK_RETURNCODE = 0
 FIXTURE_CLAUDE_RETURNCODE = 0
 FIXTURE_FAILED_RETURNCODE = 1
 FIXTURE_ROLE = "code-quality-agent"
+MIN_WORKER_TIMEOUT_SECONDS_CONSTANT_NAME = "MIN_WORKER_TIMEOUT_SECONDS"
 LARGE_PROMPT_CHARACTER_COUNT = 40000
 WINDOWS_SAFE_ARGV_ELEMENT_CEILING = 8192
 EXPECTED_PRIMARY_AGENT_FOR_DEFAULT_ROLE = Path(
@@ -261,7 +270,6 @@ def test_grok_ok_serves_tier_one(
         timeout_seconds=DEFAULT_WORKER_TIMEOUT_SECONDS,
         is_claude_tier_enabled=False,
         run_state_directory=run_state_directory,
-        max_turns=DEFAULT_SPAWN_MAX_TURNS,
     )
 
     assert spawn_outcome.is_ok is True
@@ -297,7 +305,6 @@ def test_grok_usage_limited_on_claude_host_requires_agent(
         timeout_seconds=DEFAULT_WORKER_TIMEOUT_SECONDS,
         is_claude_tier_enabled=False,
         run_state_directory=run_state_directory,
-        max_turns=DEFAULT_SPAWN_MAX_TURNS,
     )
 
     assert spawn_outcome.is_ok is False
@@ -313,6 +320,128 @@ def test_grok_usage_limited_on_claude_host_requires_agent(
     assert spawn_outcome.all_attempts[1].reason == REASON_CLAUDE_AGENT_REQUIRED
 
 
+def test_out_of_bounds_timeout_is_reported_as_config_not_worker_failure(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A refused timeout prints a structured outcome and exits 3, never a traceback.
+
+    ::
+
+        --timeout-seconds 0     ok: reason timeout_out_of_bounds, exit 3
+        --timeout-seconds 5401  ok: reason timeout_out_of_bounds, exit 3
+    """
+    prompt_file, working_directory, run_state_directory = _paths(tmp_path)
+    _install_seams(monkeypatch, grok_outcome=_grok_ok())
+    monkeypatch.setattr(
+        dispatcher, "spawn_grok_runner", grok_headless_runner.run_headless_worker
+    )
+
+    for each_refused_timeout in (
+        NON_POSITIVE_TIMEOUT_SECONDS,
+        MAXIMUM_WORKER_TIMEOUT_SECONDS + 1,
+    ):
+        exit_code = dispatcher.main(
+            [
+                CLI_ROLE_FLAG,
+                FIXTURE_ROLE,
+                PROMPT_FILE_FLAG,
+                str(prompt_file),
+                CWD_FLAG,
+                str(working_directory),
+                CLI_TIMEOUT_FLAG,
+                str(each_refused_timeout),
+                CLI_RUN_STATE_DIR_FLAG,
+                str(run_state_directory),
+            ]
+        )
+        parsed_payload = json.loads(capsys.readouterr().out)
+        all_attempt_reasons = [
+            each_attempt[ATTEMPT_KEY_REASON]
+            for each_attempt in parsed_payload[RESULT_KEY_ATTEMPTS]
+        ]
+
+        assert exit_code == SPAWN_CONFIG_ERROR_EXIT_CODE, each_refused_timeout
+        assert parsed_payload[RESULT_KEY_OK] is False, each_refused_timeout
+        assert parsed_payload[RESULT_KEY_TIER_USED] is None, each_refused_timeout
+        assert REASON_TIMEOUT_OUT_OF_BOUNDS in all_attempt_reasons, each_refused_timeout
+
+
+def test_out_of_bounds_timeout_is_refused_when_the_grok_tier_is_unreachable(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """The bounds hold on a host whose preflight never reaches the grok runner.
+
+    ::
+
+        preflight unusable, --timeout-seconds 5401
+            ok: reason timeout_out_of_bounds, exit 3, no tier invoked
+    """
+    prompt_file, working_directory, run_state_directory = _paths(tmp_path)
+    call_log = _install_seams(
+        monkeypatch,
+        preflight_outcome=_fallthrough_preflight(REASON_GROK_AUTH_FAILED),
+        claude_outcome=_claude_served(),
+    )
+
+    exit_code = dispatcher.main(
+        [
+            CLI_ROLE_FLAG,
+            FIXTURE_ROLE,
+            PROMPT_FILE_FLAG,
+            str(prompt_file),
+            CWD_FLAG,
+            str(working_directory),
+            CLI_TIMEOUT_FLAG,
+            str(MAXIMUM_WORKER_TIMEOUT_SECONDS + 1),
+            CLI_RUN_STATE_DIR_FLAG,
+            str(run_state_directory),
+        ]
+    )
+    parsed_payload = json.loads(capsys.readouterr().out)
+    all_attempt_reasons = [
+        each_attempt[ATTEMPT_KEY_REASON]
+        for each_attempt in parsed_payload[RESULT_KEY_ATTEMPTS]
+    ]
+
+    assert exit_code == SPAWN_CONFIG_ERROR_EXIT_CODE
+    assert REASON_TIMEOUT_OUT_OF_BOUNDS in all_attempt_reasons
+    assert call_log.preflight_calls == 0
+    assert call_log.claude_calls == 0
+
+
+def test_timed_out_grok_worker_is_recorded_as_timeout_not_served(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    """A killed worker reaches the dispatcher's trail as timeout, never as served.
+
+    ::
+
+        grok tier times out  ok: attempt reason timeout, tier_used moves on
+    """
+    prompt_file, working_directory, run_state_directory = _paths(tmp_path)
+    call_log = _install_seams(
+        monkeypatch,
+        grok_outcome=_grok_failure(CLASSIFICATION_TIMEOUT),
+        claude_outcome=_claude_served(),
+        host_profile=HOST_PROFILE_THIRD_PARTY,
+    )
+
+    spawn_outcome = dispatcher.resolve_worker_spawn(
+        role=FIXTURE_ROLE,
+        prompt_file=prompt_file,
+        working_directory=working_directory,
+        timeout_seconds=DEFAULT_WORKER_TIMEOUT_SECONDS,
+        is_claude_tier_enabled=False,
+        run_state_directory=run_state_directory,
+    )
+
+    assert call_log.grok_calls == 1
+    assert spawn_outcome.all_attempts[0].tier == TIER_GROK
+    assert spawn_outcome.all_attempts[0].is_ok is False
+    assert spawn_outcome.all_attempts[0].reason == CLASSIFICATION_TIMEOUT
+    assert spawn_outcome.tier_used != TIER_GROK
+
+
 def test_grok_auth_failed_on_third_party_runs_tier_three(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
@@ -331,7 +460,6 @@ def test_grok_auth_failed_on_third_party_runs_tier_three(
         timeout_seconds=DEFAULT_WORKER_TIMEOUT_SECONDS,
         is_claude_tier_enabled=False,
         run_state_directory=run_state_directory,
-        max_turns=DEFAULT_SPAWN_MAX_TURNS,
     )
 
     assert spawn_outcome.is_ok is True
@@ -423,6 +551,40 @@ def test_config_error_returns_exit_three(
     assert parsed_payload[RESULT_KEY_RETURNCODE] == SPAWN_CONFIG_ERROR_EXIT_CODE
 
 
+def test_below_floor_timeout_returns_json_config_exit(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    """A below-floor timeout reads as a config error, not an escaping traceback."""
+    prompt_file, working_directory, run_state_directory = _paths(tmp_path)
+    _install_seams(monkeypatch, grok_outcome=_grok_ok())
+    monkeypatch.setattr(dispatcher, "spawn_grok_runner", run_headless_worker)
+    below_floor_timeout_seconds = MIN_WORKER_TIMEOUT_SECONDS - 1
+
+    exit_code = dispatcher.main(
+        [
+            CLI_ROLE_FLAG,
+            FIXTURE_ROLE,
+            PROMPT_FILE_FLAG,
+            str(prompt_file),
+            CWD_FLAG,
+            str(working_directory),
+            CLI_TIMEOUT_FLAG,
+            str(below_floor_timeout_seconds),
+            CLI_RUN_STATE_DIR_FLAG,
+            str(run_state_directory),
+        ]
+    )
+
+    assert exit_code == SPAWN_CONFIG_ERROR_EXIT_CODE
+    captured = capsys.readouterr()
+    assert captured.err == ""
+    parsed_payload = json.loads(captured.out)
+    assert parsed_payload[RESULT_KEY_OK] is False
+    assert parsed_payload[RESULT_KEY_TIER_USED] is None
+    assert parsed_payload[RESULT_KEY_RETURNCODE] == SPAWN_CONFIG_ERROR_EXIT_CODE
+    assert MIN_WORKER_TIMEOUT_SECONDS_CONSTANT_NAME in parsed_payload[RESULT_KEY_OUTPUT]
+
+
 def test_attempts_array_ordering_across_tiers(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:
@@ -441,7 +603,6 @@ def test_attempts_array_ordering_across_tiers(
         timeout_seconds=DEFAULT_WORKER_TIMEOUT_SECONDS,
         is_claude_tier_enabled=True,
         run_state_directory=run_state_directory,
-        max_turns=DEFAULT_SPAWN_MAX_TURNS,
     )
 
     all_tiers = [each_attempt.tier for each_attempt in spawn_outcome.all_attempts]
@@ -515,7 +676,6 @@ def test_preflight_fallthrough_skips_grok_runner(
         timeout_seconds=DEFAULT_WORKER_TIMEOUT_SECONDS,
         is_claude_tier_enabled=False,
         run_state_directory=run_state_directory,
-        max_turns=DEFAULT_SPAWN_MAX_TURNS,
     )
 
     assert call_log.grok_calls == 0
@@ -533,9 +693,15 @@ def test_detect_host_profile_is_consumed_not_reimplemented() -> None:
     assert "THIRD_PARTY" not in source_text
 
 
-def test_default_max_turns_reaches_grok_kwargs(
+def test_dispatcher_grok_invocation_carries_no_turn_cap(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path, capsys: pytest.CaptureFixture[str]
 ) -> None:
+    """The dispatcher hands the runner no turn cap; the timeout is the only bound.
+
+    ::
+
+        grok tier kwargs  ok: timeout_seconds present, max_turns absent
+    """
     prompt_file, working_directory, run_state_directory = _paths(tmp_path)
     call_log = _install_seams(
         monkeypatch,
@@ -559,7 +725,10 @@ def test_default_max_turns_reaches_grok_kwargs(
 
     assert exit_code == SPAWN_SERVED_EXIT_CODE
     assert call_log.grok_keyword_arguments is not None
-    assert call_log.grok_keyword_arguments["max_turns"] == DEFAULT_SPAWN_MAX_TURNS
+    assert "max_turns" not in call_log.grok_keyword_arguments
+    assert call_log.grok_keyword_arguments["timeout_seconds"] == (
+        DEFAULT_WORKER_TIMEOUT_SECONDS
+    )
     parsed_payload = json.loads(capsys.readouterr().out)
     assert parsed_payload[RESULT_KEY_OK] is True
 
@@ -645,7 +814,6 @@ def test_default_role_maps_to_primary_agent_stem(
         timeout_seconds=DEFAULT_WORKER_TIMEOUT_SECONDS,
         is_claude_tier_enabled=False,
         run_state_directory=run_state_directory,
-        max_turns=DEFAULT_SPAWN_MAX_TURNS,
     )
 
     assert spawn_outcome.is_ok is True
@@ -674,7 +842,6 @@ def test_tier_three_argv_includes_agent_for_default_role(
         timeout_seconds=DEFAULT_WORKER_TIMEOUT_SECONDS,
         is_claude_tier_enabled=False,
         run_state_directory=run_state_directory,
-        max_turns=DEFAULT_SPAWN_MAX_TURNS,
     )
 
     assert spawn_outcome.tier_used == TIER_CLAUDE_HEADLESS
@@ -708,7 +875,6 @@ def test_large_prompt_stays_out_of_claude_argv(
         timeout_seconds=DEFAULT_WORKER_TIMEOUT_SECONDS,
         is_claude_tier_enabled=False,
         run_state_directory=run_state_directory,
-        max_turns=DEFAULT_SPAWN_MAX_TURNS,
     )
 
     assert spawn_outcome.tier_used == TIER_CLAUDE_HEADLESS
@@ -926,8 +1092,7 @@ def test_headless_chain_runner_lock_serializes_distinct_cwds(
                 timeout_seconds=DEFAULT_WORKER_TIMEOUT_SECONDS,
                 is_claude_tier_enabled=False,
                 run_state_directory=run_state_directory,
-                max_turns=DEFAULT_SPAWN_MAX_TURNS,
-            )
+                    )
         except (OSError, RuntimeError, ValueError, AssertionError) as raised_error:
             all_errors.append(raised_error)
 
@@ -1005,7 +1170,6 @@ def test_usage_limit_fallover_delivers_full_prompt_to_each_binary(
         timeout_seconds=DEFAULT_WORKER_TIMEOUT_SECONDS,
         is_claude_tier_enabled=False,
         run_state_directory=run_state_directory,
-        max_turns=DEFAULT_SPAWN_MAX_TURNS,
     )
 
     assert prompt_text_by_command["claude"] == FIXTURE_PROMPT_TEXT

package/scripts/test_spawn_grok_batch.py

@@ -22,15 +22,17 @@ from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
     BUILD_PROFILE_PROMPT_HEADER,
     CLASSIFICATION_ERROR,
     CLASSIFICATION_OK,
+    CLASSIFICATION_TIMEOUT,
     CLASSIFICATION_USAGE_LIMIT,
     DEBUG_FILE_FLAG,
     DEFAULT_ROLE,
-    DEFAULT_WORKER_MAX_TURNS,
     DEFAULT_WORKER_TIMEOUT_SECONDS,
     DISABLE_WEB_SEARCH_FLAG,
     DISALLOWED_TOOLS_FLAG,
     LEADER_SOCKET_FILENAME_PREFIX,
     LEADER_SOCKET_FILENAME_SUFFIX,
+    MAX_TURNS_FLAG,
+    MAXIMUM_WORKER_TIMEOUT_SECONDS,
     OUTPUT_FILENAME_PREFIX,
     PROMPT_FILENAME_PREFIX,
     READONLY_DISALLOWED_TOOLS_VALUE,
@@ -53,7 +55,6 @@ from dev_env_scripts_constants.grok_worker_constants import (  # noqa: E402
     TOOL_PROFILE_READONLY,
     UTF8_ENCODING,
     WORKER_SPEC_AGENT_NAME_KEY,
-    WORKER_SPEC_MAX_TURNS_KEY,
     WORKER_SPEC_PROMPT_PARTS_KEY,
     WORKER_SPEC_TIMEOUT_KEY,
 )
@@ -61,8 +62,10 @@ from dev_env_scripts_constants.timing import WORKER_STAGGER_SECONDS  # noqa: E40
 from grok_headless_runner import GrokRunnerOutcome  # noqa: E402
 from grok_worker_preflight import PreflightOutcome  # noqa: E402
 
+RETIRED_MAX_TURNS_KEYWORD = "max_turns"
 FIXTURE_REPORT_TEXT = '{"status":"done","role":"investigator"}'
 FIXTURE_USAGE_LIMIT_TEXT = "rate limit exceeded (HTTP 429): quota exceeded"
+FIXTURE_TIMEOUT_KILL_TEXT = "worker exceeded its timeout and was killed"
 
 
 def _write_prompt_parts(
@@ -871,7 +874,7 @@ def test_load_batch_spec_missing_worker_keys_raise_value_error(
     ).lower() or "must be" in str(raised_error.value).lower()
 
 
-def test_load_batch_spec_rejects_non_positive_timeout_and_max_turns(
+def test_load_batch_spec_rejects_non_positive_timeout(
     tmp_path: Path,
 ) -> None:
     header_part, body_part = _write_prompt_parts(tmp_path)
@@ -891,27 +894,11 @@ def test_load_batch_spec_rejects_non_positive_timeout_and_max_turns(
         zero_timeout_dir,
         all_worker_payloads=[zero_timeout_payload],
     )
-    with pytest.raises(ValueError, match=WORKER_SPEC_TIMEOUT_KEY):
+    with pytest.raises(ValueError, match="MIN_WORKER_TIMEOUT_SECONDS"):
         batch.load_batch_spec(zero_timeout_path)
 
-    negative_turns_dir = tmp_path / "negative-turns"
-    negative_turns_dir.mkdir()
-    negative_turns_payload = _worker_payload(
-        role_name="negative-turns",
-        all_prompt_parts=[str(header_part), str(body_part)],
-        working_directory=working_directory,
-        tool_profile=TOOL_PROFILE_BUILD,
-    )
-    negative_turns_payload[WORKER_SPEC_MAX_TURNS_KEY] = -1
-    negative_turns_path = _write_batch_spec(
-        negative_turns_dir,
-        all_worker_payloads=[negative_turns_payload],
-    )
-    with pytest.raises(ValueError, match=WORKER_SPEC_MAX_TURNS_KEY):
-        batch.load_batch_spec(negative_turns_path)
-
 
-def test_load_batch_spec_accepts_default_timeout_and_max_turns(
+def test_load_batch_spec_accepts_the_default_timeout(
     tmp_path: Path,
 ) -> None:
     header_part, body_part = _write_prompt_parts(tmp_path)
@@ -931,7 +918,223 @@ def test_load_batch_spec_accepts_default_timeout_and_max_turns(
 
     assert len(batch_spec.all_workers) == 1
     assert batch_spec.all_workers[0].timeout_seconds == DEFAULT_WORKER_TIMEOUT_SECONDS
-    assert batch_spec.all_workers[0].max_turns == DEFAULT_WORKER_MAX_TURNS
+
+
+def test_timeout_over_the_ceiling_is_refused_and_at_the_ceiling_passes(
+    tmp_path: Path,
+) -> None:
+    """The launcher refuses a spec past the 90-minute ceiling; it never clamps.
+
+    ::
+
+        timeout_seconds 5401  flag: ValueError naming MAXIMUM_WORKER_TIMEOUT_SECONDS
+        timeout_seconds 5400  ok:   loads, value untouched
+        timeout_seconds 30    ok:   loads, value untouched
+    """
+    header_part, body_part = _write_prompt_parts(tmp_path)
+    working_directory = tmp_path / "project"
+    working_directory.mkdir()
+
+    over_ceiling_directory = tmp_path / "over-ceiling"
+    over_ceiling_directory.mkdir()
+    over_ceiling_path = _write_batch_spec(
+        over_ceiling_directory,
+        all_worker_payloads=[
+            _worker_payload(
+                role_name="over-ceiling",
+                all_prompt_parts=[str(header_part), str(body_part)],
+                working_directory=working_directory,
+                tool_profile=TOOL_PROFILE_BUILD,
+                timeout_seconds=MAXIMUM_WORKER_TIMEOUT_SECONDS + 1,
+            )
+        ],
+    )
+    with pytest.raises(ValueError, match="MAXIMUM_WORKER_TIMEOUT_SECONDS"):
+        batch.load_batch_spec(over_ceiling_path)
+
+    at_ceiling_directory = tmp_path / "at-ceiling"
+    at_ceiling_directory.mkdir()
+    at_ceiling_path = _write_batch_spec(
+        at_ceiling_directory,
+        all_worker_payloads=[
+            _worker_payload(
+                role_name="at-ceiling",
+                all_prompt_parts=[str(header_part), str(body_part)],
+                working_directory=working_directory,
+                tool_profile=TOOL_PROFILE_BUILD,
+                timeout_seconds=MAXIMUM_WORKER_TIMEOUT_SECONDS,
+            ),
+            _worker_payload(
+                role_name="well-under-ceiling",
+                all_prompt_parts=[str(header_part), str(body_part)],
+                working_directory=working_directory,
+                tool_profile=TOOL_PROFILE_BUILD,
+                timeout_seconds=30,
+            ),
+        ],
+    )
+    at_ceiling_spec = batch.load_batch_spec(at_ceiling_path)
+
+    assert at_ceiling_spec.all_workers[0].timeout_seconds == (
+        MAXIMUM_WORKER_TIMEOUT_SECONDS
+    )
+    assert at_ceiling_spec.all_workers[1].timeout_seconds == 30
+
+
+def test_ceiling_timeout_reaches_the_runner_untouched(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    header_part, body_part = _write_prompt_parts(tmp_path, role_marker="long-worker")
+    working_directory = tmp_path / "project"
+    working_directory.mkdir()
+    run_state_directory = tmp_path / "run-state"
+    batch_spec = batch.load_batch_spec(
+        _write_batch_spec(
+            tmp_path,
+            all_worker_payloads=[
+                _worker_payload(
+                    role_name="long-worker",
+                    all_prompt_parts=[str(header_part), str(body_part)],
+                    working_directory=working_directory,
+                    tool_profile=TOOL_PROFILE_READONLY,
+                    timeout_seconds=MAXIMUM_WORKER_TIMEOUT_SECONDS,
+                )
+            ],
+        )
+    )
+    recorder = _RunnerRecorder({"long-worker": _ok_outcome()})
+    monkeypatch.setattr(
+        batch, "batch_preflight", lambda **_kwargs: PreflightOutcome(True, None)
+    )
+    monkeypatch.setattr(batch, "batch_headless_runner", recorder)
+    monkeypatch.setattr(batch, "batch_sleep", lambda _seconds: None)
+
+    batch.run_grok_batch(
+        batch_spec=batch_spec,
+        run_state_directory=run_state_directory,
+    )
+
+    assert recorder.all_keyword_arguments[0]["timeout_seconds"] == (
+        MAXIMUM_WORKER_TIMEOUT_SECONDS
+    )
+
+
+def test_worker_invocations_carry_no_turn_cap(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    header_part, body_part = _write_prompt_parts(tmp_path, role_marker="uncapped")
+    working_directory = tmp_path / "project"
+    working_directory.mkdir()
+    run_state_directory = tmp_path / "run-state"
+    batch_spec = batch.load_batch_spec(
+        _write_batch_spec(
+            tmp_path,
+            all_worker_payloads=[
+                _worker_payload(
+                    role_name="uncapped",
+                    all_prompt_parts=[str(header_part), str(body_part)],
+                    working_directory=working_directory,
+                    tool_profile=TOOL_PROFILE_READONLY,
+                )
+            ],
+        )
+    )
+    recorder = _RunnerRecorder({"uncapped": _ok_outcome()})
+    monkeypatch.setattr(
+        batch, "batch_preflight", lambda **_kwargs: PreflightOutcome(True, None)
+    )
+    monkeypatch.setattr(batch, "batch_headless_runner", recorder)
+    monkeypatch.setattr(batch, "batch_sleep", lambda _seconds: None)
+
+    batch.run_grok_batch(
+        batch_spec=batch_spec,
+        run_state_directory=run_state_directory,
+    )
+
+    launched_keyword_arguments = recorder.all_keyword_arguments[0]
+    all_extra_arguments = launched_keyword_arguments["all_extra_arguments"]
+    assert RETIRED_MAX_TURNS_KEYWORD not in launched_keyword_arguments
+    assert isinstance(all_extra_arguments, tuple)
+    assert MAX_TURNS_FLAG not in all_extra_arguments
+
+
+def test_timed_out_worker_reads_as_timeout_beside_a_completed_worker(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """A killed worker stays distinguishable from a completed one in the summary.
+
+    ::
+
+        killed worker    ok: classification timeout, is_ok False, exit code 1
+        completed worker ok: classification ok, is_ok True
+    """
+    header_done, body_done = _write_prompt_parts(tmp_path, role_marker="done-worker")
+    header_killed, body_killed = _write_prompt_parts(
+        tmp_path, role_marker="killed-worker"
+    )
+    working_directory = tmp_path / "project"
+    working_directory.mkdir()
+    run_state_directory = tmp_path / "run-state"
+    specification_path = _write_batch_spec(
+        tmp_path,
+        all_worker_payloads=[
+            _worker_payload(
+                role_name="done-worker",
+                all_prompt_parts=[str(header_done), str(body_done)],
+                working_directory=working_directory,
+                tool_profile=TOOL_PROFILE_BUILD,
+            ),
+            _worker_payload(
+                role_name="killed-worker",
+                all_prompt_parts=[str(header_killed), str(body_killed)],
+                working_directory=working_directory,
+                tool_profile=TOOL_PROFILE_BUILD,
+            ),
+        ],
+    )
+    recorder = _RunnerRecorder(
+        {
+            "done-worker": _ok_outcome(),
+            "killed-worker": GrokRunnerOutcome(
+                is_ok=False,
+                returncode=-9,
+                classification=CLASSIFICATION_TIMEOUT,
+                stdout="",
+                stderr=FIXTURE_TIMEOUT_KILL_TEXT,
+            ),
+        }
+    )
+    monkeypatch.setattr(
+        batch, "batch_preflight", lambda **_kwargs: PreflightOutcome(True, None)
+    )
+    monkeypatch.setattr(batch, "batch_headless_runner", recorder)
+    monkeypatch.setattr(batch, "batch_sleep", lambda _seconds: None)
+
+    exit_code = batch.main(
+        [
+            "--spec",
+            str(specification_path),
+            "--run-temp-dir",
+            str(run_state_directory),
+        ]
+    )
+
+    summary_payload = json.loads(capsys.readouterr().out)
+    payload_by_role_name = {
+        each_payload[SUMMARY_ROLE_NAME_KEY]: each_payload
+        for each_payload in summary_payload[SUMMARY_WORKERS_KEY]
+    }
+    killed_payload = payload_by_role_name["killed-worker"]
+    done_payload = payload_by_role_name["done-worker"]
+
+    assert exit_code == 1
+    assert killed_payload[SUMMARY_CLASSIFICATION_KEY] == CLASSIFICATION_TIMEOUT
+    assert killed_payload[SUMMARY_IS_OK_KEY] is False
+    assert killed_payload[SUMMARY_CLASSIFICATION_KEY] != CLASSIFICATION_OK
+    assert done_payload[SUMMARY_CLASSIFICATION_KEY] == CLASSIFICATION_OK
+    assert done_payload[SUMMARY_IS_OK_KEY] is True
 
 
 def test_unwritable_report_file_keeps_the_worker_outcome(

package/skills/autoconverge/workflow/converge.contract.test.mjs

@@ -434,7 +434,7 @@ test('the verdict-fence binding does not self-resolve a cwd via git rev-parse fo
   );
 });
 
-test('every verify step calls buildVerdictFenceSteps, uses code-verifier, and forbids edits', () => {
+test('every verify step calls buildVerdictFenceSteps, uses code-verifier, and forbids editing the tree under verification', () => {
   for (const verifyFunctionName of ['runVerifierTask']) {
     const verifyBody = lensPromptBody(verifyFunctionName);
     assert.match(
@@ -454,8 +454,8 @@ test('every verify step calls buildVerdictFenceSteps, uses code-verifier, and fo
     );
     assert.match(
       verifyBody,
-      /do no edits|make no edits|not edit|no file edits/i,
-      `expected ${verifyFunctionName} to be told to make no edits`,
+      /(?:no|not|never)[^.\n]{0,30}edit[^.\n]{0,40}tree[^.\n]{0,30}(?:under|being)\s+verif/i,
+      `expected ${verifyFunctionName} to forbid editing the tree under verification (a deliberate break off that tree stays allowed)`,
     );
   }
 });
@@ -467,7 +467,7 @@ test('runFixerTask never verifies — verification belongs to the separate verif
   assert.match(fixerBody, /agentType:\s*'clean-coder'/, 'expected the fixer to use clean-coder for its commit and recovery edits');
 });
 
-test('runVerifierTask uses --manifest-hash-for-branch with the hardening branch and forbids edits', () => {
+test('runVerifierTask uses --manifest-hash-for-branch with the hardening branch and forbids editing the tree under verification', () => {
   const verifyBody = lensPromptBody('runVerifierTask');
   assert.match(
     verifyBody,
@@ -476,8 +476,8 @@ test('runVerifierTask uses --manifest-hash-for-branch with the hardening branch
   );
   assert.match(
     verifyBody,
-    /do no edits|make no edits|not edit|no file edits/i,
-    'expected the verifier to be told to make no edits',
+    /(?:no|not|never)[^.\n]{0,30}edit[^.\n]{0,40}tree[^.\n]{0,30}(?:under|being)\s+verif/i,
+    'expected the verifier to forbid editing the tree under verification (a deliberate break off that tree stays allowed)',
   );
 });
 
@@ -901,6 +901,28 @@ test('convergeReadOnlyAgent prepends HEADLESS_READONLY_PREAMBLE and the worktree
   );
 });
 
+test('the read-only destructive pointer scopes its no-edit clause to the tree it reads', () => {
+  const destructivePointer = convergeSource
+    .split('\n')
+    .find((eachLine) => eachLine.includes('Never run a destructive command'));
+  assert.ok(destructivePointer, 'expected the read-only destructive pointer to be declared');
+  assert.match(
+    destructivePointer,
+    /Never run a destructive command/,
+    'expected the destructive-command prohibition to stay absolute',
+  );
+  assert.match(
+    destructivePointer,
+    /no edit to the tree it reads/,
+    'expected the no-edit clause to be scoped to the tree under verification',
+  );
+  assert.doesNotMatch(
+    destructivePointer,
+    /edits nothing/,
+    'expected no blanket edits-nothing wording, which forbids the deliberate break off that tree',
+  );
+});
+
 const taskDispatchers = [
   { name: 'runGitTask', isAsync: false },
   { name: 'runFixerTask', isAsync: false },