cli-agent-runner 0.2.9__tar.gz → 0.2.10__tar.gz

{cli_agent_runner-0.2.9 → cli_agent_runner-0.2.10}/.vulture-whitelist.py

@@ -57,6 +57,7 @@ throttled_until_epoch
 limit_type
 agent
 since_round
+phase
 
 # agent_runner.api_types.RoundResult
 round_num
@@ -106,6 +107,7 @@ reset_at_epoch
 classification
 agent
 since_round
+phase
 
 # agent_runner.config.AgentConfig
 command

{cli_agent_runner-0.2.9 → cli_agent_runner-0.2.10}/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.10] - 2026-08-29
+
+### Added
+- Throttle-aware skip: under `[phases] phase_policy = "skip"`, a phase whose provider is currently rate-limited/erroring is stepped over in the rotation — a healthy sibling runs instead of the whole loop sleeping on the throttle. No new config; the trigger is the existing `skip` policy.
+- `transient_error_detected` now carries the failing `phase`; `peek --json` `rate_limit` and the HTTP progress state surface which phase is throttled.
+- `transient_error_recovered` is emitted when a skip-around throttle clears (events-derived, restart-safe, no double-emit with the back-off path).
+
+### Notes
+- Only `skip` routes around a throttle; `wait`, `--ignore-schedule`, and non-`[phases]` configs keep the 0.2.9 global back-off. When every phase is throttled or window-closed, the loop waits until the earlier of a window opening or the throttle resetting.
+
+See `docs/migrations/0.2.md`.
+
 ## [0.2.9] - 2026-08-28
 
 ### Added

{cli_agent_runner-0.2.9 → cli_agent_runner-0.2.10}/PKG-INFO

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

@@ -188,8 +188,13 @@ def emit_transient_error_detected(
     reset_at_epoch: int,
     round_num: int,
     raw: str,
+    phase: str = "",
 ) -> None:
-    """Emit detection of a transient agent error (rate limit / 5xx / timeout)."""
+    """Emit detection of a transient agent error (rate limit / 5xx / timeout).
+
+    ``phase`` is the rotation phase the failing round ran under ("" when the
+    config has no ``[phases]``). It lets a ``phase_policy = "skip"`` serve loop
+    step over *this* phase while a healthy sibling keeps running."""
     from agent_runner._redact import redact_secrets
     from agent_runner.events import TRANSIENT_ERROR_DETECTED, emit
 
@@ -202,6 +207,7 @@ def emit_transient_error_detected(
         reset_at_epoch=reset_at_epoch,
         round_num=round_num,
         raw=raw,
+        phase=phase,
     )
 
 

cli_agent_runner-0.2.10/agent_runner/_throttle.py

