meridian-cli 0.3.52__tar.gz → 0.3.53__tar.gz

{meridian_cli-0.3.52 → meridian_cli-0.3.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meridian-cli
-Version: 0.3.52
+Version: 0.3.53
 Summary: Orchestrate CLI + MCP server for multi-model agent workflows
 Project-URL: Homepage, https://github.com/haowjy/meridian-cli
 Project-URL: Repository, https://github.com/haowjy/meridian-cli

{meridian_cli-0.3.52 → meridian_cli-0.3.53}/src/meridian/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.3.52"
+__version__ = "0.3.53"

{meridian_cli-0.3.52 → meridian_cli-0.3.53}/src/meridian/cli/spawn.py

@@ -993,10 +993,18 @@ def _spawn_stats(
 def _spawn_cancel(
     emit: Any,
     spawn_id: str,
+    force: Annotated[
+        bool,
+        Parameter(
+            name="--force",
+            help="Cancel even when the target is a live managed primary session.",
+        ),
+    ] = False,
 ) -> None:
     result = spawn_cancel_sync(
         SpawnCancelInput(
             spawn_id=spawn_id,
+            force=force,
         ),
         sink=_current_output_sink(),
         prepared=_prepare_spawn_runtime_write(),

{meridian_cli-0.3.52 → meridian_cli-0.3.53}/src/meridian/lib/core/process_cleanup.py

@@ -18,6 +18,7 @@ from meridian.lib.platform.process_scope.base import (
     ProcessScopeSnapshot,
     birth_time_unverified,
 )
+from meridian.lib.state.liveness import is_process_alive, is_process_alive_with_birth
 from meridian.lib.state.process_scope_projection import (
     is_scope_released,
     mark_scope_released,
@@ -28,6 +29,28 @@ from meridian.lib.state.spawn.model import SpawnRecord
 logger = structlog.get_logger(__name__)
 
 
+def _wait_for_scope_exit(scope: ProcessScopeSnapshot, *, timeout: float) -> None:
+    """Wait only while a scope's recorded root process is still alive."""
+
+    import time
+
+    deadline = time.monotonic() + max(0.0, timeout)
+    while True:
+        if birth_time_unverified(scope.root_created_at_epoch):
+            alive = is_process_alive(scope.root_pid)
+        else:
+            alive = is_process_alive_with_birth(
+                scope.root_pid,
+                scope.root_created_at_epoch,
+            )
+        if not alive:
+            return
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            return
+        time.sleep(min(0.05, remaining))
+
+
 def terminate_recorded_spawn_scopes(
     runtime_root: Path,
     spawn_record: SpawnRecord,
@@ -282,8 +305,6 @@ def cancel_managed_primary(
     Idempotent — already-released scopes are skipped. Safe to call even when
     primary_metadata is not available (falls back to scope records only).
     """
-    import time
-
     scopes = read_scopes_from_disk(runtime_root, SpawnId(spawn_record.id))
     results: list[CleanupResult] = []
     spawn_id = SpawnId(spawn_record.id)
@@ -309,9 +330,11 @@ def cancel_managed_primary(
             )
             results.append(result)
 
-    # 2. Brief pause to let launcher-driven shutdown propagate.
-    if results:
-        time.sleep(1.0)
+    # 2. Let launcher-driven shutdown propagate, but stop waiting as soon as
+    # the launcher scope is actually gone.
+    launcher_scope = next((scope for scope in scopes if scope.scope_id == "launcher"), None)
+    if results and launcher_scope is not None:
+        _wait_for_scope_exit(launcher_scope, timeout=1.0)
 
     # 3. Terminate backend and TUI if still unreleased.
     for scope in scopes:

{meridian_cli-0.3.52 → meridian_cli-0.3.53}/src/meridian/lib/core/spawn_service.py

@@ -52,7 +52,7 @@ from meridian.lib.launch.resolve import (
 )
 from meridian.lib.launch.types import PrimarySessionMetadata
 from meridian.lib.state import spawn_store
-from meridian.lib.state.liveness import is_process_alive
+from meridian.lib.state.liveness import is_process_alive, is_process_alive_with_birth
 from meridian.lib.state.paths import RuntimePaths
 from meridian.lib.state.spawn.model import APP_LAUNCH_MODE, LaunchMode, SpawnKind, SpawnOrigin
 from meridian.lib.state.spawn.repository import Applied, Declined
@@ -71,6 +71,49 @@ if TYPE_CHECKING:
 _WAIT_POLL_INTERVAL_SECS = 0.1
 _MANAGED_CANCEL_GRACE_SECS = 5.0
 _MANAGED_CANCEL_FALLBACK_WAIT_SECS = 1.0
+
+
+def _is_live_managed_primary(runtime_root: Path, record: SpawnRecord) -> bool:
+    if record.kind != "primary" or record.chat_id is None:
+        return False
+    from meridian.lib.state.session_store import is_session_lease_owner_alive
+
+    if is_session_lease_owner_alive(runtime_root, str(record.chat_id)):
+        return True
+
+    from meridian.lib.state.primary_meta import read_primary_metadata
+
+    metadata = read_primary_metadata(runtime_root, record.id)
+    return bool(
+        metadata is not None
+        and metadata.managed_backend
+        and metadata.launcher_pid is not None
+        and is_process_alive_with_birth(
+            metadata.launcher_pid,
+            metadata.launcher_birth_epoch,
+        )
+    )
+
+
+def _live_primary_cancel_refusal(record: SpawnRecord) -> str:
+    agent = (record.agent or "unknown").strip() or "unknown"
+    chat_id = str(record.chat_id) if record.chat_id is not None else "unknown"
+    uptime = "unknown"
+    if record.started_at is not None:
+        started_epoch = iso_timestamp_to_epoch(record.started_at)
+        if started_epoch is not None:
+            elapsed = max(0, int(time.time() - started_epoch))
+            hours, remainder = divmod(elapsed, 3600)
+            minutes, seconds = divmod(remainder, 60)
+            uptime = f"{hours}h {minutes}m" if hours else f"{minutes}m {seconds}s"
+    return (
+        f"Refusing to cancel live managed primary '{record.id}' "
+        f"(agent: {agent}, chat: {chat_id}, uptime: {uptime}). "
+        f"To end this interactive session anyway, pass --force: "
+        f"meridian spawn cancel {record.id} --force"
+    )
+
+
 _MAX_REAP_PASSES = 4
 logger = structlog.get_logger()
 
@@ -525,6 +568,7 @@ class SpawnApplicationService:
         spawn_id: SpawnId,
         *,
         requested_by: Literal["user", "system"] = "user",
+        force: bool = False,
     ) -> CancelOutcome:
         """Cancel a spawn through the shared surface-neutral pipeline."""
         lock = await self._locks.acquire(str(spawn_id))
@@ -533,6 +577,8 @@ class SpawnApplicationService:
             if self.is_terminal(record.status):
                 self._cleanup_orphan_managed_primary(spawn_id, record)
                 return _cancel_outcome_from_record(str(spawn_id), record, already_terminal=True)
+            if not force and _is_live_managed_primary(self._runtime_root, record):
+                raise RuntimeError(_live_primary_cancel_refusal(record))
 
             record = (
                 await asyncio.to_thread(
@@ -564,6 +610,18 @@ class SpawnApplicationService:
                 manager=self._spawn_manager,
             ).cancel(spawn_id)
 
+        latest_after_delivery = self.get_spawn(spawn_id) or record
+        if not _has_live_execution_owner(latest_after_delivery, primary_metadata):
+            lock = await self._locks.acquire(str(spawn_id))
+            async with lock:
+                latest_after_delivery = self.get_spawn(spawn_id) or latest_after_delivery
+                converged = await self._force_cancel_convergence(
+                    spawn_id,
+                    latest_after_delivery,
+                )
+                if converged is not None:
+                    return _cancel_outcome_from_record(str(spawn_id), converged)
+
         terminal = await self._wait_for_terminal(spawn_id, timeout=1.0)
         if terminal is not None:
             return _cancel_outcome_from_record(str(spawn_id), terminal, already_terminal=True)
@@ -606,7 +664,10 @@ class SpawnApplicationService:
             if not descendants:
                 return reaped_ids
             results = await asyncio.gather(
-                *(self.cancel(SpawnId(d.id), requested_by="system") for d in descendants),
+                *(
+                    self.cancel(SpawnId(d.id), requested_by="system", force=False)
+                    for d in descendants
+                ),
                 return_exceptions=True,
             )
             for descendant, result in zip(descendants, results, strict=True):
@@ -736,28 +797,30 @@ class SpawnApplicationService:
             launcher_pid, created_after_epoch=started_epoch
         )
         if launcher_alive:
+            assert launcher_pid is not None
             terminate_managed_primary_processes(
                 primary_metadata,
                 include_launcher=True,
                 include_runtime_children=False,
             )
-        else:
-            terminate_managed_primary_processes(
-                primary_metadata,
-                include_launcher=False,
+            latest = await self._wait_for_terminal_or_process_exit(
+                spawn_id,
+                pid=launcher_pid,
+                created_after_epoch=started_epoch,
+                timeout=_MANAGED_CANCEL_GRACE_SECS,
             )
+        else:
+            latest = None
 
-        latest = await self._wait_for_terminal(
-            spawn_id,
-            timeout=_MANAGED_CANCEL_GRACE_SECS,
-        )
-        if latest is None and launcher_alive:
+        if latest is None:
             terminate_managed_primary_processes(
                 primary_metadata,
                 include_launcher=False,
             )
-            latest = await self._wait_for_terminal(
+            latest = await self._wait_for_terminal_or_execution_exit(
                 spawn_id,
+                record=record,
+                primary_metadata=primary_metadata,
                 timeout=_MANAGED_CANCEL_FALLBACK_WAIT_SECS,
             )
 
@@ -803,6 +866,46 @@ class SpawnApplicationService:
             finalizing=latest.status == "finalizing",
         )
 
+    async def _wait_for_terminal_or_process_exit(
+        self,
+        spawn_id: SpawnId,
+        *,
+        pid: int,
+        created_after_epoch: float | None,
+        timeout: float,
+    ) -> SpawnRecord | None:
+        deadline = time.monotonic() + max(0.0, timeout)
+        while True:
+            current = self.get_spawn(spawn_id)
+            if current is not None and self.is_terminal(current.status):
+                return current
+            if not is_process_alive(pid, created_after_epoch=created_after_epoch):
+                return None
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                return None
+            await asyncio.sleep(min(_WAIT_POLL_INTERVAL_SECS, remaining))
+
+    async def _wait_for_terminal_or_execution_exit(
+        self,
+        spawn_id: SpawnId,
+        *,
+        record: SpawnRecord,
+        primary_metadata: PrimaryMetadata,
+        timeout: float,
+    ) -> SpawnRecord | None:
+        deadline = time.monotonic() + max(0.0, timeout)
+        while True:
+            current = self.get_spawn(spawn_id)
+            if current is not None and self.is_terminal(current.status):
+                return current
+            if not _has_live_execution_owner(current or record, primary_metadata):
+                return None
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                return None
+            await asyncio.sleep(min(_WAIT_POLL_INTERVAL_SECS, remaining))
+
     async def complete_spawn(
         self,
         spawn_id: SpawnId,

{meridian_cli-0.3.52 → meridian_cli-0.3.53}/src/meridian/lib/launch/process/pty_launcher.py

@@ -16,6 +16,15 @@ from meridian.lib.platform import IS_WINDOWS, fcntl, pty, select, termios, tty
 
 from .ports import LaunchedProcess, ProcessLauncher
 
+_TERMINAL_RESTORE_SEQUENCE = (
+    b"\x1b[?1000l"
+    b"\x1b[?1002l"
+    b"\x1b[?1003l"
+    b"\x1b[?1006l"
+    b"\x1b[?1049l"
+    b"\x1b[?25h"
+)
+
 
 def can_use_pty() -> bool:
     return not IS_WINDOWS and sys.stdin.isatty() and sys.stdout.isatty()
@@ -115,7 +124,10 @@ def _copy_primary_pty_output(
                     if output_handle is not None:
                         output_handle.write(chunk)
                         output_handle.flush()
-                    os.write(stdout_fd, chunk)
+                    try:
+                        os.write(stdout_fd, chunk)
+                    except BrokenPipeError:
+                        break
 
                 if stdin_open and stdin_fd in ready:
                     data = os.read(stdin_fd, 1024)
@@ -127,6 +139,9 @@ def _copy_primary_pty_output(
         restore_resize()
         if saved_tty_attrs is not None:
             termios.tcsetattr(stdin_fd, termios.TCSADRAIN, saved_tty_attrs)
+        if os.isatty(stdout_fd):
+            with suppress(OSError):
+                os.write(stdout_fd, _TERMINAL_RESTORE_SEQUENCE)
 
     _, status = os.waitpid(child_pid, 0)
     return os.waitstatus_to_exitcode(status)

{meridian_cli-0.3.52 → meridian_cli-0.3.53}/src/meridian/lib/launch/streaming_runner.py

@@ -396,7 +396,7 @@ def _persist_attempt_artifacts(
         if not source.exists():
             continue
         payload = source.read_bytes()
-        if name in {HISTORY_FILENAME, STDERR_FILENAME}:
+        if secrets and name in {HISTORY_FILENAME, STDERR_FILENAME}:
             payload = redact_secret_bytes(payload, secrets)
         artifacts.put(make_artifact_key(spawn_id, name), payload)
 

{meridian_cli-0.3.52 → meridian_cli-0.3.53}/src/meridian/lib/ops/spawn/api.py

@@ -1030,6 +1030,17 @@ async def spawn_subagents(
 
 
 def _spawn_cancel_output_from_outcome(outcome: CancelOutcome) -> SpawnActionOutput:
+    if outcome.status in {"queued", "running"} and not outcome.finalizing:
+        return SpawnActionOutput(
+            command="spawn.cancel",
+            status="failed",
+            spawn_id=outcome.spawn_id,
+            message=f"Cancellation of spawn '{outcome.spawn_id}' did not converge.",
+            error=f"Spawn remained {outcome.status} after cancellation.",
+            model=outcome.model,
+            harness_id=outcome.harness,
+            exit_code=1,
+        )
     if outcome.already_terminal:
         message = f"Spawn '{outcome.spawn_id}' is already {outcome.status}."
     elif outcome.finalizing:
@@ -1242,7 +1253,7 @@ async def _spawn_cancel_impl(
         setup_telemetry(runtime_root=runtime_root, logical_owner=cancel_owner)
     register_spawn_telemetry_observer()
     try:
-        outcome = await spawn_service.cancel(SpawnId(spawn_id))
+        outcome = await spawn_service.cancel(SpawnId(spawn_id), force=payload.force)
     except RuntimeError as exc:
         return SpawnActionOutput(
             command="spawn.cancel",
@@ -1334,6 +1345,7 @@ def spawn_cancel_all_sync(
                 SpawnCancelInput(
                     spawn_id=row.id,
                     project_root=project_root.as_posix(),
+                    force=payload.include_primaries,
                 ),
                 sink=sink,
                 prepared=prepared,

{meridian_cli-0.3.52 → meridian_cli-0.3.53}/src/meridian/lib/ops/spawn/models.py

@@ -745,6 +745,7 @@ class SpawnCancelInput(BaseModel):
 
     spawn_id: str
     project_root: str | None = None
+    force: bool = False
 
 
 class SpawnCancelAllInput(BaseModel):

{meridian_cli-0.3.52 → meridian_cli-0.3.53}/src/meridian/lib/safety/redaction.py

@@ -33,7 +33,12 @@ def redact_secrets(text: str, secrets: tuple[SecretSpec, ...]) -> str:
 def redact_secret_bytes(data: bytes, secrets: tuple[SecretSpec, ...]) -> bytes:
     """Byte wrapper around redaction for streamed logs."""
 
-    if not secrets:
+    encoded_secrets = tuple(
+        secret.value.encode("utf-8")
+        for secret in secrets
+        if secret.value
+    )
+    if not encoded_secrets or not any(secret in data for secret in encoded_secrets):
         return data
     decoded = data.decode("utf-8", errors="replace")
     return redact_secrets(decoded, secrets).encode("utf-8")

{meridian_cli-0.3.52 → meridian_cli-0.3.53}/src/meridian/lib/state/history.py

@@ -19,6 +19,8 @@ from meridian.lib.state.spawn_aggregate import mutate_published_spawn_artifact
 logger = logging.getLogger(__name__)
 
 _LAST_OBSERVED_EVENT_CHECKPOINT_INTERVAL_SECONDS = 1.0
+_RAW_UNPARSED_MAX_LENGTH = 4096
+_RAW_UNPARSED_TRUNCATION_MARKER = "\n[truncated by Meridian]"
 
 
 @dataclass(frozen=True)
@@ -74,20 +76,27 @@ class HarnessHistoryWriter:
 
         causal = self._causal_tracker.derive(event)
         timestamp = self.clock.utc_now_iso()
-        envelope = {
+        envelope: dict[str, object] = {
             "seq": self._seq,
             "byte_offset": self._byte_offset,
             "timestamp": timestamp,
-            "turn_id": causal.turn_id,
-            "item_id": causal.item_id,
-            "request_id": causal.request_id,
             "interrupt_epoch": causal.interrupt_epoch,
-            "stale_after_interrupt": causal.stale_after_interrupt,
             "event_type": event.event_type,
             "harness_id": event.harness_id,
             "payload": event.payload,
-            "raw_text": event.raw_text,
         }
+        for key, value in (
+            ("turn_id", causal.turn_id),
+            ("item_id", causal.item_id),
+            ("request_id", causal.request_id),
+        ):
+            if value is not None:
+                envelope[key] = value
+        if causal.stale_after_interrupt:
+            envelope["stale_after_interrupt"] = True
+        meta = _wire_envelope_meta(event)
+        if meta:
+            envelope["meta"] = meta
         line = json.dumps(envelope, separators=(",", ":"), sort_keys=True) + "\n"
 
         assigned_seq = self._seq
@@ -205,6 +214,38 @@ class HarnessHistoryWriter:
             )
 
 
+def _wire_envelope_meta(event: RawHarnessEvent) -> dict[str, object]:
+    """Return wire fields not already represented by the normalized payload."""
+
+    if event.raw_text is None:
+        return {}
+    try:
+        parsed = json.loads(event.raw_text)
+    except (json.JSONDecodeError, TypeError):
+        return {"raw_unparsed": _bounded_unparsed_wire(event.raw_text)}
+    if not isinstance(parsed, dict):
+        return {"raw_unparsed": _bounded_unparsed_wire(event.raw_text)}
+
+    wire = cast("dict[str, object]", parsed)
+    for payload_key in ("payload", "params"):
+        if wire.get(payload_key) == event.payload:
+            return {key: value for key, value in wire.items() if key != payload_key}
+    if wire == event.payload:
+        return {}
+    return {
+        key: value
+        for key, value in wire.items()
+        if key not in event.payload or event.payload[key] != value
+    }
+
+
+def _bounded_unparsed_wire(raw_text: str) -> str:
+    if len(raw_text) <= _RAW_UNPARSED_MAX_LENGTH:
+        return raw_text
+    prefix_length = _RAW_UNPARSED_MAX_LENGTH - len(_RAW_UNPARSED_TRUNCATION_MARKER)
+    return raw_text[:prefix_length] + _RAW_UNPARSED_TRUNCATION_MARKER
+
+
 def iter_history_events(path: Path) -> Iterator[dict[str, Any]]:
     """Yield seq-enveloped event dictionaries from a history JSONL file."""
 

{meridian_cli-0.3.52 → meridian_cli-0.3.53}/src/meridian/lib/state/liveness.py

@@ -10,6 +10,12 @@ from meridian.lib.platform.process_scope.base import birth_time_unverified
 _PID_REUSE_GUARD_SECS = 30.0
 
 
+def _is_running_non_zombie(proc: psutil.Process) -> bool:
+    """Return process liveness suitable for cancellation convergence."""
+
+    return proc.is_running() and proc.status() != psutil.STATUS_ZOMBIE
+
+
 def is_process_alive(pid: int, created_after_epoch: float | None = None) -> bool:
     """Check if a PID is alive, with create_time guard for PID reuse."""
     if not psutil.pid_exists(pid):
@@ -23,7 +29,7 @@ def is_process_alive(pid: int, created_after_epoch: float | None = None) -> bool
             and proc.create_time() > created_after_epoch + _PID_REUSE_GUARD_SECS
         ):
             return False
-        return proc.is_running()
+        return _is_running_non_zombie(proc)
     except psutil.NoSuchProcess:
         return False
     except psutil.AccessDenied:
@@ -42,7 +48,7 @@ def is_process_alive_with_birth(pid: int, birth_epoch: float | None) -> bool:
         proc = psutil.Process(pid)
         if abs(proc.create_time() - birth_epoch) > 1.0:
             return False
-        return proc.is_running()
+        return _is_running_non_zombie(proc)
     except psutil.NoSuchProcess:
         return False
     except psutil.AccessDenied:

{meridian_cli-0.3.52 → meridian_cli-0.3.53}/src/meridian/lib/state/session_store.py

@@ -7,6 +7,7 @@ from contextlib import ExitStack
 from pathlib import Path
 from typing import IO, Any, Literal, NamedTuple, cast
 
+import psutil
 from pydantic import BaseModel, ConfigDict, ValidationError
 
 from meridian.lib.core.types import (
@@ -25,7 +26,7 @@ from meridian.lib.platform.locking import (
 )
 from meridian.lib.state.atomic import atomic_write_text
 from meridian.lib.state.event_store import append_event, read_events, utc_now_iso
-from meridian.lib.state.liveness import is_process_alive
+from meridian.lib.state.liveness import is_process_alive_with_birth
 from meridian.lib.state.paths import RuntimePaths, normalize_path_for_write
 
 
@@ -175,36 +176,51 @@ def _generation_matches(expected: str, actual: str) -> bool:
     return normalized_expected == normalized_actual
 
 
-def _read_session_lease_data(paths: RuntimePaths, chat_id: str) -> tuple[bool, str, int | None]:
+def _read_session_lease_data(
+    paths: RuntimePaths,
+    chat_id: str,
+) -> tuple[bool, str, int | None, float | None]:
     lease_path = _session_lease_path(paths, chat_id)
     if not lease_path.is_file():
-        return (False, "", None)
+        return (False, "", None, None)
     try:
         payload = json.loads(lease_path.read_text(encoding="utf-8"))
     except (json.JSONDecodeError, OSError):
-        return (False, "", None)
+        return (False, "", None, None)
     if not isinstance(payload, dict):
-        return (False, "", None)
+        return (False, "", None, None)
     payload_dict = cast("dict[str, Any]", payload)
     generation = payload_dict.get("session_instance_id")
     owner_pid = payload_dict.get("owner_pid")
+    owner_created_at_epoch = payload_dict.get("owner_created_at_epoch")
     parsed_owner_pid = (
         owner_pid if isinstance(owner_pid, int) and not isinstance(owner_pid, bool) else None
     )
+    parsed_owner_created_at_epoch = (
+        float(owner_created_at_epoch)
+        if isinstance(owner_created_at_epoch, int | float)
+        and not isinstance(owner_created_at_epoch, bool)
+        else None
+    )
     if isinstance(generation, str):
-        return (True, generation, parsed_owner_pid)
-    return (True, "", parsed_owner_pid)
+        return (True, generation, parsed_owner_pid, parsed_owner_created_at_epoch)
+    return (True, "", parsed_owner_pid, parsed_owner_created_at_epoch)
 
 
 def _read_session_lease(paths: RuntimePaths, chat_id: str) -> tuple[bool, str]:
-    lease_exists, generation, _owner_pid = _read_session_lease_data(paths, chat_id)
+    lease_exists, generation, _owner_pid, _owner_birth = _read_session_lease_data(paths, chat_id)
     return (lease_exists, generation)
 
 
 def _write_session_lease(paths: RuntimePaths, chat_id: str, session_instance_id: str) -> None:
+    try:
+        owner_created_at_epoch: float | None = psutil.Process(os.getpid()).create_time()
+    except (psutil.NoSuchProcess, psutil.AccessDenied, OSError):
+        owner_created_at_epoch = None
     payload = {
         "chat_id": chat_id,
         "owner_pid": os.getpid(),
+        "owner_created_at_epoch": owner_created_at_epoch,
         "session_instance_id": session_instance_id,
     }
     atomic_write_text(
@@ -514,12 +530,20 @@ def has_live_session_leases(runtime_root: Path) -> bool:
         return False
     for lease_path in paths.sessions_dir.glob("*.lease.json"):
         chat_id = lease_path.name.removesuffix(".lease.json")
-        _exists, _generation, owner_pid = _read_session_lease_data(paths, chat_id)
-        if owner_pid is not None and is_process_alive(owner_pid):
+        _exists, _generation, owner_pid, owner_birth = _read_session_lease_data(paths, chat_id)
+        if owner_pid is not None and is_process_alive_with_birth(owner_pid, owner_birth):
             return True
     return False
 
 
+def is_session_lease_owner_alive(runtime_root: Path, chat_id: str) -> bool:
+    """Return whether one session's lease names a currently live owner process."""
+
+    paths = RuntimePaths.from_root_dir(runtime_root)
+    _exists, _generation, owner_pid, owner_birth = _read_session_lease_data(paths, chat_id)
+    return owner_pid is not None and is_process_alive_with_birth(owner_pid, owner_birth)
+
+
 def list_active_session_records(runtime_root: Path) -> list[SessionRecord]:
     """Return materialized records for active sessions."""
 
@@ -705,15 +729,18 @@ def cleanup_stale_sessions(runtime_root: Path) -> StaleSessionCleanup:
             stopped_at = utc_now_iso()
             for chat_id, _lock_path, _ in stale:
                 existing = records.get(chat_id)
-                lease_exists, lease_session_instance_id, lease_owner_pid = _read_session_lease_data(
-                    paths, chat_id
-                )
+                (
+                    lease_exists,
+                    lease_session_instance_id,
+                    lease_owner_pid,
+                    lease_owner_birth,
+                ) = _read_session_lease_data(paths, chat_id)
                 if (
                     existing is not None
                     and existing.kind == "primary"
                     and lease_exists
                     and lease_owner_pid is not None
-                    and is_process_alive(lease_owner_pid)
+                    and is_process_alive_with_birth(lease_owner_pid, lease_owner_birth)
                 ):
                     continue
                 stop_session_instance_id = lease_session_instance_id