cli-agent-runner 0.3.12__tar.gz → 0.3.13__tar.gz

cli_agent_runner-0.3.13/.ralph/items.json

@@ -0,0 +1,86 @@
+{
+  "version": 1,
+  "runtime_contract": {
+    "source_docs": [],
+    "verification_gates": [
+      {
+        "name": "ruff",
+        "command": ".venv/bin/ruff check . && .venv/bin/ruff format --check ."
+      }
+    ],
+    "require_progress_append": true,
+    "require_one_item_per_iteration": true,
+    "require_commit": true
+  },
+  "items": [
+    {
+      "category": "functional",
+      "description": "metrics.sample() always includes psi_full_total, io_psi_some_avg10, and io_psi_full_avg10 (None when unread). _read_psi returns (some_avg10, full_avg10, full_total). host_health.memory_pressure verdict and context stay identical when those extra keys are injected.",
+      "steps": [
+        "Add or update tests in tests/unit/test_metrics.py for the triple return and the three sample keys.",
+        "Add tests/unit/test_host_health.py coverage that a PSI-healthy sample plus huge io_psi_* / psi_full_total yields the same Pressure as the sample without those keys.",
+        "Implement parsing of full-line total= and a second _read_psi call on /proc/pressure/io inside sample(); do not edit host_health.py.",
+        "Run .venv/bin/python -m pytest tests/unit/test_metrics.py tests/unit/test_host_health.py tests/unit/test_monitor_detectors.py -q and the ruff gate."
+      ],
+      "passes": true,
+      "regression_notes": "76 passed (test_metrics + test_host_health + test_monitor_detectors); ruff check+format clean. host_health.py untouched. Darwin sample keys present as None."
+    },
+    {
+      "category": "functional",
+      "description": "host_cgroup_memory_limit events carry defer as a bool equal to _probe_and_emit_cgroup_defer's return value (True when both caps are finite and plausible, including MemorySwapMax=0).",
+      "steps": [
+        "Add tests/unit/test_cgroup_probe.py cases: memory_swap_max=0 with finite memory_max under host RAM returns True and emits defer true; memory_swap_max missing returns False and emits defer false.",
+        "Add defer: bool to emit_host_cgroup_memory_limit and pass the already-computed defer flag from _probe_and_emit_cgroup_defer.",
+        "Point the existing tests/e2e/test_e2e_pre_oom.py diagnostic at host_cgroup_memory_limit.defer.",
+        "Run .venv/bin/python -m pytest tests/unit/test_cgroup_probe.py -q and the ruff gate."
+      ],
+      "passes": true,
+      "regression_notes": "55 passed (test_cgroup_probe); ruff check+format clean. MemorySwapMax=0 emits defer true; missing swap.max emits defer false. D-2 diagnostic names host_cgroup_memory_limit.defer."
+    },
+    {
+      "category": "functional",
+      "description": "round_cgroup_memory may carry optional flat io_psi_some_avg10, io_psi_full_avg10, and psi_full_total from metrics.sample() at emit time. They are omitted when unread. They are never copied into Pressure.context.",
+      "steps": [
+        "Extend tests/unit/test_serve_round_cgroup_spine.py to monkeypatch metrics.sample and assert the three fields on the emitted round_cgroup_memory event.",
+        "Thread optional kwargs through emit_round_cgroup_memory and _emit_round_cgroup_memory; call sample() once at emit.",
+        "Run .venv/bin/python -m pytest tests/unit/test_serve_round_cgroup_spine.py tests/unit/test_serve_round_oom_killed.py -q and the ruff gate."
+      ],
+      "passes": true,
+      "regression_notes": "19 passed (test_serve_round_cgroup_spine + test_serve_round_oom_killed); ruff check+format clean. Optional PSI fields omitted when unread/None; present when sample() read them. Not copied into Pressure.context."
+    },
+    {
+      "category": "functional",
+      "description": "The paced pre-OOM child lives in tests/e2e/growth_child.py (8 MiB every 2.5s, page-touch). pi_growth_script installs that file instead of an inlined string. Importing the module does not start the infinite loop.",
+      "steps": [
+        "Create tests/e2e/growth_child.py with the existing constants and main() behind if __name__.",
+        "Add a constants test that imports the module and asserts _CHUNK_BYTES and _PACE_S.",
+        "Change tests/e2e/conftest.py pi_growth_script to ship that file.",
+        "Run the constants test plus the ruff gate."
+      ],
+      "passes": true,
+      "regression_notes": "1 passed (test_growth_child_constants); ruff check+format clean. pi_growth_script ships tests/e2e/growth_child.py via base64; import does not start the loop."
+    },
+    {
+      "category": "functional",
+      "description": "A skip-closed control-arm e2e exists: same unit as treatment except MemorySwapMax=0, MemoryHigh=120M kept, no oom.group and no OOMPolicy=kill. Unset AGENT_RUNNER_E2E_CGROUP and AGENT_RUNNER_E2E_PI, the new test skips. Assertions in source require defer true, no round_mem_terminated, no memory_high_engaged, events_oom_kill_delta>=1 or INVALID, DEFER-FIRST or KERNEL-FIRST named, growth child gone, host still answers.",
+      "steps": [
+        "Factor the systemd unit body so swap max is a parameter. Control uses 0. Do not add OOMPolicy or memory.oom.group.",
+        "Add the control-arm test and shared assertions. Gate with existing PI flag and/or AGENT_RUNNER_E2E_CGROUP. Control wait ceiling 180s.",
+        "Without those env flags, run .venv/bin/python -m pytest tests/e2e/test_e2e_pre_oom.py -q and confirm skip (not fail, not pass). Do not export the e2e flags. Run the ruff gate."
+      ],
+      "passes": true,
+      "regression_notes": "3 skipped (test_e2e_pre_oom.py without AGENT_RUNNER_E2E_CGROUP/PI); ruff check+format clean. Control unit MemorySwapMax=0, MemoryHigh=120M kept, no oom.group/OOMPolicy. Assertions in source: defer true, no round_mem_terminated, no memory_high_engaged, events_oom_kill_delta>=1 or INVALID, DEFER-FIRST or KERNEL-FIRST named, growth child gone, host still answers."
+    },
+    {
+      "category": "functional",
+      "description": "Root SECURITY.md gains one paragraph: isolation is the operator's job (exec_prefix, dedicated user, no passwordless sudo, egress); agent-runner stays lifecycle-safety. CHANGELOG adds ## [0.3.13] - UNRELEASED. No docs/SECURITY.md. Optional results template under gitignored docs/internal/notes is allowed and must not be staged.",
+      "steps": [
+        "Edit SECURITY.md Containment or Threat model with the reframe paragraph. Keep existing recipe links.",
+        "Insert CHANGELOG ## [0.3.13] - UNRELEASED above 0.3.12. Do not claim uncapped-before-coma.",
+        "Confirm docs/SECURITY.md does not exist. Run tests/invariants/test_docs_index_complete.py tests/invariants/test_doc_claims_match_ssot.py and the ruff gate."
+      ],
+      "passes": true,
+      "regression_notes": "4 passed (test_docs_index_complete + test_doc_claims_match_ssot); ruff check+format clean. docs/SECURITY.md absent. CHANGELOG [0.3.13] UNRELEASED; no uncapped-before-coma claim. Results template gitignored, not staged."
+    }
+  ]
+}

