cli-agent-runner 0.3.0__tar.gz → 0.3.1__tar.gz

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/.vulture-whitelist.py

@@ -77,6 +77,7 @@ service
 recent_events
 recent_hook_failures
 recent_blips
+recent_cgroup_growth_warnings
 schedule
 
 # agent_runner.api_types.RateLimitState
@@ -248,6 +249,7 @@ full_avg10_critical
 some_avg10_warning
 critical_consecutive_samples
 in_round_terminate
+cgroup_growth_rate_warning_mb_per_min
 
 # agent_runner.context_store.OrphanState
 round_num

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/CHANGELOG.md

@@ -5,6 +5,12 @@ 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.3.1] - 2026-09-14
+
+### Added
+- `monitor.host_health.pressure.cgroup_growth_rate_warning_mb_per_min` (default 512.0): a mid-round memory-growth-rate detector gives an earlier growth signal than the existing PSI/MemFree floors catch, ahead of a runaway climb reaching them. Observability only — no round action.
+- `cgroup_growth_rate_warning` event, surfaced in `peek --json` as `recent_cgroup_growth_warnings` (schema `2.1`).
+
 ## [0.3.0] - 2026-09-13
 
 **The one breaking release of the 0.3 line.** Run `agent-runner migrate` before upgrading — it rewrites everything below in one pass.

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cli-agent-runner
-Version: 0.3.0
+Version: 0.3.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.3.0 → cli_agent_runner-0.3.1}/agent_runner/_emit/__init__.py