@@ -0,0 +1,220 @@
+"""Throttle state helpers — read events.jsonl tail for transient error state.
+
+Internal module. Callers: runner.py (serve loop back-off), api.py (peek).
+Separated from runner.py to satisfy the ouroboros defense: runner.py writes
+events.jsonl but must never read it back (§3 module boundary invariant).
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import UTC
+from pathlib import Path
+from typing import Any
+
+from agent_runner.api_types import TransientErrorState
+from agent_runner.clock import SYSTEM_CLOCK, Clock
+from agent_runner.events import (
+    TRANSIENT_ERROR_DETECTED,
+    TRANSIENT_ERROR_RECOVERED,
+    parse_iso_ms,
+)
+
+# _scan_events_for_transient sentinel: file held no transient event at all
+# (distinct from "latest transient was a recovered" → None).
+_NO_TRANSIENT = object()
+
+
+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).
+
+    Forward single-pass, O(1) memory — it keeps only the latest transient event,
+    never a 100-line tail. That matters for throttle-aware skip: the loop keeps
+    emitting rounds on healthy phases during a throttle, so the ``detected`` event
+    can be thousands of lines back; a bounded tail would scroll it out and make the
+    supervisor forget the throttle mid-window."""
+    latest: Any = _NO_TRANSIENT
+    with path.open() as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                ev = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            kind = ev.get("event")
+            if kind == TRANSIENT_ERROR_DETECTED:
+                latest = ev
+            elif kind == TRANSIENT_ERROR_RECOVERED:
+                latest = None
+    return latest
+
+
+def _latest_unrecovered_detected(log_dir: Path) -> dict[str, Any] | None:
+    """The most recent ``transient_error_detected`` with no
+    ``transient_error_recovered`` after it, or None. Shared by
+    :func:`_check_throttle_state` (still-throttled?) and :func:`pending_recovered`
+    (cleared-without-a-breadcrumb?).
+
+    Scans the newest monthly ``events-*.jsonl`` and, only if it holds no transient
+    event yet, the previous month's — so a throttle that spans a month boundary
+    (detected in the old file, cleared in the new) is not orphaned."""
+    candidates = sorted(log_dir.glob("events-*.jsonl"))
+    for path in reversed(candidates[-2:]):
+        result = _scan_events_for_transient(path)
+        if result is not _NO_TRANSIENT:
+            return result  # a detected dict, or None (latest transient was recovered)
+    return None
+
+
+def _check_throttle_state(
+    log_dir: Path, *, clock: Clock = SYSTEM_CLOCK
+) -> TransientErrorState | None:
+    """Scan events.jsonl tail for latest unmatched transient error.
+
+    Reads `transient_error_detected` / `transient_error_recovered` event names.
+    Returns TransientErrorState if currently throttled (reset still in future,
+    no matching recovered after). Restart-safe.
+
+    ``clock`` supplies the wall clock the reset is compared against — inject a
+    ``FakeClock`` in tests to pin an exact instant. Only the reset comparison
+    reads it; the event scan is pure.
+    """
+    now = clock.epoch()
+    latest_detected = _latest_unrecovered_detected(log_dir)
+    if latest_detected is None:
+        return None
+    reset_at = int(latest_detected.get("reset_at_epoch", 0))
+    if reset_at <= now:
+        return None  # Reset already passed without recovery emit; treat as recovered
+
+    classification = str(latest_detected.get("classification", "rate_limit_account"))
+
+    return TransientErrorState(
+        reset_at_epoch=reset_at,
+        classification=classification,
+        agent=str(latest_detected.get("agent", "unknown")),
+        since_round=int(latest_detected.get("round_num", 0)),
+        phase=str(latest_detected.get("phase", "")),
+    )
+
+
+def _throttled_for_s(ts: Any, *, clock: Clock = SYSTEM_CLOCK) -> int:
+    """Seconds since a detected event's ``ts`` (best-effort; 0 if unparseable).
+    ``clock`` supplies now; inject a ``FakeClock`` for exact-value tests."""
+    if not ts:
+        return 0
+    try:
+        detected = parse_iso_ms(str(ts))  # events.py owns the Z→+00:00 workaround
+    except (ValueError, TypeError):
+        return 0
+    if detected.tzinfo is None:
+        detected = detected.replace(tzinfo=UTC)  # hand-injected naive ts → treat as UTC
+    return max(0, int(clock.epoch() - detected.timestamp()))
+
+
+def pending_recovered(log_dir: Path, *, clock: Clock = SYSTEM_CLOCK) -> tuple[str, str, int] | None:
+    """``(classification, agent, throttled_for_s)`` iff a transient throttle
+    cleared WITHOUT a recovered breadcrumb — the latest
+    ``transient_error_detected`` has ``reset_at <= now`` and NO
+    ``transient_error_recovered`` after it.
+
+    This is the throttle-aware-skip path: the loop rotated to a healthy phase
+    instead of calling ``_apply_back_off`` (which emits its own recovered), so
+    the multi-hour throttle would otherwise close with no breadcrumb. Being
+    events-derived, it is restart-safe AND never double-emits — once the caller
+    emits recovered, that event sits after the detected one and the predicate
+    goes quiet. Returns None while still throttled (reset in the future) or when
+    the back-off path already left a recovered."""
+    now = clock.epoch()
+    latest_detected = _latest_unrecovered_detected(log_dir)
+    if latest_detected is None:
+        return None
+    if int(latest_detected.get("reset_at_epoch", 0)) > now:
+        return None  # still throttled — not a clear transition
+    return (
+        str(latest_detected.get("classification", "rate_limit_account")),
+        str(latest_detected.get("agent", "unknown")),
+        _throttled_for_s(latest_detected.get("ts"), clock=clock),
+    )
+
+
+# Module-level supervisor state — bucket → consecutive-failure count.
+# Cleared by reset_counters() or by serve restart.
+_consecutive_failures: dict[str, int] = {}
+
+
+def compute_adjusted_reset_at(
+    *,
+    classification: str,
+    original_reset_at_epoch: int,
+    agent: str,
+    log_dir: Path,
+    clock: Clock = SYSTEM_CLOCK,
+) -> tuple[int, int, bool]:
+    """Apply exp backoff for estimated-class transient errors.
+
+    Returns (applied_reset_at_epoch, consecutive_count, capped_by_absolute_max).
+
+    For server-authoritative classification (``rate_limit_account``): returns
+    the original reset epoch verbatim, never increments the counter, and
+    never emits an adjustment event. Anthropic's resetsAt is authoritative.
+
+    For any classification absent from ``_BACK_OFF_DEFAULTS`` — i.e. one a
+    third-party plugin defined itself, which ``api_types.py`` types
+    ``classification`` as ``str`` to permit — the same verbatim path applies:
+    core has no base duration for it, so the emitter's reset_at_epoch is the
+    only non-invented answer.
+
+    For estimated classifications (``rate_limit_model``, ``api_transient_5xx``,
+    ``api_timeout``): increments the counter for this bucket, computes
+    duration = base × 2^min(n, _EXP_CAP), caps at _ABSOLUTE_CAP_S, emits
+    ``transient_error_backoff_capped`` if multiplier > 1 or capped.
+    """
+    from agent_runner._emit import emit_transient_error_backoff_capped
+    from agent_runner.builtin_plugins._constants import (
+        _ABSOLUTE_CAP_S,
+        _BACK_OFF_DEFAULTS,
+        _EXP_CAP,
+    )
+
+    if classification == "rate_limit_account" or classification not in _BACK_OFF_DEFAULTS:
+        # Server-authoritative, or a plugin's own classification (api_types.py types
+        # `classification` as str precisely so plugins can add their own): the emitter
+        # supplied reset_at_epoch, so respect it verbatim and never touch the counter.
+        return (original_reset_at_epoch, 0, False)
+
+    # Estimated class: apply exp backoff.
+    base = _BACK_OFF_DEFAULTS[classification]
+    n = _consecutive_failures.get(classification, 0)
+    multiplier = 2 ** min(n, _EXP_CAP)
+    extended_duration = base * multiplier
+    capped_by_absolute_max = extended_duration > _ABSOLUTE_CAP_S
+    applied_duration = min(extended_duration, _ABSOLUTE_CAP_S)
+    applied_reset_at = int(clock.epoch()) + applied_duration
+
+    new_count = n + 1
+    _consecutive_failures[classification] = new_count
+
+    # Emit observability event when supervisor adjusted the wait.
+    if multiplier > 1 or capped_by_absolute_max:
+        emit_transient_error_backoff_capped(
+            log_dir,
+            classification=classification,
+            agent=agent,
+            requested_sleep_s=int(base),
+            applied_sleep_s=applied_duration,
+            original_reset_at_epoch=original_reset_at_epoch,
+            applied_reset_at_epoch=applied_reset_at,
+            consecutive_count=new_count,
+            capped_by_absolute_max=capped_by_absolute_max,
+        )
+
+    return (applied_reset_at, new_count, capped_by_absolute_max)
+
+
+def reset_counters() -> None:
+    """Clear all bucket counters. Called by serve loop when no active throttle."""
+    _consecutive_failures.clear()

