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

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

@@ -5,6 +5,26 @@ 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
+- Dirty-tree handling is now pluggable. The clean-exit-dirty policy moved out of core into a `dirty_handler` hook; `stash` / `ignore` / `auto_commit` now ship as the bundled, default-on `default_dirty_handler` plugin. **No behavior or config change for existing users** — `[vcs] dirty_action` works exactly as before.
+
+### Added
+- `dirty_handler` plugin seam (4th lifecycle hook) + `DirtyOutcome` on `RoundResult`; `stash_orphan` / `try_auto_commit` are now public `api` primitives. Consumers can fully own dirty-tree policy — see `docs/migrations/0.2.0.md`.
+- `dirty_auto_committed` event (emitted when a handler auto-commits).
+
 ## [0.1.42] - 2026-06-25
 
 ### Added
@@ -866,7 +886,8 @@ Initial public release on PyPI as `cli-agent-runner`.
 - Tag-triggered release publishing to PyPI via Trusted Publishing OIDC,
   gated by a manual approval on the `pypi` GitHub environment.
 
-[Unreleased]: https://github.com/wan9yu/cli-agent-runner/compare/v0.1.26...HEAD
+[Unreleased]: https://github.com/wan9yu/cli-agent-runner/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/wan9yu/cli-agent-runner/compare/v0.1.42...v0.2.0
 [0.1.26]: https://github.com/wan9yu/cli-agent-runner/compare/v0.1.25...v0.1.26
 [0.1.25]: https://github.com/wan9yu/cli-agent-runner/compare/v0.1.24...v0.1.25
 [0.1.24]: https://github.com/wan9yu/cli-agent-runner/compare/v0.1.23...v0.1.24

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-agent-runner
-Version: 0.1.42
+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
@@ -109,7 +109,7 @@ Full list and rationale: [`docs/architecture.md`](docs/architecture.md).
 ## Monitor: 11 detectors
 
 Notify only: `timeout_rate`, `hung`, `orphan_chain`, `disk_warning`,
-`mem_pressure`, `smoke_fail_rate`, `network_fail`, `rate_limit_active`,
+`mem_pressure`, `network_fail`, `rate_limit_active`,
 `anomaly_repetitive_active`, `supervisor_stale`.
 
 **Auto-stop the service** (continuing is harmful):

{cli_agent_runner-0.1.42 → cli_agent_runner-0.2.1}/README.md

@@ -72,7 +72,7 @@ Full list and rationale: [`docs/architecture.md`](docs/architecture.md).
 ## Monitor: 11 detectors
 
 Notify only: `timeout_rate`, `hung`, `orphan_chain`, `disk_warning`,
-`mem_pressure`, `smoke_fail_rate`, `network_fail`, `rate_limit_active`,
+`mem_pressure`, `network_fail`, `rate_limit_active`,
 `anomaly_repetitive_active`, `supervisor_stale`.
 
 **Auto-stop the service** (continuing is harmful):

{cli_agent_runner-0.1.42 → cli_agent_runner-0.2.1}/README.zh.md

@@ -99,7 +99,7 @@ agent-runner monitor              # 实时异常检测，OAuth/磁盘 critical
 
 **只告警**（warning 级，服务继续跑）：
 `timeout_rate` / `hung` / `orphan_chain` / `disk_warning` /
-`mem_pressure` / `smoke_fail_rate` / `network_fail` / `rate_limit_active` /
+`mem_pressure` / `network_fail` / `rate_limit_active` /
 `anomaly_repetitive_active` / `supervisor_stale`
 
 **自动停服**（critical 级，继续是 net negative）：

{cli_agent_runner-0.1.42 → cli_agent_runner-0.2.1}/agent_runner/__init__.py

@@ -14,6 +14,7 @@ _HOOK_GROUPS = (
     "agent_runner.context_enrichers",
     "agent_runner.post_round_hooks",
     "agent_runner.serve_startup_hooks",
+    "agent_runner.dirty_handler_hooks",
 )
 
 # Tracks the names passed to the most recent ``apply_plugin_disable`` call.
@@ -111,6 +112,9 @@ def apply_plugin_disable(names: list[str]) -> None:
     # Serve-startup hooks
     _prune_by_name(hooks._SERVE_STARTUP_HOOKS, desired, found)
 