@@ -29,6 +29,7 @@ from agent_runner._emit.agent import (  # noqa: F401 — public re-export
     emit_transient_error_recovered,
 )
 from agent_runner._emit.memory import (  # noqa: F401 — public re-export
+    emit_cgroup_growth_rate_warning,
     emit_host_cgroup_memory_limit,
     emit_mem_pressure_deferred_to_cgroup,
     emit_round_cgroup_memory,
@@ -69,6 +70,7 @@ __all__ = [
     "emit_agent_auth_error_detected",
     "emit_agent_usage_recorded",
     "emit_anomaly_repetitive_tool",
+    "emit_cgroup_growth_rate_warning",
     "emit_config_broken",
     "emit_config_migrated",
     "emit_crash_loop",

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/agent_runner/_emit/memory.py

@@ -238,3 +238,33 @@ def emit_mem_pressure_deferred_to_cgroup(
     from agent_runner.events import MEM_PRESSURE_DEFERRED_TO_CGROUP, emit
 
     emit(log_dir, MEM_PRESSURE_DEFERRED_TO_CGROUP, pid=pid, signal=signal, message=message)
+
+
+def emit_cgroup_growth_rate_warning(
+    log_dir: Path,
+    *,
+    round_num: int,
+    rate_mb_per_min: float,
+    threshold_mb_per_min: float,
+    source: str,
+    context: dict,
+) -> None:
+    """Emit on a False->True crossing of _spawn_round's mid-round growth-rate
+    derivative (host_health.cgroup_growth_rate_pressure) -- observability
+    only, no action path. ``source`` names which per-tick reading the
+    derivative used: "cgroup" (a finite cgroup memory.max bound exists,
+    memory.current is read) or "rss_sum" (no finite bound -- the psutil
+    children_rss_sum_bytes tree sum is used instead). Edge-triggered: fires
+    once per crossing episode, not once per tick, so a sustained climb does
+    not spam the event stream."""
+    from agent_runner.events import CGROUP_GROWTH_RATE_WARNING, emit
+
+    emit(
+        log_dir,
+        CGROUP_GROWTH_RATE_WARNING,
+        round_num=round_num,
+        rate_mb_per_min=rate_mb_per_min,
+        threshold_mb_per_min=threshold_mb_per_min,
+        source=source,
+        context=context,
+    )

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/agent_runner/_observe.py

@@ -21,12 +21,14 @@ from agent_runner.clock import SYSTEM_CLOCK
 from agent_runner.config import load_config
 from agent_runner.events import (
     AGENT_NETWORK_BLIP,
+    CGROUP_GROWTH_RATE_WARNING,
     HOOK_FAILED,
     MONITOR_STARTED,
 )
 
 _RECENT_HOOK_FAILURES_LIMIT = 10
 _RECENT_BLIPS_LIMIT = 5
+_RECENT_GROWTH_LIMIT = 5
 _MONITOR_SEEN_CAP = 512
 """Bound on `_monitor_loop_iter`'s dedup set — an unbounded set of alert-identity
 keys would grow forever across a long-lived monitor process; oldest-episode
@@ -80,6 +82,9 @@ def peek(
         parsed_events, HOOK_FAILED, _RECENT_HOOK_FAILURES_LIMIT
     )
     recent_blips = _recent_events_of_kind(parsed_events, AGENT_NETWORK_BLIP, _RECENT_BLIPS_LIMIT)
+    recent_cgroup_growth_warnings = _recent_events_of_kind(
+        parsed_events, CGROUP_GROWTH_RATE_WARNING, _RECENT_GROWTH_LIMIT
+    )
 
     from agent_runner._throttle import effective_throttle_view
 
@@ -121,6 +126,7 @@ def peek(
         recent_events=recent,
         recent_hook_failures=recent_hook_failures,
         recent_blips=recent_blips,
+        recent_cgroup_growth_warnings=recent_cgroup_growth_warnings,
         schedule=monitor.latest_schedule_state(parsed_events),
     )
     return state if select is None else select_path(state, select)

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.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.3.0'
-__version_tuple__ = version_tuple = (0, 3, 0)
+__version__ = version = '0.3.1'
+__version_tuple__ = version_tuple = (0, 3, 1)
 
 __commit_id__ = commit_id = None

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/agent_runner/agent_runtime.py

@@ -247,6 +247,26 @@ def _live_children(
     return live, ignored
 
 
+def children_rss_sum_bytes(proc: subprocess.Popen) -> int | None:
+    """Sum RSS (bytes) across the process tree (self + all recursive children)
+    -- the no-finite-cgroup-bound fallback for the mid-round growth-rate
+    derivative (see cli/_serve_round.py). Uncapped, unlike _live_children
+    (a 5-child cap would undercount a wider tree); fail-open on the same
+    PID-race guards _live_children uses: None when the leader itself is gone
+    or unreadable, per-child skip (not abort) when a child vanishes mid-walk."""
+    try:
+        parent = psutil.Process(proc.pid)
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        return None
+    total = 0
+    for p in [parent, *parent.children(recursive=True)]:
+        try:
+            total += p.memory_info().rss
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            continue
+    return total
+
+
 # Decoupled from the 0.2s poll tick: the marker scan only needs to notice the
 # result within max_grace_after_result_s (seconds, integer), so scanning more
 # often than this buys nothing but re-read cost on a growing round log.

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/agent_runner/api.py

@@ -31,6 +31,7 @@ from agent_runner._emit import (  # noqa: E402,F401 — intentional bottom re-ex
     emit_agent_auth_error_detected,
     emit_agent_usage_recorded,
     emit_anomaly_repetitive_tool,
+    emit_cgroup_growth_rate_warning,
     emit_config_broken,
     emit_config_migrated,
     emit_crash_loop,

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/agent_runner/api_types.py

@@ -114,6 +114,7 @@ class ProjectState:
     recent_events: list[dict[str, Any]] = field(default_factory=list)
     recent_hook_failures: list[dict[str, Any]] = field(default_factory=list)
     recent_blips: list[dict[str, Any]] = field(default_factory=list)
+    recent_cgroup_growth_warnings: list[dict[str, Any]] = field(default_factory=list)
     schedule: dict | None = None
 
 

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/agent_runner/cli/_serve_round.py

@@ -44,8 +44,13 @@ from agent_runner._throttle import (
     pending_recovered,
     round_had_no_progress,
 )
-from agent_runner.agent_runtime import _kill_stray_descendants, _snapshot_stray_descendants
+from agent_runner.agent_runtime import (
+    _kill_stray_descendants,
+    _snapshot_stray_descendants,
+    children_rss_sum_bytes,
+)
 from agent_runner.api import (
+    emit_cgroup_growth_rate_warning,
     emit_config_broken,
     emit_crash_loop,
     emit_mem_loop,
@@ -337,7 +342,14 @@ def _spawn_round(
     run (cgroup-defer, or the off switch) would otherwise write one event
     per ~10s tick for up to a whole ``round_budget_s``. The streak still
     resets to 0 on any non-critical tick, so the cap is per streak-episode:
-    sampling resumes from 1 the next time critical pressure recurs."""
+    sampling resumes from 1 the next time critical pressure recurs.
+
+    A second, independent derivative rides the SAME mem-check tick: growth
+    RATE (MB/min) of the round's own memory (cgroup memory.current when a
+    finite bound exists, else a psutil RSS-sum over the process tree),
+    evaluated by host_health.cgroup_growth_rate_pressure and, on a crossing,
+    emitting cgroup_growth_rate_warning once per episode -- observability
+    only, no termination action."""
     log_dir = round_log_path.parent
     with round_log_path.open("w") as f:
         proc = subprocess.Popen(
@@ -362,6 +374,9 @@ def _spawn_round(
             prev_tick_sample: dict | None = None
             critical_streak = 0
             cgroup_defer_notified = False
+            prev_mem_bytes: int | None = None
+            prev_mem_mono: float | None = None
+            growth_warned = False
             # cgroup pressure spine (round_cgroup_memory): baseline read
             # once at spawn start, empty ({}) when this host has no finite
             # cgroup bound -- cg_base then stays falsy and _stash_cgroup
@@ -404,6 +419,50 @@ def _spawn_round(
                         cg_now = metrics.cgroup_memory_usage(bounding_cgroup=cg_bounding)
                         cg_peak_current = max(cg_peak_current, cg_now.get("memory_current", 0))
                         cg_peak_swap = max(cg_peak_swap, cg_now.get("memory_swap_current", 0))
+                        cur_mem_bytes = cg_now.get("memory_current") if cg_now else None
+                        mem_source = "cgroup"
+                    else:
+                        cur_mem_bytes = children_rss_sum_bytes(proc)
+                        mem_source = "rss_sum"
+                    now_mono = clock.monotonic()
+                    if cur_mem_bytes is not None:
+                        rate_mb_per_min = None
+                        if prev_mem_bytes is not None and prev_mem_mono is not None:
+                            elapsed_s = max(now_mono - prev_mem_mono, 0.0)
+                            rate_mb_per_min = (
+                                0.0
+                                if elapsed_s == 0
+                                else max(
+                                    (cur_mem_bytes - prev_mem_bytes)
+                                    / 1024
+                                    / 1024
+                                    / (elapsed_s / 60),
+                                    0.0,
+                                )
+                            )
+                        growth_pressure = host_health.cgroup_growth_rate_pressure(
+                            rate_mb_per_min, host_health_cfg
+                        )
+                        if growth_pressure is not None:
+                            if not growth_warned:
+                                growth_warned = True
+                                emit_cgroup_growth_rate_warning(
+                                    log_dir,
+                                    round_num=round_num,
+                                    rate_mb_per_min=rate_mb_per_min,
+                                    threshold_mb_per_min=(
+                                        host_health_cfg.pressure.cgroup_growth_rate_warning_mb_per_min
+                                    ),
+                                    source=mem_source,
+                                    context=growth_pressure.context,
+                                )
+                        else:
+                            growth_warned = False
+                        prev_mem_bytes, prev_mem_mono = cur_mem_bytes, now_mono
+                    # else: fail-open -- cur_mem_bytes unavailable this tick
+                    # (a {}/None source read). Keep prev_mem_bytes/prev_mem_mono
+                    # untouched so the NEXT successful tick still diffs against
+                    # the last real reading, not a spurious reset.
                     if pressure is not None and pressure.severity == "critical":
                         critical_streak += 1
                         if (

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/agent_runner/cli/common.py

@@ -19,7 +19,7 @@ from agent_runner.hooks import plugin_context_enrichers, post_round_hooks, pre_r
 from agent_runner.monitor import plugin_detectors
 from agent_runner.vcs_state import plugin_owned_paths
 
-PEEK_SCHEMA_VERSION = "2.0"
+PEEK_SCHEMA_VERSION = "2.1"
 
 
 def cfg_from_args(args) -> Config:

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/agent_runner/config/models.py

@@ -200,6 +200,10 @@ class _HostHealthPressureConfig:
     critical_consecutive_samples: int = 3
     # Off switch for the mid-round hard floor's termination action only.
     in_round_terminate: bool = True
+    # Mid-round growth-RATE floor (MB/min) -- observability only in this
+    # release: no critical/terminate action exists for it yet, see
+    # host_health.cgroup_growth_rate_pressure.
+    cgroup_growth_rate_warning_mb_per_min: float = 512.0
 
 
 @dataclass(frozen=True)

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/agent_runner/config/parsers.py

@@ -57,6 +57,7 @@ from agent_runner.config.validators import (
     _require_bool,
     _require_non_negative_int,
     _require_pct,
+    _require_positive_float,
     _require_positive_int,
     _require_positive_pct,
     _require_str_list,
@@ -515,6 +516,10 @@ def _parse_monitor(monitor_d: dict) -> MonitorConfig:
                 pres_d.get("in_round_terminate", True),
                 field="monitor.host_health.pressure.in_round_terminate",
             ),
+            cgroup_growth_rate_warning_mb_per_min=_require_positive_float(
+                pres_d.get("cgroup_growth_rate_warning_mb_per_min", 512.0),
+                field="monitor.host_health.pressure.cgroup_growth_rate_warning_mb_per_min",
+            ),
         ),
     )
     monitor = MonitorConfig(

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/agent_runner/config/validators.py

@@ -166,6 +166,19 @@ def _require_positive_pct(value: Any, *, field: str) -> float:
     return v
 
 
+def _require_positive_float(value: Any, *, field: str) -> float:
+    """Validate a TOML value is a positive float (int accepted too -- TOML's
+    bare integer form). Sibling of ``_require_positive_pct`` for a raw-unit
+    threshold (e.g. MB/min) that has no natural [0, 100] percent ceiling.
+    Rejects bool (subclass of int, would silently coerce ``true`` -> 1.0)."""
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ConfigError(f"{field}: must be a number, got {type(value).__name__} ({value!r})")
+    v = float(value)
+    if not v > 0.0:
+        raise ConfigError(f"{field}: must be positive, got {v}")
+    return v
+
+
 def _validate_regex_list(value: Any, *, field: str) -> list[str]:
     """Validate a list of regex pattern strings (each must compile). Returns the
     raw strings unchanged; callers compile when they need ``re.Pattern`` objects."""

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/agent_runner/events.py

@@ -36,6 +36,7 @@ ANOMALY_REPETITIVE_TOOL = "anomaly_repetitive_tool"
 AGENT_NETWORK_BLIP = "agent_network_blip"
 AGENT_SPAWN = "agent_spawn"
 AGENT_USAGE_RECORDED = "agent_usage_recorded"
+CGROUP_GROWTH_RATE_WARNING = "cgroup_growth_rate_warning"
 CONFIG_BROKEN = "config_broken"
 CONFIG_MIGRATED = "config_migrated"
 CRASH_LOOP = "crash_loop"

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/agent_runner/host_health.py

@@ -183,3 +183,25 @@ def configured_gate_inert(sample: dict[str, Any], prev_sample: dict[str, Any], c
         return False  # the gate would fire (or we can't evaluate it) -- not inert
     pressure = memory_pressure(sample, prev_sample, cfg)
     return pressure is not None and pressure.signal in ("psi", "swap_out_rate")
+
+
+def cgroup_growth_rate_pressure(rate_mb_per_min: float | None, cfg: Any) -> Pressure | None:
+    """WARNING when the round's memory-growth rate (MB/min) meets/exceeds the
+    configured warning floor. Independent of the memory_pressure ladder above
+    (NOT a 5th fall-through tier -- PSI's early return there would mask an
+    otherwise-live growth-rate signal). Observability only -- never returns
+    "critical" in this release; a growth-driven termination path needs
+    calibration on a constrained host before it can safely exist.
+    ``rate_mb_per_min`` is None when no prior-tick sample pair is available
+    yet (the first tick of a round) -- returns None (no signal), not warning."""
+    if rate_mb_per_min is None:
+        return None
+    warn = cfg.pressure.cgroup_growth_rate_warning_mb_per_min
+    if rate_mb_per_min >= warn:
+        return Pressure(
+            severity="warning",
+            signal="cgroup_growth_rate",
+            message=f"memory growing {rate_mb_per_min:.0f} MB/min (>= {warn:.0f})",
+            context={"rate_mb_per_min": rate_mb_per_min, "threshold_mb_per_min": warn},
+        )
+    return None

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/docs/architecture.md

@@ -211,6 +211,7 @@ See `docs/plugins.md` for the `DirtyHandler` protocol and override recipe.
 - `agent_spawn`
 - `agent_usage_recorded`
 - `anomaly_repetitive_tool`
+- `cgroup_growth_rate_warning`
 - `config_broken`
 - `config_migrated`
 - `crash_loop`

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/docs/configuration.md

@@ -81,7 +81,7 @@ running with newly-set `dirty_action = "auto_commit"` is undefined).
 | `remote_failure_tolerance_s` | `int` | 90 |
 | `anomaly_repetitive_window` | `int` | 0 |
 | `anomaly_repetitive_threshold` | `int` | 0 |
-| `host_health` | `MonitorHostHealthConfig` | MonitorHostHealthConfig(disk=_HostHealthDiskConfig(warning_pct=90.0, critical_pct=95.0), memory=_HostHealthMemoryConfig(avail_min_mb=200, free_low_mb=16, swap_out_noise_floor_mb=32), pressure=_HostHealthPressureConfig(full_avg10_critical=60.0, some_avg10_warning=5.0, critical_consecutive_samples=3, in_round_terminate=True)) |
+| `host_health` | `MonitorHostHealthConfig` | MonitorHostHealthConfig(disk=_HostHealthDiskConfig(warning_pct=90.0, critical_pct=95.0), memory=_HostHealthMemoryConfig(avail_min_mb=200, free_low_mb=16, swap_out_noise_floor_mb=32), pressure=_HostHealthPressureConfig(full_avg10_critical=60.0, some_avg10_warning=5.0, critical_consecutive_samples=3, in_round_terminate=True, cgroup_growth_rate_warning_mb_per_min=512.0)) |
 | `round_progress_interval_s` | `int` | 0 |
 | `supervisor_stale_threshold_s` | `int \| None` | None |
 
@@ -91,7 +91,7 @@ running with newly-set `dirty_action = "auto_commit"` is undefined).
 |---|---|---|
 | `disk` | `_HostHealthDiskConfig` | _HostHealthDiskConfig(warning_pct=90.0, critical_pct=95.0) |
 | `memory` | `_HostHealthMemoryConfig` | _HostHealthMemoryConfig(avail_min_mb=200, free_low_mb=16, swap_out_noise_floor_mb=32) |
-| `pressure` | `_HostHealthPressureConfig` | _HostHealthPressureConfig(full_avg10_critical=60.0, some_avg10_warning=5.0, critical_consecutive_samples=3, in_round_terminate=True) |
+| `pressure` | `_HostHealthPressureConfig` | _HostHealthPressureConfig(full_avg10_critical=60.0, some_avg10_warning=5.0, critical_consecutive_samples=3, in_round_terminate=True, cgroup_growth_rate_warning_mb_per_min=512.0) |
 
 #### `[monitor.host_health.disk]`
 
@@ -116,6 +116,7 @@ running with newly-set `dirty_action = "auto_commit"` is undefined).
 | `some_avg10_warning` | `float` | 5.0 |
 | `critical_consecutive_samples` | `int` | 3 |
 | `in_round_terminate` | `bool` | True |
+| `cgroup_growth_rate_warning_mb_per_min` | `float` | 512.0 |
 
 ### `[phases]`
 

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/docs/memory-efficiency.md

@@ -287,6 +287,17 @@ neutrality argument above (same objects, same import-graph shape, no new
 per-round allocation), no regression is expected on that host either, but
 that claim is unverified pending whoever runs the next prerelease build there.
 
+## 0.3.0 → 0.3.1
+
+Not independently re-measured this release. No import-time work changed:
+`children_rss_sum_bytes` and `cgroup_growth_rate_pressure` are plain
+functions added beside existing ones in already-imported modules, not new
+imports. The mid-round tick loop's existing ~10s cadence gains a few extra
+local-variable holders and, at most, one more psutil (or reused cgroup)
+read on that SAME already-scheduled tick — no new per-round allocation
+growth pattern. `tests/invariants/test_round_alloc_growth.py` stays green
+unmodified.
+
 ## Methodology
 
 Machine: macOS 26.6.2, arm64, 16 KB pages. Python 3.11.3 (CPython, pyenv),

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/docs/plugins.md

@@ -188,7 +188,7 @@ The round itself continues — a broken plugin must not crash the supervisor.
 
 ```json
 {
-  "schema_version": "2.0",
+  "schema_version": "2.1",
   "plugins": {
     "event_kinds": [...],
     "context_enrichers": ["current_branch"],
@@ -537,7 +537,7 @@ detector. Other plugin detectors and all builtins still run normally.
 
 ```json
 {
-  "schema_version": "2.0",
+  "schema_version": "2.1",
   "plugins": {
     "event_kinds": [...],
     "context_enrichers": [...],

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/tests/contract/test_public_api_surface.py

@@ -221,6 +221,7 @@ EXPECTED_API_SURFACE = {
     "emit_agent_auth_error_detected",
     "emit_agent_usage_recorded",
     "emit_anomaly_repetitive_tool",
+    "emit_cgroup_growth_rate_warning",
     "emit_config_broken",
     "emit_config_migrated",
     "emit_crash_loop",

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/tests/invariants/test_architecture.py

@@ -93,7 +93,10 @@ ALLOWED_SERVE_ROUND_IMPORTS = {
 }
 ALLOWED_SERVE_ROUND_FROM = [
     ("agent_runner", {"host_health", "metrics"}),
-    ("agent_runner.agent_runtime", {"_kill_stray_descendants", "_snapshot_stray_descendants"}),
+    (
+        "agent_runner.agent_runtime",
+        {"_kill_stray_descendants", "_snapshot_stray_descendants", "children_rss_sum_bytes"},
+    ),
     (
         "agent_runner._serve_policy",
         {
@@ -118,6 +121,7 @@ ALLOWED_SERVE_ROUND_FROM = [
     (
         "agent_runner.api",
         {
+            "emit_cgroup_growth_rate_warning",
             "emit_config_broken",
             "emit_crash_loop",
             "emit_mem_loop",

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/tests/invariants/test_peek_schema_version.py

@@ -72,7 +72,7 @@ def test_peek_json_should_include_schema_version_when_emitted(tmp_path: Path) ->
         f"schema_version regressed: got {payload['schema_version']!r}, "
         f"expected >= {PEEK_SCHEMA_VERSION!r}"
     )
-    assert payload["schema_version"] == "2.0"
+    assert payload["schema_version"] == "2.1"
     assert "plugins" in payload
     assert isinstance(payload["plugins"], dict)
     assert "event_kinds" in payload["plugins"]

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/tests/unit/test_agent_runtime_grace.py

@@ -9,6 +9,7 @@ import subprocess
 import sys
 from pathlib import Path
 
+import psutil
 import pytest
 
 from agent_runner import agent_runtime
@@ -284,6 +285,68 @@ def test_live_children_should_return_empty_when_process_already_exited():
     assert _live_children(p) == ([], [])  # NoSuchProcess swallowed
 
 
+def test_children_rss_sum_bytes_should_return_none_when_process_already_exited():
+    from agent_runner.agent_runtime import children_rss_sum_bytes
+
+    p = subprocess.Popen(["true"])
+    p.wait()
+
+    assert children_rss_sum_bytes(p) is None  # NoSuchProcess swallowed, mirrors _live_children
+
+
+def test_children_rss_sum_bytes_should_sum_parent_and_child_rss_when_tree_alive():
+    from agent_runner.agent_runtime import children_rss_sum_bytes
+
+    p = subprocess.Popen(["bash", "-c", "sleep 30 & wait"], start_new_session=True)
+    box: dict = {}
+
+    def _ready() -> bool:
+        box["total"] = children_rss_sum_bytes(p)
+        return box["total"] is not None and box["total"] > 0
+
+    try:
+        assert poll_until(_ready, timeout_s=5.0), "rss sum never became positive"
+        assert box["total"] > 0
+    finally:
+        os.killpg(p.pid, signal.SIGKILL)
+        p.wait()
+
+
+def test_children_rss_sum_bytes_should_skip_a_vanished_child_when_others_remain(monkeypatch):
+    """A child that raises NoSuchProcess mid-walk (PID race) must not abort the
+    whole sum -- the remaining process(es) still contribute."""
+    from agent_runner.agent_runtime import children_rss_sum_bytes
+
+    p = subprocess.Popen(["sleep", "3"], start_new_session=True)
+
+    class _FailingChild:
+        def memory_info(self):
+            raise psutil.NoSuchProcess(pid=99999)
+
+    real_process = psutil.Process
+
+    class _FakeParent:
+        def __init__(self, pid):
+            self._real = real_process(pid)
+
+        def memory_info(self):
+            return self._real.memory_info()
+
+        def children(self, recursive=True):
+            return [_FailingChild()]
+
+    try:
+        monkeypatch.setattr(agent_runtime.psutil, "Process", lambda pid: _FakeParent(pid))
+
+        total = children_rss_sum_bytes(p)
+
+        assert total is not None
+        assert total > 0  # parent's own RSS still counted
+    finally:
+        os.killpg(p.pid, signal.SIGKILL)
+        p.wait()
+
+
 def test_run_should_extend_grace_when_child_still_live_after_result(tmp_path, monkeypatch):
     """Agent emits result then backgrounds a long child -> live worker -> NOT
     grace-killed; round_budget_s (wall) reaps it instead; extended fired once.

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/tests/unit/test_api_observation.py

@@ -392,6 +392,39 @@ def test_peek_should_populate_recent_blips_when_events_contain_blips(
     assert rounds == [2, 3, 4, 5, 6]
 
 
+def test_peek_should_populate_recent_cgroup_growth_warnings_when_events_contain_them(
+    tmp_git_repo: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("HOME", str(tmp_git_repo))
+    api.init(tmp_git_repo, force=False, commit=False)
+    _seed_logs(tmp_git_repo)
+    cfg = load_config(tmp_git_repo / "agent-runner.toml")
+    log_dir = cfg.runtime.log_dir
+    warning_lines = [
+        json.dumps(
+            {
+                "ts": f"2026-05-12T11:00:0{i}.000Z",
+                "event": "cgroup_growth_rate_warning",
+                "round_num": i,
+                "rate_mb_per_min": 900.0,
+                "threshold_mb_per_min": 512.0,
+                "source": "cgroup",
+                "context": {},
+            }
+        )
+        for i in range(7)
+    ]
+    with (log_dir / "events-2026-05.jsonl").open("a", encoding="utf-8") as f:
+        f.write("\n".join(warning_lines) + "\n")
+
+    state = api.peek(tmp_git_repo)
+
+    assert len(state.recent_cgroup_growth_warnings) == 5, "default limit is 5, most-recent first"
+    rounds = [w["round_num"] for w in state.recent_cgroup_growth_warnings]
+    assert rounds == [2, 3, 4, 5, 6]
+
+
 def test_narrate_events_should_yield_formatted_lines_when_events_seeded(
     tmp_path: Path,
 ) -> None:

{cli_agent_runner-0.3.0 → cli_agent_runner-0.3.1}/tests/unit/test_config.py

@@ -2072,6 +2072,44 @@ def test_in_round_terminate_should_reject_non_bool_value(tmp_path: Path, bad: st
         load_config(toml)
 
 
+@pytest.mark.parametrize("bad", ["0", "-1", '"x"', "true", "nan"])
+def test_cgroup_growth_rate_warning_mb_per_min_should_reject_non_positive_or_bool_values(
+    tmp_path: Path, bad: str
+) -> None:
+
+    toml = _write_toml(
+        tmp_path, _HOST_HEALTH_PRESSURE_BASE + f"cgroup_growth_rate_warning_mb_per_min = {bad}\n"
+    )
+
+    with pytest.raises(
+        ValueError, match="monitor.host_health.pressure.cgroup_growth_rate_warning_mb_per_min"
+    ):
+        load_config(toml)
+
+
+@pytest.mark.parametrize(("literal", "expected"), [("256", 256.0), ("128.5", 128.5)])
+def test_cgroup_growth_rate_warning_mb_per_min_should_accept_int_or_float_when_positive(
+    tmp_path: Path, literal: str, expected: float
+) -> None:
+
+    toml = _write_toml(
+        tmp_path,
+        _HOST_HEALTH_PRESSURE_BASE + f"cgroup_growth_rate_warning_mb_per_min = {literal}\n",
+    )
+
+    cfg = load_config(toml)
+
+    assert cfg.monitor.host_health.pressure.cgroup_growth_rate_warning_mb_per_min == expected
+
+
+def test_cgroup_growth_rate_warning_mb_per_min_should_default_to_512() -> None:
+    from agent_runner.config import MonitorHostHealthConfig
+
+    cfg = MonitorHostHealthConfig()
+
+    assert cfg.pressure.cgroup_growth_rate_warning_mb_per_min == 512.0
+
+
 _INJECT_CONTEXT_BASE = """\
 [agent]
 command = ["true"]