{cli_agent_runner-0.2.9 → cli_agent_runner-0.2.10}/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.9'
-__version_tuple__ = version_tuple = (0, 2, 9)
+__version__ = version = '0.2.10'
+__version_tuple__ = version_tuple = (0, 2, 10)
 
 __commit_id__ = commit_id = None

{cli_agent_runner-0.2.9 → cli_agent_runner-0.2.10}/agent_runner/agent_runtime.py

@@ -15,13 +15,14 @@ import shutil
 import signal
 import subprocess  # noqa: TID251 — sanctioned subprocess caller
 import threading
-import time
 from collections.abc import Callable
 from dataclasses import dataclass, field
 from pathlib import Path
 
 import psutil
 
+from agent_runner.clock import SYSTEM_CLOCK, Clock
+
 REAP_GRACE_S = 5
 
 
@@ -68,15 +69,15 @@ def _build_argv(command: list[str], prompt_arg_template: list[str], prompt: str)
     return list(command) + [a.replace("{prompt}", prompt) for a in prompt_arg_template]
 
 
-def _kill_pgroup(proc: subprocess.Popen) -> None:
+def _kill_pgroup(proc: subprocess.Popen, clock: Clock = SYSTEM_CLOCK) -> None:
     pgid = proc.pid
     try:
         os.killpg(pgid, signal.SIGTERM)
     except OSError:
         pass
