cli-agent-runner 0.3.9__tar.gz → 0.3.10__tar.gz

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/.vulture-whitelist.py

@@ -17,6 +17,7 @@ buffer
 name
 post_round_hooks
 cooperative_stop
+resume_flag
 
 # agent_runner._round_outcome.RoundOutcome
 mem_terminated

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/CHANGELOG.md

@@ -5,6 +5,15 @@ 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.10] - 2026-09-17
+
+### Added
+- Cross-round resume for `pi`: `PluginManifest.resume_flag` (pi = `--session-id`) lets a preset declare an idempotent session flag; `serve` mints one session id per phase and publishes it via `AGENT_RUNNER_RESUME_FLAG`/`AGENT_RUNNER_RESUME_SESSION_ID`, and the round child appends `[flag, id]` to its command. claude/gemini/codewhale/kimi are untouched (`resume_flag` stays `None`) — later release.
+- A new `session_resumed` event records when a round reuses a prior session id.
+- Boot guard: a preset whose static command already contains its `resume_flag` token now fails config load (agent-runner injects it per round; remove the static copy).
+
+No config migration — `resume_flag` is a manifest field, not a TOML key. `peek --json` schema stays `2.6`.
+
 ## [0.3.9] - 2026-09-17
 
 ### Changed

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/PKG-INFO

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

@@ -65,6 +65,7 @@ from agent_runner._emit.serve import (  # noqa: F401 — public re-export
     emit_schedule_paused,
     emit_schedule_phase_skipped,
     emit_schedule_resumed,
+    emit_session_resumed,
     emit_stalled_no_progress,
     emit_stop_file_detected,
 )
