cli-agent-runner 0.2.16__tar.gz → 0.2.17__tar.gz

{cli_agent_runner-0.2.16 → cli_agent_runner-0.2.17}/.vulture-whitelist.py

@@ -13,6 +13,13 @@ log_dir
 offsets
 buffer
 
+# agent_runner._throttle.RoundOutcome
+mem_terminated
+usage_capable
+newest_usage_ts
+newest_substrate_before_ts
+latest_transient_per_agent
+
 # agent_runner.agent_runtime.RunResult
 exit_code
 duration_s

{cli_agent_runner-0.2.16 → cli_agent_runner-0.2.17}/CHANGELOG.md

@@ -5,6 +5,18 @@ 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.17] - 2026-09-05
+
+### Changed
+- Internal refactor ("round-outcome unification"): per-round classification now does one events-tail scan per round (was up to three), the give-up decision is unified behind a single `post_round_verdicts` (precedence and exit codes `78`/`70`/`71`/`75` unchanged), and the `_serve_round`↔`serve_cmd` import cycle is removed. Behavior-preserving.
+- `round_mem_critical_sample` is now capped at `2 × mem_critical_consecutive_samples` emits per critical episode (any non-critical tick resets it), so a host stuck under sustained pressure no longer writes that calibration event unbounded for a whole round.
+
+### Fixed
+- Auto-stop no longer records `monitor_auto_stop_failed` for a stop that actually succeeds: under load a round can outlast the stop-confirmation window while draining, which was mis-reported as a failure. The monitor now recognizes a still-draining round and records the real outcome (triggered or failed) once it resolves on the next poll, instead of a false failure.
+
+### Notes
+- Not breaking: no `agent-runner migrate`, no systemd unit change, no new event kinds, `peek --json` schema unchanged. The only non-fix behavior change is the bounded `round_mem_critical_sample` above.
+
 ## [0.2.16] - 2026-09-05
 
 ### Added

{cli_agent_runner-0.2.16 → cli_agent_runner-0.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cli-agent-runner
-Version: 0.2.16
+Version: 0.2.17
 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.16 → cli_agent_runner-0.2.17}/agent_runner/_emit.py