-    deadline = time.time() + REAP_GRACE_S
-    while time.time() < deadline and proc.poll() is None:
-        time.sleep(0.1)
+    deadline = clock.epoch() + REAP_GRACE_S
+    while clock.epoch() < deadline and proc.poll() is None:
+        clock.sleep(0.1)
     try:
         os.killpg(pgid, signal.SIGKILL)
     except OSError:
@@ -173,6 +174,7 @@ def run(
     progress_interval_s: int = 0,
     on_grace_extended: Callable[[list[dict], list[dict]], None] | None = None,
     grace_kill_ignore_patterns: list[re.Pattern[str]] | None = None,
+    clock: Clock = SYSTEM_CLOCK,
 ) -> RunResult:
     """Spawn the agent subprocess and wait for exit or timeout.
 
@@ -213,7 +215,7 @@ def run(
     env = {**os.environ, **env_extra, "PWD": str(work_dir)}
     log_path.parent.mkdir(parents=True, exist_ok=True)
     log_file = log_path.open("w", encoding="utf-8")
-    start = time.time()
+    start = clock.epoch()
     last_progress_at = start
     proc = subprocess.Popen(
         argv,
@@ -246,13 +248,13 @@ def run(
     try:
         while True:
             ret = proc.poll()
-            now = time.time()
+            now = clock.epoch()
             if ret is not None:
                 duration = now - start
                 return RunResult(exit_code=ret, duration_s=duration, timed_out=False, pid=proc.pid)
             if now - start > timeout_s:
-                _kill_pgroup(proc)
-                duration = time.time() - start
+                _kill_pgroup(proc, clock)
+                duration = clock.epoch() - start
                 exit_code = proc.returncode if proc.returncode is not None else -1
                 return RunResult(
                     exit_code=exit_code, duration_s=duration, timed_out=True, pid=proc.pid
@@ -276,8 +278,8 @@ def run(
                                 on_grace_extended(live, ignored)
                             grace_extended_emitted = True
                     else:
-                        _kill_pgroup(proc)
-                        duration = time.time() - start
+                        _kill_pgroup(proc, clock)
+                        duration = clock.epoch() - start
                         exit_code = proc.returncode if proc.returncode is not None else -1
                         return RunResult(
                             exit_code=exit_code,
@@ -305,6 +307,6 @@ def run(
                         }
                     )
                     last_progress_at = now
-            time.sleep(0.2)
+            clock.sleep(0.2)
     finally:
         log_file.close()

{cli_agent_runner-0.2.9 → cli_agent_runner-0.2.10}/agent_runner/api.py

@@ -15,7 +15,6 @@ import shutil
 import signal
 import subprocess  # noqa: TID251 — api uses systemctl + ssh, both subprocess
 import sysconfig
-import time
 from collections.abc import Iterator, Sequence
 from pathlib import Path
 from typing import Any, Literal, TextIO
@@ -30,6 +29,7 @@ from agent_runner.api_types import (
     ServiceStatus,
     select_path,
 )
+from agent_runner.clock import SYSTEM_CLOCK
 from agent_runner.config import Config, RuntimeConfig, load_config
 from agent_runner.lifecycle import (
     PIDFile,
@@ -323,13 +323,13 @@ def kill(project: str | Path) -> ServiceStatus:
     if pid is None:
         return status(project)
     send_signal_to_pid(pid, signal.SIGTERM)
-    deadline = time.time() + 5
+    deadline = SYSTEM_CLOCK.epoch() + 5
     alive = True
-    while time.time() < deadline:
+    while SYSTEM_CLOCK.epoch() < deadline:
         alive = pid_alive(pid)
         if not alive:
             break
-        time.sleep(0.1)
+        SYSTEM_CLOCK.sleep(0.1)
     if alive:
         send_signal_to_pid(pid, signal.SIGKILL)
     return ServiceStatus(mode=ServiceMode.PID_FILE, active=alive, pid=pid)
@@ -448,6 +448,7 @@ def peek(
             limit_type=throttle.classification,
             agent=throttle.agent,
             since_round=throttle.since_round,
+            phase=throttle.phase,
         )
     raw_service = status(project if project is not None else work_dir)
     svc = dataclasses.replace(raw_service, rate_limit=rate_limit)
@@ -567,7 +568,7 @@ def _monitor_loop_iter(
                 log_dir=cfg.runtime.log_dir,
                 allowed_stop_names=cfg.monitor.auto_stop_on,
             )
-        time.sleep(interval_s)
+        SYSTEM_CLOCK.sleep(interval_s)
 
 
 def _tail_events_jsonl(
@@ -586,7 +587,6 @@ def _tail_events_jsonl(
     appears, it is picked up from byte 0.
     """
     import json as _json
