cli-agent-runner 0.1.32__tar.gz → 0.1.34__tar.gz

{cli_agent_runner-0.1.32 → cli_agent_runner-0.1.34}/.gitignore

@@ -1,6 +1,9 @@
 # Internal working notes (specs, plans, drafts) — not for public repo.
 docs/internal/
 
+# Local git hooks — opt-in per clone; CI lint-commits is the authoritative gate.
+.githooks/
+
 # Python
 __pycache__/
 *.py[cod]

{cli_agent_runner-0.1.32 → cli_agent_runner-0.1.34}/CHANGELOG.md

@@ -7,6 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.34] - 2026-05-20
+
+### Added
+- New verb `agent-runner events --kind K[,K2,...] [--window N] [--tail]` for event-stream observation. One-shot or streaming mode (JSON Lines output). Verbs: 13 → 14.
+- `SystemMetrics.agent_process_count: int` — `pgrep -xc` of agent binary basename, host-wide. Surfaces orphan agent processes in peek output.
+- `docs/plugins.md` worked example for custom monitor detector with plugin-emitted exempt flag — pattern for project-specific detectors that exclude exempt-by-design rounds.
+
+### Removed
+- `peek --select events.<kind>` selector (mis-placed in state-snapshot verb). Use `events --kind <kind>` instead. 1-line `s///` migration.
+
+See `docs/migrations/0.1.34.md`.
+
+## [0.1.33] - 2026-05-19
+
+### Added
+- `_5XX_STATUSES` includes 529 (Anthropic's "overloaded") — now classified as `api_transient_5xx`.
+- Exp backoff for estimated-class transient errors (`rate_limit_model` / `api_transient_5xx` / `api_timeout`): consecutive failures multiply the wait `2^N` capped at 32× and 30 minutes absolute. Server-authoritative `rate_limit_account` unchanged.
+- `transient_error_backoff_capped` event gains `original_reset_at_epoch`, `applied_reset_at_epoch`, `consecutive_count`, `capped_by_absolute_max` fields for backoff-curve observability.
+- `docs/thesis.md` names the server-authoritative vs estimated reset principle.
+
+See `docs/migrations/0.1.33.md`.
+
 ## [0.1.32] - 2026-05-18
 
 ### Added

{cli_agent_runner-0.1.32 → cli_agent_runner-0.1.34}/CONTRIBUTING.md

@@ -9,7 +9,6 @@ git clone https://github.com/wan9yu/cli-agent-runner.git
 cd cli-agent-runner
 python3 -m venv .venv && source .venv/bin/activate
 pip install -e ".[dev]"
-git config core.hooksPath .githooks    # enables the commit-msg lint hook
 ./build.sh check
 ```
 
@@ -17,13 +16,6 @@ git config core.hooksPath .githooks    # enables the commit-msg lint hook
 + integration tests, the literate quickstart, and the docs CI gate. It's
 what GitHub Actions runs on every push and PR.
 
-`git config core.hooksPath .githooks` activates the in-repo
-[`.githooks/commit-msg`](.githooks/commit-msg) hook which rejects commit
-messages containing `Co-Authored-By:` trailers, robot emojis, or other
-AI-tool attribution patterns. The same check runs in CI (`lint-commits`
-job) and as a pytest invariant (`tests/invariants/test_no_ai_signatures.py`)
-— defense in depth.
-
 ## Workflow
 
 1. Open an issue first for non-trivial changes — saves wasted work on both sides.
@@ -33,6 +25,9 @@ job) and as a pytest invariant (`tests/invariants/test_no_ai_signatures.py`)
 5. Run `./build.sh check` locally before pushing.
 6. Conventional Commits: `feat:` / `fix:` / `docs:` / `refactor:` / `test:` /
    `chore:` / `ci:` / `build:` / `perf:`. Subjects in English, imperative mood.
+   CI (`lint-commits` job) and `tests/invariants/test_no_ai_signatures.py`
+   reject auto-generated trailers and robot signatures — keep messages
+   human-authored.
 
 ## Architecture / docs
 

{cli_agent_runner-0.1.32 → cli_agent_runner-0.1.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-agent-runner
-Version: 0.1.32
+Version: 0.1.34
 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
@@ -80,14 +80,14 @@ agent-runner monitor              # live anomaly detection
 
 Full walkthrough: [`docs/quickstart.md`](docs/quickstart.md).
 
-## 13 verbs
+## 14 verbs
 
 | Lifecycle | Observation |
 |---|---|
 | `init` / `install` / `uninstall` | `peek` — state snapshot |
 | `start` / `stop` / `kill` / `cancel` | `watch` — peek in a refresh loop |
 | `restart` / `status` | `monitor` — 11 detectors, alerts, auto-stop |
-| `round` / `serve` | |
+| `round` / `serve` / `upgrade` | `events` — query / stream events.jsonl |
 
 Verb reference: [`docs/commands.md`](docs/commands.md).
 

{cli_agent_runner-0.1.32 → cli_agent_runner-0.1.34}/README.md

@@ -43,14 +43,14 @@ agent-runner monitor              # live anomaly detection
 
 Full walkthrough: [`docs/quickstart.md`](docs/quickstart.md).
 
-## 13 verbs
+## 14 verbs
 
 | Lifecycle | Observation |
 |---|---|
 | `init` / `install` / `uninstall` | `peek` — state snapshot |
 | `start` / `stop` / `kill` / `cancel` | `watch` — peek in a refresh loop |
 | `restart` / `status` | `monitor` — 11 detectors, alerts, auto-stop |
-| `round` / `serve` | |
+| `round` / `serve` / `upgrade` | `events` — query / stream events.jsonl |
 
 Verb reference: [`docs/commands.md`](docs/commands.md).
 

{cli_agent_runner-0.1.32 → cli_agent_runner-0.1.34}/agent_runner/_emit.py

@@ -281,15 +281,40 @@ def emit_transient_error_backoff_capped(
     agent: str,
     requested_sleep_s: int,
     applied_sleep_s: int,
+    original_reset_at_epoch: int | None = None,
+    applied_reset_at_epoch: int | None = None,
+    consecutive_count: int | None = None,
+    capped_by_absolute_max: bool | None = None,
 ) -> None:
-    """Emit defensive event when computed back-off exceeded 8h cap."""
+    """Emit when supervisor adjusts the plugin-emitted transient back-off.
+
+    Fires in two cases:
+    1. **Exp backoff applied** (0.1.33+): estimated-class transient errors
+       (`rate_limit_model` / `api_transient_5xx` / `api_timeout`) doubled
+       on consecutive failures. ``consecutive_count`` > 1, multiplier > 1×.
+    2. **Defensive cap hit** (0.1.20+): malformed `reset_at_epoch` or the
+       30-min absolute cap clipped the wait. ``capped_by_absolute_max`` True.
+
+    Fields ``original_reset_at_epoch`` / ``applied_reset_at_epoch`` /
+    ``consecutive_count`` / ``capped_by_absolute_max`` are 0.1.33+. Older
+    callers that pass only the first 4 kwargs continue to work; the new
+    fields are omitted from the payload when None.
+    """
     from agent_runner.events import TRANSIENT_ERROR_BACKOFF_CAPPED, emit
 
-    emit(
-        log_dir,
-        TRANSIENT_ERROR_BACKOFF_CAPPED,
-        classification=classification,
-        agent=agent,
-        requested_sleep_s=requested_sleep_s,
-        applied_sleep_s=applied_sleep_s,
-    )
+    kwargs: dict = {
+        "classification": classification,
+        "agent": agent,
+        "requested_sleep_s": requested_sleep_s,
+        "applied_sleep_s": applied_sleep_s,
+    }
+    if original_reset_at_epoch is not None:
+        kwargs["original_reset_at_epoch"] = original_reset_at_epoch
+    if applied_reset_at_epoch is not None:
+        kwargs["applied_reset_at_epoch"] = applied_reset_at_epoch
+    if consecutive_count is not None:
+        kwargs["consecutive_count"] = consecutive_count
+    if capped_by_absolute_max is not None:
+        kwargs["capped_by_absolute_max"] = capped_by_absolute_max
+
+    emit(log_dir, TRANSIENT_ERROR_BACKOFF_CAPPED, **kwargs)

cli_agent_runner-0.1.34/agent_runner/_throttle.py

@@ -0,0 +1,133 @@
+"""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
+import time
+from collections import deque
+from pathlib import Path
+from typing import Any
+
+from agent_runner.api_types import TransientErrorState
+
+
+def _check_throttle_state(log_dir: Path) -> 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.
+    """
+    candidates = sorted(log_dir.glob("events-*.jsonl"))
+    if not candidates:
+        return None
+    with candidates[-1].open() as f:
+        tail = deque(f, maxlen=100)
+    events: list[dict[str, Any]] = []
+    for line in tail:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            events.append(json.loads(line))
+        except json.JSONDecodeError:
+            continue
+
+    latest_detected: dict[str, Any] | None = None
+    for ev in reversed(events):
+        kind = ev.get("event")
+        if kind == "transient_error_recovered":
+            return None
+        if kind == "transient_error_detected":
+            latest_detected = ev
+            break
+
+    if latest_detected is None:
+        return None
+    reset_at = int(latest_detected.get("reset_at_epoch", 0))
+    if reset_at <= time.time():
+        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)),
+    )
+
+
+# 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,
+) -> 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 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":
+        # Server-authoritative: respect resetsAt verbatim, no counter touch.
+        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(time.time()) + 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.1.32 → cli_agent_runner-0.1.34}/agent_runner/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.32'
-__version_tuple__ = version_tuple = (0, 1, 32)
+__version__ = version = '0.1.34'
+__version_tuple__ = version_tuple = (0, 1, 34)
 
 __commit_id__ = commit_id = None

{cli_agent_runner-0.1.32 → cli_agent_runner-0.1.34}/agent_runner/api_types.py

@@ -56,6 +56,7 @@ class SystemMetrics:
     disk_free_gb: float = 0.0
     load_1m: float | None = None
     cpu_pct: float | None = None
+    agent_process_count: int = 0  # 0.1.34 — pgrep -xc <agent_binary>, host-wide
 
 
 @dataclass(frozen=True)

{cli_agent_runner-0.1.32 → cli_agent_runner-0.1.34}/agent_runner/builtin_plugins/_constants.py

@@ -21,9 +21,11 @@ _BACK_OFF_DEFAULTS: dict[str, int] = {
 }
 
 # 5xx codes treated as transient (retry-worthy server errors per RFC 9110):
-# 500=unexpected, 502=bad gateway, 503=unavailable, 504=gateway timeout.
+# 500=unexpected, 502=bad gateway, 503=unavailable, 504=gateway timeout,
+# 529=overloaded (Anthropic's non-RFC code emitted during sustained capacity
+# issues; treated as transient per Anthropic SDK behavior).
 # Excluded: 501 (not implemented = permanent), 505 (HTTP version mismatch).
-_5XX_STATUSES: frozenset[int] = frozenset({500, 502, 503, 504})
+_5XX_STATUSES: frozenset[int] = frozenset({500, 502, 503, 504, 529})
 
 _CLASSIFICATIONS: frozenset[str] = frozenset(
     {
@@ -38,3 +40,17 @@ _CLASSIFICATIONS: frozenset[str] = frozenset(
 rate_limit_account uses server-provided resetsAt (excluded from
 _BACK_OFF_DEFAULTS table); others use defaults from that table.
 """
+
+_EXP_CAP: int = 5
+"""Maximum exponent for transient-error consecutive backoff: 2^5 = 32×.
+
+Beyond this, the multiplier plateaus. Combined with _ABSOLUTE_CAP_S, this
+prevents runaway wait times during sustained outages (max wait = 30min).
+"""
+
+_ABSOLUTE_CAP_S: int = 1800
+"""Absolute upper bound on supervisor-applied transient back-off (30 min).
+
+Applies after exp multiplier — even if base × 2^5 exceeds this, the wait
+is clipped here. Defends against an indefinitely-stuck supervisor.
+"""

{cli_agent_runner-0.1.32 → cli_agent_runner-0.1.34}/agent_runner/cli/__init__.py

@@ -17,6 +17,7 @@ from pathlib import Path
 
 from agent_runner import __version__
 from agent_runner.cli import (
+    events_cmd,
     init_cmd,
     install_cmd,
     monitor_cmd,
@@ -63,6 +64,7 @@ def _build_parser() -> argparse.ArgumentParser:
     install_cmd.add_parser(sub, parent)
     service_cmd.add_parser(sub, parent)
     peek_cmd.add_parser(sub, parent)
+    events_cmd.add_parser(sub, parent)
     monitor_cmd.add_parser(sub, parent)
     serve_cmd.add_parser(sub, parent)
     round_cmd.add_parser(sub, parent)

cli_agent_runner-0.1.34/agent_runner/cli/events_cmd.py

@@ -0,0 +1,188 @@
+"""agent-runner events — event-stream observation verb (0.1.34+).
+
+One-shot (--window N) or streaming (--tail) query against events.jsonl.
+JSON Lines output (one JSON object per line, no pretty-print).
+
+Current-month scope only. Tail mode follows month rollover via per-poll glob.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import signal
+import sys
+import time
+from datetime import UTC, datetime
+from pathlib import Path
+
+# Sentinel for "user did not explicitly set --window" so we can detect
+# --window + --tail combinations. argparse mutually-exclusive group would
+# be cleaner but argparse doesn't support "exclusive only when X has value Y".
+_WINDOW_DEFAULT_SENTINEL = -1
+
+
+def _positive_int(s: str) -> int:
+    """Parse positive integer (duplicate of peek_cmd._positive_int; KISS)."""
+    try:
+        n = int(s)
+    except ValueError as e:
+        raise argparse.ArgumentTypeError(f"expects positive int, got {s!r}") from e
+    if n <= 0:
+        raise argparse.ArgumentTypeError(f"expects positive int (> 0), got {n}")
+    return n
+
+
+def _parse_kinds(raw: str) -> set[str]:
+    """Parse comma-separated kinds; strip whitespace; reject empty."""
+    parts = [k.strip() for k in (raw or "").split(",") if k.strip()]
+    return set(parts)
+
+
+def add_parser(sub, parent) -> None:
+    p = sub.add_parser(
+        "events",
+        parents=[parent],
+        help="Query / stream events from events.jsonl by kind",
+    )
+    p.add_argument(
+        "--kind",
+        type=str,
+        required=True,
+        metavar="K[,K2,...]",
+        help="Comma-separated event kinds (OR-filtered). At least one required.",
+    )
+    p.add_argument(
+        "--window",
+        type=_positive_int,
+        default=_WINDOW_DEFAULT_SENTINEL,
+        metavar="N",
+        help="One-shot mode: emit last N matching events (default 10).",
+    )
+    p.add_argument(
+        "--tail",
+        action="store_true",
+        help=("Streaming mode: emit each new matching event as it fires (blocks until SIGINT)."),
+    )
+    p.set_defaults(func=cmd_events)
+
+
+def _resolve_log_dir(args) -> Path:
+    """Resolve log_dir from --config (used by both cmd_events and tests)."""
+    if getattr(args, "_log_dir_override", None) is not None:
+        return args._log_dir_override
+    from agent_runner.cli.common import work_dir_from_args
+    from agent_runner.config import load_config
+
+    cfg = load_config(work_dir_from_args(args) / "agent-runner.toml")
+    return cfg.runtime.log_dir
+
+
+def cmd_events(args) -> int:
+    kind_set = _parse_kinds(args.kind)
+    if not kind_set:
+        print(
+            "Error: --kind requires at least one non-empty event kind",
+            file=sys.stderr,
+        )
+        return 2
+
+    window_explicit = getattr(args, "_window_explicit", False) or (
+        args.window != _WINDOW_DEFAULT_SENTINEL
+    )
+    if args.tail and window_explicit:
+        print(
+            "Error: --window and --tail are mutually exclusive",
+            file=sys.stderr,
+        )
+        return 2
+
+    try:
+        log_dir = _resolve_log_dir(args)
+    except FileNotFoundError as e:
+        print(f"Error: config not found: {e}", file=sys.stderr)
+        return 1
+
+    if args.tail:
+        return _tail_events(log_dir, kind_set)
+
+    window = args.window if args.window != _WINDOW_DEFAULT_SENTINEL else 10
+    return _query_events(log_dir, kind_set, window)
+
+
+def _current_month_events_file(log_dir: Path) -> Path:
+    month = datetime.now(UTC).strftime("%Y-%m")
+    return log_dir / f"events-{month}.jsonl"
+
+
+def _query_events(log_dir: Path, kind_set: set[str], window: int) -> int:
+    """One-shot: read current-month events.jsonl, filter, print last N."""
+    events_file = _current_month_events_file(log_dir)
+    if not events_file.exists():
+        return 0
+
+    matches: list[str] = []
+    try:
+        with events_file.open("r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    evt = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if evt.get("event") in kind_set:
+                    matches.append(line)
+    except OSError as e:
+        print(f"Error: events file unreadable: {e}", file=sys.stderr)
+        return 1
+
+    for line in matches[-window:]:
+        print(line)
+    return 0
+
+
+def _tail_events(log_dir: Path, kind_set: set[str]) -> int:
+    """Streaming: poll current-month events.jsonl at 1s interval; emit each
+    new matching line as it fires. Blocks until SIGINT (KeyboardInterrupt).
+    Follows month rollover via per-poll glob.
+    """
+    last_size = 0
+    current_file: Path | None = None
+
+    def _handle_sigint(_signum, _frame):
+        raise KeyboardInterrupt()
+
+    signal.signal(signal.SIGINT, _handle_sigint)
+
+    try:
+        while True:
+            events_file = _current_month_events_file(log_dir)
+            if events_file != current_file:
+                # Month rollover OR first iteration: reset offset
+                current_file = events_file
+                last_size = events_file.stat().st_size if events_file.exists() else 0
+
+            if events_file.exists():
+                size = events_file.stat().st_size
+                if size > last_size:
+                    with events_file.open("r", encoding="utf-8") as f:
+                        f.seek(last_size)
+                        for line in f:
+                            line = line.strip()
+                            if not line:
+                                continue
+                            try:
+                                evt = json.loads(line)
+                            except json.JSONDecodeError:
+                                continue
+                            if evt.get("event") in kind_set:
+                                print(line, flush=True)
+                    last_size = size
+                elif size < last_size:
+                    # File truncated / rotated underneath us; reset
+                    last_size = 0
+            time.sleep(1.0)
+    except KeyboardInterrupt:
+        return 0

cli_agent_runner-0.1.34/agent_runner/cli/peek_cmd.py

@@ -0,0 +1,85 @@
+"""peek and watch subcommands — snapshot + auto-refresh."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+import time
+
+from agent_runner import api
+from agent_runner.cli.common import emit, fail, work_dir_from_args
+
+
+def _round_arg(s: str) -> int | str:
+    if s == "latest":
+        return s
+    try:
+        return int(s)
+    except ValueError as e:
+        raise argparse.ArgumentTypeError(f"--round expects int or 'latest', got {s!r}") from e
+
+
+def add_parser(sub, parent) -> None:
+    for verb, fn in (("peek", cmd_peek), ("watch", cmd_watch)):
+        p = sub.add_parser(
+            verb, parents=[parent], help=f"{verb} project state with optional drill-down"
+        )
+        p.add_argument(
+            "--round",
+            type=_round_arg,
+            default=None,
+            metavar="N",
+            help="Drill into round N (int or 'latest')",
+        )
+        p.add_argument("--log", action="store_true", help="Include current round's log tail")
+        p.add_argument(
+            "--events", type=int, default=None, metavar="N", help="Include last N events"
+        )
+        p.add_argument(
+            "--select",
+            type=str,
+            default=None,
+            help=(
+                "Selector: dot-path (e.g. system.disk_used_pct) extracts a subtree from "
+                "peek state. For event-stream queries, use the dedicated `events` verb."
+            ),
+        )
+        if verb == "watch":
+            p.add_argument(
+                "--interval",
+                type=int,
+                default=2,
+                metavar="SECONDS",
+                help="Refresh interval (default 2)",
+            )
+        p.set_defaults(func=fn)
+
+
+def cmd_peek(args) -> int:
+    select = args.select
+    try:
+        result = api.peek(
+            work_dir_from_args(args),
+            round=args.round,
+            log=args.log,
+            events=args.events,
+            select=select,
+        )
+    except KeyError as e:
+        return fail(str(e))
+    except FileNotFoundError as e:
+        return fail(f"config not found: {e}")
+    emit(result, json_mode=getattr(args, "json", False))
+    return 0
+
+
+def cmd_watch(args) -> int:
+    while True:
+        sys.stdout.write("\x1b[2J\x1b[H")
+        rc = cmd_peek(args)
+        if rc != 0:
+            return rc
+        try:
+            time.sleep(args.interval)
+        except KeyboardInterrupt:
+            return 0

{cli_agent_runner-0.1.32 → cli_agent_runner-0.1.34}/agent_runner/cli/serve_cmd.py

@@ -20,6 +20,7 @@ from pathlib import Path
 
 from agent_runner._substrate import compute_git_head, compute_paths_hash
 from agent_runner._throttle import _check_throttle_state
+from agent_runner._throttle import reset_counters as _reset_counters
 from agent_runner.api import (
     check_self_terminated_sentinel,
     emit_fresh_eyes_round_triggered,
@@ -151,6 +152,10 @@ def cmd(args) -> int:
                 elif action == "stop":
                     emit_rate_limit_stop(log_dir)
                     break
+            else:
+                # No active throttle this round — supervisor counters can reset.
+                # Next failure (if any) restarts the exp backoff curve from 1×.
+                _reset_counters()
             if stop_file is not None and stop_file.exists():
                 try:
                     content = stop_file.read_text(encoding="utf-8", errors="replace")[:200]