cli_agent_runner-0.3.13/.ralph/progress.md

@@ -0,0 +1,47 @@
+## 2026-09-18 sample() IO-PSI + psi_full_total
+
+- item: metrics.sample() always includes psi_full_total, io_psi_some_avg10, and io_psi_full_avg10 (None when unread). _read_psi returns (some_avg10, full_avg10, full_total). host_health.memory_pressure verdict and context stay identical when those extra keys are injected.
+- rationale: plan prefers ladder-blindness before defer-field / e2e fixture work. First unfinished item.
+- files: agent_runner/metrics.py, tests/unit/test_metrics.py, tests/unit/test_host_health.py
+- verification: `.venv/bin/python -m pytest tests/unit/test_metrics.py tests/unit/test_host_health.py tests/unit/test_monitor_detectors.py -q` → 76 passed; `.venv/bin/ruff check . && .venv/bin/ruff format --check .` clean
+- notes: did not edit host_health.py or _NEW_MEM_SAMPLE_KEYS. Pre-existing pi-lens findings in cgroup_delegated / _brake_high_value left untouched (outside this item).
+
+## 2026-09-18 host_cgroup_memory_limit.defer bool
+
+- item: host_cgroup_memory_limit events carry defer as a bool equal to _probe_and_emit_cgroup_defer's return value (True when both caps are finite and plausible, including MemorySwapMax=0).
+- rationale: plan prefers locking the defer-field contract before e2e fixture work. First remaining unfinished item after sample() IO-PSI.
+- files: agent_runner/_emit/memory.py, agent_runner/cli/_serve_cgroup.py, tests/unit/test_cgroup_probe.py, tests/e2e/test_e2e_pre_oom.py
+- verification: `.venv/bin/python -m pytest tests/unit/test_cgroup_probe.py -q` → 55 passed; `.venv/bin/ruff check . && .venv/bin/ruff format --check .` clean
+- notes: defer is a required emit kwarg (every probe is yes/no). Did not touch runbook.md (docs item). Pre-existing pi-lens typing findings in _serve_cgroup left untouched.
+
+## 2026-09-18 round_cgroup_memory corroborating PSI fields
+
+- item: round_cgroup_memory may carry optional flat io_psi_some_avg10, io_psi_full_avg10, and psi_full_total from metrics.sample() at emit time. They are omitted when unread. They are never copied into Pressure.context.
+- rationale: plan prefers locking ladder-blindness and defer-field contracts before e2e fixture work. First remaining unfinished item after host_cgroup_memory_limit.defer.
+- files: agent_runner/_emit/memory.py, agent_runner/cli/_serve_cgroup.py, tests/unit/test_serve_round_cgroup_spine.py
+- verification: `.venv/bin/python -m pytest tests/unit/test_serve_round_cgroup_spine.py tests/unit/test_serve_round_oom_killed.py -q` → 19 passed; `.venv/bin/ruff check . && .venv/bin/ruff format --check .` clean
+- notes: assumed sample() runs only on the successful emit path (skip-no-op paths do not sample); each None key is omitted independently. Did not edit host_health.py, events.md, or runbook.md. Pre-existing pi-lens typing findings in _serve_cgroup left untouched.
+
+## 2026-09-18 extract growth_child.py
+
+- item: The paced pre-OOM child lives in tests/e2e/growth_child.py (8 MiB every 2.5s, page-touch). pi_growth_script installs that file instead of an inlined string. Importing the module does not start the infinite loop.
+- rationale: plan prefers extracting growth_child.py after ladder-blindness/defer-field contracts, before skip-closed control tests. First remaining unfinished item.
+- files: tests/e2e/growth_child.py, tests/e2e/conftest.py, tests/unit/test_growth_child_constants.py
+- verification: `.venv/bin/python -m pytest tests/unit/test_growth_child_constants.py -q` → 1 passed; `.venv/bin/ruff check . && .venv/bin/ruff format --check .` clean
+- notes: assumed the constants test lives under tests/unit because CI and build.sh --ignore=tests/e2e. pi_growth_script still base64-over-ssh (same install path), reading tests/e2e/growth_child.py bytes instead of an inlined string. Importing the module does not enter main().
+
+## 2026-09-18 skip-closed control-arm e2e
+
+- item: A skip-closed control-arm e2e exists: same unit as treatment except MemorySwapMax=0, MemoryHigh=120M kept, no oom.group and no OOMPolicy=kill. Unset AGENT_RUNNER_E2E_CGROUP and AGENT_RUNNER_E2E_PI, the new test skips. Assertions in source require defer true, no round_mem_terminated, no memory_high_engaged, events_oom_kill_delta>=1 or INVALID, DEFER-FIRST or KERNEL-FIRST named, growth child gone, host still answers.
+- rationale: plan prefers skip-closed control tests after extracting growth_child.py. First remaining unfinished item.
+- files: tests/e2e/conftest.py, tests/e2e/test_e2e_pre_oom.py
+- verification: `.venv/bin/python -m pytest tests/e2e/test_e2e_pre_oom.py -q` → 3 skipped; `.venv/bin/ruff check . && .venv/bin/ruff format --check .` clean
+- notes: assumed PI control pytest timeout includes +600 install budget matching treatment; local uses +120 per plan. Two thin wrappers (PI + local CGROUP) share `_assert_control`. Skip-closed (unset env => skip) is the honest local proof; did not export e2e flags or run sudo/systemctl. Did not add OOMPolicy or memory.oom.group.
+
+## 2026-09-18 SECURITY reframe + CHANGELOG stub
+
+- item: Root SECURITY.md gains one paragraph: isolation is the operator's job (exec_prefix, dedicated user, no passwordless sudo, egress); agent-runner stays lifecycle-safety. CHANGELOG adds ## [0.3.13] - UNRELEASED. No docs/SECURITY.md. Optional results template under gitignored docs/internal/notes is allowed and must not be staged.
+- rationale: plan says docs last. Last remaining unfinished item.
+- files: SECURITY.md, CHANGELOG.md
+- verification: `.venv/bin/python -m pytest tests/invariants/test_docs_index_complete.py tests/invariants/test_doc_claims_match_ssot.py -q` → 4 passed; `.venv/bin/ruff check . && .venv/bin/ruff format --check .` clean; `docs/SECURITY.md` absent
+- notes: assumed not naming a competitor in SECURITY.md (Ralph item asks for the operator-vs-lifecycle split). Did not edit runbook.md (not in the Ralph item). Results template written under gitignored docs/internal/notes and not staged. Did not claim uncapped-before-coma or a live two-arm run.

