cli-agent-runner 0.2.0__tar.gz → 0.2.1__tar.gz

{cli_agent_runner-0.2.0 → cli_agent_runner-0.2.1}/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.1] - 2026-07-16
+
+### Added
+- `[agent] prompt_delivery = "argv" | "stdin"` (default `argv`). `stdin` pipes the prompt to the agent's stdin instead of placing it in argv, closing a `pkill -f <token>` self-kill footgun (a background worker matching on a token from the prompt could match the agent's own argv). The `claude` preset now defaults to `stdin`; existing configs are unaffected.
+- `agent_exit` gains `exit_cause` (`clean` / `error` / `signal:<NAME>` / `timeout`) so monitors can distinguish a clean exit from a signal-kill without a heuristic.
+
+### Fixed
+- A signal-killed round is no longer misclassified as `agent_network_blip` when its log happens to contain a network-error string; signal deaths are terminations, not network blips.
+
+See `docs/migrations/0.2.1.md`.
+
 ## [0.2.0] - 2026-07-02
 
 ### Changed

{cli_agent_runner-0.2.0 → cli_agent_runner-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-agent-runner
-Version: 0.2.0
+Version: 0.2.1
 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.2.0 → cli_agent_runner-0.2.1}/agent_runner/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.2.1'
+__version_tuple__ = version_tuple = (0, 2, 1)
 
 __commit_id__ = commit_id = None

{cli_agent_runner-0.2.0 → cli_agent_runner-0.2.1}/agent_runner/agent_runtime.py

@@ -14,6 +14,7 @@ import os
 import re
 import signal
 import subprocess  # noqa: TID251 — sanctioned subprocess caller
+import threading
 import time
 from collections.abc import Callable
 from dataclasses import dataclass, field
@@ -24,6 +25,25 @@ import psutil
 REAP_GRACE_S = 5
 
 
+def signal_name(exit_code: int) -> str | None:
+    """Signal name for a signal death, else None.
+
+    Handles both the Python-negative form (``-15``) and the shell ``128+N``
+    form (``143``). Returns None for a non-signal exit — including a legitimate
+    ``> 128`` code (e.g. 200) that is not a valid signal number.
+    """
+    if exit_code < 0:
+        n = -exit_code
+    elif exit_code > 128:
+        n = exit_code - 128
+    else:
+        return None
+    try:
+        return signal.Signals(n).name
+    except ValueError:
+        return None
+
+
 @dataclass(frozen=True)
 class RunResult:
     exit_code: int