-    import time as _time
 
     seen_positions: dict[Path, int] = {}
     if start_at_now:
@@ -620,7 +620,7 @@ def _tail_events_jsonl(
                     any_new = True
                 seen_positions[path] = f.tell()
         if not any_new:
-            _time.sleep(poll_interval_s)
+            SYSTEM_CLOCK.sleep(poll_interval_s)
 
 
 def _primary_prompt_file(cfg: Config) -> Path | None:

{cli_agent_runner-0.2.9 → cli_agent_runner-0.2.10}/agent_runner/api_types.py

@@ -48,6 +48,7 @@ class RateLimitState:
     limit_type: str
     agent: str
     since_round: int
+    phase: str = ""  # which rotation phase is throttled ("" = no [phases])
 
 
 @dataclass(frozen=True)
@@ -151,6 +152,7 @@ class TransientErrorState:
     classification: str
     agent: str
     since_round: int
+    phase: str = ""  # rotation phase the failing round ran under ("" = no [phases])
 
 
 @dataclass(frozen=True)

{cli_agent_runner-0.2.9 → cli_agent_runner-0.2.10}/agent_runner/builtin_plugins/claude_rate_limit.py

@@ -14,7 +14,6 @@ rate-limit detector was generalized to multi-classification in 0.1.23
 
 from __future__ import annotations
 
-import time
 from pathlib import Path
 from typing import Any
 
@@ -29,6 +28,7 @@ from agent_runner.builtin_plugins._constants import (
     classify_transient_status,
     json_events,
 )
+from agent_runner.clock import SYSTEM_CLOCK
 from agent_runner.hooks import HookContext, register_post_round_hook
 
 
@@ -51,7 +51,9 @@ class ClaudeErrorDetector:
 
         if parsed.get("transient_error"):
             te = parsed["transient_error"]
-            emit_transient_error_detected(ctx.log_dir, round_num=ctx.round_num, **te)
+            emit_transient_error_detected(
+                ctx.log_dir, round_num=ctx.round_num, phase=ctx.phase or "", **te
+            )
 
         if parsed.get("usage"):
             emit_agent_usage_recorded(
@@ -175,7 +177,7 @@ def _classify_transient_error(
         return {
             "classification": "rate_limit_account",
             "agent": "claude",
-            "reset_at_epoch": int(rate_limit_info.get("resetsAt", time.time() + 300)),
+            "reset_at_epoch": int(rate_limit_info.get("resetsAt", SYSTEM_CLOCK.epoch() + 300)),
             "raw": str((result_event or {}).get("result", ""))[:_RAW_CAP],
         }
     # rate_limit_event with null/other rateLimitType falls through to status-based
@@ -230,7 +232,7 @@ def _classify(classification: str, raw: str) -> dict[str, Any]:
     return {
         "classification": classification,
         "agent": "claude",
-        "reset_at_epoch": int(time.time() + duration),
+        "reset_at_epoch": int(SYSTEM_CLOCK.epoch() + duration),
         "raw": raw,
     }
 

{cli_agent_runner-0.2.9 → cli_agent_runner-0.2.10}/agent_runner/builtin_plugins/codewhale.py

@@ -12,7 +12,6 @@ is added when a real rate-limit sample is captured.
 
 from __future__ import annotations
 
-import time
 from pathlib import Path
 from typing import Any
 
@@ -26,6 +25,7 @@ from agent_runner.builtin_plugins._constants import (
     classify_transient_status,
     json_events,
 )
+from agent_runner.clock import SYSTEM_CLOCK
 from agent_runner.hooks import HookContext, register_post_round_hook
 
 
@@ -43,7 +43,10 @@ class CodewhaleErrorDetector:
         parsed = _parse_codewhale_log(log_path)
         if parsed.get("transient_error"):
             emit_transient_error_detected(
-                ctx.log_dir, round_num=ctx.round_num, **parsed["transient_error"]
+                ctx.log_dir,
+                round_num=ctx.round_num,
+                phase=ctx.phase or "",
+                **parsed["transient_error"],
             )
         if parsed.get("usage"):
             emit_agent_usage_recorded(
@@ -92,7 +95,7 @@ def _parse_codewhale_log(log_path: Path) -> dict[str, Any]:
             out["transient_error"] = {
                 "classification": classification,
                 "agent": "codewhale",
-                "reset_at_epoch": int(time.time() + duration),
+                "reset_at_epoch": int(SYSTEM_CLOCK.epoch() + duration),
                 "raw": str(error_event.get("error", "error"))[:_RAW_CAP],
             }
     return out

{cli_agent_runner-0.2.9 → cli_agent_runner-0.2.10}/agent_runner/builtin_plugins/gemini.py

@@ -7,7 +7,6 @@ agent_usage_recorded event families without any agent-runner core changes.
 
 from __future__ import annotations
 
-import time
 from pathlib import Path
 from typing import Any
 
@@ -21,6 +20,7 @@ from agent_runner.builtin_plugins._constants import (
     classify_transient_status,
     json_events,
 )
+from agent_runner.clock import SYSTEM_CLOCK
 from agent_runner.hooks import HookContext, register_post_round_hook
 
 
@@ -38,7 +38,9 @@ class GeminiErrorDetector:
         parsed = _parse_gemini_log(log_path)
         if parsed.get("transient_error"):
             te = parsed["transient_error"]
-            emit_transient_error_detected(ctx.log_dir, round_num=ctx.round_num, **te)
+            emit_transient_error_detected(
+                ctx.log_dir, round_num=ctx.round_num, phase=ctx.phase or "", **te
+            )
         if parsed.get("usage"):
             emit_agent_usage_recorded(
                 ctx.log_dir,
@@ -82,7 +84,7 @@ def _parse_gemini_log(log_path: Path) -> dict[str, Any]:
             out["transient_error"] = {
                 "classification": classification,
                 "agent": "gemini",
-                "reset_at_epoch": int(time.time() + duration),
+                "reset_at_epoch": int(SYSTEM_CLOCK.epoch() + duration),
                 "raw": raw,
             }
     return out

{cli_agent_runner-0.2.9 → cli_agent_runner-0.2.10}/agent_runner/builtin_plugins/kimi.py

@@ -30,7 +30,6 @@ retry record -- they arrive as plain text on stderr, e.g.
 
 from __future__ import annotations
 
-import time
 from pathlib import Path
 from typing import Any
 
@@ -41,6 +40,7 @@ from agent_runner.builtin_plugins._constants import (
     classify_transient_status,
     json_events,
 )
+from agent_runner.clock import SYSTEM_CLOCK
 from agent_runner.hooks import HookContext, register_post_round_hook
 
 
@@ -62,7 +62,9 @@ class KimiErrorDetector:
             return
         transient_error = _parse_kimi_log(log_path)
         if transient_error:
-            emit_transient_error_detected(ctx.log_dir, round_num=ctx.round_num, **transient_error)
+            emit_transient_error_detected(
+                ctx.log_dir, round_num=ctx.round_num, phase=ctx.phase or "", **transient_error
+            )
 
 
 def _parse_kimi_log(log_path: Path) -> dict[str, Any] | None:
@@ -85,7 +87,7 @@ def _parse_kimi_log(log_path: Path) -> dict[str, Any] | None:
     return {
         "classification": classification,
         "agent": "kimi",
-        "reset_at_epoch": int(time.time() + _BACK_OFF_DEFAULTS[classification]),
+        "reset_at_epoch": int(SYSTEM_CLOCK.epoch() + _BACK_OFF_DEFAULTS[classification]),
         "raw": str(retry_event.get("error_message", "retrying"))[:_RAW_CAP],
     }
 

{cli_agent_runner-0.2.9 → cli_agent_runner-0.2.10}/agent_runner/builtin_plugins/pi.py

@@ -57,7 +57,6 @@ from __future__ import annotations
 
 import json
 import re
-import time
 from datetime import datetime
 from itertools import islice
 from pathlib import Path
@@ -74,6 +73,7 @@ from agent_runner.builtin_plugins._constants import (
     classify_transient_status,
     json_events,
 )
+from agent_runner.clock import SYSTEM_CLOCK
 from agent_runner.hooks import HookContext, register_post_round_hook
 
 _STATUS_RE = re.compile(r"^\s*(\d{3})\b")
@@ -118,8 +118,9 @@ class PiErrorDetector:
                     round_num=ctx.round_num,
                     classification=classification,
                     agent="pi",
-                    reset_at_epoch=int(time.time() + _BACK_OFF_DEFAULTS[classification]),
+                    reset_at_epoch=int(SYSTEM_CLOCK.epoch() + _BACK_OFF_DEFAULTS[classification]),
                     raw=str(error_text)[:_RAW_CAP],
+                    phase=ctx.phase or "",
                 )
             elif _is_auth_error(error_text):
                 # No transient classification on purpose — an auth failure is

{cli_agent_runner-0.2.9 → cli_agent_runner-0.2.10}/agent_runner/cli/events_cmd.py

@@ -18,10 +18,10 @@ import argparse
 import json
 import signal
 import sys
-import time
 from datetime import UTC, datetime
 from pathlib import Path
 
+from agent_runner.clock import SYSTEM_CLOCK
 from agent_runner.events import parse_iso_ms
 
 # Sentinel for "user did not explicitly set --window" so we can detect
@@ -160,7 +160,7 @@ def cmd_events(args) -> int:
 
 
 def _current_month_events_file(log_dir: Path) -> Path:
-    month = datetime.now(UTC).strftime("%Y-%m")
+    month = SYSTEM_CLOCK.now_utc().strftime("%Y-%m")
     return log_dir / f"events-{month}.jsonl"
 
 
@@ -308,6 +308,6 @@ def _tail_events(log_dir: Path, kind_set: set[str], since: datetime | None = Non
                 elif size < last_size:
                     # File truncated / rotated underneath us; reset
                     last_size = 0
-            time.sleep(1.0)
+            SYSTEM_CLOCK.sleep(1.0)
     except KeyboardInterrupt:
         return 0