{cli_agent_runner-0.3.12 → cli_agent_runner-0.3.13}/CHANGELOG.md

@@ -5,6 +5,19 @@ 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.13] - 2026-09-18
+
+### Added
+- Two production cgroup modes are now checkable on the same paced growth child: treatment (`MemorySwapMax` infinity) still cooperatively terminates and reaps; control (`MemorySwapMax=0`) defers to kernel cgroup-OOM of the capped child. Both leave the host up. The uncapped-before-coma case stays inferred.
+- `metrics.sample()` always includes corroborating `psi_full_total`, `io_psi_some_avg10`, and `io_psi_full_avg10` (`None` when unread). They are not kill rungs; `host_health.memory_pressure` stays blind to them.
+- `host_cgroup_memory_limit` carries `defer` as a bool (`True` when both caps are finite and plausible, including `MemorySwapMax=0`).
+- `round_cgroup_memory` may carry those PSI fields as optional flat keys at emit time; omitted when unread.
+
+### Docs
+- SECURITY.md: isolation is the operator's job (`exec_prefix`, dedicated user, no passwordless sudo, egress); agent-runner stays lifecycle-safety.
+
+No config migration required. `peek --json` schema stays `2.6`.
+
 ## [0.3.12] - 2026-09-18
 
 ### Added