@@ -104,6 +105,7 @@ __all__ = [
     "emit_schedule_paused",
     "emit_schedule_phase_skipped",
     "emit_schedule_resumed",
+    "emit_session_resumed",
     "emit_stale_index_lock_cleared",
     "emit_stalled_no_progress",
     "emit_stop_file_detected",

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/agent_runner/_emit/serve.py

@@ -191,3 +191,15 @@ def emit_schedule_resumed(log_dir: Path, *, paused_for_s: int) -> None:
     from agent_runner.events import SCHEDULE_RESUMED, emit
 
     emit(log_dir, SCHEDULE_RESUMED, paused_for_s=paused_for_s)
+
+
+def emit_session_resumed(log_dir: Path, *, session_id: str, phase: str = "") -> None:
+    """Emit session_resumed when serve resumes an existing agent session on a
+    non-first round of an epoch (the runtime property peek cannot show). ``phase``
+    is omitted when empty so the base (no-override) phase stays a clean payload."""
+    from agent_runner.events import SESSION_RESUMED, emit
+
+    fields = {"session_id": session_id}
+    if phase:
+        fields["phase"] = phase
+    emit(log_dir, SESSION_RESUMED, **fields)

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/agent_runner/_plugin_manifest.py

@@ -43,6 +43,13 @@ class PluginManifest:
     SIGTERM-first at the reap site (today's behavior), never "skip the first
     signal"."""
 
+    resume_flag: str | None = None
+    """The flag that carries a supervisor-chosen session id on EVERY round for a
+    CLI whose session flag is IDEMPOTENT (create-or-resume). pi = "--session-id".
+    ``None`` = no resume (today's cold start). Resolved ONLY by
+    ``resolve_resume_flag``; ``__post_init__`` rejects an empty string. Source-
+    verified per preset (pi's --session-id is idempotent), NEVER assumed."""
+
     def __post_init__(self) -> None:
         # Errors-unlikely-by-construction: an unknown signal name (or a
         # freeze/zero-grace one like SIGSTOP/SIGKILL) is unrepresentable -- it
@@ -52,6 +59,10 @@ class PluginManifest:
                 "cooperative_stop must be one of {None, 'SIGTERM', 'SIGINT'}, "
                 f"got {self.cooperative_stop!r}"
             )
+        if self.resume_flag is not None and not self.resume_flag:
+            raise ValueError(
+                f"resume_flag must be None or a non-empty flag string, got {self.resume_flag!r}"
+            )
 
 
 _LOADED_MANIFESTS: list[PluginManifest] = []
@@ -102,6 +113,21 @@ def resolve_cooperative_signal(agent_binary: str | None) -> signal.Signals | Non
     return _COOPERATIVE_SIGNALS.get(_cooperative_stop_for_name(agent_binary))
 
 
+def resolve_resume_flag(agent_binary: str | None) -> str | None:
+    """The resume flag the agent named `agent_binary` declares, or None when no
+    such manifest is registered (or it declares no resume). THE registry lookup
+    for resume -- sibling to resolve_cooperative_signal, the SAME
+    ``m.name == agent_binary`` join (so it stays correct whenever a preset's
+    manifest name is kept equal to its agent binary). serve resolves it once
+    per phase and publishes the id via env so the round child never
+    re-derives. No signal table: the flag string IS what serve publishes and
+    the child appends, so the scan IS the resolve."""
+    for m in _LOADED_MANIFESTS:
+        if m.name == agent_binary:
+            return m.resume_flag
+    return None
+
+
 def cooperative_signal_from_name(name: str | None) -> signal.Signals | None:
     """Map a published cooperative-stop signal NAME (e.g. from
     AGENT_RUNNER_COOPERATIVE_STOP_SIGNAL) back to a ``signal.Signals`` through

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.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.3.9'
-__version_tuple__ = version_tuple = (0, 3, 9)
+__version__ = version = '0.3.10'
+__version_tuple__ = version_tuple = (0, 3, 10)
 
 __commit_id__ = commit_id = None

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/agent_runner/agent_runtime.py

@@ -634,6 +634,7 @@ def run(
     clock: Clock = SYSTEM_CLOCK,
     reap_grace_s: int = REAP_GRACE_S,
     cooperative_first_signal: signal.Signals = signal.SIGTERM,
+    resume_args: tuple[str, ...] = (),
 ) -> RunResult:
     """Spawn the agent subprocess and wait for exit or timeout.
 
@@ -653,6 +654,14 @@ def run(
     cooperative_stop / standalone `agent-runner round`), so every existing caller
     is unchanged.
 
+    resume_args: ``[flag, session_id]`` appended after ``command`` and before
+    the prompt args, for a resume-capable agent picking its session back up
+    across rounds. The id is minted once by the caller's own env-published
+    single-source (``runner._resolve_resume_args``) and copied verbatim here --
+    this module never mints or derives one (no ``os.environ`` read for the
+    session id; see the module docstring). Defaults to ``()``, so every
+    existing caller's argv is byte-identical to before.
+
     work_dir: the agent child's working directory; callers pass the
     already-absolute cfg.runtime.work_dir. CLIs with no --cwd flag of their
     own (e.g. pi) depend on this.
@@ -760,10 +769,11 @@ def run(
     # template for stdin mode, but run() must be safe even if called
     # directly with a mismatched template. In stdin mode, never substitute
     # {prompt} into argv — build it verbatim so the prompt cannot reach argv.
+    resumed_command = list(spawn_command) + list(resume_args)
     argv = (
-        list(spawn_command) + list(prompt_arg_template)
+        list(resumed_command) + list(prompt_arg_template)
         if stdin_mode
-        else _build_argv(spawn_command, prompt_arg_template, prompt)
+        else _build_argv(resumed_command, prompt_arg_template, prompt)
     )
     # PWD pinned last — it mirrors cwd= (a correctness pin, not a knob), so
     # an [agent.env] PWD cannot silently diverge from where the child runs.

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/agent_runner/api.py

@@ -62,6 +62,7 @@ from agent_runner._emit import (  # noqa: E402,F401 — intentional bottom re-ex
     emit_schedule_paused,
     emit_schedule_phase_skipped,
     emit_schedule_resumed,
+    emit_session_resumed,
     emit_stale_index_lock_cleared,
     emit_stalled_no_progress,
     emit_stop_file_detected,

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/agent_runner/builtin_plugins/pi.py

@@ -281,5 +281,8 @@ def _is_auth_error(text: str | None) -> bool:
 
 
 PLUGIN = PluginManifest(
-    name="pi", post_round_hooks=(PiErrorDetector(),), cooperative_stop="SIGTERM"
+    name="pi",
+    post_round_hooks=(PiErrorDetector(),),
+    cooperative_stop="SIGTERM",
+    resume_flag="--session-id",
 )

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/agent_runner/cli/serve_cmd.py

@@ -43,6 +43,7 @@ from agent_runner.api import (
     emit_schedule_paused,
     emit_schedule_phase_skipped,
     emit_schedule_resumed,
+    emit_session_resumed,
     emit_stop_file_detected,
     outer_round_ceiling_s,
 )
@@ -558,9 +559,8 @@ def _is_fresh_eyes_round(*, round_num: int, every_n: int | None) -> bool:
     return round_num % every_n == 0
 
 
-def _apply_fresh_eyes(cfg, log_dir, round_num: int, round_env: dict) -> None:
+def _apply_fresh_eyes(cfg, log_dir, round_num: int, round_env: dict, fresh_eyes: bool) -> None:
     """Set the round's fresh-eyes env flag and emit the trigger event when due."""
-    fresh_eyes = _is_fresh_eyes_round(round_num=round_num, every_n=cfg.runtime.fresh_eyes_every_n)
     round_env["AGENT_RUNNER_FRESH_EYES"] = "1" if fresh_eyes else "0"
     if fresh_eyes:
         emit_fresh_eyes_round_triggered(
@@ -659,6 +659,45 @@ def _apply_cooperative_signal_env(
     round_env["AGENT_RUNNER_COOPERATIVE_STOP_SIGNAL"] = name
 
 
+def _apply_resume_env(
+    cfg, round_env: dict, phase_arg: str | None, is_fresh_eyes: bool, session_ids: dict, log_dir
+) -> None:
+    """Publish this round's cross-round-resume flag + session id via
+    AGENT_RUNNER_RESUME_FLAG / AGENT_RUNNER_RESUME_SESSION_ID -- the 4th
+    serve->child env single-source (siblings _apply_reap_grace_env /
+    _apply_cooperative_signal_env). UNLIKE those boot-invariant siblings the id
+    is MUTABLE per-phase state: `session_ids` (keyed by PHASE, not binary --
+    per-role continuity) carries it across rounds; a first-use OR fresh-eyes
+    round mints a new uuid. A non-resume phase (resolve_resume_flag is None)
+    POPS both keys so a prior resume-capable phase's id never leaks onto this
+    round's child argv. Emits session_resumed only when RESUMING (id reused)."""
+    import uuid
+
+    from agent_runner._plugin_manifest import resolve_resume_flag
+
+    # Resume needs serve to PIN the child's phase. When phase_arg is None but
+    # [phases] exists, serve is non-phase-aware (phase_policy="wait", or
+    # --ignore-schedule) and the round child SELF-ROTATES phases by round_num --
+    # serve cannot know which agent ran, so publishing the base id would bleed
+    # one role's session across all rotated roles. Cold-start (pop) when the
+    # phase is ambiguous; resume only with an explicit phase or a single base
+    # agent (empty phases.list).
+    flag = resolve_resume_flag(cfg.profile_for(phase_arg).agent.binary)
+    if flag is None or (phase_arg is None and cfg.phases.list):
+        round_env.pop("AGENT_RUNNER_RESUME_FLAG", None)
+        round_env.pop("AGENT_RUNNER_RESUME_SESSION_ID", None)
+        return
+    sid = session_ids.get(phase_arg)
+    resuming = sid is not None and not is_fresh_eyes
+    if not resuming:
+        sid = str(uuid.uuid4())
+        session_ids[phase_arg] = sid
+    round_env["AGENT_RUNNER_RESUME_FLAG"] = flag
+    round_env["AGENT_RUNNER_RESUME_SESSION_ID"] = sid
+    if resuming:
+        emit_session_resumed(log_dir, session_id=sid, phase=phase_arg or "")
+
+
 def _capture_substrate(work_dir, cfg, log_dir, round_num, *, when):
     """Snapshot git-head + paths-hash and emit the round-substrate event for `when`."""
     git_head = compute_git_head(work_dir)
@@ -742,6 +781,10 @@ def cmd(args) -> int:
         _release_serve_lock(serve_lock_fd)
         raise ConfigError(f"phase-window overlap: {detail}; run `agent-runner doctor` for details")
     rounds_completed = 0
+    # Cross-round resume: this serve lifetime's minted session id per phase
+    # (None key = the base, no-override agent). Mutable, unlike grace_by_phase/
+    # cooperative_signal_by_phase above -- see _apply_resume_env.
+    session_ids: dict[str | None, str] = {}
     # Three independent consecutive-failure counters, one per breaker: b12
     # crash-loop (unknown short crashes), mem-loop (mem-terminated
     # rounds), no-progress (exit-0, no usage). LOC-neutral
@@ -801,10 +844,14 @@ def cmd(args) -> int:
             if stop["requested"]:
                 break  # SIGTERM landed during selection/back-off — don't spawn a round
             _capture_substrate(work_dir, cfg, log_dir, round_num, when="before")
-            _apply_fresh_eyes(cfg, log_dir, round_num, round_env)
+            is_fresh_eyes = _is_fresh_eyes_round(
+                round_num=round_num, every_n=cfg.runtime.fresh_eyes_every_n
+            )
+            _apply_fresh_eyes(cfg, log_dir, round_num, round_env, is_fresh_eyes)
             _apply_round_num_env(round_env, round_num)
             _apply_reap_grace_env(cfg, round_env, phase_arg, grace_by_phase)
             _apply_cooperative_signal_env(cfg, round_env, phase_arg, cooperative_signal_by_phase)
+            _apply_resume_env(cfg, round_env, phase_arg, is_fresh_eyes, session_ids, log_dir)
             round_log_path = log_dir / f"round-{round_num}.log"
             round_started = SYSTEM_CLOCK.monotonic()
             round_argv = [

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/agent_runner/config/loader.py

@@ -32,6 +32,30 @@ from agent_runner.config.validators import (
 _CURRENT_SCHEMA_VERSION = 1
 
 
+def _reject_static_resume_flag(cfg) -> None:
+    """A resume-capable preset must not already carry its resume_flag token in
+    the static command/prompt_arg_template -- agent-runner injects [flag, id]
+    per round, so a static copy would duplicate it. Boot refusal (ConfigError)
+    keeps best-effort-never-error at round time. Runs AFTER
+    load_and_register_plugins so resolve_resume_flag can see the manifests
+    (it is registry-backed, unlike the boot-time {prompt} guard)."""
+    from agent_runner._plugin_manifest import resolve_resume_flag
+
+    agents = [(None, cfg.agent)] + [
+        (name, ov.agent) for name, ov in cfg.phases.overrides.items() if ov.agent is not None
+    ]
+    for phase_name, a in agents:
+        flag = resolve_resume_flag(a.binary)
+        if flag is None:
+            continue
+        if flag in a.command or flag in a.prompt_arg_template:
+            where = "[agent]" if phase_name is None else f"[phases.{phase_name}.agent]"
+            raise ConfigError(
+                f"{where} command already contains {flag!r}: agent-runner injects it "
+                "per round for cross-round resume; remove it from the static command"
+            )
+
+
 def _check_schema_version(raw: dict) -> None:
     """Boot gate: a config's ``schema_version`` decouples the on-disk config
     shape from the installed package version, so a config can be migrated
@@ -133,4 +157,6 @@ def load_config(toml_path: Path) -> Config:
     if plugins.disable:
         apply_plugin_disable(plugins.disable)
 
+    _reject_static_resume_flag(cfg)
+
     return cfg

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/agent_runner/events.py

@@ -84,6 +84,7 @@ SELF_TERMINATED = "agent_self_terminated"
 SERVICE_UPGRADE_ROLLBACK_FAILED = "service_upgrade_rollback_failed"
 SERVICE_UPGRADE_ROLLED_BACK = "service_upgrade_rolled_back"
 SERVICE_UPGRADED = "service_upgraded"
+SESSION_RESUMED = "session_resumed"
 SMOKE_CHECK_FAILED = "smoke_check_failed"
 STALE_INDEX_LOCK_CLEARED = "stale_index_lock_cleared"
 STALLED_NO_PROGRESS = "stalled_no_progress"

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/agent_runner/runner.py

@@ -220,6 +220,20 @@ def _resolve_cooperative_signal() -> signal.Signals:
     return resolved if resolved is not None else signal.SIGTERM
 
 
+def _resolve_resume_args() -> list[str]:
+    """The ``[flag, session_id]`` the round child appends for cross-round
+    resume, or ``[]`` when no serve parent published them (systemd / standalone
+    ``round`` -> cold start by construction). Pure consumption -- the id is
+    minted once serve-side and copied verbatim; the child NEVER derives it.
+    Sibling of ``_resolve_reap_grace_s`` / ``_resolve_cooperative_signal``: the
+    same serve->child env single-source, both-vars-or-neither."""
+    flag = os.environ.get("AGENT_RUNNER_RESUME_FLAG")
+    session_id = os.environ.get("AGENT_RUNNER_RESUME_SESSION_ID")
+    if flag and session_id:
+        return [flag, session_id]
+    return []
+
+
 def _previous_block(prev: context_store.Status | None, dirty_last: bool) -> dict[str, Any] | None:
     if prev is None:
         return None
@@ -507,6 +521,7 @@ def _run_one_round_inner(cfg: Config, *, phase_override: str | None = None) -> R
         on_container_orphan_risk=_container_orphan_risk_emit,
         reap_grace_s=_resolve_reap_grace_s(),
         cooperative_first_signal=_resolve_cooperative_signal(),
+        resume_args=_resolve_resume_args(),
     )
     events.emit(
         log_dir,

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/docs/architecture.md

@@ -248,6 +248,7 @@ The result is recorded as `RoundResult.dirty_outcome: DirtyOutcome | None`, whic
 - `service_upgrade_rollback_failed`
 - `service_upgrade_rolled_back`
 - `service_upgraded`
+- `session_resumed`
 - `smoke_check_failed`
 - `stale_index_lock_cleared`
 - `stalled_no_progress`

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/docs/memory-efficiency.md

@@ -652,6 +652,71 @@ since 0.2.17. No constrained-host-specific claim this release — the
 subtraction is host-independent code removal, not a runtime-behavior change
 under pressure.
 
+## 0.3.9 → 0.3.10
+
+Cross-round resume for `pi`: `PluginManifest.resume_flag` (a new dataclass
+field, `str | None`, default `None`), `resolve_resume_flag`, a per-phase
+session-id mint + env publish (`AGENT_RUNNER_RESUME_FLAG`/
+`AGENT_RUNNER_RESUME_SESSION_ID`) in `serve_cmd`, the round child appending
+`[flag, id]`, a `session_resumed` event, and a config boot guard. Same macOS
+harness (§ methodology above), comparing **v0.3.9** = `095c5f1` (measured in a
+throwaway worktree) against **0.3.10**, the tip of this branch.
+
+### 1. Import/startup RSS
+
+| | v0.3.9 | 0.3.10 | Δ |
+|---|---|---|---|
+| RSS (avg of 5 cold runs) | 23.42 MB | 23.39 MB | −0.03 MB (flat, within noise) |
+| RSS range | 23.39–23.45 MB | 23.34–23.42 MB | |
+| `sys.modules` count | 211 | 211 | +0 |
+
+Flat, as expected: `uuid` (the only new stdlib name resume touches) is
+imported inside `_apply_resume_env`, not at module level, so it never joins
+the cold-startup graph — confirmed directly (`"uuid" in sys.modules` is
+`False` after `import agent_runner.cli`), not just inferred from a flat RSS
+number. A direct `sys.modules` set diff (not just the count) confirms the
+`agent_runner.*` module set `import agent_runner.cli` loads is byte-for-byte
+identical, 211 modules, before and after — the same check this page has run
+at every release since 0.3.9's own close-out.
+
+### 2. Base dependencies
+
+Unchanged: `psutil>=5.9` is still the only runtime dependency
+(`pip show cli-agent-runner` → `Requires: psutil`). Resume introduces no new
+dependency and no new extra.
+
+### 3. Module count, source LOC, largest module
+
+Tracked source only (`git ls-tree`, same convention as the rows above).
+
+| | v0.3.9 | 0.3.10 | Δ |
+|---|---|---|---|
+| `.py` files | 81 | 81 | +0 |
+| total LOC | 20,195 | 20,338 | +143 |
+| largest module | `migrations.py`, 972 | `migrations.py`, 972 | +0 |
+
+The `+143` LOC is the new manifest field, its resolver, the boot guard, the
+per-phase env publish/consume, the `session_resumed` event, and their tests
+— no module decomposition this release.
+
+### 4. Per-round allocation growth
+
+`tests/invariants/test_round_alloc_growth.py` green, unmodified harness.
+`_apply_resume_env` runs once per round (same call site as the other
+per-round `serve_cmd` readers) and, on the no-resume branch every
+non-`pi` preset takes, does two dict `.pop()`s and returns — no new retained
+per-round state. On the resume branch (`pi` only), the session id is minted
+once per phase at `serve` startup (`session_ids` dict, sized by phase count,
+not by round count) and reused verbatim every round after — not re-allocated
+per round.
+
+### Constrained-host (honesty)
+
+Dev-host-relative (macOS) numbers only, same methodology as every release
+since 0.2.17. No constrained-host-specific claim this release — resume is a
+pi-only session-id mechanism verified so far by an ssh-pi property test, not
+a memory-pressure-path change.
+
 ## Enforcement
 
 Four invariant tests keep these numbers from drifting silently:

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/docs/migrations/0.3.md

@@ -127,3 +127,14 @@ rather than partially trusted. The exact errors:
 
 Any of these means the same fix: run `agent-runner migrate` (or, for the
 newer-than-supported case, upgrade the `agent-runner` package instead).
+
+## Upgrading to 0.3.10 — no config migration
+
+0.3.10 adds cross-round resume (`PluginManifest.resume_flag`, pi's
+`--session-id`). It is additive and inert for every preset that doesn't
+declare a `resume_flag` — nothing to run, nothing to rewrite. If your config
+already passes `--session-id` (or another preset's resume flag) as a static
+argument in `[agent] command`/`prompt_arg_template` (or a `[phases.<name>]`
+override), remove it: agent-runner now injects `[flag, session id]` itself on
+every round for a resume-capable preset, and a static copy of the same flag
+fails config load at boot.

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/docs/plugins.md

@@ -47,6 +47,7 @@ empty:
 | `name` | `str` | The plugin's own identity — `[plugins] disable` keys on this, not on any individual hook's own `.name`. |
 | `post_round_hooks` | `tuple[PostRoundHook, ...]` | Runs after each agent round. |
 | `cooperative_stop` | `Literal["SIGTERM", "SIGINT"] \| None` | The signal this preset's agent CLI catches to drain/wrap up when a round is stopped (`None` = no cooperative drain — the hard SIGTERM-first path). Reported under `peek --json`'s `plugins.cooperative_stop` (§ below). |
+| `resume_flag` | `str \| None` | The idempotent session flag `serve` injects on every round of this preset for cross-round resume (pi = `--session-id`); `serve` mints one session id per phase and the round child appends `[flag, id]` to its command. `None` = no resume (cold start every round, today's behavior for every other preset). |
 
 A plugin that provides more than one capability just fills in more than one
 field on the same manifest — there is nothing to register per-capability.

{cli_agent_runner-0.3.9 → cli_agent_runner-0.3.10}/tests/contract/test_public_api_surface.py

@@ -217,6 +217,7 @@ EXPECTED_API_SURFACE = {
     "emit_schedule_paused",
     "emit_schedule_phase_skipped",
     "emit_schedule_resumed",
+    "emit_session_resumed",
     "emit_stale_index_lock_cleared",
     # "emit_stalled_no_progress" added 0.2.16 Task 6: exit-0 no-progress breaker
     # (pi-class CLIs exit 0 on a provider failure that never reaches the model).