cli-agent-runner 0.2.4__tar.gz → 0.2.5__tar.gz

{cli_agent_runner-0.2.4 → cli_agent_runner-0.2.5}/.github/workflows/release.yml

@@ -9,9 +9,13 @@ permissions:
 
 # Trusted Publishing: the `environment` name below MUST match the
 # `Environment name` field in the PyPI pending publisher config.
-# A mismatch fails publish with an opaque OIDC error.
-# Note: TestPyPI stage intentionally omitted — first release verification
-# happens via the manual approval gate on the `pypi` environment.
+# A mismatch fails publish with an opaque OIDC error. Keep the environment
+# declared even when it carries no protection rules — it is the OIDC claim,
+# not just an approval gate; deleting it breaks publishing outright. Whether
+# a tag publishes straight through or waits for a reviewer is configured in
+# the repo's environment settings, not here.
+# Note: TestPyPI stage intentionally omitted — the tag is the release signal;
+# pre-tag verification is `./build.sh check` plus the CI matrix on main.
 
 concurrency:
   group: release-${{ github.ref }}

{cli_agent_runner-0.2.4 → cli_agent_runner-0.2.5}/.vulture-whitelist.py

@@ -228,10 +228,6 @@ path
 # agent_runner.monitor.LocalSource
 log_dir
 
-# agent_runner.monitor.RemoteSource
-host
-project
-
 # agent_runner.startup_check.CheckResult
 name
 ok

{cli_agent_runner-0.2.4 → cli_agent_runner-0.2.5}/CHANGELOG.md

@@ -5,6 +5,17 @@ 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.5] - 2026-07-27
+
+### Added
+- `events --since <ISO ts>` — replays every matching event with `ts >= since`, across month files, one-shot or as the backlog phase of `--tail`. At-least-once: a client whose stream dropped reconnects with the last ts it saw and loses nothing (that one event may repeat).
+- `monitor --host <alias> --mode events` — a managed ssh event relay, replacing a hand-rolled `ssh … --tail; sleep` loop. Passes the remote's JSONL through unmodified, reconnects with `--since <last ts>` so a dropped link replays its gap, emits `monitor_remote_blip` per drop and `monitor_remote_giveup` + exit 1 once the outage passes `[monitor] remote_failure_tolerance_s`, and kills the ssh process GROUP on exit so no orphan tree survives. New flags `--kind` and `--remote-config`.
+
+### Removed
+- The polling remote monitor (`RemoteSource`, `run_remote_command`, `MonitorRemoteError`, auto-stop over ssh) — it read remote paths on the local filesystem and was already failing loud since 0.2.4. Detection is on-host by design; remote observation is the relay above. `monitor.on_alert` lost its `host` parameter and `monitor_auto_stop_triggered` its `host` field; `monitor_auto_stop_failed` now reports a failed *local* stop (previously a failed ssh stop) instead of crashing the monitor loop.
+
+See `docs/migrations/0.2.5.md`.
+
 ## [0.2.4] - 2026-07-27
 
 ### Added
@@ -648,6 +659,7 @@ No breaking changes. Plugin authors:
   between rounds, opt them out:
   ```python
   from agent_runner.vcs_state import register_plugin_owned_paths
+
   register_plugin_owned_paths(["your-output-dir/", "logs/your-plugin/**/*"])
   ```
 - If you followed the old `_register()` pattern from docs and noticed
@@ -938,7 +950,8 @@ Initial public release on PyPI as `cli-agent-runner`.
 - Tag-triggered release publishing to PyPI via Trusted Publishing OIDC,
   gated by a manual approval on the `pypi` GitHub environment.
 
-[Unreleased]: https://github.com/wan9yu/cli-agent-runner/compare/v0.2.4...HEAD
+[Unreleased]: https://github.com/wan9yu/cli-agent-runner/compare/v0.2.5...HEAD
+[0.2.5]: https://github.com/wan9yu/cli-agent-runner/compare/v0.2.4...v0.2.5
 [0.2.4]: https://github.com/wan9yu/cli-agent-runner/compare/v0.2.3...v0.2.4
 [0.2.3]: https://github.com/wan9yu/cli-agent-runner/compare/v0.2.2...v0.2.3
 [0.2.2]: https://github.com/wan9yu/cli-agent-runner/compare/v0.2.1...v0.2.2

