fix(claude-code): kill the CLI on a cooperative stop

The cooperative stop ended the message loop but left the CLI running, since closing the SDK's query() stream does not end it. A stopped-early turn kept spending and could keep changing the sandbox while grading ran. Kill the CLI on that stop as the max_turns backstop does, and keep a process handle whenever a stop can fire.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: bai-uipath

src/coder_eval/agents/claude_code_agent.py

@@ -987,7 +987,7 @@ def capture_stderr(line: str) -> None:
 
         try:
             options, transport, effective_model = self._build_claude_query(
-                user_input, timeout, max_turns, capture_stderr
+                user_input, timeout, max_turns, capture_stderr, can_stop=should_stop is not None
             )
             # Set on the state BEFORE the AgentStart emit and any finalize path
             # (finalize reads it for cost backfill); stays None if setup crashed.
@@ -1147,6 +1147,7 @@ async def _pump_messages(
             if should_stop is not None and should_stop():
                 state.stopped_early_hit = True
                 self._log.debug("Cooperative stop requested; ending message loop at this boundary")
+                self._kill_transport(self._active_transport)
                 break
 
     def _build_claude_query(
@@ -1155,11 +1156,14 @@ def _build_claude_query(
         timeout: float | None,
         max_turns: int | None,
         stderr_callback: Callable[[str], None],
+        *,
+        can_stop: bool = False,
     ) -> tuple[ClaudeAgentOptions, SubprocessCLITransport | None, str | None]:
-        """Build the SDK options (+ a timeout-only transport) for one turn.
+        """Build the SDK options (+ a killable transport) for one turn.
 
-        ``transport`` is None unless a ``timeout`` is set: it is pre-constructed
-        only so the watchdog can hard-kill the subprocess. ``effective_model`` may
+        ``transport`` is None unless a timeout, a turn cap or a cooperative stop
+        (``can_stop``) can end the turn: it is pre-constructed only so the harness
+        can hard-kill the subprocess. ``effective_model`` may
         be None on a DirectRoute with no configured model. ``stderr_callback`` is
         wired in here but owned by ``communicate``.
         """
@@ -1226,12 +1230,12 @@ def _build_claude_query(
         # For later inspection: captures every field, defaults included.
         self._sdk_options_dump = dump_dataclass(options)
 
-        # Pre-constructed only under a timeout or turn cap, to retain the subprocess
-        # handle for hard-kill. None otherwise, so the SDK uses its own default and
+        # Pre-constructed only when the harness may end the turn, to retain the
+        # subprocess handle for hard-kill. None otherwise, so the SDK uses its own default and
         # tests can mock query() without a real CLI. Closing the SDK's query()
         # stream does not end the CLI: it never closes the generator it wraps.
         transport: SubprocessCLITransport | None = None
-        if timeout is not None or max_turns is not None:
+        if timeout is not None or max_turns is not None or can_stop:
             transport = SubprocessCLITransport(prompt=user_input, options=options)
 
         return options, transport, effective_model

tests/test_agent.py

@@ -1770,6 +1770,36 @@ async def mock_query(prompt, options, transport=None):
     assert len(turn_record.commands) == 3
 
 
+@pytest.mark.asyncio
+async def test_claude_agent_cooperative_stop_kills_the_cli():
+    """A cooperative stop with no timeout or cap still kills the CLI instead of leaving it running."""
+    agent = ClaudeCodeAgent(parse_agent_config(type=AgentKind.CLAUDE_CODE, permission_mode="acceptEdits"))
+    pulled = 0
+    passed_transport = []
+
+    async def mock_query(prompt, options, transport=None):
+        nonlocal pulled
+        passed_transport.append(transport)
+        for n in range(200):
+            for message in _api_call(n):
+                pulled += 1
+                yield message
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        await agent.start(tmpdir)
+        with (
+            patch("coder_eval.agents.claude_code_agent.query", mock_query),
+            patch.object(ClaudeCodeAgent, "_kill_transport") as kill,
+        ):
+            turn_record = await agent.communicate("loop forever", should_stop=lambda: pulled >= 4)
+
+    assert passed_transport[0] is not None
+    kill.assert_called_once_with(passed_transport[0])
+    assert pulled == 4
+    assert turn_record.crashed is False
+    assert turn_record.max_turns_exhausted is False
+
+
 @pytest.mark.asyncio
 async def test_claude_agent_max_turns_backstop_ignores_emissions_and_subagent_calls():
     """Per-block emissions share one API call, and sub-agent calls have their own cap."""