cli-agent-runner 0.1.37__tar.gz → 0.1.38__tar.gz

{cli_agent_runner-0.1.37 → cli_agent_runner-0.1.38}/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.38] - 2026-05-24
+
+### Fixed
+- Grace-kill (`max_grace_after_result_s`) no longer reaps a round that emitted `type=result` while a backgrounded child process (e.g. a long build) is still running. It now reaps only when the agent's process group has no live worker processes left (a genuine hang); otherwise it waits for the round to finish or for the `round_timeout_s` ceiling.
+- Corrected `round_grace_kill`'s description: the kill is gated on the process group being idle (no live workers), not on log silence.
+
+### Added
+- New event `round_grace_extended` — emitted once when grace elapsed after `type=result` but a live worker process kept the round busy; carries the worker cmdlines.
+- `round_grace_kill` now carries `live_children` (cmdlines observed at kill time; empty for a genuine idle hang).
+
 ## [0.1.37] - 2026-05-22
 
 ### Fixed

{cli_agent_runner-0.1.37 → cli_agent_runner-0.1.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-agent-runner
-Version: 0.1.37
+Version: 0.1.38
 Summary: Restart-on-exit supervisor for autonomous CLI agents
 Project-URL: Homepage, https://github.com/wan9yu/cli-agent-runner
 Project-URL: Documentation, https://github.com/wan9yu/cli-agent-runner#readme

{cli_agent_runner-0.1.37 → cli_agent_runner-0.1.38}/agent_runner/_emit.py

@@ -19,6 +19,7 @@ __all__ = [
     "emit_fresh_eyes_round_triggered",
     "emit_max_rounds_reached",
     "emit_rate_limit_stop",
+    "emit_round_grace_extended",
     "emit_round_grace_kill",
     "emit_round_progress",
     "emit_round_substrate_after",
@@ -233,16 +234,44 @@ def emit_round_grace_kill(
     *,
     round_num: int,
     grace_s: int,
+    live_children: list[str] | None = None,
 ) -> None:
-    """Emit when subprocess killed because grace-after-result timer expired.
-
-    Subprocess emitted type=result in JSONL log then sat silent for longer
-    than max_grace_after_result_s seconds. Distinguishes from round_timeout_kill
-    (wall-clock exceeded without result event).
+    """Emit when the subprocess was killed because the grace-after-result timer
+    expired AND the agent's process group had no live worker processes left
+    (a genuine hang). Distinct from round_grace_extended (grace elapsed but a
+    worker was still running) and round_timeout_kill (wall-clock exceeded).
     """
     from agent_runner.events import ROUND_GRACE_KILL, emit
 
-    emit(log_dir, ROUND_GRACE_KILL, round_num=round_num, grace_s=grace_s)
+    emit(
+        log_dir,
+        ROUND_GRACE_KILL,
+        round_num=round_num,
+        grace_s=grace_s,
+        live_children=live_children or [],
+    )
+
+
+def emit_round_grace_extended(
+    log_dir: Path,
+    *,
+    round_num: int,
+    grace_s: int,
+    live_children: list[str],
+) -> None:
+    """Emit when the grace-after-result timer expired but the agent still had
+    live worker processes (e.g. a backgrounded build), so the round was NOT
+    killed; it continues until it finishes or hits round_timeout_s.
+    """
+    from agent_runner.events import ROUND_GRACE_EXTENDED, emit
+
+    emit(
+        log_dir,
+        ROUND_GRACE_EXTENDED,
+        round_num=round_num,
+        grace_s=grace_s,
+        live_children=live_children,
+    )
 
 
 def emit_anomaly_repetitive_tool(

{cli_agent_runner-0.1.37 → cli_agent_runner-0.1.38}/agent_runner/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.37'
-__version_tuple__ = version_tuple = (0, 1, 37)
+__version__ = version = '0.1.38'
+__version_tuple__ = version_tuple = (0, 1, 38)
 
 __commit_id__ = commit_id = None

{cli_agent_runner-0.1.37 → cli_agent_runner-0.1.38}/agent_runner/agent_runtime.py

@@ -15,9 +15,11 @@ import signal
 import subprocess  # noqa: TID251 — sanctioned subprocess caller
 import time
 from collections.abc import Callable
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 
+import psutil
+
 REAP_GRACE_S = 5
 
 
@@ -28,6 +30,7 @@ class RunResult:
     timed_out: bool
     pid: int
     killed_for_grace: bool = False
+    grace_kill_children: list[str] = field(default_factory=list)
 
 
 def _build_argv(command: list[str], prompt_arg_template: list[str], prompt: str) -> list[str]:
@@ -54,6 +57,31 @@ def _kill_pgroup(proc: subprocess.Popen) -> None:
         pass
 
 
+def _live_children(proc: subprocess.Popen, *, max_n: int = 5, max_len: int = 120) -> list[str]:
+    """Cmdlines of live (non-zombie) descendant processes of ``proc``.
+
+    Empty when ``proc`` has no live workers (a stuck agent that emitted
+    type=result then hung). Non-empty when the round backgrounded work (e.g. a
+    build) still running. Bounded so the resulting event stays small.
+    """
+    try:
+        parent = psutil.Process(proc.pid)
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        return []
+    out: list[str] = []
+    for child in parent.children(recursive=True):
+        try:
+            if child.status() == psutil.STATUS_ZOMBIE:
+                continue
+            line = " ".join(child.cmdline()) or child.name()
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            continue
+        out.append(line[:max_len])
+        if len(out) >= max_n:
+            break
+    return out
+
+
 # Exact compact bytes — matches claude CLI's no-whitespace JSONL output.
 # A future CLI variant emitting `{"type": "result", ...}` (with space) would
 # bypass this scan; revisit if that happens.
@@ -71,14 +99,18 @@ def run(
     max_grace_after_result_s: int = 0,
     progress_callback: Callable[[dict], None] | None = None,
     progress_interval_s: int = 0,
+    on_grace_extended: Callable[[list[str]], None] | None = None,
 ) -> RunResult:
     """Spawn the agent subprocess and wait for exit or timeout.
 
     Wall-clock timeout (R1128). On timeout: SIGTERM pgroup → REAP_GRACE_S → SIGKILL.
 
     max_grace_after_result_s: when > 0, start a countdown after the first
-    type=result event is detected in the log; kill if subprocess is still
-    running after this many seconds (HUNG defense). 0 = disabled.
+    type=result event is detected in the log. After it elapses, reap the
+    process group only if the agent has no live worker processes left (a
+    genuine hang). If a worker is still running (e.g. a backgrounded build),
+    do not reap — invoke ``on_grace_extended`` once and keep waiting until the
+    round finishes or hits the wall-clock ``timeout_s`` ceiling. 0 = disabled.
 
     progress_callback: when not None and progress_interval_s > 0, called every
     progress_interval_s seconds with a dict of log stats (log_size_kb,
@@ -100,6 +132,7 @@ def run(
         start_new_session=True,
     )
     result_seen_at: float | None = None
+    grace_extended_emitted = False
     try:
         while True:
             ret = proc.poll()
@@ -114,10 +147,9 @@ def run(
                 return RunResult(
                     exit_code=exit_code, duration_s=duration, timed_out=True, pid=proc.pid
                 )
-            # Grace kill: result emitted but subprocess still running
+            # Grace kill: result emitted but subprocess still running.
             if max_grace_after_result_s > 0:
                 if result_seen_at is None:
-                    # Cheap check: byte-scan log for marker substring
                     try:
                         with log_path.open("rb") as f:
                             if _RESULT_MARKER in f.read():
@@ -125,16 +157,26 @@ def run(
                     except OSError:
                         pass  # log not flushed yet; check next tick
                 if result_seen_at is not None and now - result_seen_at > max_grace_after_result_s:
-                    _kill_pgroup(proc)
-                    duration = time.time() - start
-                    exit_code = proc.returncode if proc.returncode is not None else -1
-                    return RunResult(
-                        exit_code=exit_code,
-                        duration_s=duration,
-                        timed_out=True,
-                        pid=proc.pid,
-                        killed_for_grace=True,
-                    )
+                    children = _live_children(proc)
+                    if children:
+                        # Busy: a backgrounded worker is still running. Don't
+                        # reap — defer to the wall-clock ceiling. Signal once.
+                        if not grace_extended_emitted:
+                            if on_grace_extended is not None:
+                                on_grace_extended(children)
+                            grace_extended_emitted = True
+                    else:
+                        _kill_pgroup(proc)
+                        duration = time.time() - start
+                        exit_code = proc.returncode if proc.returncode is not None else -1
+                        return RunResult(
+                            exit_code=exit_code,
+                            duration_s=duration,
+                            timed_out=True,
+                            pid=proc.pid,
+                            killed_for_grace=True,
+                            grace_kill_children=[],
+                        )
             # Progress heartbeat: call back if interval elapsed
             if progress_callback is not None and progress_interval_s > 0:
                 if now - last_progress_at >= progress_interval_s:

{cli_agent_runner-0.1.37 → cli_agent_runner-0.1.38}/agent_runner/api.py

@@ -733,6 +733,7 @@ from agent_runner._emit import (  # noqa: E402,F401 — intentional bottom re-ex
     emit_fresh_eyes_round_triggered,
     emit_max_rounds_reached,
     emit_rate_limit_stop,
+    emit_round_grace_extended,
     emit_round_grace_kill,
     emit_round_progress,
     emit_round_substrate_after,

{cli_agent_runner-0.1.37 → cli_agent_runner-0.1.38}/agent_runner/events.py

@@ -49,6 +49,7 @@ ORPHAN_STASHED = "orphan_stashed"
 PACKAGE_UPGRADED = "package_upgraded"
 PROMPT_OVERWRITTEN = "prompt_overwritten"
 ROUND_END = "round_end"
+ROUND_GRACE_EXTENDED = "round_grace_extended"
 ROUND_GRACE_KILL = "round_grace_kill"
 ROUND_PROGRESS = "round_progress"
 ROUND_START = "round_start"

{cli_agent_runner-0.1.37 → cli_agent_runner-0.1.38}/agent_runner/runner.py

@@ -466,6 +466,14 @@ def _run_one_round_inner(cfg: Config, *, phase_override: str | None = None) -> R
             **stats,
         )
 
+    def _grace_extended_emit(children: list[str]) -> None:
+        api.emit_round_grace_extended(
+            log_dir,
+            round_num=round_num,
+            grace_s=cfg.runtime.max_grace_after_result_s,
+            live_children=children,
+        )
+
     result = agent_runtime.run(
         command=cfg.agent.command,
         prompt_arg_template=cfg.agent.prompt_arg_template,
@@ -476,6 +484,7 @@ def _run_one_round_inner(cfg: Config, *, phase_override: str | None = None) -> R
         max_grace_after_result_s=cfg.runtime.max_grace_after_result_s,
         progress_callback=_progress_emit,
         progress_interval_s=cfg.monitor.round_progress_interval_s,
+        on_grace_extended=_grace_extended_emit,
     )
     events.emit(
         log_dir,
@@ -549,6 +558,7 @@ def _run_one_round_inner(cfg: Config, *, phase_override: str | None = None) -> R
             log_dir,
             round_num=round_num,
             grace_s=cfg.runtime.max_grace_after_result_s,
+            live_children=result.grace_kill_children,
         )
     elif result.timed_out:
         events.emit(

{cli_agent_runner-0.1.37 → cli_agent_runner-0.1.38}/docs/architecture.md

@@ -168,6 +168,7 @@ hook (vs ALL pre-round hooks), use `[plugins] disable = ["that_entry_point_name"
 - `package_upgraded`
 - `prompt_overwritten`
 - `round_end`
+- `round_grace_extended`
 - `round_grace_kill`
 - `round_progress`
 - `round_start`

cli_agent_runner-0.1.38/docs/migrations/0.1.38.md

@@ -0,0 +1,53 @@
+# Migrating to 0.1.38
+
+## TL;DR
+
+```bash
+pip install --upgrade cli-agent-runner==0.1.38
+```
+
+No action or config change. If you use `max_grace_after_result_s`, grace-kill
+now distinguishes a hung agent from a still-busy one.
+
+## What changed
+
+Previously, grace-kill reaped the whole process group `max_grace_after_result_s`
+seconds after the agent emitted `type=result`, with no awareness of child
+processes. A round that backgrounded a long build and emitted `type=result`
+("waiting for build…") could have the still-running build reaped.
+
+Now, at grace expiry, agent-runner checks for live worker processes in the
+agent's process group:
+
+- **No live workers** → genuine hang → reaped (`round_grace_kill`, as before).
+- **A live worker** (e.g. a build) → not reaped; agent-runner emits
+  `round_grace_extended` once and waits until the round finishes or hits the
+  `round_timeout_s` wall-clock ceiling.
+
+The check re-runs each poll tick, so once a backgrounded worker exits, a still-
+stuck agent is reaped promptly rather than waiting out `round_timeout_s`.
+
+## Three distinct outcomes
+
+- `round_grace_extended` — grace elapsed but a worker is still running (busy).
+- `round_grace_kill` — grace elapsed and the process group is idle (hang).
+- `round_timeout_kill` — wall-clock `round_timeout_s` exceeded (hard ceiling).
+
+## Recommended agent contract
+
+Treat the safety net as a net, not a crutch: emit `type=result` only when the
+turn is truly done. Run long builds/tests foreground and commit before ending
+the turn, rather than backgrounding work past `type=result`.
+
+## Known limitation
+
+The "live worker" check treats *any* live non-zombie descendant as busy. If
+your agent keeps persistent helper subprocesses alive past `type=result` (e.g.
+MCP servers), grace-kill will defer hangs to the `round_timeout_s` ceiling. This
+never false-kills; the `round_grace_extended` events make it visible if it
+happens.
+
+## What did NOT change
+
+- `max_grace_after_result_s` config, default, and `0 = disabled`.
+- `round_timeout_s` wall-clock kill (still the hard ceiling and backstop).

{cli_agent_runner-0.1.37 → cli_agent_runner-0.1.38}/docs/runbook.md

@@ -565,6 +565,25 @@ agent-runner kill                                    # force terminate
 ls -la ~/.agent-runner/<project>/logs/rounds/        # most recent R*.log
 ```
 
+### Grace-kill and backgrounded work (`max_grace_after_result_s`)
+
+Grace-kill is now process-group-liveness-aware. At grace expiry, agent-runner
+inspects the agent's process group for live (non-zombie) worker processes and
+takes one of three paths:
+
+- **`round_grace_extended`** — grace elapsed but a live worker is still running
+  (e.g. a backgrounded build). Round is NOT killed; agent-runner waits until the
+  round finishes or hits the `round_timeout_s` wall-clock ceiling.
+- **`round_grace_kill`** — grace elapsed and the process group is idle (genuine
+  hang). Round is reaped, same as pre-0.1.38.
+- **`round_timeout_kill`** — `round_timeout_s` wall-clock exceeded (hard ceiling,
+  fires regardless of process-group state).
+
+If you see repeated `round_grace_extended` events, the agent is backgrounding
+work past `type=result`. Check the `live_children` field in the event to identify
+the process; consider restructuring the agent to emit `type=result` only when
+truly done.
+
 ### Disk pressure
 
 **Symptom:** `[WARN] disk_warning` at >90%; `[CRIT] disk_critical` at >95% (auto-stops).

{cli_agent_runner-0.1.37 → cli_agent_runner-0.1.38}/tests/integration/test_grace_kill_emission.py

@@ -57,7 +57,7 @@ def test_grace_kill_emits_round_grace_kill_event(tmp_path: Path) -> None:
 
     script = tmp_path / "agent.sh"
     script.write_text(
-        '#!/bin/bash\necho \'{"type":"result","is_error":false}\'\nsleep 10\n',
+        '#!/bin/bash\necho \'{"type":"result","is_error":false}\'\nexec sleep 10\n',
         encoding="utf-8",
     )
     script.chmod(0o755)
@@ -77,3 +77,35 @@ def test_grace_kill_emits_round_grace_kill_event(tmp_path: Path) -> None:
     # round_timeout_kill must NOT appear (grace kill is distinct)
     timeout_events = [e for e in events if e.get("event") == "round_timeout_kill"]
     assert len(timeout_events) == 0
+
+
+def test_round_grace_extended_emitted_when_worker_alive(tmp_path: Path) -> None:
+    """Full runner flow: subprocess emits result then backgrounds a long child;
+    round_grace_extended event fires (not round_grace_kill); wall timeout reaps."""
+    _init_git(tmp_path)
+
+    script = tmp_path / "agent.sh"
+    script.write_text(
+        '#!/bin/bash\necho \'{"type":"result","is_error":false}\'\nsleep 30 &\nwait\n',
+        encoding="utf-8",
+    )
+    script.chmod(0o755)
+
+    cfg = _make_grace_config(tmp_path, script, grace_s=1)
+    result = run_one_round(cfg)
+
+    assert result.killed_for_grace is False  # spared by liveness
+    assert result.timed_out is True  # wall-clock ceiling reaped it
+
+    events = read_events_for_current_month(cfg.runtime.log_dir)
+
+    # round_grace_extended must appear with live_children populated
+    extended_events = [e for e in events if e.get("event") == "round_grace_extended"]
+    assert len(extended_events) == 1
+    assert extended_events[0]["round_num"] == 1
+    assert extended_events[0]["grace_s"] == 1
+    assert any("sleep" in c for c in extended_events[0]["live_children"])
+
+    # round_grace_kill must NOT appear (round was busy, not idle)
+    grace_kill_events = [e for e in events if e.get("event") == "round_grace_kill"]
+    assert len(grace_kill_events) == 0

{cli_agent_runner-0.1.37 → cli_agent_runner-0.1.38}/tests/invariants/test_catalogs.py

@@ -220,3 +220,10 @@ def test_given_package_upgraded_kind_when_registered_then_in_known_event_kinds()
 
     assert PACKAGE_UPGRADED == "package_upgraded"
     assert PACKAGE_UPGRADED in _BUILTIN_KINDS
+
+
+def test_given_round_grace_extended_kind_when_registered_then_in_known_event_kinds() -> None:
+    from agent_runner.events import _BUILTIN_KINDS, ROUND_GRACE_EXTENDED
+
+    assert ROUND_GRACE_EXTENDED == "round_grace_extended"
+    assert ROUND_GRACE_EXTENDED in _BUILTIN_KINDS

cli_agent_runner-0.1.38/tests/unit/test_agent_runtime_grace.py

@@ -0,0 +1,159 @@
+"""Tests for max_grace_after_result_s HUNG defense (0.1.31+)."""
+
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import time
+from pathlib import Path
+
+from agent_runner.agent_runtime import run
+
+
+def _write_fake_script(tmp_path: Path, body: str) -> Path:
+    p = tmp_path / "fake.sh"
+    p.write_text(f"#!/bin/bash\nset -e\n{body}\n", encoding="utf-8")
+    p.chmod(0o755)
+    return p
+
+
+def test_grace_kill_fires_when_result_then_idle(tmp_path):
+    """Agent writes type=result then becomes a childless sleeper (exec) -> no
+    live workers -> reaped within grace + tick latency."""
+    script = _write_fake_script(
+        tmp_path,
+        'echo \'{"type":"result","is_error":false}\'\nexec sleep 5\n',
+    )
+    log_path = tmp_path / "round.log"
+    result = run(
+        command=[str(script)],
+        prompt_arg_template=[],
+        prompt="x",
+        timeout_s=10,
+        log_path=log_path,
+        env_extra={},
+        max_grace_after_result_s=1,
+    )
+    assert result.killed_for_grace is True
+    assert result.grace_kill_children == []
+    assert result.duration_s < 4
+
+
+def test_no_grace_kill_when_disabled(tmp_path):
+    """max_grace=0 -> grace logic disabled; wall timeout governs."""
+    script = _write_fake_script(
+        tmp_path,
+        'echo \'{"type":"result","is_error":false}\'\nsleep 5\n',
+    )
+    log_path = tmp_path / "round.log"
+    result = run(
+        command=[str(script)],
+        prompt_arg_template=[],
+        prompt="x",
+        timeout_s=2,  # short wall timeout
+        log_path=log_path,
+        env_extra={},
+        max_grace_after_result_s=0,
+    )
+    assert result.killed_for_grace is False
+    assert result.timed_out is True  # killed by wall timeout instead
+
+
+def test_no_grace_kill_when_result_not_emitted(tmp_path):
+    """No result event -> grace countdown never starts."""
+    script = _write_fake_script(tmp_path, 'echo "no result here"\nexit 0\n')
+    log_path = tmp_path / "round.log"
+    result = run(
+        command=[str(script)],
+        prompt_arg_template=[],
+        prompt="x",
+        timeout_s=5,
+        log_path=log_path,
+        env_extra={},
+        max_grace_after_result_s=1,
+    )
+    assert result.killed_for_grace is False
+    assert result.timed_out is False
+    assert result.exit_code == 0
+
+
+def test_live_children_empty_when_no_children():
+    from agent_runner.agent_runtime import _live_children
+
+    p = subprocess.Popen(["sleep", "3"], start_new_session=True)
+    try:
+        assert _live_children(p) == []
+    finally:
+        os.killpg(p.pid, signal.SIGKILL)
+        p.wait()
+
+
+def test_live_children_lists_backgrounded_child():
+    from agent_runner.agent_runtime import _live_children
+
+    p = subprocess.Popen(["bash", "-c", "sleep 30 & wait"], start_new_session=True)
+    try:
+        time.sleep(0.5)  # let the backgrounded child spawn
+        kids = _live_children(p)
+        assert any("sleep" in k for k in kids)
+    finally:
+        os.killpg(p.pid, signal.SIGKILL)
+        p.wait()
+
+
+def test_live_children_empty_when_process_gone():
+    from agent_runner.agent_runtime import _live_children
+
+    p = subprocess.Popen(["true"])
+    p.wait()
+    assert _live_children(p) == []  # NoSuchProcess swallowed
+
+
+def test_grace_extended_when_result_but_child_running(tmp_path):
+    """Agent emits result then backgrounds a long child -> live worker -> NOT
+    grace-killed; round_timeout_s (wall) reaps it instead; extended fired once."""
+    script = _write_fake_script(
+        tmp_path,
+        'echo \'{"type":"result"}\'\nsleep 30 &\nwait\n',
+    )
+    log_path = tmp_path / "round.log"
+    extended = []
+    result = run(
+        command=[str(script)],
+        prompt_arg_template=[],
+        prompt="x",
+        timeout_s=4,
+        log_path=log_path,
+        env_extra={},
+        max_grace_after_result_s=1,
+        on_grace_extended=lambda kids: extended.append(kids),
+    )
+    assert result.killed_for_grace is False  # spared by liveness
+    assert result.timed_out is True  # round_timeout_s backstop reaped it
+    assert len(extended) == 1  # emitted once, not per-tick
+    assert any("sleep" in k for k in extended[0])
+
+
+def test_grace_kill_after_child_exits_then_idle(tmp_path):
+    """Live child first (extend), child exits, agent becomes childless (exec)
+    -> next tick reaps via grace (well before wall timeout)."""
+    script = _write_fake_script(
+        tmp_path,
+        'echo \'{"type":"result"}\'\nsleep 2 &\nwait\nexec sleep 30\n',
+    )
+    log_path = tmp_path / "round.log"
+    extended = []
+    result = run(
+        command=[str(script)],
+        prompt_arg_template=[],
+        prompt="x",
+        timeout_s=10,
+        log_path=log_path,
+        env_extra={},
+        max_grace_after_result_s=1,
+        on_grace_extended=lambda kids: extended.append(kids),
+    )
+    assert result.killed_for_grace is True  # reaped after child exited
+    assert result.duration_s < 6  # ~2s child + reap, well under timeout
+    assert len(extended) == 1

cli_agent_runner-0.1.37/tests/unit/test_agent_runtime_grace.py

@@ -1,72 +0,0 @@
-"""Tests for max_grace_after_result_s HUNG defense (0.1.31+)."""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from agent_runner.agent_runtime import run
-
-
-def _write_fake_script(tmp_path: Path, body: str) -> Path:
-    p = tmp_path / "fake.sh"
-    p.write_text(f"#!/bin/bash\nset -e\n{body}\n", encoding="utf-8")
-    p.chmod(0o755)
-    return p
-
-
-def test_grace_kill_fires_when_result_then_silent(tmp_path):
-    """Fake agent writes type=result then sleeps 5s. max_grace=1s -> kill within 3s."""
-    script = _write_fake_script(
-        tmp_path,
-        'echo \'{"type":"result","is_error":false}\'\nsleep 5\n',
-    )
-    log_path = tmp_path / "round.log"
-    result = run(
-        command=[str(script)],
-        prompt_arg_template=[],
-        prompt="x",
-        timeout_s=10,
-        log_path=log_path,
-        env_extra={},
-        max_grace_after_result_s=1,
-    )
-    assert result.killed_for_grace is True
-    assert result.duration_s < 4  # ~1s grace + tick latency + reap grace
-
-
-def test_no_grace_kill_when_disabled(tmp_path):
-    """max_grace=0 -> grace logic disabled; wall timeout governs."""
-    script = _write_fake_script(
-        tmp_path,
-        'echo \'{"type":"result","is_error":false}\'\nsleep 5\n',
-    )
-    log_path = tmp_path / "round.log"
-    result = run(
-        command=[str(script)],
-        prompt_arg_template=[],
-        prompt="x",
-        timeout_s=2,  # short wall timeout
-        log_path=log_path,
-        env_extra={},
-        max_grace_after_result_s=0,
-    )
-    assert result.killed_for_grace is False
-    assert result.timed_out is True  # killed by wall timeout instead
-
-
-def test_no_grace_kill_when_result_not_emitted(tmp_path):
-    """No result event -> grace countdown never starts."""
-    script = _write_fake_script(tmp_path, 'echo "no result here"\nexit 0\n')
-    log_path = tmp_path / "round.log"
-    result = run(
-        command=[str(script)],
-        prompt_arg_template=[],
-        prompt="x",
-        timeout_s=5,
-        log_path=log_path,
-        env_extra={},
-        max_grace_after_result_s=1,
-    )
-    assert result.killed_for_grace is False
-    assert result.timed_out is False
-    assert result.exit_code == 0