{cli_agent_runner-0.2.4 → cli_agent_runner-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-agent-runner
-Version: 0.2.4
+Version: 0.2.5
 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
@@ -28,7 +28,7 @@ Requires-Dist: psutil>=5.9
 Provides-Extra: dev
 Requires-Dist: pytest-cov>=5; extra == 'dev'
 Requires-Dist: pytest>=8; extra == 'dev'
-Requires-Dist: ruff>=0.5; extra == 'dev'
+Requires-Dist: ruff<0.17,>=0.16; extra == 'dev'
 Requires-Dist: vulture>=2.13; extra == 'dev'
 Provides-Extra: e2e
 Requires-Dist: pytest>=8; extra == 'e2e'
@@ -123,13 +123,24 @@ agent-runner monitor                  # 30s poll
 agent-runner monitor --json | jq -c   # pipe to downstream consumers
 ```
 
-> **Remote monitoring is unsupported in this version**: `monitor --host <alias>`
-> cannot read a remote host's round logs or events, so it exits with an error at
-> startup instead of watching an empty world and reporting healthy. Run the
-> monitor on the supervised host itself (`ssh <alias>`, then `agent-runner
-> monitor`). See [`docs/runbook.md`](docs/runbook.md) § "Remote monitor & SSH
-> trust" — the SSH trust boundary applies to any agent-runner command you drive
-> over ssh.
+Watch a remote host's event stream from your laptop — one command instead of a
+hand-rolled `ssh … ; sleep` loop:
+
+```bash
+agent-runner monitor --host pi --mode events   # managed ssh relay, JSONL stdout
+```
+
+The relay reconnects with `--since <last ts>` so a dropped link replays its gap,
+gives up (exit 1) once the outage passes `remote_failure_tolerance_s`, and kills
+the ssh process group on exit so no orphan tree is left behind.
+
+> **Detection stays on the host.** `--host` with `--mode anomaly | narrate |
+> http` exits with an error: the detectors read the supervised host's logs and
+> auto-stop its service, which must keep working with your laptop closed. Run
+> the monitor there (`ssh <alias>`, then `agent-runner monitor`) and relay its
+> events here. See [`docs/runbook.md`](docs/runbook.md) § "Remote event relay &
+> SSH trust" — the SSH trust boundary applies to any agent-runner command you
+> drive over ssh.
 
 ## Documentation
 

{cli_agent_runner-0.2.4 → cli_agent_runner-0.2.5}/README.md

@@ -87,13 +87,24 @@ agent-runner monitor                  # 30s poll
 agent-runner monitor --json | jq -c   # pipe to downstream consumers
 ```
 
-> **Remote monitoring is unsupported in this version**: `monitor --host <alias>`
-> cannot read a remote host's round logs or events, so it exits with an error at
-> startup instead of watching an empty world and reporting healthy. Run the
-> monitor on the supervised host itself (`ssh <alias>`, then `agent-runner
-> monitor`). See [`docs/runbook.md`](docs/runbook.md) § "Remote monitor & SSH
-> trust" — the SSH trust boundary applies to any agent-runner command you drive
-> over ssh.
+Watch a remote host's event stream from your laptop — one command instead of a
+hand-rolled `ssh … ; sleep` loop:
+
+```bash
+agent-runner monitor --host pi --mode events   # managed ssh relay, JSONL stdout
+```
+
+The relay reconnects with `--since <last ts>` so a dropped link replays its gap,
+gives up (exit 1) once the outage passes `remote_failure_tolerance_s`, and kills
+the ssh process group on exit so no orphan tree is left behind.
+
+> **Detection stays on the host.** `--host` with `--mode anomaly | narrate |
+> http` exits with an error: the detectors read the supervised host's logs and
+> auto-stop its service, which must keep working with your laptop closed. Run
+> the monitor there (`ssh <alias>`, then `agent-runner monitor`) and relay its
+> events here. See [`docs/runbook.md`](docs/runbook.md) § "Remote event relay &
+> SSH trust" — the SSH trust boundary applies to any agent-runner command you
+> drive over ssh.
 
 ## Documentation
 

{cli_agent_runner-0.2.4 → cli_agent_runner-0.2.5}/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.4'
-__version_tuple__ = version_tuple = (0, 2, 4)
+__version__ = version = '0.2.5'
+__version_tuple__ = version_tuple = (0, 2, 5)
 
 __commit_id__ = commit_id = None

{cli_agent_runner-0.2.4 → cli_agent_runner-0.2.5}/agent_runner/api.py

@@ -16,9 +16,9 @@ import signal
 import subprocess  # noqa: TID251 — api uses systemctl + ssh, both subprocess
 import sysconfig
 import time
-from collections.abc import Iterator
+from collections.abc import Iterator, Sequence
 from pathlib import Path
-from typing import Any, Literal
+from typing import Any, Literal, TextIO
 
 from agent_runner import events, lifecycle
 from agent_runner.api_types import (
@@ -383,8 +383,6 @@ from agent_runner import defenses, monitor  # noqa: E402
 from agent_runner.events import (  # noqa: E402
     AGENT_NETWORK_BLIP,
     HOOK_FAILED,
-    MONITOR_REMOTE_BLIP,
-    MONITOR_REMOTE_GIVEUP,
     MONITOR_STARTED,
 )
 
@@ -479,16 +477,13 @@ def peek(
     return state if select is None else select_path(state, select)
 
 
-def _poll_once(project: str | Path, *, host: str | None) -> list[monitor.Alert]:
+def _poll_once(project: str | Path) -> list[monitor.Alert]:
     work_dir = project if isinstance(project, Path) else Path.cwd()
     cfg = load_config(work_dir / "agent-runner.toml")
-    src: monitor.StateSource
-    if host is None:
-        src = monitor.LocalSource(log_dir=cfg.runtime.log_dir)
-    else:
-        # Dormant: monitor_loop rejects --host before any poll, so this branch
-        # is unreachable today. See monitor.MonitorRemoteUnsupportedError.
-        src = monitor.RemoteSource(host=host, project=_project_name(work_dir))
+    # Always local: detection runs on the supervised host by design. Remote
+    # observation is an event RELAY (``monitor --host X --mode events``), not a
+    # remote poll — see agent_runner/remote_relay.py.
+    src: monitor.StateSource = monitor.LocalSource(log_dir=cfg.runtime.log_dir)
     events = monitor.parse_events_from_jsonl_files(src.events_files())
     metrics = monitor.parse_events_from_jsonl_files(src.metrics_files())
     log_tails = monitor.load_round_log_tails(src.rounds_dir())
@@ -512,11 +507,6 @@ def _poll_once(project: str | Path, *, host: str | None) -> list[monitor.Alert]:
     return builtin + plugin
 
 
-# Backoff schedule for remote-failure retries: each element is the sleep duration
-# in seconds for that attempt index (capped at 30s per step).
-_REMOTE_FAILURE_BACKOFF = (1, 2, 4, 8, 16, 30)
-
-
 def monitor_loop(
     project: str | Path | None = None, *, host: str | None = None, interval_s: int = 30
 ) -> Iterator[monitor.Alert]:
@@ -527,11 +517,11 @@ def monitor_loop(
     to that kind as the canonical "supervision is up" signal (monitor is otherwise
     silent during healthy operation by design).
 
-    ``host`` (remote mode) raises ``MonitorRemoteUnsupportedError`` immediately:
-    remote reads are unimplemented, so a remote loop would poll an empty world
-    and report healthy forever. The check is eager — this wrapper validates
-    before handing back the generator, so the failure lands at startup rather
-    than at the first ``next()``.
+    ``host`` raises ``MonitorRemoteUnsupportedError`` immediately: detection runs
+    on the supervised host by design, so there is no remote polling mode. The
+    check is eager — this wrapper validates before handing back the generator,
+    so the failure lands at startup rather than at the first ``next()``. For a
+    remote event stream, see ``relay_remote_events``.
     """
     if host is not None:
         raise monitor.MonitorRemoteUnsupportedError(host)
@@ -543,13 +533,9 @@ def _monitor_loop_iter(
 ) -> Iterator[monitor.Alert]:
     """Polling generator behind ``monitor_loop``.
 
-    Tolerates transient ``MonitorRemoteError`` failures (from ``--host`` ssh)
-    for up to ``cfg.monitor.remote_failure_tolerance_s`` seconds with exponential
-    backoff (1s → 2s → 4s → ... → 30s cap). Each retry emits ``monitor_remote_blip``;
-    crossing the cap emits one ``monitor_remote_giveup`` and propagates the error
-    (CLI exits 1; systemd restarts the process). Setting tolerance to 0 preserves
-    the 0.1.10 immediate-propagate behavior with no blip events emitted. That
-    path is dormant while remote mode is rejected at startup.
+    ``host`` is None by construction (``monitor_loop`` rejects anything else);
+    it is carried into the ``monitor_started`` payload as an explicit record
+    that this monitor watches its own host.
     """
     import json as _json
 
@@ -566,51 +552,8 @@ def _monitor_loop_iter(
         mode="anomaly-only",
     )
 
-    tolerance_s = cfg.monitor.remote_failure_tolerance_s
-    blip_start: float | None = None
-    attempt = 0
-
     while True:
-        try:
-            alerts = _poll_once(work_dir, host=host)
-            # Success: reset retry state.
-            blip_start = None
-            attempt = 0
-        except monitor.MonitorRemoteError as e:
-            if tolerance_s == 0:
-                raise  # 0.1.10 behavior preserved
-            now = time.monotonic()
-            if blip_start is None:
-                blip_start = now
-            attempt += 1
-            elapsed = now - blip_start
-            if elapsed >= tolerance_s:
-                events.emit(
-                    cfg.runtime.log_dir,
-                    MONITOR_REMOTE_GIVEUP,
-                    host=host,
-                    total_attempts=attempt,
-                    total_elapsed_s=elapsed,
-                    cap_s=tolerance_s,
-                    final_error=e.stderr,
-                )
-                raise
-            backoff_idx = min(attempt - 1, len(_REMOTE_FAILURE_BACKOFF) - 1)
-            next_sleep_s = min(_REMOTE_FAILURE_BACKOFF[backoff_idx], tolerance_s - elapsed)
-            events.emit(
-                cfg.runtime.log_dir,
-                MONITOR_REMOTE_BLIP,
-                host=host,
-                error=e.stderr,
-                attempt=attempt,
-                elapsed_s=elapsed,
-                cap_s=tolerance_s,
-                interval_s=interval_s,
-                next_sleep_s=next_sleep_s,
-            )
-            time.sleep(next_sleep_s)
-            continue
-
+        alerts = _poll_once(work_dir)
         for alert in alerts:
             key = f"{alert.detector}:{_json.dumps(alert.context, sort_keys=True)}"
             if key in seen:
@@ -620,7 +563,6 @@ def _monitor_loop_iter(
             monitor.on_alert(
                 alert,
                 project=_project_name(work_dir),
-                host=host,
                 log_dir=cfg.runtime.log_dir,
                 allowed_stop_names=cfg.monitor.auto_stop_on,
             )
@@ -849,6 +791,41 @@ def stream_events_jsonl(log_dir: Path, *, poll_interval_s: float = 0.1) -> Itera
     yield from _tail_events_jsonl(log_dir, start_at_now=True, poll_interval_s=poll_interval_s)
 
 
+def relay_remote_events(
+    host: str,
+    *,
+    log_dir: Path,
+    kinds: Sequence[str] | None = None,
+    remote_config: str | None = None,
+    failure_tolerance_s: float = 90.0,
+    out: TextIO | None = None,
+) -> int:
+    """Remote sibling of ``stream_events_jsonl``: relay ``host``'s event stream.
+
+    Spawns a managed ``ssh <host> -- agent-runner events --tail`` and passes its
+    JSONL through, reconnecting with ``--since`` so a dropped link replays its
+    gap. Returns a CLI exit code (0 on interrupt, 1 once the link stays down
+    past ``failure_tolerance_s``). Blocks until then.
+
+    ``log_dir`` is this CLIENT's log dir: the ``monitor_remote_blip`` /
+    ``monitor_remote_giveup`` events it writes describe the local machine's link
+    to ``host``, not the supervised project. Detection is deliberately NOT
+    relayed — the detectors run on ``host`` (see ``monitor_loop``).
+    """
+    # Late import: pulls agent_runtime (psutil, threading) only for the callers
+    # that actually stream from a remote host.
+    from agent_runner.remote_relay import relay_remote_events as _relay
+
+    return _relay(
+        host,
+        log_dir=log_dir,
+        kinds=kinds,
+        remote_config=remote_config,
+        failure_tolerance_s=failure_tolerance_s,
+        out=out,
+    )
+
+
 def _format_narrate_line(evt: dict[str, Any]) -> str:
     """Format an event dict as a one-line human-readable string.
 

{cli_agent_runner-0.2.4 → cli_agent_runner-0.2.5}/agent_runner/cli/events_cmd.py

@@ -3,7 +3,13 @@
 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.
+Current-month scope only, except under ``--since <ISO ts>``, which replays every
+matching event with ``ts >= since`` across month files (and then follows, under
+``--tail``). That replay is at-least-once by contract: a client resumes by
+passing the last ts it saw, so the boundary event may arrive twice — no event is
+ever silently lost across a dropped connection.
+
+Tail mode follows month rollover via per-poll glob.
 """
 
 from __future__ import annotations
@@ -16,6 +22,8 @@ import time
 from datetime import UTC, datetime
 from pathlib import Path
 
+from agent_runner.events import parse_iso_ms
+
 # 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".
@@ -64,6 +72,18 @@ def add_parser(sub, parent) -> None:
         action="store_true",
         help=("Streaming mode: emit each new matching event as it fires (blocks until SIGINT)."),
     )
+    p.add_argument(
+        "--since",
+        type=str,
+        default=None,
+        metavar="ISO-TS",
+        help=(
+            "Replay every matching event with ts >= this ISO-8601 timestamp "
+            "(e.g. 2026-07-27T10:00:00.000Z), across month files, then keep "
+            "streaming if --tail. At-least-once: resume by passing the last ts "
+            "you saw — that event may repeat, none is lost. Excludes --window."
+        ),
+    )
     p.set_defaults(func=cmd_events)
 
 
@@ -97,6 +117,27 @@ def cmd_events(args) -> int:
         )
         return 2
 
+    since_raw = getattr(args, "since", None)
+    since: datetime | None = None
+    if since_raw is not None:
+        if window_explicit:
+            print(
+                "Error: --window and --since are mutually exclusive",
+                file=sys.stderr,
+            )
+            return 2
+        try:
+            since = parse_iso_ms(since_raw)
+        except ValueError:
+            print(
+                f"Error: --since expects an ISO-8601 timestamp "
+                f"(e.g. 2026-07-27T10:00:00.000Z), got {since_raw!r}",
+                file=sys.stderr,
+            )
+            return 2
+        if since.tzinfo is None:
+            since = since.replace(tzinfo=UTC)
+
     try:
         log_dir = _resolve_log_dir(args)
     except FileNotFoundError as e:
@@ -104,7 +145,15 @@ def cmd_events(args) -> int:
         return 1
 
     if args.tail:
-        return _tail_events(log_dir, kind_set)
+        return _tail_events(log_dir, kind_set, since=since)
+
+    if since is not None:
+        try:
+            _replay_since(log_dir, kind_set, since)  # offset only matters to --tail
+        except OSError as e:
+            print(f"Error: events file unreadable: {e}", file=sys.stderr)
+            return 1
+        return 0
 
     window = args.window if args.window != _WINDOW_DEFAULT_SENTINEL else 10
     return _query_events(log_dir, kind_set, window)
@@ -115,6 +164,68 @@ def _current_month_events_file(log_dir: Path) -> Path:
     return log_dir / f"events-{month}.jsonl"
 
 
+def _month_of(events_file: Path) -> str:
+    """The YYYY-MM embedded in an ``events-YYYY-MM.jsonl`` filename."""
+    return events_file.name[len("events-") : -len(".jsonl")]
+
+
+def _matches_since(line: str, kind_set: set[str], since: datetime) -> bool:
+    """True if ``line`` is a matching kind whose ts is at or after ``since``.
+
+    Malformed lines and lines carrying no parseable ``ts`` are skipped silently,
+    matching the tolerance of the other parse loops in this module.
+    """
+    try:
+        evt = json.loads(line)
+    except json.JSONDecodeError:
+        return False
+    if evt.get("event") not in kind_set:
+        return False
+    ts = evt.get("ts")
+    if not isinstance(ts, str):
+        return False
+    try:
+        parsed = parse_iso_ms(ts)
+    except ValueError:
+        return False
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=UTC)
+    return parsed >= since
+
+
+def _replay_since(log_dir: Path, kind_set: set[str], since: datetime) -> tuple[Path, int]:
+    """Emit every matching event with ``ts >= since``, oldest month file first.
+
+    Not windowed: replay is the resume path, so it emits the whole backlog.
+
+    Returns ``(current-month file, bytes consumed of it)``. That offset is the
+    handoff point for ``--tail``: it is the true end-of-read position, so a line
+    appended while the replay was running is picked up by the poll loop instead
+    of being skipped, and no line is emitted in both phases.
+    """
+    since_month = since.astimezone(UTC).strftime("%Y-%m")
+    current = _current_month_events_file(log_dir)
+    offset = 0
+    for path in sorted(log_dir.glob("events-*.jsonl")):
+        if _month_of(path) < since_month:
+            # Nothing to replay from a month that ended before `since`. The live
+            # file lands here only when `since` names a future month — seed the
+            # tail at its end rather than rewinding it to 0.
+            if path == current:
+                offset = path.stat().st_size
+            continue
+        with path.open("r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                if _matches_since(line, kind_set, since):
+                    print(line, flush=True)
+            if path == current:
+                offset = f.tell()
+    return current, offset
+
+
 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)
@@ -143,10 +254,15 @@ def _query_events(log_dir: Path, kind_set: set[str], window: int) -> int:
     return 0
 
 
-def _tail_events(log_dir: Path, kind_set: set[str]) -> int:
+def _tail_events(log_dir: Path, kind_set: set[str], since: datetime | None = None) -> 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.
+
+    With ``since``, the backlog (``ts >= since``, across month files) is replayed
+    first and the poll resumes at the exact byte the replay stopped on — no gap
+    and no duplicate across the handoff. At-least-once overall: the caller
+    resumes from the last ts it saw, so that one event may repeat.
     """
     last_size = 0
     current_file: Path | None = None
@@ -156,6 +272,13 @@ def _tail_events(log_dir: Path, kind_set: set[str]) -> int:
 
     signal.signal(signal.SIGINT, _handle_sigint)
 
+    if since is not None:
+        try:
+            current_file, last_size = _replay_since(log_dir, kind_set, since)
+        except OSError as e:
+            print(f"Error: events file unreadable: {e}", file=sys.stderr)
+            return 1
+
     try:
         while True:
             events_file = _current_month_events_file(log_dir)

{cli_agent_runner-0.2.4 → cli_agent_runner-0.2.5}/agent_runner/cli/monitor_cmd.py

@@ -1,4 +1,4 @@
-"""monitor subcommand — anomaly detection daemon (local or remote)."""
+"""monitor subcommand — anomaly detection, event stream (local or relayed), HTTP page."""
 
 from __future__ import annotations
 
@@ -20,14 +20,29 @@ def add_parser(sub, parent) -> None:
         type=str,
         default=None,
         metavar="SSH-ALIAS",
-        help="Remote ssh alias (unsupported in this version — errors at startup)",
+        help=(
+            "Remote ssh alias — supported with --mode events only: agent-runner "
+            "manages the ssh, resumes with --since after a drop, and kills the "
+            "ssh process group on exit. Detection modes run on the host itself."
+        ),
     )
     p.add_argument(
         "--interval",
         type=int,
         default=None,
         metavar="SECONDS",
-        help="Poll interval (default 30s, 60s for remote)",
+        help="Poll interval (default 30s)",
+    )
+    p.add_argument(
+        "--kind",
+        type=str,
+        default=None,
+        metavar="K[,K2,...]",
+        help=(
+            "Event kinds to relay (--host --mode events only). Default: every "
+            "kind this client knows — built-ins plus locally installed plugin "
+            "kinds. A kind that exists only on the remote must be named here."
+        ),
     )
     p.add_argument(
         "--mode",
@@ -45,13 +60,32 @@ def add_parser(sub, parent) -> None:
         metavar="PORT",
         help="HTTP port for --mode http (default 8765, local-only)",
     )
+    p.add_argument(
+        "--remote-config",
+        type=str,
+        default=None,
+        metavar="PATH",
+        help=(
+            "Config path ON THE REMOTE HOST for the relayed events command "
+            "(--host --mode events only). Default: omit --config entirely, so "
+            "the remote resolves ./agent-runner.toml in the ssh landing directory."
+        ),
+    )
     p.set_defaults(func=cmd)
 
 
 def cmd(args) -> int:
     mode = getattr(args, "mode", "anomaly")
-    if mode in ("narrate", "events", "http") and args.host is not None:
-        return fail(f"--mode {mode} is local-only; remove --host or use --mode anomaly")
+    host = getattr(args, "host", None)
+    remote_only = [
+        f"--{name}"
+        for name in ("kind", "remote-config")
+        if getattr(args, name.replace("-", "_"), None) is not None
+    ]
+    if host is not None and mode != "events":
+        return fail(str(monitor.MonitorRemoteUnsupportedError(host, mode)))
+    if remote_only and (host is None or mode != "events"):
+        return fail(f"{', '.join(remote_only)} applies to --host --mode events only")
 
     if mode == "narrate":
         return _cmd_narrate(args)
@@ -63,11 +97,12 @@ def cmd(args) -> int:
 
 
 def _cmd_anomaly(args) -> int:
-    interval = args.interval if args.interval is not None else (60 if args.host else 30)
+    interval = args.interval if args.interval is not None else 30
     json_mode = getattr(args, "json", False)
     try:
         work_dir = work_dir_from_args(args)
-        for alert in api.monitor_loop(work_dir, host=args.host, interval_s=interval):
+        # No host: cmd() has already rejected --host for every detection mode.
+        for alert in api.monitor_loop(work_dir, interval_s=interval):
             if json_mode:
                 print(json.dumps(_to_jsonable(alert)))
                 sys.stdout.flush()
@@ -77,21 +112,33 @@ def _cmd_anomaly(args) -> int:
                 sys.stdout.flush()
     except KeyboardInterrupt:
         return 0
-    except monitor.MonitorRemoteUnsupportedError as e:
-        return fail(str(e))
-    except monitor.MonitorRemoteError as e:
-        # Dormant alongside the rest of remote mode: ssh only runs under --host,
-        # which the MonitorRemoteUnsupportedError handler above already rejects.
-        return fail(f"cannot reach {e.host!r} via ssh: {e.stderr}")
     return 0
 
 
 def _cmd_events(args) -> int:
-    """JSONL event stream — machine-readable variant of narrate."""
+    """JSONL event stream — a local tail, or a managed ssh relay under --host.
+
+    Both variants read the CLIENT's config: locally for the log dir to tail,
+    remotely for where the relay writes its own link telemetry (blip / give-up)
+    and for the reconnect deadline.
+    """
     from agent_runner.cli.common import cfg_from_args
 
     cfg = cfg_from_args(args)
     log_dir = cfg.runtime.log_dir
+
+    host = getattr(args, "host", None)
+    if host is not None:
+        raw_kinds = getattr(args, "kind", None)
+        kinds = [k.strip() for k in raw_kinds.split(",") if k.strip()] if raw_kinds else None
+        return api.relay_remote_events(
+            host,
+            log_dir=log_dir,
+            kinds=kinds,
+            remote_config=getattr(args, "remote_config", None),
+            failure_tolerance_s=cfg.monitor.remote_failure_tolerance_s,
+        )
+
     try:
         for evt in api.stream_events_jsonl(log_dir):
             print(json.dumps(evt), flush=True)