cc-session-control 0.6.0__tar.gz → 0.6.2__tar.gz

{cc_session_control-0.6.0/src/cc_session_control.egg-info → cc_session_control-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cc-session-control
-Version: 0.6.0
+Version: 0.6.2
 Summary: TUI manager for Claude Code sessions and Remote Control
 Author: dzshzx
 License-Expression: MIT
@@ -29,9 +29,9 @@ TUI manager for [Claude Code](https://claude.ai/code) sessions and Remote Contro
 
 ## Features
 
-- **Sessions Tab** — View, resume, terminate, and delete Claude Code sessions across all projects
+- **Sessions Tab** — View, resume (bare terminal / tmux / background + Remote Control), terminate, and delete Claude Code sessions across all projects; a cleanup submenu (`c`) prunes empty/short sessions and sweeps orphan artifact directories
 - **Projects Tab** — Start a new tmux claude session in a project dir (`t`), start/stop RC servers per project, toggle auto-start, show running/stopped/dead states
-- **Cleanup Tab** — Prune empty/short sessions, sweep orphan artifact directories
+- **Background agents Tab** — List background agent jobs; take over, respawn, watch their timeline, stop, or remove them
 
 Built with [urwid](https://urwid.org/).
 

{cc_session_control-0.6.0 → cc_session_control-0.6.2}/README.md

@@ -6,9 +6,9 @@ TUI manager for [Claude Code](https://claude.ai/code) sessions and Remote Contro
 
 ## Features
 
-- **Sessions Tab** — View, resume, terminate, and delete Claude Code sessions across all projects
+- **Sessions Tab** — View, resume (bare terminal / tmux / background + Remote Control), terminate, and delete Claude Code sessions across all projects; a cleanup submenu (`c`) prunes empty/short sessions and sweeps orphan artifact directories
 - **Projects Tab** — Start a new tmux claude session in a project dir (`t`), start/stop RC servers per project, toggle auto-start, show running/stopped/dead states
-- **Cleanup Tab** — Prune empty/short sessions, sweep orphan artifact directories
+- **Background agents Tab** — List background agent jobs; take over, respawn, watch their timeline, stop, or remove them
 
 Built with [urwid](https://urwid.org/).
 

{cc_session_control-0.6.0 → cc_session_control-0.6.2}/src/cc_session_control/__init__.py

@@ -1,3 +1,3 @@
 """cc-session-control — TUI manager for Claude Code sessions and Remote Control."""
 
-__version__ = "0.6.0"
+__version__ = "0.6.2"

{cc_session_control-0.6.0 → cc_session_control-0.6.2}/src/cc_session_control/actions/agent_ops.py

@@ -25,34 +25,11 @@ import os
 import shlex
 import signal
 import time
-from dataclasses import replace
 
 from ..config import cfg
 from ..data import cleanup, liveness, proc, rc, registry
 from ..models import AgentJob, Session
 
-# --- User-facing labels/help (Simplified Chinese, read by the Phase 7 view) ---
-
-TAKEOVER_LABEL = "接回"
-
-# Unified verb table (matches Sessions/RC): Enter/o=接回(primary), s=停止(kill a
-# live thing), d=删除, R=重启(respawn). `r`=刷新 lives in the App-level footer
-# prefix now, so it is NOT repeated here; separators are ` · ` like the other tabs.
-KEYHINTS = "Enter/o 接回 · s 停止 · d 删除 · w 查看 · R 重启"
-
-# Orphan-process risk (R4.5 red line): stop only kills the host pid joined from
-# the sessions registry, killing a --remote-control/bg worker does not always
-# fully reap it, and a live worker with no sessions file can't be located at all.
-HELP = (
-    "后台 agent 生命周期：\n"
-    "  Enter/o 接回(拉回前台，复用 resume；接运行中的 agent 会先确认接管)  w 查看 timeline(只读)\n"
-    "  R 重启(respawn)  d 删除(仅已结束)  s 停止(仅运行中，需确认)  r 刷新\n"
-    "停止/孤儿风险：停止只能杀经 sessions 文件 join 到的 host pid；"
-    "杀 --remote-control/后台 agent 不一定彻底回收，可能残留孤儿进程，需手动确认；"
-    "找不到运行中的后台 agent 的 host pid 时无法停止。"
-)
-
-
 # --- host-pid join (shared by stop_job, remove_job, and the view) -------------
 
 def job_host(job: AgentJob) -> tuple[int | None, bool]:
@@ -68,10 +45,7 @@ def job_host(job: AgentJob) -> tuple[int | None, bool]:
     Injects `/proc` liveness onto the registry rows, then defers to the single
     pure join `registry.host_pid_for_sid` (shared with `snapshot._enrich_jobs`).
     """
-    procs = [
-        replace(sp, proc_alive=proc.pid_alive(sp.pid, sp.proc_start))
-        for sp in registry.read_session_procs()
-    ]
+    procs = liveness.live_session_procs()
     return registry.host_pid_for_sid(job.sid, procs)
 
 
@@ -151,7 +125,7 @@ def resume_takeover(job: AgentJob) -> Session:
 
     Bringing a bg session to the foreground is just a resume of its
     `resume_sid`, so this returns a Session the view feeds to the SAME
-    `app.exit_with_resume` → `do_resume` pipeline used for foreground sessions —
+    `app.exit_with(ResumeIntent)` → `do_resume` pipeline used for foreground sessions —
     all kill/exec/`_resume_plan` logic is reused, none duplicated (R4.4 takeover).
     `pid`/`alive` come from the host join so a live worker is killed first
     (resume = takeover); `current` is computed so the launching session stays

{cc_session_control-0.6.0 → cc_session_control-0.6.2}/src/cc_session_control/actions/session_ops.py

@@ -6,6 +6,7 @@ import os
 import shlex
 import signal
 import time
+from dataclasses import dataclass
 
 from .. import clipboard
 from ..data import proc, rc
@@ -202,6 +203,72 @@ def do_tmux_new(directory: str) -> str | None:
     return rc.run_in_tmux(rc.session_name_for(directory), "claude", cmd)
 
 
+# --- exit intents (the payload crossing the exit-then-exec seam) ------------
+#
+# The TUI cannot run `claude` (or replace itself with tmux) inside the urwid
+# loop, so a resume-family action exits the MainLoop carrying ONE of these
+# intents and `cli._cmd_tui` calls `intent.run()` afterwards. Each intent owns
+# its own finalizer + failure messages, so adding a variant means adding one
+# class here + one view call — app.py and cli.py stay untouched.
+
+class ExitIntent:
+    """What a view asks csctl to do AFTER the MainLoop exits."""
+
+    def run(self) -> None:
+        """Finalize outside the loop; may exec-replace the csctl process."""
+        raise NotImplementedError
+
+
+@dataclass(frozen=True)
+class ResumeIntent(ExitIntent):
+    """Enter/f: bare-terminal resume (execvp; takeover kill inside do_resume)."""
+
+    session: Session
+    fork: bool = False
+
+    def run(self) -> None:
+        do_resume(self.session, fork=self.fork)
+
+
+@dataclass(frozen=True)
+class AttachIntent(ExitIntent):
+    """`t` on a tmux-hosted session: enter its window in place (no kill)."""
+
+    target: str
+
+    def run(self) -> None:
+        if not enter_window(self.target):
+            print(f"Failed to enter tmux window {self.target} (is tmux running?)")
+
+
+@dataclass(frozen=True)
+class TmuxResumeIntent(ExitIntent):
+    """`t` on a dead / bare-terminal session: resume inside tmux, then enter."""
+
+    session: Session
+
+    def run(self) -> None:
+        target = do_tmux_resume(self.session)
+        if target is None:
+            print("Failed to resume the session inside tmux (R10 degraded, or tmux unavailable).")
+        elif not enter_window(target):
+            print(f"Session resumed in tmux window {target}, but attaching failed.")
+
+
+@dataclass(frozen=True)
+class TmuxNewIntent(ExitIntent):
+    """项目-tab `t`: start a NEW claude in tmux, then enter (pure spawn)."""
+
+    directory: str
+
+    def run(self) -> None:
+        target = do_tmux_new(self.directory)
+        if target is None:
+            print("Failed to start a new session inside tmux (is tmux available?).")
+        elif not enter_window(target):
+            print(f"Session started in tmux window {target}, but attaching failed.")
+
+
 def enter_window(target: str) -> bool:
     """Bring `target` ("session:window") to the user's terminal foreground.
 

{cc_session_control-0.6.0 → cc_session_control-0.6.2}/src/cc_session_control/app.py

@@ -30,7 +30,8 @@ class TabView(Protocol):
     widgets; `apply_data()` runs on the main loop and swaps `_pending` into the
     walker. The `snapshot` is the shared per-cycle world (R11/D8); it is OPTIONAL
     — a view called with `None` self-fetches (back-compat / tests). Adding a tab
-    means honoring every member below.
+    means honoring every member below; subclass `views/_base.py::ListTabView`
+    for the shared walker/overlay/footer plumbing instead of re-writing it.
     """
 
     widget: urwid.Widget
@@ -41,6 +42,7 @@ class TabView(Protocol):
     def apply_data(self) -> None: ...
     def keyhints(self) -> str: ...
     def handle_key(self, key: str) -> None: ...
+    def deactivate(self) -> None: ...  # tab switch-away: close transient FOOTER modes
 
 # 6-tuple: (name, fg_16, bg_16, mono, fg_256, bg_256)
 # ONE semantic set — views reference these names only (no per-tab duplicates;
@@ -87,9 +89,10 @@ def _make_screen() -> urwid.raw_display.Screen:
 
 class App:
     def __init__(self) -> None:
-        self.result: tuple | None = None
+        self.result: object | None = None  # a session_ops.ExitIntent, or None
         self._exiting = False
         self._alarm_handle: object | None = None
+        self._notify_alarm: object | None = None
         self._pipe_fd: int | None = None
         self._refreshing = False
         # When set, a confirm modal is up: `_input` routes Enter/y/n/esc here and
@@ -140,6 +143,10 @@ class App:
         self.header.contents[1] = (tab_bar, self.header.options())
 
     def _switch_tab(self) -> None:
+        # Close the outgoing tab's transient footer modes (e.g. the Sessions
+        # filter Edit) — they turn invisible once the next tab's hints replace
+        # the footer, but would keep eating keys after switching back.
+        self.views[self._active].deactivate()
         self._active = (self._active + 1) % len(self.views)
         self.body.original_widget = self.views[self._active].widget
         self._update_tab_bar()
@@ -181,10 +188,19 @@ class App:
         self._confirm_base = self.body.original_widget
         text = urwid.Text(f"  {message}\n\n  Enter / y 确认    n / Esc 取消")
         box = urwid.AttrMap(urwid.LineBox(urwid.Filler(text)), "notify")
+        # Size to the content: the old fixed 50%×7 clipped long labels and the
+        # n/Esc line on narrow terminals. Width floors at 46 cells (capped to
+        # the screen); height = wrapped text rows + the LineBox border.
+        try:
+            cols, rows = self._screen.get_cols_rows()
+        except Exception:
+            cols, rows = 80, 24
+        width = min(max(cols // 2, 46), cols)
+        height = min(text.rows((max(width - 2, 1),)) + 2, max(rows - 2, 3))
         self.body.original_widget = urwid.Overlay(
             box, self._confirm_base,
-            align="center", width=("relative", 50),
-            valign="middle", height=7,
+            align="center", width=width,
+            valign="middle", height=height,
         )
         self.footer_text.set_text(" Enter/y 确认 · n/Esc 取消")
 
@@ -195,37 +211,52 @@ class App:
         self._confirm_yes = None
         self.set_hints(self.views[self._active].keyhints())
 
-    def _exit(self, result: tuple | None = None) -> None:
+    def _exit(self, result: object = None) -> None:
         self._exiting = True
         if self._alarm_handle:
             self.loop.remove_alarm(self._alarm_handle)
         self.result = result
         raise urwid.ExitMainLoop()
 
-    def exit_with_resume(self, session: object, fork: bool = False) -> None:
-        self._exit(("resume", session, fork))
-
-    def exit_with_attach(self, target: str) -> None:
-        """`t` on a session already living in a tmux window: enter it in place."""
-        self._exit(("attach", target))
+    def exit_with(self, intent: object) -> None:
+        """Exit the MainLoop carrying a `session_ops.ExitIntent`.
 
-    def exit_with_tmux_resume(self, session: object) -> None:
-        """`t` on a dead / bare-terminal session: resume it inside tmux, then enter."""
-        self._exit(("tmux_resume", session))
-
-    def exit_with_tmux_new(self, directory: str) -> None:
-        """`t` on a project row: start a NEW claude session in tmux, then enter."""
-        self._exit(("tmux_new", directory))
+        Views construct the intent (they know the verb); `cli._cmd_tui` calls
+        `intent.run()` after the loop ends — resume must exec OUTSIDE urwid, so
+        the finalizer cannot run here. App stays variant-agnostic: adding a
+        resume variant touches only the intent class + the view key handler.
+        """
+        self._exit(intent)
 
     def set_hints(self, hints: str) -> None:
         """Footer = shared prefix + the active tab's keyhints (D1 single source)."""
         self.footer_text.set_text(FOOTER_PREFIX + hints)
 
+    # --- the view-facing façade (views call these, never App internals) ---
+
+    def is_active(self, view: TabView) -> bool:
+        """Whether `view` is the tab currently shown — the one question views
+        may ask about tab state (no peeking at `views`/`_active`)."""
+        return self.views[self._active] is view
+
+    def own_footer(self, widget: urwid.Widget) -> None:
+        """Hand the footer to a view's transient widget (e.g. the filter Edit)."""
+        self.frame.footer = widget
+
+    def release_footer(self) -> None:
+        """Give the footer back to the standard hints line."""
+        self._restore_footer()
+
     def notify(self, msg: str, seconds: float = 3) -> None:
+        # The newest notification owns the footer: cancel the previous restore
+        # alarm so an older timer can't clear this message early.
+        if self._notify_alarm is not None:
+            self.loop.remove_alarm(self._notify_alarm)
         self.frame.footer = urwid.AttrMap(urwid.Text(f" {msg}"), "notify")
-        self.loop.set_alarm_in(seconds, lambda *_: self._restore_footer())
+        self._notify_alarm = self.loop.set_alarm_in(seconds, lambda *_: self._restore_footer())
 
     def _restore_footer(self) -> None:
+        self._notify_alarm = None
         self.frame.footer = self.footer
 
     def _run_fetch_cycle(self) -> None:
@@ -245,6 +276,12 @@ class App:
         for v in self.views:
             v.fetch_pending(snapshot)
 
+    def refresh_with_notice(self) -> None:
+        """Refresh + the standard footer notice — the single body of the
+        footer-prefix promise `r 刷新` (list AND modal modes, every tab)."""
+        self.trigger_async_refresh()
+        self.notify("刷新中…")
+
     def trigger_async_refresh(self) -> None:
         if self._refreshing or self._exiting:
             return
@@ -275,7 +312,7 @@ class App:
                 view.apply_data()
         return True
 
-    def run(self) -> tuple | None:
+    def run(self) -> object | None:
         self._pipe_fd = self.loop.watch_pipe(self._on_pipe)
         self.views[self._active].load()
         self.set_hints(self.views[self._active].keyhints())

{cc_session_control-0.6.0 → cc_session_control-0.6.2}/src/cc_session_control/cli.py

@@ -87,7 +87,8 @@ def _cmd_rc(args: argparse.Namespace) -> None:
         for p in projects:
             icon = {"running": "[running]", "dead": "[dead   ]", "stopped": "[stopped]"}.get(p.status, p.status)
             auto = "auto" if p.auto_start else "    "
-            print(f"  {icon} {auto}  {p.name}")
+            missing = "" if p.dir_exists else "  (directory missing)"
+            print(f"  {icon} {auto}  {p.name}{missing}")
 
     elif sub == "add":
         proj = args.project
@@ -187,18 +188,13 @@ def _cmd_prune_zombies(args: argparse.Namespace) -> None:
     gated here too — off `/proc` every pid looks dead, so `current` can't be
     determined and we must not even claim the files are sweepable (R10).
     """
-    from dataclasses import replace
-
-    from .data import proc, registry
+    from .data import liveness, proc
     from .data.cleanup import remove_zombie_session_files, select_zombie_pids
 
     if not proc.current_determinable():
         print("Refused: '/proc' unavailable — cannot determine the current session (R10).")
         return
-    procs = [
-        replace(sp, proc_alive=proc.pid_alive(sp.pid, sp.proc_start))
-        for sp in registry.read_session_procs(max_age=0.0)
-    ]
+    procs = liveness.live_session_procs(max_age=0.0)
     cur = proc.ancestor_pids()
     zombies = select_zombie_pids(procs, cur)
     print(f"Would sweep {len(zombies)} zombie session file(s)")
@@ -298,38 +294,15 @@ def _cmd_env(args: argparse.Namespace) -> None:
 
 
 def _cmd_tui(args: argparse.Namespace) -> None:
-    from .actions.session_ops import do_resume, do_tmux_new, do_tmux_resume, enter_window
+    from .actions.session_ops import ExitIntent
     from .app import App
 
-    app = App()
-    result = app.run()
+    result = App().run()
 
-    if not result or not isinstance(result, tuple):
-        return
-    if result[0] == "resume":
-        _, session, fork = result
-        do_resume(session, fork=fork)
-    elif result[0] == "attach":
-        # `t` on a tmux-hosted session: enter its window (exec replaces csctl
-        # outside tmux; switch-client + normal exit inside).
-        if not enter_window(result[1]):
-            print(f"Failed to enter tmux window {result[1]} (is tmux running?)")
-    elif result[0] == "tmux_resume":
-        # `t` on a dead / bare-terminal session: spawn the resume window, then
-        # enter it. Kill semantics (takeover) are handled inside do_tmux_resume.
-        target = do_tmux_resume(result[1])
-        if target is None:
-            print("Failed to resume the session inside tmux (R10 degraded, or tmux unavailable).")
-        elif not enter_window(target):
-            print(f"Session resumed in tmux window {target}, but attaching failed.")
-    elif result[0] == "tmux_new":
-        # `t` on a 项目-tab project row: start a NEW claude session in tmux,
-        # then enter it (nothing is killed — pure spawn).
-        target = do_tmux_new(result[1])
-        if target is None:
-            print("Failed to start a new session inside tmux (is tmux available?).")
-        elif not enter_window(target):
-            print(f"Session started in tmux window {target}, but attaching failed.")
+    # The intent finalizes itself outside the urwid loop (it may exec-replace
+    # csctl — resume/attach) and prints its own failure messages.
+    if isinstance(result, ExitIntent):
+        result.run()
 
 
 def main() -> None:

{cc_session_control-0.6.0 → cc_session_control-0.6.2}/src/cc_session_control/data/cleanup.py

@@ -37,7 +37,6 @@ from __future__ import annotations
 import os
 import shutil
 import time
-from dataclasses import replace
 
 from ..config import cfg
 from ..models import AgentJob, Session, SessionProc
@@ -100,17 +99,6 @@ def _remove_path(path: str) -> bool:
 
 # --- Strategy A: sid-keyed orphan dirs (H1 protected-sid set) --------------
 
-def _live_session_procs(max_age: float = 5.0) -> list[SessionProc]:
-    """Registry session files with `/proc` liveness injected (swallow-error)."""
-    try:
-        return [
-            replace(sp, proc_alive=proc.pid_alive(sp.pid, sp.proc_start))
-            for sp in registry.read_session_procs(max_age=max_age)
-        ]
-    except Exception:
-        return []
-
-
 def known_sids(
     sessions: list[Session],
     session_procs: list[SessionProc],
@@ -163,7 +151,7 @@ def _gather_known(
     self-read swallows its own errors → safe empties.
     """
     if session_procs is None:
-        session_procs = _live_session_procs()
+        session_procs = liveness.live_session_procs()
     if agent_jobs is None:
         try:
             agent_jobs = registry.read_agent_jobs()
@@ -353,7 +341,7 @@ def remove_session(s: Session) -> bool:
         if _remove_path(p):
             removed = True
     # M3: never delete a LIVE agent worker's jobs/<short> dir.
-    _, host_alive = registry.host_pid_for_sid(s.sid, _live_session_procs())
+    _, host_alive = registry.host_pid_for_sid(s.sid, liveness.live_session_procs())
     if not host_alive and _remove_path(_jobs_path(s.sid)):
         removed = True
     return removed

{cc_session_control-0.6.0 → cc_session_control-0.6.2}/src/cc_session_control/data/environments.py

@@ -48,12 +48,18 @@ import contextlib
 import json
 import os
 from collections.abc import Iterator
-from dataclasses import replace
 from typing import Any
 
 from ..config import cfg
-from ..models import AgentJob, BridgeEnv, EnvRecord, RCServer, SessionProc
-from . import proc, registry
+from ..models import (
+    AgentJob,
+    BridgeEnv,
+    EnvRecord,
+    RCServer,
+    SessionProc,
+    split_env_id,
+)
+from . import liveness, registry
 
 try:  # POSIX advisory locking; absent on Windows → degrade to no lock.
     import fcntl
@@ -65,17 +71,51 @@ _RETENTION_SECONDS = 90 * 86400
 _MAX_ENTRIES = 500
 
 
-# --- bridge id parsing -----------------------------------------------------
+# --- observation builder (reads registry + liveness, never rc) -------------
 
-def _split_bridge(bridge: str) -> tuple[str, str]:
-    """`cse_abc` -> (`cse`, `abc`); the suffix is the namespace-local env id."""
-    prefix, sep, suffix = bridge.partition("_")
-    if not sep:
-        return "", ""
-    return prefix, suffix
+def _collect(
+    session_procs: list[SessionProc],
+    agent_jobs: list[AgentJob],
+    rc_servers: list[RCServer] | None,
+    *,
+    alive_gated: bool,
+) -> list[EnvRecord]:
+    """The ONE observation walk over the three env sources (R6).
 
+    `alive_gated=False` → the FILE-REFERENCED membership set (any env a file
+    references, alive or zombie). `alive_gated=True` → the CURRENT set, each
+    source gated by its own liveness rule: `session_*` by the single
+    `liveness.is_rc_exposed` predicate, `cse_*` by a host-alive job or a
+    proc-alive session sharing the job sid, `env_*` by a running RC server.
+    """
+    alive_sids = {sp.sid for sp in session_procs if sp.proc_alive}
+    records: list[EnvRecord] = []
+    for sp in session_procs:
+        if not sp.bridge:
+            continue
+        if alive_gated and not liveness.is_rc_exposed(sp.bridge, sp.proc_alive):
+            continue
+        prefix, key = split_env_id(sp.bridge)
+        if prefix and key:
+            records.append(EnvRecord(prefix=prefix, key=key, bound_sid=sp.sid))
+    for job in agent_jobs:
+        if not job.env_suffix:
+            continue
+        if alive_gated and not (job.host_alive or job.sid in alive_sids):
+            continue
+        records.append(
+            EnvRecord(prefix="cse", key=job.env_suffix, bound_sid=job.sid)
+        )
+    for srv in rc_servers or []:
+        if not srv.env_id:
+            continue
+        if alive_gated and srv.status != "running":
+            continue
+        prefix, key = split_env_id(srv.env_id)
+        if prefix and key:
+            records.append(EnvRecord(prefix=prefix, key=key, bound_sid=None))
+    return records
 
-# --- observation builder (reads registry only, never rc) -------------------
 
 def observe(
     session_procs: list[SessionProc] | None = None,
@@ -102,24 +142,7 @@ def observe(
             session_procs = registry.read_session_procs(max_age=max_age)
         if agent_jobs is None:
             agent_jobs = registry.read_agent_jobs(max_age=max_age)
-        records: list[EnvRecord] = []
-        for sp in session_procs:
-            if not sp.bridge:
-                continue
-            prefix, key = _split_bridge(sp.bridge)
-            if prefix and key:
-                records.append(EnvRecord(prefix=prefix, key=key, bound_sid=sp.sid))
-        for job in agent_jobs:
-            if job.env_suffix:
-                records.append(
-                    EnvRecord(prefix="cse", key=job.env_suffix, bound_sid=job.sid)
-                )
-        for srv in rc_servers or []:
-            if srv.env_id:
-                prefix, sep, key = srv.env_id.partition("_")
-                if sep and prefix and key:
-                    records.append(EnvRecord(prefix=prefix, key=key, bound_sid=None))
-        return records
+        return _collect(session_procs, agent_jobs, rc_servers, alive_gated=False)
     except Exception:
         return []
 
@@ -132,13 +155,14 @@ def observe_live(
 ) -> list[EnvRecord]:
     """Alive-gated "currently exposed" bridge envs (R3/R6) — the CURRENT set.
 
-    Where `observe()` is a bridge-truthy passive collector, this lifts the
-    `_is_rc_exposed` predicate to the env ledger: a bridge is CURRENT only when
-    its owner is alive — `session_*` gated by proc-alive, `cse_*` by a proc-alive
-    session sharing the job sid (host-alive), `env_*` by a running RC server. So a
-    zombie session's stale `bridgeSessionId` is NOT reported as current — it falls
-    through to `orphan_envs` (a manual-delete candidate) instead of overstating
-    the bound count.
+    Where `observe()` is a bridge-truthy passive collector, this applies the
+    single `liveness.is_rc_exposed` predicate (and the per-source gates in
+    `_collect`): a bridge is CURRENT only when its owner is alive — `session_*`
+    gated by proc-alive, `cse_*` by a proc-alive session sharing the job sid
+    (host-alive), `env_*` by a running RC server. So a zombie session's stale
+    `bridgeSessionId` is NOT reported as current — it falls through to
+    `orphan_envs` (a manual-delete candidate) instead of overstating the bound
+    count.
 
     Pure when `session_procs`/`agent_jobs` are supplied (the snapshot path passes
     its already-liveness-resolved data — DI for tests); reads the registry +
@@ -147,30 +171,10 @@ def observe_live(
     """
     try:
         if session_procs is None:
-            session_procs = [
-                replace(sp, proc_alive=proc.pid_alive(sp.pid, sp.proc_start))
-                for sp in registry.read_session_procs(max_age=max_age)
-            ]
+            session_procs = liveness.live_session_procs(max_age=max_age)
         if agent_jobs is None:
             agent_jobs = registry.read_agent_jobs(max_age=max_age)
-        alive_sids = {sp.sid for sp in session_procs if sp.proc_alive}
-        records: list[EnvRecord] = []
-        for sp in session_procs:
-            if sp.bridge and sp.proc_alive:
-                prefix, key = _split_bridge(sp.bridge)
-                if prefix and key:
-                    records.append(EnvRecord(prefix=prefix, key=key, bound_sid=sp.sid))
-        for job in agent_jobs:
-            if job.env_suffix and (job.host_alive or job.sid in alive_sids):
-                records.append(
-                    EnvRecord(prefix="cse", key=job.env_suffix, bound_sid=job.sid)
-                )
-        for srv in rc_servers or []:
-            if srv.env_id and srv.status == "running":
-                prefix, sep, key = srv.env_id.partition("_")
-                if sep and prefix and key:
-                    records.append(EnvRecord(prefix=prefix, key=key, bound_sid=None))
-        return records
+        return _collect(session_procs, agent_jobs, rc_servers, alive_gated=True)
     except Exception:
         return []
 

{cc_session_control-0.6.0 → cc_session_control-0.6.2}/src/cc_session_control/data/liveness.py

@@ -1,7 +1,6 @@
 """Session liveness — the single authority.
 
-Owns the ONE module-global cache for `claude agents --json` (mirrored by the
-`agents.py` re-export shim so terminate's invalidate and scan's read share it).
+Owns the ONE module-global cache for `claude agents --json`.
 `live_index` is a pure merge of already-fetched liveness inputs (registry
 session files with injected proc liveness + `claude agents --json`).
 """
@@ -12,9 +11,10 @@ import json
 import subprocess
 import time
 from collections.abc import Callable
+from dataclasses import replace
 
 from ..models import LiveInfo, SessionProc
-from . import proc
+from . import proc, registry
 
 _cache: dict[str, int | None] | None = None
 _cache_time: float = 0.0
@@ -69,6 +69,23 @@ def invalidate_cache() -> None:
     _cache = None
 
 
+def live_session_procs(max_age: float = 5.0) -> list[SessionProc]:
+    """Registry session files with `/proc` liveness injected — THE assembly point.
+
+    `registry.read_session_procs` deliberately leaves `proc_alive=False` (pure
+    parse, no `/proc`); a `SessionProc.proc_alive` is only trustworthy after
+    this injection. Every consumer must come through here rather than re-inline
+    the `replace(sp, proc_alive=pid_alive(...))` idiom. Swallows errors → [].
+    """
+    try:
+        return [
+            replace(sp, proc_alive=proc.pid_alive(sp.pid, sp.proc_start))
+            for sp in registry.read_session_procs(max_age=max_age)
+        ]
+    except Exception:
+        return []
+
+
 def _source_of(entrypoint: str, kind: str) -> str:
     """Coarse source bucket from the registry entrypoint/kind (D9)."""
     if kind == "bg":
@@ -80,7 +97,7 @@ def _source_of(entrypoint: str, kind: str) -> str:
     return "cli"
 
 
-def _is_rc_exposed(bridge: str | None, pid_alive: bool) -> bool:
+def is_rc_exposed(bridge: str | None, pid_alive: bool) -> bool:
     """Whether session remote control is CURRENTLY exposed (pure predicate).
 
     Exposed iff the bridge id is a truthy string AND the owning process is still