{cli_agent_runner-0.3.12 → cli_agent_runner-0.3.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cli-agent-runner
-Version: 0.3.12
+Version: 0.3.13
 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.12 → cli_agent_runner-0.3.13}/SECURITY.md

@@ -37,6 +37,12 @@ unprivileged user, inside a container or VM, without passwordless sudo, and
 with egress limits. The supervisor's defenses bound the blast radius of a
 *misbehaving* agent, not a *hostile* one.
 
+Isolation is the operator's job. Isolation-enforcing supervisors exist;
+agent-runner deliberately is not one of them. Lifecycle-safety stays ours
+(round timeouts, process-group reaping, orphan stashing, auto-stop on
+critical alerts). Containment stays yours: `[agent] exec_prefix`, a dedicated
+unprivileged user, no passwordless sudo, and egress limits.
+
 ## Containment
 
 If you need to bound what the agent can reach, run it inside a container (or

{cli_agent_runner-0.3.12 → cli_agent_runner-0.3.13}/agent_runner/_emit/memory.py

@@ -112,6 +112,7 @@ def emit_host_cgroup_memory_limit(
     memory_max: int | None,
     memory_swap_max: int | None,
     cgroup_path: str | None,
+    defer: bool,
     swap_total_bytes: int | None = None,
     swap_cap_pct: float | None = None,
     memory_high: int | None = None,
@@ -120,8 +121,11 @@ def emit_host_cgroup_memory_limit(
 ) -> None:
     """Emit once at serve startup: this process's cgroup v2 memory budget
     (``metrics.cgroup_memory_limits``). ``None`` fields mean unlimited (or
-    cgroup v2 unavailable). Serve uses this once to decide whether the
-    mid-round hard floor can defer to kernel cgroup-OOM -- see
+    cgroup v2 unavailable). ``defer`` is the already-computed mid-round-floor
+    decision (True when both caps are finite and plausible, including
+    ``MemorySwapMax=0``) -- the event carries that yes/no, not just the
+    inputs. Serve uses this once to decide whether the mid-round hard floor
+    can defer to kernel cgroup-OOM -- see
     ``emit_mem_pressure_deferred_to_cgroup`` below.
 
     This also carries an optional startup advisory
@@ -152,6 +156,7 @@ def emit_host_cgroup_memory_limit(
         memory_max=memory_max,
         memory_swap_max=memory_swap_max,
         cgroup_path=cgroup_path,
+        defer=defer,
         swap_total_bytes=swap_total_bytes,
         swap_cap_pct=swap_cap_pct,
         memory_high=memory_high,
@@ -171,6 +176,9 @@ def emit_round_cgroup_memory(
     events_oom_delta: int,
     events_oom_kill_delta: int,
     bounding_cgroup_path: str | None,
+    io_psi_some_avg10: float | None = None,
+    io_psi_full_avg10: float | None = None,
+    psi_full_total: float | int | None = None,
 ) -> None:
     """Emit once per round: the round's peak cgroup ``memory.current`` (+swap) and
     the ``memory.events`` DELTAS (high/max/oom/oom_kill) over the round, read at the
@@ -185,9 +193,24 @@ def emit_round_cgroup_memory(
     process's own) cgroup; here it names the BOUNDING ANCESTOR (the one whose
     ``memory.max`` actually binds). Same key, two meanings across the two
     events an operator correlates would be a trap -- events.md pins field
-    semantics permanently once shipped, so the distinct name is chosen now."""
+    semantics permanently once shipped, so the distinct name is chosen now.
+
+    Optional corroborating PSI fields (``io_psi_some_avg10``,
+    ``io_psi_full_avg10``, ``psi_full_total``) come from ``metrics.sample()``
+    at emit time. Each is omitted when unread (``None``). They ride FLAT on
+    this event -- never copied into ``Pressure.context``, so the kill ladder
+    stays blind to them."""
     from agent_runner.events import ROUND_CGROUP_MEMORY, emit
 
+    extra = {
+        k: v
+        for k, v in (
+            ("io_psi_some_avg10", io_psi_some_avg10),
+            ("io_psi_full_avg10", io_psi_full_avg10),
+            ("psi_full_total", psi_full_total),
+        )
+        if v is not None
+    }
     emit(
         log_dir,
         ROUND_CGROUP_MEMORY,
@@ -199,6 +222,7 @@ def emit_round_cgroup_memory(
         events_oom_delta=events_oom_delta,
         events_oom_kill_delta=events_oom_kill_delta,
         bounding_cgroup_path=bounding_cgroup_path,
+        **extra,
     )
 
 

{cli_agent_runner-0.3.12 → cli_agent_runner-0.3.13}/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.12'
-__version_tuple__ = version_tuple = (0, 3, 12)
+__version__ = version = '0.3.13'
+__version_tuple__ = version_tuple = (0, 3, 13)
 
 __commit_id__ = commit_id = None

{cli_agent_runner-0.3.12 → cli_agent_runner-0.3.13}/agent_runner/cli/_serve_cgroup.py

@@ -128,6 +128,8 @@ def _emit_round_cgroup_memory(
     def _delta(key: str) -> int:
         return max(0, cur_ev.get(key, 0) - base_ev.get(key, 0))
 
+    # One sample() at emit -- corroborating IO/mem-PSI, omitted when unread.
+    s = metrics.sample()
     emit_round_cgroup_memory(
         log_dir,
         round_num=round_num,
@@ -138,6 +140,9 @@ def _emit_round_cgroup_memory(
         events_oom_delta=_delta("oom"),
         events_oom_kill_delta=_delta("oom_kill"),
         bounding_cgroup_path=state["bounding_cgroup_path"],
+        io_psi_some_avg10=s.get("io_psi_some_avg10"),
+        io_psi_full_avg10=s.get("io_psi_full_avg10"),
+        psi_full_total=s.get("psi_full_total"),
     )
     return cur, oom_kill_baseline
 
@@ -277,8 +282,9 @@ def _release_brake(log_dir: Path, round_num: int, previous: str, *, reason: str)
 
 def _probe_and_emit_cgroup_defer(log_dir: Path, *, brake_memory_high: bool = False) -> bool:
     """Probe this process's cgroup v2 memory budget once at serve startup,
-    emit host_cgroup_memory_limit for observability, and return whether the
-    mid-round hard floor should defer to kernel cgroup-OOM: True only when
+    emit host_cgroup_memory_limit (including the ``defer`` decision, not just
+    the inputs) for observability, and return whether the mid-round hard
+    floor should defer to kernel cgroup-OOM: True only when
     BOTH memory.max and memory.swap.max are finite (the field host's
     MemoryMax=320M + MemorySwapMax=160M shape) -- that budget is bounded end
     to end, so cgroup-OOM WILL fire and contain the agent while the host
@@ -401,6 +407,7 @@ def _probe_and_emit_cgroup_defer(log_dir: Path, *, brake_memory_high: bool = Fal
         memory_max=limits["memory_max"],
         memory_swap_max=swap_max,
         cgroup_path=limits["cgroup_path"],
+        defer=defer,
         swap_total_bytes=swap_total,
         swap_cap_pct=swap_cap_pct,
         memory_high=memory_high,

{cli_agent_runner-0.3.12 → cli_agent_runner-0.3.13}/agent_runner/metrics.py

@@ -17,14 +17,18 @@ from agent_runner.clock import SYSTEM_CLOCK
 from agent_runner.events import now_iso_ms
 
 _PSI_MEMORY_PATH = Path("/proc/pressure/memory")
+_PSI_IO_PATH = Path("/proc/pressure/io")
 
 
-def _read_psi(path: Path = _PSI_MEMORY_PATH) -> tuple[float, float] | None:
-    """Parse ``/proc/pressure/memory``'s ``some``/``full`` ``avg10`` fields.
+def _read_psi(path: Path = _PSI_MEMORY_PATH) -> tuple[float, float, int | None] | None:
+    """Parse a PSI file's ``some``/``full`` ``avg10`` and full-line ``total``.
 
-    Returns ``None`` when the file is absent (non-Linux, or a kernel built
-    without ``CONFIG_PSI``) or unreadable (``psi=0`` boot param) — the
-    caller (``host_health``) degrades gracefully down the signal ladder.
+    Returns ``(some_avg10, full_avg10, full_total)``. ``full_avg10`` is ``0.0``
+    when the full line is missing; ``full_total`` is ``int(total=)`` from the
+    full line, else ``None``. Returns ``None`` when the file is absent
+    (non-Linux, or a kernel built without ``CONFIG_PSI``) or unreadable
+    (``psi=0`` boot param) — the caller (``host_health``) degrades
+    gracefully down the signal ladder.
     """
     try:
         text = path.read_text(encoding="utf-8")
@@ -32,11 +36,17 @@ def _read_psi(path: Path = _PSI_MEMORY_PATH) -> tuple[float, float] | None:
         return None
     some_avg10: float | None = None
     full_avg10: float | None = None
+    full_total: int | None = None
     for line in text.splitlines():
         parts = line.split()
         if not parts:
             continue
         fields = dict(p.split("=", 1) for p in parts[1:] if "=" in p)
+        if parts[0] == "full":
+            try:
+                full_total = int(fields["total"])
+            except (KeyError, ValueError):
+                pass
         raw = fields.get("avg10")
         if raw is None:
             continue
@@ -50,7 +60,7 @@ def _read_psi(path: Path = _PSI_MEMORY_PATH) -> tuple[float, float] | None:
             full_avg10 = value
     if some_avg10 is None:
         return None
-    return some_avg10, full_avg10 if full_avg10 is not None else 0.0
+    return some_avg10, full_avg10 if full_avg10 is not None else 0.0, full_total
 
 
 def sample() -> dict[str, Any]:
@@ -58,22 +68,28 @@ def sample() -> dict[str, Any]:
 
     Deliberately NOT ``collect()`` (which shells out to ``pgrep`` for
     ``agent_process_count``, see ``_count_agent_processes`` below) — this is
-    psutil counters + one optional ``/proc`` file read, safe to call every
-    ~10s in a hot loop (e.g. a serve-loop mid-round check). ``host_health``
-    is the pure interpreter of what this returns; this function only samples.
+    psutil counters + optional ``/proc/pressure/{memory,io}`` reads, safe to
+    call every ~10s in a hot loop (e.g. a serve-loop mid-round check).
+    ``host_health`` is the pure interpreter of what this returns; this
+    function only samples. IO-PSI and mem-PSI ``total`` are corroborating
+    fields the ladder ignores.
 
     ``swap_sout`` is cumulative (bytes swapped out since boot) — callers
     wanting a rate/delta diff two samples themselves.
     """
     vm = psutil.virtual_memory()
     swap = psutil.swap_memory()
-    psi = _read_psi()
+    mem = _read_psi() or (None, None, None)
+    io_some, io_full, _ = _read_psi(_PSI_IO_PATH) or (None, None, None)
     return {
         "mem_available_mb": vm.available // (1024 * 1024),
         "mem_free_mb": vm.free // (1024 * 1024),
         "swap_sout": swap.sout,
-        "psi_some_avg10": psi[0] if psi is not None else None,
-        "psi_full_avg10": psi[1] if psi is not None else None,
+        "psi_some_avg10": mem[0],
+        "psi_full_avg10": mem[1],
+        "psi_full_total": mem[2],
+        "io_psi_some_avg10": io_some,
+        "io_psi_full_avg10": io_full,
     }
 
 

cli_agent_runner-0.3.13/tests/_clock.py

@@ -0,0 +1,95 @@
+"""Test clocks — FakeClock and TickingClock, both the full Clock surface.
+
+Lives in tests/ (not agent_runner/) so it has no production consumer to keep
+vulture happy.
+
+* ``FakeClock`` pins epoch, monotonic, UTC-now and tz-now together; ``sleep``
+  advances virtual time, so a chunked pause loop terminates deterministically
+  instead of needing a monkeypatched ``stop`` flag.
+* ``TickingClock`` is for real-subprocess poll loops: ``monotonic()`` jumps
+  ``step`` per call so a 10s sample interval elapses without waiting 10s;
+  ``sleep()`` is a real short block so the child can actually exit. Do not
+  substitute FakeClock there — FakeClock.sleep never yields to a live child.
+"""
+
+from __future__ import annotations
+
+import time
+from datetime import UTC, datetime
+from zoneinfo import ZoneInfo
+
+
+class FakeClock:
+    def __init__(self, epoch: float = 1_700_000_000.0, *, start: str | None = None):
+        """``start``, when given, is an ISO-8601 UTC timestamp (e.g.
+        ``"2026-09-16T00:00:00Z"``) converted to ``epoch`` -- a more readable
+        alternative to a raw epoch float for tests that pin a calendar date."""
+        if start is not None:
+            epoch = datetime.fromisoformat(start.replace("Z", "+00:00")).timestamp()
+        self._epoch = epoch
+        self._mono = 0.0
+        self.slept: list[float] = []
+
+    # --- Clock surface -------------------------------------------------------
+    def epoch(self) -> float:
+        return self._epoch
+
+    def monotonic(self) -> float:
+        return self._mono
+
+    def sleep(self, seconds: float) -> None:
+        self.slept.append(seconds)
+        self.advance(seconds)  # virtual time moves so pause loops make progress
+
+    def now_utc(self) -> datetime:
+        return datetime.fromtimestamp(self._epoch, UTC)
+
+    def now_in_zone(self, tz_name: str | None) -> datetime:
+        if tz_name is None:
+            return self.now_utc().astimezone()
+        return self.now_utc().astimezone(ZoneInfo(tz_name))
+
+    # --- test controls -------------------------------------------------------
+    def advance(self, seconds: float) -> None:
+        self._epoch += seconds
+        self._mono += seconds
+
+    def warp_epoch(self, delta: float) -> None:
+        """Shift the WALL clock only (simulates an NTP step); monotonic unmoved —
+        so a deadline measured on monotonic must be unaffected."""
+        self._epoch += delta
+
+
+class TickingClock:
+    """Clock for real-subprocess poll loops.
+
+    ``monotonic()`` advances by ``step`` on every call so a ~10s sample interval
+    elapses without waiting ~10 real seconds. ``sleep()`` is a real short block
+    and does **not** advance monotonic — the poll fallback's per-tick pacing,
+    so a live child gets repeated chances to exit. Wall methods (``epoch`` /
+    ``now_utc`` / ``now_in_zone``) sit on a fixed epoch so this is a full
+    ``Clock``, not a two-method stub.
+    """
+
+    def __init__(self, step: float = 5.0, epoch: float = 1_700_000_000.0):
+        self._mono = 0.0
+        self._step = step
+        self._epoch = epoch
+
+    def epoch(self) -> float:
+        return self._epoch
+
+    def monotonic(self) -> float:
+        self._mono += self._step
+        return self._mono
+
+    def sleep(self, seconds: float) -> None:
+        time.sleep(seconds)
+
+    def now_utc(self) -> datetime:
+        return datetime.fromtimestamp(self._epoch, UTC)
+
+    def now_in_zone(self, tz_name: str | None) -> datetime:
+        if tz_name is None:
+            return self.now_utc().astimezone()
+        return self.now_utc().astimezone(ZoneInfo(tz_name))