@@ -296,18 +296,28 @@ def emit_round_mem_terminated(
 def emit_round_mem_critical_sample(
     log_dir: Path, *, round_num: int, consecutive: int, context: dict
 ) -> None:
-    """Emit on EACH critical host_health sample inside _spawn_round's mid-round
-    hard floor -- deliberately NOT deduped (unlike round_mem_terminated): the
-    point is calibration visibility into near-misses, so an operator watching
-    the event stream sees the critical_streak build (1, 2, ...) even on ticks
-    that never reach the terminate threshold (a healthy tick resets it before
-    3-in-a-row). ``context`` carries the same Pressure.context numbers as
+    """Emit on each critical host_health sample inside _spawn_round's mid-round
+    hard floor, up to the per-episode cap (0.2.17, below) -- unlike
+    round_mem_terminated (deduped to once-per-episode), this fires on every
+    critical tick within that cap: the point is calibration visibility into
+    near-misses, so an operator watching the event stream sees the
+    critical_streak build (1, 2, ...) even on ticks that never reach the
+    terminate threshold (a healthy tick resets it before 3-in-a-row).
+    ``context`` carries the same Pressure.context numbers as
     round_mem_terminated. Fires only during critical pressure -- never during
     warning/healthy -- so it adds no normal-operation noise, including while
     ``defer_to_cgroup`` steps back from terminating (the streak/context is
     still useful calibration there; this event stays scoped to the
     sample-level signal, distinct from mem_pressure_deferred_to_cgroup's
-    once-per-episode terminate-vs-defer notice)."""
+    once-per-episode terminate-vs-defer notice).
+
+    0.2.17: the caller caps this at ``2 * mem_critical_consecutive_samples``
+    consecutive ticks (1..6 at the default 3) -- a sustained-critical
+    don't-terminate run (cgroup-defer, or the off switch) would otherwise
+    write one event per ~10s tick for up to a whole ``round_timeout_s`` on a
+    permanently-deferred/off host. The cap is per streak-episode, not a
+    lifetime limit: any non-critical tick still resets the streak to 0, and
+    sampling resumes from 1 the next time critical pressure recurs."""
     from agent_runner.events import ROUND_MEM_CRITICAL_SAMPLE, emit
 
     emit(

{cli_agent_runner-0.2.16 → cli_agent_runner-0.2.17}/agent_runner/_serve_policy.py

@@ -157,6 +157,25 @@ def post_round_decision(
     return ("continue", delay, 0)
 
 
+def _consecutive_streak_decision(
+    *, triggered: bool, consecutive: int, threshold: int, verdict: str
+) -> tuple[str, int]:
+    """The generic give-up-cap shape both :func:`_mem_loop_decision` and
+    :func:`_no_progress_decision` delegate to (0.2.17 Task 2 — de-duplicated
+    out of the two, which were byte-identical apart from their reset
+    condition, threshold constant, and verdict string). A NEW, SEPARATE,
+    private counter from ``post_round_decision``'s crash-loop breaker, not a
+    widening of its 3-tuple contract. Returns ``(verdict, consecutive)`` once
+    ``consecutive`` reaches ``threshold``; a non-``triggered`` round resets the
+    counter to 0."""
+    if not triggered:
+        return ("continue", 0)
+    consecutive += 1
+    if consecutive >= threshold:
+        return (verdict, consecutive)
+    return ("continue", consecutive)
+
+
 def _mem_loop_decision(
     *, mem_terminated: bool, consecutive: int
 ) -> tuple[Literal["mem_loop", "continue"], int]:
@@ -168,12 +187,12 @@ def _mem_loop_decision(
     eventually giving up. Returns ``("mem_loop", consecutive)`` once
     ``consecutive`` reaches ``MEM_LOOP_THRESHOLD``; a non-mem-terminated round
     resets the counter to 0, same reset shape as the crash-loop breaker."""
-    if not mem_terminated:
-        return ("continue", 0)
-    consecutive += 1
-    if consecutive >= MEM_LOOP_THRESHOLD:
-        return ("mem_loop", consecutive)
-    return ("continue", consecutive)
+    return _consecutive_streak_decision(
+        triggered=mem_terminated,
+        consecutive=consecutive,
+        threshold=MEM_LOOP_THRESHOLD,
+        verdict="mem_loop",
+    )
 
 
 def _no_progress_decision(
@@ -190,12 +209,12 @@ def _no_progress_decision(
     via a different signal. A round WITH progress (usage recorded, non-zero
     exit, or slow) resets the counter to 0, same reset shape as
     crash-loop/mem-loop."""
-    if not no_progress:
-        return ("continue", 0)
-    consecutive += 1
-    if consecutive >= CRASH_LOOP_THRESHOLD:
-        return ("stalled_no_progress", consecutive)
-    return ("continue", consecutive)
+    return _consecutive_streak_decision(
+        triggered=no_progress,
+        consecutive=consecutive,
+        threshold=CRASH_LOOP_THRESHOLD,
+        verdict="stalled_no_progress",
+    )
 
 
 def classify_round_exit(exc: BaseException) -> int:
@@ -256,7 +275,7 @@ def classify_round_exit(exc: BaseException) -> int:
 _REAP_GRACE_S = 5
 _GIT_COMMIT_TIMEOUT_S = 120
 _HOOK_ALLOWANCE_S = 60  # slack for post-round hooks between the inner wall and the ceiling
-_ROUND_TERM_GRACE_S = 15  # mirrors api._ROUND_TERM_GRACE_S / serve_cmd._ROUND_TERM_GRACE_S
+_ROUND_TERM_GRACE_S = 15  # mirrors api._ROUND_TERM_GRACE_S / cli._serve_round._ROUND_TERM_GRACE_S
 _STOP_GRACE_MARGIN_S = 10  # pad above _ROUND_TERM_GRACE_S for systemd stop-request overhead
 
 

{cli_agent_runner-0.2.16 → cli_agent_runner-0.2.17}/agent_runner/_throttle.py

@@ -13,7 +13,8 @@ from __future__ import annotations
 import math
 import random
 import warnings
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass
 from datetime import UTC
 from pathlib import Path
 from typing import Any
@@ -41,7 +42,9 @@ __all__ = [
     "mem_loop_events_in_window",
     "pending_recovered",
     "round_had_no_progress",
+    "round_outcome",
     "round_was_mem_terminated",
+    "RoundOutcome",  # trailing: class, not function -- kept with its round_outcome() sibling above
 ]
 
 # _scan_events_for_transient sentinel: file held no transient event at all
@@ -107,6 +110,21 @@ def _iter_events(path: Path):
     return iter_event_dicts(path)
 
 
+def _tail_events(log_dir: Path) -> Iterator[dict[str, Any]]:
+    """The ONE events-tail scan every per-round / per-agent / global-latest
+    reader below builds on: the newest TWO monthly ``events-*.jsonl`` files
+    (oldest-first), each read forward. 0.2.17 Task 1 consolidated 5 copies of
+    this exact ``sorted(log_dir.glob(...))[-2:]`` loop into this single
+    generator so a refactor of the tail-selection logic (e.g. widening the
+    window) touches one place, not five.
+
+    Forward, OLD-then-NEW order matters (INVARIANT 2 for callers that merge a
+    per-key "latest wins" map: iterating oldest file first means a later event
+    for the same key naturally overwrites an earlier one)."""
+    for path in sorted(log_dir.glob("events-*.jsonl"))[-2:]:
+        yield from _iter_events(path)
+
+
 def _scan_events_for_transient(path: Path):
     """The file's LAST transient event: the detected dict, ``None`` (latest was a
     recovered), or ``_NO_TRANSIENT`` (no transient event in the file).
@@ -152,13 +170,15 @@ def _latest_transient_per_agent(log_dir: Path) -> dict[str, Any]:
     agent A in the old file must not be masked by agent B's event in the newer one.
     Iterates old-then-new so the newest event per agent wins."""
     latest: dict[str, Any] = {}
-    for path in sorted(log_dir.glob("events-*.jsonl"))[-2:]:
-        for ev in _iter_events(path):
-            kind = ev.get("event")
-            if kind == TRANSIENT_ERROR_DETECTED:
-                latest[str(ev.get("agent", "unknown"))] = ev
-            elif kind == TRANSIENT_ERROR_RECOVERED:
-                latest[str(ev.get("agent", "unknown"))] = None
+    for ev in _tail_events(log_dir):
+        kind = ev.get("event")
+        # INVARIANT 2: keyed by str(agent), forward old->new merge (_tail_events
+        # yields the newest-two-files tail oldest-first) — newest event per agent
+        # wins, matching every other latest_transient_per_agent copy pre-0.2.17.
+        if kind == TRANSIENT_ERROR_DETECTED:
+            latest[str(ev.get("agent", "unknown"))] = ev
+        elif kind == TRANSIENT_ERROR_RECOVERED:
+            latest[str(ev.get("agent", "unknown"))] = None
     return latest
 
 
@@ -174,15 +194,14 @@ def _backoff_exponent(log_dir: Path, agent: str) -> int:
     deliberately NOT a reset point — the throttle-aware-skip path emits one every
     cycle, which would pin the exponent at <=1 and flatten the ladder."""
     count = 0
-    for path in sorted(log_dir.glob("events-*.jsonl"))[-2:]:
-        for ev in _iter_events(path):
-            if str(ev.get("agent", "")) != agent:
-                continue
-            kind = ev.get("event")
-            if kind == TRANSIENT_ERROR_DETECTED:
-                count += 1
-            elif kind == AGENT_USAGE_RECORDED and ev.get("success"):
-                count = 0
+    for ev in _tail_events(log_dir):
+        if str(ev.get("agent", "")) != agent:
+            continue
+        kind = ev.get("event")
+        if kind == TRANSIENT_ERROR_DETECTED:
+            count += 1
+        elif kind == AGENT_USAGE_RECORDED and ev.get("success"):
+            count = 0
     return max(0, count - 1)
 
 
@@ -240,7 +259,11 @@ def _events_derived_reset(
 
 
 def _active_throttles(
-    log_dir: Path, *, clock: Clock = SYSTEM_CLOCK, _exponent_cache: dict[str, int] | None = None
+    log_dir: Path,
+    *,
+    clock: Clock = SYSTEM_CLOCK,
+    _exponent_cache: dict[str, int] | None = None,
+    _latest: dict[str, Any] | None = None,
 ) -> dict[str, TransientErrorState]:
     """Currently-active throttles keyed by AGENT label (binary basename), one entry
     per agent whose latest transient event is an unrecovered ``detected`` with its
@@ -251,10 +274,16 @@ def _active_throttles(
     healthy agent's phase keeps running. Restart-safe (events-derived). The effective
     reset applies the events-derived exp-backoff ladder (:func:`_events_derived_reset`)
     so a permanently-failing agent escalates here too, not just on the wait/back_off
-    path — ONE ladder, shared by both regimes."""
+    path — ONE ladder, shared by both regimes.
+
+    ``_latest``, when given, is an already-computed :func:`_latest_transient_per_agent`
+    map (e.g. :attr:`RoundOutcome.latest_transient_per_agent`) — skips a fresh
+    events-tail scan here, the same memoization idea as ``_exponent_cache``. Omitted,
+    it is computed fresh (unchanged pre-0.2.17 behavior)."""
     now = clock.epoch()
     active: dict[str, TransientErrorState] = {}
-    for agent, detected in _latest_transient_per_agent(log_dir).items():
+    latest = _latest if _latest is not None else _latest_transient_per_agent(log_dir)
+    for agent, detected in latest.items():
         if detected is None:
             continue
         classification = str(detected.get("classification", "rate_limit_account"))
@@ -277,7 +306,79 @@ def _active_throttles(
     return active
 
 
-def round_was_mem_terminated(log_dir: Path) -> bool:
+@dataclass(frozen=True)
+class RoundOutcome:
+    """Every PER-ROUND-scoped verdict :func:`round_was_mem_terminated` and
+    :func:`round_had_no_progress` need, folded from ONE :func:`_tail_events`
+    scan (0.2.17 Task 1) instead of the pre-0.2.17 three separate ones (those
+    two functions' own scans, plus the throttle check's
+    :func:`_latest_transient_per_agent` scan serve_cmd ran back-to-back with
+    them every round).
+
+    Deliberately does NOT include :func:`mem_loop_events_in_window` (give-up-only,
+    needs its own clock cutoff — a different axis than "this round") or
+    :func:`_backoff_exponent` (agent-scoped, keyed by a caller-supplied agent, not
+    "the round that just ran") — both stay on :func:`_tail_events` directly."""
+
+    mem_terminated: bool
+    usage_capable: bool
+    newest_usage_ts: str | None
+    newest_substrate_before_ts: str | None
+    latest_transient_per_agent: dict[str, Any]
+
+
+def round_outcome(log_dir: Path) -> RoundOutcome:
+    """Single-pass fold over :func:`_tail_events` computing :class:`RoundOutcome`.
+    Callers: :func:`round_was_mem_terminated`, :func:`round_had_no_progress` (each
+    accepts a precomputed ``outcome=`` to skip re-scanning), and
+    ``serve_cmd.cmd()``'s post-round block, which computes this ONCE per round
+    (INVARIANT 3) and reuses it for the mem-terminated / throttle / no-progress
+    checks that used to scan separately."""
+    newest_before_ts: str | None = None
+    newest_terminated_ts: str | None = None
+    newest_usage_ts: str | None = None
+    usage_capable = False
+    transient: dict[str, Any] = {}
+    for ev in _tail_events(log_dir):
+        kind = ev.get("event")
+        # INVARIANT 2: latest_transient_per_agent keys by str(agent), no ts guard,
+        # forward old->new merge (_tail_events yields oldest-file-first) — identical
+        # to the pre-0.2.17 _latest_transient_per_agent copy this replaces.
+        if kind == TRANSIENT_ERROR_DETECTED:
+            transient[str(ev.get("agent", "unknown"))] = ev
+        elif kind == TRANSIENT_ERROR_RECOVERED:
+            transient[str(ev.get("agent", "unknown"))] = None
+        # INVARIANT 1: usage_capable set UNCONDITIONALLY here, on the raw kind check,
+        # BEFORE the `ts` guard below — matches the pre-refactor round_had_no_progress
+        # (usage_capable must arm even off a ts-less agent_usage_recorded event).
+        if kind == AGENT_USAGE_RECORDED:
+            usage_capable = True
+        ts = ev.get("ts")
+        if not ts:
+            continue
+        if kind == ROUND_SUBSTRATE_BEFORE:
+            newest_before_ts = ts
+        elif kind == ROUND_MEM_TERMINATED:
+            newest_terminated_ts = ts
+        elif kind == AGENT_USAGE_RECORDED:
+            newest_usage_ts = ts
+    # round_was_mem_terminated's own scoping logic (see its docstring): >=, not >,
+    # since a fast loop can legitimately stamp both events in the same millisecond.
+    mem_terminated = (
+        newest_before_ts is not None
+        and newest_terminated_ts is not None
+        and parse_iso_ms(newest_terminated_ts) >= parse_iso_ms(newest_before_ts)
+    )
+    return RoundOutcome(
+        mem_terminated=mem_terminated,
+        usage_capable=usage_capable,
+        newest_usage_ts=newest_usage_ts,
+        newest_substrate_before_ts=newest_before_ts,
+        latest_transient_per_agent=transient,
+    )
+
+
+def round_was_mem_terminated(log_dir: Path, *, outcome: RoundOutcome | None = None) -> bool:
     """True iff the round that JUST ran was killed by ``_spawn_round``'s
     mid-round memory-pressure hard floor (``round_mem_terminated``) rather
     than a genuine crash — so ``serve_cmd.cmd`` can excuse it from the
@@ -299,22 +400,15 @@ def round_was_mem_terminated(log_dir: Path) -> bool:
     ``round_mem_terminated`` within the very round it is scoping. ``>=``, not
     ``>``: a fast loop (or millisecond-resolution ties) can legitimately stamp
     both events in the same millisecond; erring toward "this round's" on a tie
-    only risks over-excusing, never mistaking a genuine crash for a rescue."""
-    newest_before_ts: str | None = None
-    newest_terminated_ts: str | None = None
-    for path in sorted(log_dir.glob("events-*.jsonl"))[-2:]:
-        for ev in _iter_events(path):
-            ts = ev.get("ts")
-            if not ts:
-                continue
-            kind = ev.get("event")
-            if kind == ROUND_SUBSTRATE_BEFORE:
-                newest_before_ts = ts
-            elif kind == ROUND_MEM_TERMINATED:
-                newest_terminated_ts = ts
-    if newest_before_ts is None or newest_terminated_ts is None:
-        return False
-    return parse_iso_ms(newest_terminated_ts) >= parse_iso_ms(newest_before_ts)
+    only risks over-excusing, never mistaking a genuine crash for a rescue.
+
+    ``outcome``, when given (the serve post-round block's one-scan path — see
+    :class:`RoundOutcome`), is used verbatim instead of triggering a fresh
+    :func:`round_outcome` scan; every existing caller/test omits it and gets the
+    pre-0.2.17 from-scratch-scan behavior unchanged."""
+    if outcome is None:
+        outcome = round_outcome(log_dir)
+    return outcome.mem_terminated
 
 
 def round_had_no_progress(
@@ -324,6 +418,7 @@ def round_had_no_progress(
     duration_s: float,
     threshold_s: float,
     throttle_active: bool = False,
+    outcome: RoundOutcome | None = None,
 ) -> bool:
     """True iff the round that JUST ran exited 0, finished fast, but never
     reached the model -- pi (and CLIs like it: see builtin_plugins/pi.py's
@@ -352,9 +447,11 @@ def round_had_no_progress(
        round), a round with none is genuine no-progress and still trips --
        this makes the breaker CLI-adaptive with no config descriptor.
 
-    Short-circuits on ``returncode != 0`` or ``duration_s >= threshold_s``
-    without touching the events tail: a non-zero exit already has its own
-    crash-loop signal, and a slow round (even with no usage) is not a TIGHT
+    INVARIANT 4: short-circuits on ``returncode != 0`` or ``duration_s >=
+    threshold_s`` (or ``throttle_active``) BEFORE touching ``outcome`` at all --
+    still ahead of any events-tail scan / ``newest_usage_ts`` comparison, exactly
+    as the pre-0.2.17 single-scan version did: a non-zero exit already has its
+    own crash-loop signal, and a slow round (even with no usage) is not a TIGHT
     loop -- a wedged/hung round already has its own signal
     (``round_supervisor_wedged``), so this floor is specifically the fast spin.
 
@@ -367,31 +464,22 @@ def round_had_no_progress(
     (newest-event-timestamp comparison against the newest
     ``round_substrate_before``), with the comparison inverted: no progress
     means the newest usage event is EITHER absent OR older than this round's
-    own start."""
+    own start.
+
+    ``outcome``, when given (the serve post-round block's one-scan path), is used
+    verbatim instead of triggering a fresh :func:`round_outcome` scan — see
+    :func:`round_was_mem_terminated`."""
     if throttle_active or returncode != 0 or duration_s >= threshold_s:
         return False
-    newest_before_ts: str | None = None
-    newest_usage_ts: str | None = None
-    usage_capable = False
-    for path in sorted(log_dir.glob("events-*.jsonl"))[-2:]:
-        for ev in _iter_events(path):
-            kind = ev.get("event")
-            if kind == AGENT_USAGE_RECORDED:
-                usage_capable = True
-            ts = ev.get("ts")
-            if not ts:
-                continue
-            if kind == ROUND_SUBSTRATE_BEFORE:
-                newest_before_ts = ts
-            elif kind == AGENT_USAGE_RECORDED:
-                newest_usage_ts = ts
-    if not usage_capable:
+    if outcome is None:
+        outcome = round_outcome(log_dir)
+    if not outcome.usage_capable:
         return False  # this CLI/plugin stack has never emitted usage -- can't arm
-    if newest_before_ts is None:
+    if outcome.newest_substrate_before_ts is None:
         return False
-    if newest_usage_ts is None:
+    if outcome.newest_usage_ts is None:
         return True
-    return parse_iso_ms(newest_usage_ts) < parse_iso_ms(newest_before_ts)
+    return parse_iso_ms(outcome.newest_usage_ts) < parse_iso_ms(outcome.newest_substrate_before_ts)
 
 
 def mem_loop_events_in_window(log_dir: Path, clock: Clock, window_s: int) -> int:
@@ -399,7 +487,7 @@ def mem_loop_events_in_window(log_dir: Path, clock: Clock, window_s: int) -> int
     ``window_s`` seconds of ``clock.epoch()`` — events-derived, no state file,
     same tail-reconstruction shape as :func:`round_was_mem_terminated` above.
 
-    Feeds ``_serve_round.round_outcome_exit_code``'s cross-restart escalation
+    Feeds ``_serve_round.post_round_verdicts``'s cross-restart escalation
     (0.2.16 Task 5): ``MEM_LOOP_EXIT`` (71) alone resets on every serve
     process restart, so a host stuck in sustained pressure respawns into the
     identical loop forever (field-confirmed: NRestarts climbs, never
@@ -407,15 +495,16 @@ def mem_loop_events_in_window(log_dir: Path, clock: Clock, window_s: int) -> int
     an all-time total, or a restart-local counter — gives "ages out on its
     own after a sustained-healthy stretch" for free: an old mem_loop episode
     outside the window simply stops counting, no explicit reset needed."""
+    # Kept OUT of RoundOutcome/round_outcome (0.2.17 Task 1): give-up-only, and its
+    # window cutoff needs its OWN clock read, unlike anything folded into that struct.
     cutoff = clock.epoch() - window_s
     count = 0
-    for path in sorted(log_dir.glob("events-*.jsonl"))[-2:]:
-        for ev in _iter_events(path):
-            if ev.get("event") != MEM_LOOP:
-                continue
-            ts = ev.get("ts")
-            if ts and parse_iso_ms(ts).timestamp() >= cutoff:
-                count += 1
+    for ev in _tail_events(log_dir):
+        if ev.get("event") != MEM_LOOP:
+            continue
+        ts = ev.get("ts")
+        if ts and parse_iso_ms(ts).timestamp() >= cutoff:
+            count += 1
     return count
 
 
@@ -657,9 +746,9 @@ def _interruptible_sleep(
     :func:`_apply_back_off` so a SIGTERM or a stop_file lands within one chunk instead
     of after the full sleep (e.g. the 8h back-off cap).
 
-    ``should_stop`` matches :func:`_pause_poll`'s contract (serve_cmd.py): a zero-arg
-    predicate the caller closes over its own stop_file check with, so this module never
-    needs to know what "should stop" means beyond calling it.
+    ``should_stop`` matches :func:`_pause_poll`'s contract (cli/_serve_round.py): a
+    zero-arg predicate the caller closes over its own stop_file check with, so this
+    module never needs to know what "should stop" means beyond calling it.
 
     Counts down the *intended* nap per slice rather than measuring a wall/monotonic
     deadline: NTP-step immune (no clock read for the deadline) AND does not busy-spin
@@ -669,7 +758,7 @@ def _interruptible_sleep(
     ``deadline_epoch``, when given, additionally re-checks ``clock.epoch() >=
     deadline_epoch`` at each chunk boundary and returns False (completed, NOT
     interrupted) the moment it's reached — mirroring the skip path's self-correcting
-    ``clock.epoch() >= wake_epoch`` (serve_cmd.py:251). Only :func:`_apply_back_off`
+    ``clock.epoch() >= wake_epoch`` (serve_cmd.py:238). Only :func:`_apply_back_off`
     passes this: its ``total_s`` is computed against the caller's OWN clock reading at
     call time, which on an RTC-less host booting hours behind is stale, inflating
     ``total_s`` well past the real wall-clock target; re-checking the target itself

{cli_agent_runner-0.2.16 → cli_agent_runner-0.2.17}/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.16'
-__version_tuple__ = version_tuple = (0, 2, 16)
+__version__ = version = '0.2.17'
+__version_tuple__ = version_tuple = (0, 2, 17)
 
 __commit_id__ = commit_id = None

{cli_agent_runner-0.2.16 → cli_agent_runner-0.2.17}/agent_runner/api.py

@@ -319,9 +319,9 @@ def start(project: str | Path) -> ServiceStatus:
 _PID_SIGNAL_GRACE_S = 5
 
 # Grace after TERMing the round-lock holder before escalating to SIGKILL: mirrors
-# serve_cmd._ROUND_TERM_GRACE_S (the round's own SIGTERM handler needs
+# cli._serve_round._ROUND_TERM_GRACE_S (the round's own SIGTERM handler needs
 # agent_runtime.REAP_GRACE_S + margin to reap its agent pgroup and exit).
-# Cross-checked against serve_cmd's value by
+# Cross-checked against that module's value by
 # test_round_kill_grace_matches_serve so the two never drift.
 _ROUND_TERM_GRACE_S = 15
 
@@ -712,12 +712,29 @@ def _monitor_loop_iter(
             # work_dir with a non-preset log_dir would target the wrong dir, see no
             # pidfile, and no-op while serve keeps running. The Path resolves to the
             # real cfg.runtime.log_dir.
-            monitor.on_alert(
+            verdict = monitor.on_alert(
                 alert,
                 project=work_dir,
                 log_dir=cfg.runtime.log_dir,
                 allowed_stop_names=cfg.monitor.auto_stop_on,
             )
+            if verdict == "draining":
+                # Nothing was recorded for this alert this poll (see on_alert's
+                # docstring) — force-clear its `seen` entry so it is NOT treated
+                # as "still firing, stay suppressed" below: the alert condition
+                # persisting is exactly the case that must re-fire on_alert next
+                # poll, unlike every other verdict (recorded outcome, or never
+                # eligible), which keeps the normal dedup.
+                #
+                # Trade-off: `seen` also gates the `yield alert` above (the
+                # dedup consumers of the monitor stream see), so re-arming it
+                # to retry on_alert ALSO re-yields this same alert to the
+                # stream consumer next poll. Accepted: a persisting alert
+                # re-appearing each poll while its stop drains just reads as a
+                # "still draining" signal to that consumer. A fuller design
+                # would split consumer-yield dedup from on_alert-retry state,
+                # but that split isn't warranted for this narrow case.
+                del seen[key]
         # Re-arm: an episode absent from this poll has cleared, so forget it — a
         # later recurrence is a NEW episode and must fire again (not stay suppressed
         # until bounded eviction). Only keys still firing this poll survive.