+    # Dirty handlers
+    _prune_by_name(hooks._DIRTY_HANDLERS, desired, found)
+
     # Plugin event kinds
     for name in list(events._PLUGIN_KINDS):
         if name in desired:

{cli_agent_runner-0.1.42 → 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.1.42'
-__version_tuple__ = version_tuple = (0, 1, 42)
+__version__ = version = '0.2.1'
+__version_tuple__ = version_tuple = (0, 2, 1)
 
 __commit_id__ = commit_id = None

{cli_agent_runner-0.1.42 → 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.1.42 → cli_agent_runner-0.2.1}/agent_runner/api.py

@@ -799,6 +799,12 @@ from agent_runner._emit import (  # noqa: E402,F401 — intentional bottom re-ex
     emit_transient_error_recovered,
 )
 
+# Re-export git primitives so external callers can reach them via the api facade.
+from agent_runner.vcs_state import (  # noqa: E402,F401 — public primitives
+    stash_orphan,
+    try_auto_commit,
+)
+
 
 def narrate_events(log_dir: Path, *, poll_interval_s: float = 0.5) -> Iterator[str]:
     """Tail events-*.jsonl files in log_dir, yielding one formatted line per event.

{cli_agent_runner-0.1.42 → cli_agent_runner-0.2.1}/agent_runner/api_types.py

@@ -28,6 +28,18 @@ class ServiceMode(StrEnum):
     NONE = "none"
 
 
+@dataclass(frozen=True)
+class DirtyOutcome:
+    """What a dirty tree resolved to, reported on RoundResult and via events.
+
+    ``ref`` is the stash SHA (kind="stashed") or commit SHA (kind="committed");
+    None for "ignored".
+    """
+
+    kind: Literal["stashed", "committed", "ignored"]
+    ref: str | None = None
+
+
 @dataclass(frozen=True)
 class RateLimitState:
     """Public: surfaced via peek --json when supervisor is currently throttled."""
@@ -158,6 +170,7 @@ class RoundResult:
     log_path: Path
     dirty_files: list[str]
     stashed: bool
+    dirty_outcome: DirtyOutcome | None = None
     killed_for_grace: bool = False
 
 

cli_agent_runner-0.2.1/agent_runner/builtin_plugins/default_dirty_handler.py

@@ -0,0 +1,83 @@
+"""Bundled default dirty-tree handler — reproduces the pre-0.2.0 built-in
+behavior (stash / ignore / auto_commit per [vcs] dirty_action) as a plugin.
+Ships enabled; disable via [plugins] disable = ["default_dirty_handler"]."""
+
+from __future__ import annotations
+
+from agent_runner import api, context_store, events, vcs_state
+from agent_runner.api_types import DirtyOutcome
+from agent_runner.events import now_iso_ms  # match the helper runner.py uses
+from agent_runner.hooks import HookContext, register_dirty_handler
+from agent_runner.vcs_state import AutoCommitError
+
+
+class DefaultDirtyHandler:
+    name = "default_dirty_handler"
+    priority = 1000  # last-resort fallback
+
+    def handle_dirty(self, ctx: HookContext, dirty_files) -> DirtyOutcome | None:
+        action = ctx.vcs.dirty_action if ctx.vcs else "stash"
+        if action == "ignore":
+            return DirtyOutcome(kind="ignored")
+        if action == "auto_commit":
+            try:
+                sha = api.try_auto_commit(
+                    ctx.work_dir, ctx.round_num, ctx.phase, log_dir=ctx.log_dir
+                )
+            except AutoCommitError as exc:
+                # Parity with runner.py: emit failure event, leave tree dirty
+                # (no stash fallback). Dirty tree carries into the next round.
+                events.emit(
+                    ctx.log_dir,
+                    events.DIRTY_COMMIT_FAILED,
+                    round_num=ctx.round_num,
+                    phase=ctx.phase,
+                    reason=str(exc),
+                )
+                return DirtyOutcome(kind="ignored")
+            if not sha:
+                return DirtyOutcome(kind="ignored")
+            events.emit(
+                ctx.log_dir,
+                events.DIRTY_AUTO_COMMITTED,
+                round_num=ctx.round_num,
+                files=dirty_files[:20],
+                ref=sha,
+            )
+            return DirtyOutcome(kind="committed", ref=sha)
+        return self._stash(ctx, dirty_files)
+
+    def _stash(self, ctx: HookContext, dirty_files) -> DirtyOutcome:
+        # via vcs_state (not api): test_runner.py monkeypatches vcs_state.stash_orphan;
+        # the api re-export is a separate binding a patch wouldn't intercept.
+        ref = vcs_state.stash_orphan(
+            ctx.work_dir,
+            round_num=ctx.round_num,
+            phase=ctx.phase,
+            idempotency_s=ctx.vcs.stash_idempotency_s if ctx.vcs else 5,
+            log_dir=ctx.log_dir,
+        )
+        if ref is None:
+            return DirtyOutcome(kind="ignored")
+        context_store.write_orphan_state(
+            ctx.log_dir,
+            context_store.OrphanState(
+                round_num=ctx.round_num,
+                files=dirty_files,
+                stashed_ref=ref.sha,
+                stash_message=ref.message,
+                timestamp=now_iso_ms(),
+                phase=ctx.phase,
+            ),
+        )
+        events.emit(
+            ctx.log_dir,
+            events.ORPHAN_STASHED,
+            round_num=ctx.round_num,
+            ref=ref.sha,
+            reason="clean_exit_with_dirty_tree",
+        )
+        return DirtyOutcome(kind="stashed", ref=ref.sha)
+
+
+register_dirty_handler(DefaultDirtyHandler())

{cli_agent_runner-0.1.42 → 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.1.42 → cli_agent_runner-0.2.1}/agent_runner/events.py

@@ -34,6 +34,7 @@ AGENT_SPAWN = "agent_spawn"
 AGENT_USAGE_RECORDED = "agent_usage_recorded"
 CONFIG_BROKEN = "config_broken"
 CRASH_LOOP = "crash_loop"
+DIRTY_AUTO_COMMITTED = "dirty_auto_committed"
 DIRTY_COMMIT_FAILED = "dirty_commit_failed"
 DIRTY_DETECTED = "dirty_detected"
 FRESH_EYES_ROUND_TRIGGERED = "fresh_eyes_round_triggered"

{cli_agent_runner-0.1.42 → cli_agent_runner-0.2.1}/agent_runner/hooks.py

@@ -30,6 +30,7 @@ Public API:
 from __future__ import annotations
 
 import sys
+import traceback as tb_mod
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Protocol, runtime_checkable
@@ -43,6 +44,14 @@ _TAIL_BYTES = 1024
 _TRUNC_MARKER = "\n... [truncated] ...\n"
 
 
+@dataclass(frozen=True)
+class VcsHookView:
+    """Minimal vcs config a dirty handler needs (keeps HookContext narrow)."""
+
+    dirty_action: str
+    stash_idempotency_s: int
+
+
 @dataclass(frozen=True)
 class HookContext:
     """Narrow per-round context passed to all hook callbacks.
@@ -86,6 +95,26 @@ class HookContext:
     """Count threshold for repetitive-tool anomaly (0 = disabled).
     Populated from ``[monitor] anomaly_repetitive_threshold`` (0.1.31+).
     """
+    vcs: VcsHookView | None = None
+    """Narrowed vcs config slice populated by the runner for all per-round hooks
+    (pre-round, enrichers, post-round, dirty-handler) (0.2.0+).
+    May be None only when a HookContext is constructed without it (e.g. tests).
+    """
+
+
+@runtime_checkable
+class DirtyHandler(Protocol):
+    """Resolves a clean-exit dirty tree. Runs ascending by ``priority``; the
+    first to return a DirtyOutcome wins. Return None to pass to the next."""
+
+    name: str
+    priority: int
+
+    def handle_dirty(
+        self,
+        ctx: HookContext,
+        dirty_files: list[str],
+    ) -> Any | None: ...
 
 
 @runtime_checkable
@@ -148,6 +177,7 @@ _PRE_ROUND_HOOKS: list[PreRoundHook] = []
 _CONTEXT_ENRICHERS: list[ContextEnricher] = []
 _POST_ROUND_HOOKS: list[PostRoundHook] = []
 _SERVE_STARTUP_HOOKS: list[ServeStartupHook] = []
+_DIRTY_HANDLERS: list[DirtyHandler] = []
 
 
 def register_pre_round_hook(hook: PreRoundHook) -> None:
@@ -191,6 +221,43 @@ def plugin_context_enrichers() -> list[str]:
     return sorted(e.name for e in _CONTEXT_ENRICHERS)
 
 
+def register_dirty_handler(handler: DirtyHandler) -> None:
+    ensure_unique(handler.name, _DIRTY_HANDLERS, "dirty_handler")
+    _DIRTY_HANDLERS.append(handler)
+
+
+def dirty_handlers() -> list[DirtyHandler]:
+    return list(_DIRTY_HANDLERS)
+
+
+def dispatch_dirty(
+    ctx: HookContext,
+    dirty_files: list[str],
+    log_dir: Path,
+) -> Any | None:
+    """Run registered DirtyHandlers ascending by priority; first non-None wins.
+
+    A handler that raises is isolated — emits ``hook_failed`` with
+    ``hook_kind="dirty_handler"`` and treated as pass (continue to next).
+    """
+    ordered = sorted(_DIRTY_HANDLERS, key=lambda h: getattr(h, "priority", 0))
+    for h in ordered:
+        try:
+            outcome = h.handle_dirty(ctx, dirty_files)
+        except Exception as exc:  # noqa: BLE001 — isolate; fall through to next
+            events.emit(
+                log_dir,
+                events.HOOK_FAILED,
+                hook_name=h.name,
+                hook_kind="dirty_handler",
+                **_summarize_error(exc, tb=tb_mod.format_exc()),
+            )
+            continue
+        if outcome is not None:
+            return outcome
+    return None
+
+
 def run_serve_startup_hooks(cfg: Any, log_dir: Path) -> bool:
     """Run all serve_startup_hooks. Returns True on success, False on abort.
 

{cli_agent_runner-0.1.42 → 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.1.42 → 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:
@@ -423,6 +440,10 @@ def _run_one_round_inner(cfg: Config, *, phase_override: str | None = None) -> R
         dry_run=cfg.runtime.dry_run,
         anomaly_repetitive_window=cfg.monitor.anomaly_repetitive_window,
         anomaly_repetitive_threshold=cfg.monitor.anomaly_repetitive_threshold,
+        vcs=hooks.VcsHookView(
+            dirty_action=cfg.vcs.dirty_action,
+            stash_idempotency_s=cfg.vcs.stash_idempotency_s,
+        ),
     )
     _run_pre_round_hooks(
         hook_ctx,
@@ -482,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)},
@@ -498,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(
@@ -512,54 +535,12 @@ def _run_one_round_inner(cfg: Config, *, phase_override: str | None = None) -> R
     if dirty:
         events.emit(log_dir, "dirty_detected", round_num=round_num, files=dirty[:20])
 
-    stashed = False
-    action = cfg.vcs.dirty_action
+    dirty_outcome = None
     if dirty and not result.timed_out and result.exit_code == 0:
-        if action == "stash":
-            ref = vcs_state.stash_orphan(
-                cfg.runtime.work_dir,
-                round_num=round_num,
-                phase=phase,
-                idempotency_s=cfg.vcs.stash_idempotency_s,
-                log_dir=cfg.runtime.log_dir,
-            )
-            if ref is not None:
-                context_store.write_orphan_state(
-                    log_dir,
-                    context_store.OrphanState(
-                        round_num=round_num,
-                        files=dirty,
-                        stashed_ref=ref.sha,
-                        stash_message=ref.message,
-                        timestamp=now_iso_ms(),
-                        phase=phase,
-                    ),
-                )
-                events.emit(
-                    log_dir,
-                    "orphan_stashed",
-                    round_num=round_num,
-                    ref=ref.sha,
-                    reason="clean_exit_with_dirty_tree",
-                )
-                stashed = True
-        elif action == "ignore":
-            # Leave tree dirty for next round; dirty_detected already emitted
-            pass
-        elif action == "auto_commit":
-            err = vcs_state.try_auto_commit(
-                cfg.runtime.work_dir, round_num, phase, log_dir=cfg.runtime.log_dir
-            )
-            if err is not None:
-                events.emit(
-                    log_dir,
-                    events.DIRTY_COMMIT_FAILED,
-                    round_num=round_num,
-                    phase=phase,
-                    reason=err,
-                )
+        dirty_outcome = hooks.dispatch_dirty(hook_ctx, dirty, log_dir=log_dir)
     elif not dirty:
         context_store.clear_orphan_state(log_dir)
+    stashed = bool(dirty_outcome and dirty_outcome.kind == "stashed")
 
     if result.killed_for_grace:
         api.emit_round_grace_kill(
@@ -609,6 +590,7 @@ def _run_one_round_inner(cfg: Config, *, phase_override: str | None = None) -> R
         log_path=log_path,
         dirty_files=dirty,
         stashed=stashed,
+        dirty_outcome=dirty_outcome,
         killed_for_grace=result.killed_for_grace,
     )
     _run_post_round_hooks(hook_ctx, round_result, log_dir)

{cli_agent_runner-0.1.42 → cli_agent_runner-0.2.1}/agent_runner/vcs_state.py

@@ -72,6 +72,10 @@ def _matches_owned_path(path: str) -> bool:
     return False
 
 
+class AutoCommitError(RuntimeError):
+    """git add/commit failed during try_auto_commit (reason capped at 200 chars)."""
+
+
 @dataclass(frozen=True)
 class StashRef:
     sha: str  # full commit SHA — IMMUTABLE under concurrent stash
@@ -322,20 +326,13 @@ def try_auto_commit(
     phase: str | None,
     *,
     log_dir: Path | None = None,
-) -> str | None:
-    """Auto-commit dirty tree with hardcoded subject. Return None on success, error on failure.
-
-    Subject: ``agent-runner auto-commit: R<N> <phase>`` (phase part omitted if None).
-    Uses ``git -c commit.gpgsign=false`` to skip GPG; honors pre-commit hooks
-    (no ``--no-verify``). DOES NOT push — local commit only.
+) -> str:
+    """Auto-commit the dirty tree with a hardcoded subject; return the commit SHA.
 
-    ``log_dir`` (when under ``work_dir``) is excluded from the add so a zero-work
-    round that only churned the runner's own bookkeeping (lock/pid/event logs)
-    does not advance ``git_head``. The agent's work and ``.evolving/`` live
-    outside ``log_dir`` and are still committed. If nothing remains staged after
-    the exclusion, this is a no-op (returns None, leaves HEAD untouched).
-
-    Callers (runner.py) emit ``dirty_commit_failed`` event when return value is not None.
+    Returns "" when nothing remained staged after excluding log_dir (no-op;
+    HEAD untouched). Raises AutoCommitError on git failure. DOES NOT push.
+    Subject: ``agent-runner auto-commit: R<N> <phase>``. Uses
+    ``git -c commit.gpgsign=false``; honors pre-commit hooks (no --no-verify).
     """
     phase_part = f" {phase}" if phase else ""
     subject = f"agent-runner auto-commit: R{round_num}{phase_part}"
@@ -343,13 +340,13 @@ def try_auto_commit(
     exclude = _log_dir_exclude_pathspec(work_dir, log_dir)
     add_result = _git(work_dir, "add", "-A", *exclude)
     if add_result.returncode != 0:
-        return (add_result.stderr or "git add failed")[:200]
+        raise AutoCommitError((add_result.stderr or "git add failed")[:200])
 
     # Only the exclusion can leave nothing staged (a zero-work round that churned
     # only log_dir); without it the tree was dirty so there is always something to
     # commit. Skip the extra git call on the common (no-exclusion) path.
     if exclude and _git(work_dir, "diff", "--cached", "--quiet").returncode == 0:
-        return None
+        return ""
 
     commit_result = _git(
         work_dir,
@@ -359,6 +356,7 @@ def try_auto_commit(
         pre_flags=("-c", "commit.gpgsign=false"),
     )
     if commit_result.returncode != 0:
-        return (commit_result.stderr or "git commit failed")[:200]
+        raise AutoCommitError((commit_result.stderr or "git commit failed")[:200])
 
-    return None
+    head = _git(work_dir, "rev-parse", "HEAD")
+    return head.stdout.strip()