@@ -116,6 +136,7 @@ def run(
     command: list[str],
     prompt_arg_template: list[str],
     prompt: str,
+    prompt_delivery: str = "argv",
     timeout_s: int,
     log_path: Path,
     env_extra: dict[str, str],
@@ -145,7 +166,16 @@ def run(
     matching any pattern (re.search) are excluded from the liveness count
     (persistent helpers that aren't real workers). None = no filtering.
     """
-    argv = _build_argv(command, prompt_arg_template, prompt)
+    stdin_mode = prompt_delivery == "stdin"
+    # Defense-in-depth: config validation already rejects {prompt} in the
+    # template for stdin mode, but run() must be safe even if called
+    # directly with a mismatched template. In stdin mode, never substitute
+    # {prompt} into argv — build it verbatim so the prompt cannot reach argv.
+    argv = (
+        list(command) + list(prompt_arg_template)
+        if stdin_mode
+        else _build_argv(command, prompt_arg_template, prompt)
+    )
     env = {**os.environ, **env_extra}
     log_path.parent.mkdir(parents=True, exist_ok=True)
     log_file = log_path.open("w", encoding="utf-8")
@@ -154,11 +184,26 @@ def run(
     proc = subprocess.Popen(
         argv,
         env=env,
-        stdin=subprocess.DEVNULL,
+        stdin=subprocess.PIPE if stdin_mode else subprocess.DEVNULL,
         stdout=log_file,
         stderr=subprocess.STDOUT,
         start_new_session=True,
     )
+    if stdin_mode and proc.stdin is not None:
+        # Write+close on a daemon thread so the wall-clock timeout loop below
+        # is never blocked by a write >64KB (OS pipe buffer) to an agent that
+        # doesn't drain stdin (R1128: no unbounded-hang path).
+        stdin_pipe = proc.stdin
+        stdin_data = prompt.encode("utf-8")
+
+        def _write_stdin():
+            try:
+                stdin_pipe.write(stdin_data)
+                stdin_pipe.close()
+            except (BrokenPipeError, OSError):
+                pass  # agent exited before reading stdin; the poll loop handles exit
+
+        threading.Thread(target=_write_stdin, daemon=True).start()
     result_seen_at: float | None = None
     grace_extended_emitted = False
     try:

{cli_agent_runner-0.2.0 → cli_agent_runner-0.2.1}/agent_runner/config.py

@@ -11,6 +11,7 @@ from typing import Any, Literal
 _VALID_INJECTION_MODES: frozenset[str] = frozenset({"prepend", "file", "none"})
 _VALID_DIRTY_ACTIONS: frozenset[str] = frozenset({"stash", "ignore", "auto_commit"})
 _VALID_TRANSIENT_ERROR_ACTIONS: frozenset[str] = frozenset({"back_off", "skip", "stop"})
+_VALID_PROMPT_DELIVERY: frozenset[str] = frozenset({"argv", "stdin"})
 
 
 class ConfigError(ValueError):
@@ -23,6 +24,7 @@ class AgentConfig:
     prompt_arg_template: list[str]
     name: str | None = None
     env: dict[str, str] = field(default_factory=dict)
+    prompt_delivery: Literal["argv", "stdin"] = "argv"
 
 
 @dataclass(frozen=True)
@@ -338,11 +340,23 @@ def load_config(toml_path: Path) -> Config:
         raw = tomllib.load(f)
 
     agent_d = raw.get("agent", {})
+    prompt_delivery = str(agent_d.get("prompt_delivery", "argv"))
+    prompt_arg_template = list(_require(agent_d, "prompt_arg_template"))
+    if prompt_delivery not in _VALID_PROMPT_DELIVERY:
+        raise ValueError(
+            f'invalid [agent] prompt_delivery {prompt_delivery!r}: use "argv" or "stdin"'
+        )
+    if prompt_delivery == "stdin" and any("{prompt}" in a for a in prompt_arg_template):
+        raise ValueError(
+            "stdin delivery: remove {prompt} from [agent] prompt_arg_template "
+            "(the prompt is piped to stdin, not placed in argv)"
+        )
     agent = AgentConfig(
         command=list(_require(agent_d, "command")),
-        prompt_arg_template=list(_require(agent_d, "prompt_arg_template")),
+        prompt_arg_template=prompt_arg_template,
         name=agent_d.get("name"),
         env={str(k): str(v) for k, v in agent_d.get("env", {}).items()},
+        prompt_delivery=prompt_delivery,
     )
     raw_work_dir = str(_require(raw, "runtime", "work_dir"))
     work_dir = _expand_path(raw_work_dir, "").resolve()

{cli_agent_runner-0.2.0 → cli_agent_runner-0.2.1}/agent_runner/presets/claude.toml

@@ -4,7 +4,8 @@
 command = ["claude", "--model", "claude-opus-4-7",
            "--dangerously-skip-permissions",
            "--verbose", "--output-format", "stream-json"]
-prompt_arg_template = ["-p", "{prompt}"]
+prompt_arg_template = ["-p"]
+prompt_delivery = "stdin"
 name = "claude"
 
 [agent.env]

{cli_agent_runner-0.2.0 → cli_agent_runner-0.2.1}/agent_runner/runner.py

@@ -28,6 +28,7 @@ from agent_runner import (
     startup_check,
     vcs_state,
 )
+from agent_runner.agent_runtime import signal_name
 from agent_runner.api import _primary_prompt_file, resolve_runtime_for_phase
 from agent_runner.api import assemble_prompt as _api_assemble_prompt
 from agent_runner.api_types import RoundResult, TransientErrorState
@@ -217,6 +218,20 @@ def _round_context_for_prompt(
     return ctx
 
 
+def _exit_cause(result: agent_runtime.RunResult) -> str:
+    """Classify a round's exit for the ``agent_exit`` event.
+
+    Precedence: timeout > signal:<NAME> > clean > error. Timeout wins even
+    when agent-runner signal-killed the process to enforce the timeout.
+    """
+    if result.timed_out:
+        return "timeout"
+    s = signal_name(result.exit_code)
+    if s is not None:
+        return f"signal:{s}"
+    return "clean" if result.exit_code == 0 else "error"
+
+
 def _scan_round_log_for_network_blip(
     *,
     log_dir: Path,
@@ -233,6 +248,8 @@ def _scan_round_log_for_network_blip(
     # Skip the I/O on the success path.
     if result.exit_code == 0 and not result.timed_out:
         return
+    if signal_name(result.exit_code) is not None:
+        return  # signal death is a termination, not a network blip
     try:
         text = log_path.read_text(encoding="utf-8", errors="replace")
     except FileNotFoundError:
@@ -486,6 +503,7 @@ def _run_one_round_inner(cfg: Config, *, phase_override: str | None = None) -> R
         command=cfg.agent.command,
         prompt_arg_template=cfg.agent.prompt_arg_template,
         prompt=prompt,
+        prompt_delivery=cfg.agent.prompt_delivery,
         timeout_s=timeout_s,
         log_path=log_path,
         env_extra={**framework_env, **dict(cfg.agent.env)},
@@ -502,6 +520,7 @@ def _run_one_round_inner(cfg: Config, *, phase_override: str | None = None) -> R
         exit_code=result.exit_code,
         duration_s=result.duration_s,
         timed_out=result.timed_out,
+        exit_cause=_exit_cause(result),
     )
 
     _scan_round_log_for_network_blip(

{cli_agent_runner-0.2.0 → cli_agent_runner-0.2.1}/docs/configuration.md

@@ -28,6 +28,7 @@ running with newly-set `dirty_action = "auto_commit"` is undefined).
 | `prompt_arg_template` | `list[str]` | — |
 | `name` | `str | None` | None |
 | `env` | `dict[str, str]` | {} |
+| `prompt_delivery` | `Literal['argv', 'stdin']` | 'argv' |
 
 ### `[runtime]`
 
@@ -84,6 +85,20 @@ running with newly-set `dirty_action = "auto_commit"` is undefined).
 | `supervisor_stale_threshold_s` | `int | None` | None |
 <!-- /gen:config-schema -->
 
+### `agent.prompt_delivery`
+
+Type: string, one of `"argv"`, `"stdin"`
+Default: `"argv"`
+
+Controls how the assembled prompt reaches the agent subprocess. `"argv"`
+(default, unchanged behavior) substitutes the prompt into
+`prompt_arg_template` and passes it as a command-line argument. `"stdin"`
+writes the prompt to the subprocess's stdin instead — it never appears in
+argv, which avoids a `pkill -f <token>` self-kill if the agent's own cleanup
+commands happen to match a token drawn from its prompt. The `claude` preset
+defaults to `"stdin"`; existing configs are unchanged. See
+`docs/migrations/0.2.1.md` to adopt on an existing config.
+
 ### `vcs.dirty_action`
 
 Type: string, one of `"stash"`, `"ignore"`, `"auto_commit"`

cli_agent_runner-0.2.1/docs/migrations/0.2.1.md

@@ -0,0 +1,77 @@
+# Migration guide: 0.2.1
+
+## TL;DR — zero migration for existing users
+
+`[agent] prompt_delivery` defaults to `"argv"`, the pre-0.2.1 behavior. No TOML
+changes are required to keep your current setup working exactly as before.
+
+---
+
+## New: `[agent] prompt_delivery`
+
+The prompt can now reach the agent two ways:
+
+| `prompt_delivery` | Behavior |
+|---|---|
+| `"argv"` (default) | Unchanged: the prompt is substituted into `prompt_arg_template` and passed as a command-line argument, as in every prior release. |
+| `"stdin"` | The prompt is written to the agent subprocess's stdin instead. It never appears in the process's argv. |
+
+### The `pkill -f` footgun this fixes
+
+A round's agent sometimes needs to reap background helper processes it
+started earlier in the same session (e.g. a long build or a watcher). A
+tempting one-liner is `pkill -f <some-token>` — kill anything whose command
+line matches a token. If that token also happens to appear in the *agent's
+own* prompt (a file path, a project name, a phrase the agent echoed back),
+and the prompt was placed in the agent's own argv, `pkill -f` can match and
+kill the agent process itself. This was reported from a production
+deployment: an agent's own cleanup command silently killed its own round.
+
+`prompt_delivery = "stdin"` closes this: with the prompt off argv, a
+`pkill -f <token>` run by the agent can no longer self-match on prompt
+content.
+
+**New `claude` scaffolds** (`agent-runner init --preset claude`) already
+default to `prompt_delivery = "stdin"`.
+
+**To adopt on an existing config**, two edits are required together:
+
+```toml
+[agent]
+prompt_delivery = "stdin"
+prompt_arg_template = ["-p"]   # remove {prompt} — it is no longer substituted into argv
+```
+
+Both changes are required: `prompt_delivery = "stdin"` alone does not remove
+`{prompt}` from `prompt_arg_template` for you, and config load rejects the
+combination of `prompt_delivery = "stdin"` with a `{prompt}` placeholder
+still present (`ConfigError` at startup) — the prompt is piped to stdin, not
+placed in argv.
+
+The right-hand side of `prompt_arg_template` (flags like `-p`) is unaffected;
+only the `{prompt}` substitution changes.
+
+Regardless of `prompt_delivery`, agents should reap background workers via
+process-group-aware means rather than `pkill -f <pattern>` — see
+`docs/runbook.md`.
+
+---
+
+## New: `agent_exit.exit_cause`
+
+The `agent_exit` event gains an `exit_cause` field: one of `clean`, `error`,
+`signal:<NAME>` (e.g. `signal:SIGTERM`), or `timeout`. Monitor/consumer code
+that previously inferred a signal-kill from `exit_code` heuristics can read
+`exit_cause` directly instead. Additive field; existing consumers reading
+only `exit_code` are unaffected.
+
+---
+
+## Fixed: signal-killed rounds no longer misclassified as network blips
+
+A round terminated by a signal (e.g. a self-SIGTERM from a background
+process) whose log happened to contain a network-error-looking string was
+previously misclassified as `agent_network_blip`, which could feed
+retry/back-off logic. Signal deaths are now recognized as terminations and
+excluded from the network-blip scan. No config change; this only affects
+which event a signal-killed round emits.

{cli_agent_runner-0.2.0 → cli_agent_runner-0.2.1}/docs/runbook.md

@@ -624,6 +624,12 @@ post-result hang to `round_timeout_s`. Set `[runtime] grace_kill_ignore_patterns
 `round_grace_extended` event's `ignored_children` field shows which cmdlines
 matched a pattern.
 
+**Reaping background workers:** if an agent needs to clean up its own
+backgrounded helper processes, use process-group-aware means (its own
+`bg`/job-control tooling, or killing by recorded PID/pgid) — not
+`pkill -f <pattern>`, which matches on command-line substrings and can
+self-match the agent's own process or hit unrelated siblings.
+
 ### Disk pressure
 
 **Symptom:** `[WARN] disk_warning` at >90%; `[CRIT] disk_critical` at >95% (auto-stops).

{cli_agent_runner-0.2.0 → cli_agent_runner-0.2.1}/tests/_test_helpers.py

@@ -8,6 +8,8 @@ the test suite. After: one factory.
 
 from __future__ import annotations
 
+import json
+import tomllib
 from pathlib import Path
 from typing import Any
 
@@ -104,6 +106,50 @@ def make_toml_with_sections(
     return toml
 
 
+def _format_toml_value(v: Any) -> str:
+    """Serialize a Python scalar/list back to a TOML literal (str/list only;
+    sufficient for the [agent] overrides write_min_config supports)."""
+    if isinstance(v, list):
+        return "[" + ", ".join(_format_toml_value(x) for x in v) + "]"
+    if isinstance(v, str):
+        return json.dumps(v)  # TOML basic-string quoting matches JSON's
+    if isinstance(v, bool):  # must precede the int check: bool is an int subclass
+        return "true" if v else "false"
+    return str(v)
+
+
+def write_min_config(tmp_path: Path, *, agent_extra: str = "") -> Path:
+    """Write a minimal agent-runner.toml, letting callers override [agent] fields.
+
+    agent_extra: raw TOML lines parsed as a fragment and merged into the
+    default [agent] table (``command = ["true"]``, ``prompt_arg_template =
+    ["{prompt}"]``) — keys in agent_extra replace the corresponding default
+    (avoids emitting duplicate TOML keys, which tomllib rejects). e.g.
+    ``'prompt_delivery = "stdin"\\nprompt_arg_template = ["-p"]\\n'``.
+    """
+    log_dir = tmp_path / "logs"
+    log_dir.mkdir(exist_ok=True)
+    prompt_file = tmp_path / "prompt.md"
+    prompt_file.write_text(_VALID_PROMPT)
+
+    agent: dict[str, Any] = {"command": ["true"], "prompt_arg_template": ["{prompt}"]}
+    if agent_extra:
+        agent.update(tomllib.loads(agent_extra))
+
+    agent_lines = "\n".join(f"{k} = {_format_toml_value(v)}" for k, v in agent.items())
+    toml = tmp_path / "agent-runner.toml"
+    toml.write_text(
+        "[agent]\n"
+        f"{agent_lines}\n"
+        "[runtime]\n"
+        f'work_dir = "{tmp_path}"\n'
+        f'log_dir = "{log_dir}"\n'
+        "[prompt]\n"
+        f'file = "{prompt_file}"\n'
+    )
+    return toml
+
+
 def read_events_for_current_month(log_dir: Path) -> list[dict]:
     """Read all events from the current month's events-YYYY-MM.jsonl."""
     import json

cli_agent_runner-0.2.1/tests/integration/test_prompt_delivery_stdin.py

@@ -0,0 +1,103 @@
+import sys
+import textwrap
+from pathlib import Path
+
+from agent_runner import agent_runtime
+
+
+def _fake_agent(tmp_path: Path) -> Path:
+    # Echoes its own argv and whatever it reads from stdin, into stdout.
+    p = tmp_path / "fake_agent.py"
+    p.write_text(
+        textwrap.dedent("""
+        import sys
+        sys.stdout.write("ARGV:" + "\\x1f".join(sys.argv) + "\\n")
+        sys.stdout.write("STDIN:" + sys.stdin.read() + "\\n")
+    """)
+    )
+    return p
+
+
+def test_stdin_mode_keeps_prompt_out_of_argv(tmp_path):
+    fake = _fake_agent(tmp_path)
+    log_path = tmp_path / "round.log"
+    marker = "PYTEST_MARKER_TOKEN_XYZ"
+    res = agent_runtime.run(
+        command=[sys.executable, str(fake)],
+        prompt_arg_template=["-p"],
+        prompt=f"do the thing {marker}",
+        prompt_delivery="stdin",
+        timeout_s=15,
+        log_path=log_path,
+        env_extra={},
+    )
+    out = log_path.read_text()
+    assert res.exit_code == 0
+    argv_line = next(line for line in out.splitlines() if line.startswith("ARGV:"))
+    stdin_line = next(line for line in out.splitlines() if line.startswith("STDIN:"))
+    assert marker not in argv_line  # prompt NOT in argv
+    assert marker in stdin_line  # prompt received on stdin
+
+
+def test_argv_mode_unchanged(tmp_path):
+    fake = _fake_agent(tmp_path)
+    log_path = tmp_path / "round.log"
+    marker = "ARGV_MARKER_TOKEN"
+    agent_runtime.run(
+        command=[sys.executable, str(fake)],
+        prompt_arg_template=["-p", "{prompt}"],
+        prompt=f"hello {marker}",
+        prompt_delivery="argv",
+        timeout_s=15,
+        log_path=log_path,
+        env_extra={},
+    )
+    argv_line = next(line for line in log_path.read_text().splitlines() if line.startswith("ARGV:"))
+    assert marker in argv_line  # default argv behavior intact
+
+
+def test_stdin_mode_delivers_large_prompt_without_hanging(tmp_path):
+    # Prompt exceeds the OS pipe buffer (~64KB); if the write were still
+    # blocking on the main thread before the poll loop, an agent that reads
+    # stdin only after some delay (or a full-pipe write) could hang run()
+    # with no timeout_s protection. The write now happens on a daemon
+    # thread, so run() reaches the poll loop immediately regardless.
+    fake = _fake_agent(tmp_path)
+    log_path = tmp_path / "round.log"
+    marker = "LARGE_PROMPT_MARKER"
+    big_prompt = "x" * 100_000 + marker
+    res = agent_runtime.run(
+        command=[sys.executable, str(fake)],
+        prompt_arg_template=["-p"],
+        prompt=big_prompt,
+        prompt_delivery="stdin",
+        timeout_s=15,
+        log_path=log_path,
+        env_extra={},
+    )
+    assert res.exit_code == 0
+    assert not res.timed_out
+    stdin_line = next(
+        line for line in log_path.read_text().splitlines() if line.startswith("STDIN:")
+    )
+    assert marker in stdin_line  # fully delivered despite exceeding pipe buffer
+
+
+def test_stdin_mode_guards_against_prompt_in_argv_template(tmp_path):
+    # Config validation already rejects {prompt} in the template for stdin
+    # mode, but run() itself must never substitute {prompt} into argv in
+    # stdin mode, even if called directly with a mismatched template.
+    fake = _fake_agent(tmp_path)
+    log_path = tmp_path / "round.log"
+    marker = "SECRET_MARKER"
+    agent_runtime.run(
+        command=[sys.executable, str(fake)],
+        prompt_arg_template=["-p", "{prompt}"],
+        prompt=marker,
+        prompt_delivery="stdin",
+        timeout_s=15,
+        log_path=log_path,
+        env_extra={},
+    )
+    argv_line = next(line for line in log_path.read_text().splitlines() if line.startswith("ARGV:"))
+    assert marker not in argv_line  # runtime guard holds even with a bad template

cli_agent_runner-0.2.1/tests/unit/test_agent_runtime_signal_name.py

@@ -0,0 +1,21 @@
+from agent_runner.agent_runtime import signal_name
+
+
+def test_negative_form_is_signal():
+    assert signal_name(-15) == "SIGTERM"
+    assert signal_name(-9) == "SIGKILL"
+
+
+def test_shell_128_plus_n_form_is_signal():
+    assert signal_name(143) == "SIGTERM"
+    assert signal_name(137) == "SIGKILL"
+
+
+def test_clean_and_plain_error_are_not_signals():
+    assert signal_name(0) is None
+    assert signal_name(1) is None
+
+
+def test_high_nonsignal_exit_is_not_a_signal_and_does_not_crash():
+    # 200 -> 72 is not a valid signal number; must return None, not raise.
+    assert signal_name(200) is None

cli_agent_runner-0.2.1/tests/unit/test_config_prompt_delivery.py

@@ -0,0 +1,33 @@
+import pytest
+
+from agent_runner.config import load_config
+from tests._test_helpers import write_min_config
+
+
+def _cfg(tmp_path, agent_extra):
+    return write_min_config(tmp_path, agent_extra=agent_extra)
+
+
+def test_default_is_argv(tmp_path):
+    cfg = load_config(_cfg(tmp_path, agent_extra=""))
+    assert cfg.agent.prompt_delivery == "argv"
+
+
+def test_stdin_accepted_when_template_has_no_prompt(tmp_path):
+    cfg = load_config(_cfg(tmp_path, 'prompt_delivery = "stdin"\nprompt_arg_template = ["-p"]\n'))
+    assert cfg.agent.prompt_delivery == "stdin"
+
+
+def test_stdin_with_prompt_token_rejected(tmp_path):
+    with pytest.raises(ValueError, match="stdin"):
+        load_config(
+            _cfg(
+                tmp_path,
+                'prompt_delivery = "stdin"\nprompt_arg_template = ["-p", "{prompt}"]\n',
+            )
+        )
+
+
+def test_invalid_value_rejected(tmp_path):
+    with pytest.raises(ValueError):
+        load_config(_cfg(tmp_path, 'prompt_delivery = "file"\n'))

cli_agent_runner-0.2.1/tests/unit/test_exit_cause.py

@@ -0,0 +1,15 @@
+from agent_runner.agent_runtime import RunResult
+from agent_runner.runner import _exit_cause  # small pure helper we add
+
+
+def _rr(exit_code, timed_out=False):
+    return RunResult(exit_code=exit_code, duration_s=1.0, timed_out=timed_out, pid=1)
+
+
+def test_exit_cause_mapping():
+    assert _exit_cause(_rr(0)) == "clean"
+    assert _exit_cause(_rr(1)) == "error"
+    assert _exit_cause(_rr(143)) == "signal:SIGTERM"
+    assert _exit_cause(_rr(-15)) == "signal:SIGTERM"
+    # timeout wins even though agent-runner signal-killed it to enforce the timeout
+    assert _exit_cause(_rr(-15, timed_out=True)) == "timeout"

cli_agent_runner-0.2.1/tests/unit/test_network_blip_signal_guard.py

@@ -0,0 +1,47 @@
+from agent_runner.agent_runtime import RunResult
+from agent_runner.runner import _scan_round_log_for_network_blip
+from tests._test_helpers import read_events_for_current_month  # existing helper
+
+# NOTE: "temporary failure in name resolution" does NOT match NETWORK_PATTERNS
+# in agent_runner/monitor.py (verified) — the regex has no "resolution"/"failure"
+# alternative. "DNS lookup failed" does match via the bare "dns" alternative, so
+# it is used here to keep the RED/GREEN honest.
+DNS_LOG_LINE = "... DNS lookup failed ...\n"
+
+
+def _blip_kinds(log_dir):
+    try:
+        events = read_events_for_current_month(log_dir)
+    except FileNotFoundError:
+        return []
+    return [e.get("event") for e in events]
+
+
+def test_signal_death_with_network_string_is_not_a_blip(tmp_path):
+    log_dir = tmp_path / "logs"
+    log_dir.mkdir()
+    log_path = tmp_path / "round.log"
+    log_path.write_text(DNS_LOG_LINE)
+    _scan_round_log_for_network_blip(
+        log_dir=log_dir,
+        log_path=log_path,
+        result=RunResult(exit_code=143, duration_s=1.0, timed_out=False, pid=1),
+        round_num=1,
+        phase=None,
+    )
+    assert "agent_network_blip" not in _blip_kinds(log_dir)
+
+
+def test_plain_error_with_network_string_still_blips(tmp_path):
+    log_dir = tmp_path / "logs"
+    log_dir.mkdir()
+    log_path = tmp_path / "round.log"
+    log_path.write_text(DNS_LOG_LINE)
+    _scan_round_log_for_network_blip(
+        log_dir=log_dir,
+        log_path=log_path,
+        result=RunResult(exit_code=1, duration_s=1.0, timed_out=False, pid=1),
+        round_num=1,
+        phase=None,
+    )
+    assert "agent_network_blip" in _blip_kinds(log_dir)

{cli_agent_runner-0.2.0 → cli_agent_runner-0.2.1}/tests/unit/test_presets.py

@@ -48,12 +48,28 @@ def test_given_preset_when_substituted_and_parsed_then_valid_toml(name: str) ->
 
 @pytest.mark.parametrize("name", PRESET_NAMES)
 def test_given_preset_when_parsed_then_prompt_arg_template_contains_prompt(name: str) -> None:
+    """argv-delivery presets must place {prompt} in the template; stdin-delivery
+    presets (e.g. claude) deliberately omit it — the prompt travels on stdin
+    instead, so it never lands in process argv."""
     text = _preset_text(name).replace("{project}", "test-project")
     parsed = tomllib.loads(text)
     template = parsed["agent"]["prompt_arg_template"]
-    assert any("{prompt}" in arg for arg in template), (
-        f"{name}.toml: prompt_arg_template lacks {{prompt}}"
-    )
+    if parsed["agent"].get("prompt_delivery", "argv") == "stdin":
+        assert not any("{prompt}" in arg for arg in template), (
+            f"{name}.toml: stdin delivery but prompt_arg_template still has {{prompt}}"
+        )
+    else:
+        assert any("{prompt}" in arg for arg in template), (
+            f"{name}.toml: prompt_arg_template lacks {{prompt}}"
+        )
+
+
+def test_given_claude_preset_when_parsed_then_uses_stdin_delivery() -> None:
+    """claude preset opts into stdin prompt delivery: -p with no {prompt} arg."""
+    text = _preset_text("claude").replace("{project}", "test-project")
+    parsed = tomllib.loads(text)
+    assert parsed["agent"]["prompt_arg_template"] == ["-p"]
+    assert parsed["agent"]["prompt_delivery"] == "stdin"
 
 
 def test_given_claude_preset_when_parsed_then_includes_disable_autoupdater() -> None: